refactor modelica parser into separate crate

1 files changed, 231 insertions, 0 deletions

diff --git a/src/modelica_model.rs b/src/modelica_model.rs
new file mode 100644
index 0000000..bcc00b1
--- /dev/null
+++ b/src/modelica_model.rs
@@ -0,0 +1,231 @@
+
+extern crate modelica_parser;
+
+use std::clone::Clone;
+use std::collections::HashMap;
+use std::collections::HashSet;
+
+use self::modelica_parser::ast::*;
+
+
+//// Helpers
+
+pub trait ModelicaModelExt {
+    fn get_constant_vars(&self) -> HashMap<String,Option<Expr>>;
+    fn get_free_vars(&self) -> Vec<String>;
+    fn solve_for(&self, indep_vars: Vec<String>, dep_vars: Vec<String>) -> Result<ModelicaModel,String>;
+}
+
+impl ModelicaModelExt for ModelicaModel {
+
+    fn get_constant_vars(&self) -> HashMap<String,Option<Expr>> {
+        let mut binds = HashMap::new();
+        // XXX: actually implement this...
+        for c in &self.components {
+            match c.prefix {
+                Some(ComponentPrefix::Constant) => { binds.insert(c.name.clone(), Some(Expr::Integer(123))); },
+                Some(ComponentPrefix::Parameter) => { binds.insert(c.name.clone(), Some(Expr::Float(4.56))); },
+                _ => (),
+            }
+        }
+        binds
+    }
+
+    // This crude function finds "unbound" variables: those which are not constants, parameters, or
+    // the sole element on the LHS of an equation.
+    // Bugs:
+    //   if a var is on LHS and RHS of same equation
+    fn get_free_vars(&self) -> Vec<String> {
+        // Start with components, and remove constants and parameters
+        let vars = self.components.iter().filter(|v| match v.prefix {
+                Some(ComponentPrefix::Constant) | Some(ComponentPrefix::Parameter) => false,
+                _ => true,
+            });
+
+        // Remove LHS (bound) vars
+        let mut outputs = vec![];
+        for eq in self.equations.iter() {
+            // TODO:
+            if let Expr::Ident(ref symb) = eq.lhs {
+                outputs.push(symb.to_string());
+            }
+        }
+        let vars = vars.filter(|v| !outputs.contains(&v.name));
+
+        vars.map(|c| c.name.clone()).collect()
+    }
+
+    // V variables
+    // Q constants (become kwargs)
+    // P bound vars (independent, inputs/passed, become like constants)
+    // M unknowns (dependent, outputs)
+    // N' total equations
+    // N equations with unknowns
+    //
+    // TODO: allow passing in Q
+    fn solve_for(&self, indep_vars: Vec<String>, dep_vars: Vec<String>) -> Result<ModelicaModel,String> {
+        let constants = self.get_constant_vars();
+        let mut all_vars: HashSet<String> = HashSet::new();
+        for eqn in &self.equations {
+            all_vars.extend(eqn.identifiers());
+        }
+
+        // check that all dep and indep are in equations
+        let mut passed_vars = indep_vars.clone();
+        passed_vars.extend(dep_vars.clone());
+        for var in passed_vars {
+            if !all_vars.contains(&var) {
+                return Err(format!("Variable not found in equations: {}", var));
+            }
+        }
+
+        // check that  V = Q + P + M
+        if all_vars.len() != (constants.len() + indep_vars.len() + dep_vars.len()) {
+            return Err(format!("Variable counts don't add up (V={} Q={} P={} M={})",
+                all_vars.len(),
+                constants.len(),
+                indep_vars.len(),
+                dep_vars.len()));
+        }
+
+        // check that all constants are bound and simple
+        for (name, value) in &constants {
+            match *value {
+                None => return Err(format!("UnderSpecifiedConstant: {}", name)),
+                Some(Expr::Integer(_)) | Some(Expr::Float(_)) => (), // Ok,
+                Some(_) => return Err(format!("NaiveImplementation: can't handle constant: {}", name)),
+            }
+        }
+
+        // check that there is a depdendent variable in each equation
+        for eqn in &self.equations {
+            if intersect_strings(&dep_vars, &eqn.identifiers()).len() == 0 {
+                return Err("NaiveImplementation/OverConstrained: at least one equation is missing a dependent variable".to_string());
+            }
+        }
+
+        // check N >= M
+        if self.equations.len() < dep_vars.len() {
+            return Err("UnderConstrained: more dependent variables than equations".to_string());
+        }
+
+        println!("Soliving for {:?} in terms of params {:?} and constants {:?}, with {} equations",
+            dep_vars, indep_vars, constants, self.equations.len());
+
+        let mut unsolved_eqns = self.equations.clone();
+        let mut solved: Vec<SimpleEquation> = vec![];
+        let mut unsolved_vars = dep_vars.clone();
+        while unsolved_eqns.len() > 0 {
+            let next_i = unsolved_eqns
+                .iter()
+                .position(|ref x| intersect_strings(&unsolved_vars, &x.identifiers()).len() == 1);
+            let eqn = match next_i {
+                None => { return Err("NaiveImplementation (or poor equation selection?)".to_string()); },
+                Some(i) => unsolved_eqns.remove(i),
+            };
+            let ref var = intersect_strings(&unsolved_vars, &eqn.identifiers())[0];
+            let eqn = eqn.rebalance_for(var.to_string()).expect("rebalance for success");
+            solved.push(eqn);
+            let var_i = unsolved_vars.iter().position(|ref x| x == &var).unwrap();
+            unsolved_vars.remove(var_i);
+        };
+
+        // TODO: sort output equations by LHS
+        Ok(ModelicaModel{
+            name: self.name.clone(),
+            components: self.components.clone(),
+            connections: vec![],
+            equations: solved,
+            extends: vec![],
+        })
+    }
+}
+
+fn intersect_strings(a: &Vec<String>, b: &Vec<String>) -> Vec<String> {
+    let mut both = vec![];
+    for e in a {
+        if b.contains(&e) {
+            both.push(e.clone());
+        }
+    }
+    both
+}
+
+pub trait SimpleEquationExt {
+    fn rebalance_for(&self, ident: String) -> Result<SimpleEquation,String>;
+    fn simplify_lhs(&self, ident: &str) -> Result<SimpleEquation,String>;
+}
+
+impl SimpleEquationExt for SimpleEquation {
+
+    fn rebalance_for(&self, ident: String) -> Result<SimpleEquation,String> {
+        let lvars = self.lhs.identifiers();
+        let rvars = self.rhs.identifiers();
+
+        let ret = match (lvars.contains(&ident), rvars.contains(&ident)) {
+            (true, true) => Err("SymbolicError: NaiveImplementation".to_string()),
+            (false, false) => Err("SymbolicError: VariableNotFound".to_string()),
+            (true, false) => self.simplify_lhs(&ident),
+            (false, true) =>
+                SimpleEquation{lhs: self.rhs.clone(),
+                               rhs: self.lhs.clone()}.simplify_lhs(&ident),
+        };
+        match ret {
+            Ok(eqn) => {
+                if eqn.rhs.contains(&ident) {
+                    Err("SymbolicError: NaiveImplementation".to_string())
+                } else {
+                    Ok(eqn)
+                }},
+            Err(_) => ret,
+        }
+    }
+
+    fn simplify_lhs(&self, ident: &str) -> Result<SimpleEquation,String> {
+        use modelica_parser::ast::Expr::*;
+        use modelica_parser::ast::BinOperator::*;
+        match self.lhs {
+            Ident(ref s) if s == ident => Ok((*self).clone()),
+            Ident(_) | Integer(_) | Float(_) =>
+                Err("SymbolicError: InternalError: expected var on LHS".to_string()),
+            Der(_) | Abs(_) =>
+                Err("SymbolicError: NaiveImplementation: can't simplify der() or abs()".to_string()),
+            // TODO: create a macro for the below...
+            BinExpr(Multiply, ref a, ref b) if a.contains(ident) => {
+                SimpleEquation{
+                    lhs: *a.clone(),
+                    rhs: BinExpr(Divide, Box::new(self.rhs.clone()), b.clone())}.simplify_lhs(&ident) },
+            BinExpr(Multiply, ref a, ref b) if b.contains(ident) => {
+                SimpleEquation{
+                    lhs: *b.clone(),
+                    rhs: BinExpr(Divide, Box::new(self.rhs.clone()), a.clone())}.simplify_lhs(&ident) },
+            BinExpr(Divide, ref a, ref b) if a.contains(ident) => {
+                SimpleEquation{
+                    lhs: *a.clone(),
+                    rhs: BinExpr(Multiply, Box::new(self.rhs.clone()), b.clone())}.simplify_lhs(&ident) },
+            BinExpr(Divide, ref a, ref b) if b.contains(ident) => {
+                SimpleEquation{
+                    lhs: *b.clone(),
+                    rhs: BinExpr(Divide, a.clone(), Box::new(self.rhs.clone()))}.simplify_lhs(&ident) },
+            BinExpr(Add, ref a, ref b) if a.contains(ident) => {
+                SimpleEquation{
+                    lhs: *a.clone(),
+                    rhs: BinExpr(Subtract, Box::new(self.rhs.clone()), b.clone())}.simplify_lhs(&ident) },
+            BinExpr(Add, ref a, ref b) if b.contains(ident) => {
+                SimpleEquation{
+                    lhs: *b.clone(),
+                    rhs: BinExpr(Subtract, Box::new(self.rhs.clone()), a.clone())}.simplify_lhs(&ident) },
+            BinExpr(Subtract, ref a, ref b) if a.contains(ident) => {
+                SimpleEquation{
+                    lhs: *a.clone(),
+                    rhs: BinExpr(Add, Box::new(self.rhs.clone()), b.clone())}.simplify_lhs(&ident) },
+            BinExpr(Subtract, ref a, ref b) if b.contains(ident) => {
+                SimpleEquation{
+                    lhs: *b.clone(),
+                    rhs: BinExpr(Subtract, a.clone(), Box::new(self.rhs.clone()))}.simplify_lhs(&ident) },
+            BinExpr(_, _, _) => Err("SymbolicError: NotImplemented BinOperator (or else couldn't find var...)".to_string()),
+            // in case we add opers: _ => Err("NotImplemented".to_string()),
+        }
+    }
+}
+