Stroke is a leading cause of long-term disability, with highly variable recovery trajectories and challenges in prediction and monitoring. Frequently used measures (e.g., National Institute of Health Stroke Scale (NIHSS) and Fugl-Meyer (FM) assessment of motor impairment) have significant limitations. As the societal burden of stroke increases, developing robust methodologies for assessing and predicting recovery is essential to optimize treatment plans and improve outcomes. This paper presents our Integrated Motion Analysis Suite (IMAS), which leverages multi-modal data (clinical, sensor, and neuroimaging inputs) and multimodal-machine-learning (MML) to predict FM scores and motor recovery in stroke. Its potential is demonstrated via analysis of 28 S patients in acute and subacute phases of recovery, where features extracted from a set of motor tasks were used to predict FM scores and motor recovery, achieving a coefficient of determination (R 2 ) of 0.75 and Mean Absolute Error (MAE) of 2.83 and R 2 = 0.83 and MAE = 2.6 %, respectively. IMAS is designed to continuously improve through its integration with a Big Data database, allowing for ongoing refinement of predictive algorithms as new data is collected in real-world clinical environments. Its ability to complement inherently limited clinical scales, handle incomplete data, and adapt to diverse applications highlights its potential for broader use in recovery after stroke, including long-term monitoring and precision rehabilitation.

Previously published algorithms for LR ( k ) incremental parsing are inefficient, unnecessarily restrictive, and in some cases incorrect. We present a simple algorithm based on parsing LR( k ) sentential forms that can incrementally parse an arbitrary number of textual and/or structural modifications in optimal time and with no storage overhead. The central role of balanced sequences in achieving truly incremental behavior from analysis algorithms is described, along with automated methods to support balancing during parse table generation and parsing. Our approach extends the theory of sentential-form parsing to allow for ambiguity in the grammar, exploiting it for notational convenience, to denote sequences, and to construct compact (“abstract”) syntax trees directly. Combined, these techniques make the use of automatically generated incremental parsers in interactive software development environments both practical and effective. In addition, we address information preservation in these environments: Optimal node reuse is defined; previous definitions are shown to be insufficient; and a method for detecting node reuse is provided that is both simpler and faster than existing techniques. A program representation based on self-versioning documents is used to detect changes in the program, generate efficient change reports for subsequent analyses, and allow the parsing transformation itself to be treated as a reversible modification in the edit log.

A major research goal for compilers and environments is the automatic derivation of tools from formal specifications. However, the formal model of the language is often inadequate; in particular, LR(k) grammars are unable to describe the natural syntax of many languages, such as C++ and Fortran, which are inherently non-deterministic. Designers of batch compilers work around such limitations by combining generated components with ad hoc techniques (for instance, performing partial type and scope analysis in tandem with parsing). Unfortunately, the complexity of incremental systems precludes the use of batch solutions. The inability to generate incremental tools for important languages inhibits the widespread use of language-rich interactive environments.We address this problem by extending the language model itself, introducing a program representation based on parse dags that is suitable for both batch and incremental analysis. Ambiguities unresolved by one stage are retained in this representation until further stages can complete the analysis, even if the reaolution depends on further actions by the user. Representing ambiguity explicitly increases the number and variety of languages that can be analyzed incrementally using existing methods.To create this representation, we have developed an efficient incremental parser for general context-free grammars. Our algorithm combines Tomita's generalized LR parser with reuse of entire subtrees via state-matching. Disambiguation can occur statically, during or after parsing, or during semantic analysis (using existing incremental techniques); program errors that preclude disambiguation retsin multiple interpretations indefinitely. Our representation and analyses gain efficiency by exploiting the local nature of ambiguities: for the SPEC95 C programs, the explicit representation of ambiguity requires only 0.5% additional space and less than 1% additional time during reconstruction.

Determining the relative execution frequency of program regions is essential for many important optimization techniques, including register allocation, function inlining, and instruction scheduling. Estimates derived from profiling with sample inputs are generally regarded as the most accurate source of this information; static (compile-time) estimates are considered to be distinctly inferior. If static estimates were shown to be competitive, however, their convenience would outweigh minor gains from profiling, and they would provide a sound basis for optimization when profiling is impossible.