/// <summary> /// Constructor /// </summary> /// <param name="symbol">Symbol of variable</param> /// <param name="measure">Measure</param> /// <param name="detector">Detector of variables</param> internal VariableMeasurement(string symbol, IMeasurement measure, IVariableDetector detector) { this.symbol = symbol; this.measurement = measure; this.detector = detector; object par = measure.Type; if (par is IOneVariableFunction) { func = par as IOneVariableFunction; operationDetector = new OneVariableFunctionDetector(detector); funcwrapper = new OneVariableFunctionDetector(func); } else if (par is Table2D) { table2D = par as Table2D; } else if (par is Table3D) { table3D = par as Table3D; } /*!!! else if (par is FuncReturn) * { * funcReturn = par as FuncReturn; * //operationDetector = new FormulaEditor.Func.FuncDetector(detector, ) * }*/ else { acceptor = this; } tree = new ObjectFormulaTree(this, new List <ObjectFormulaTree>()); }
/// <summary> /// Detects operation /// </summary> /// <param name="s">First symbol of the formula</param> /// <returns>Acceptor of operation</returns> public IOperationAcceptor Detect(MathSymbol s) { IOperationAcceptor acc = detector.Detect(s); if (acc == null) { return(null); } if (acc is IMultiVariableOperationAcceptor) { return(new MultiVariableArrayOperationAcceptor(acc as IMultiVariableOperationAcceptor)); } return(new ArrayOperationAcceptor(acc)); }
/// <summary> /// Adds acceptor /// </summary> /// <param name="type">Return type</param> /// <param name="acc">Acceptor to add</param> public void Add(object type, IOperationAcceptor acc) { List <IOperationAcceptor> l = null; if (addAcceptors.ContainsKey(type)) { l = addAcceptors[type]; } else { l = new List <IOperationAcceptor>(); addAcceptors[type] = l; } l.Add(acc); }
/// <summary> /// Sets operations to formula /// </summary> /// <param name="formula">The formula</param> /// <param name="table">Table of operations</param> public static void SetOperations(MathFormula formula, Dictionary <int, IOperationAcceptor> table) { for (int i = 0; i < formula.Count; i++) { MathSymbol s = formula[i]; for (int j = 0; j < s.Count; j++) { SetOperations(s[j], table); } if (!(s is SeriesSymbol)) { continue; } SeriesSymbol ss = s as SeriesSymbol; int ind = ss.index; ss.acceptor = null; if (!table.ContainsKey(ind)) { throw new Exception("Operation with index " + ind + " does not exist"); } IOperationAcceptor acc = table[ind]; ss.acceptor = acc; } }
/// <summary> /// Implements the Visitor design pattern. /// </summary> /// <param name="acceptor"> /// The object accepting this operation. /// </param> public override void Visit(IOperationAcceptor acceptor) { Guard.NotNull(acceptor, nameof(acceptor)); acceptor.Accept(this); }
/// <summary> /// Implements the Visitor design pattern. /// </summary> /// <param name="acceptor"> /// The object accepting this operation. /// </param> public override void Visit(IOperationAcceptor acceptor) { }
/// <summary> /// Constructor /// </summary> /// <param name="acceptor">Prototype acceptor</param> public ArrayOperationAcceptor(IOperationAcceptor acceptor) { this.acceptor = acceptor; }
/// <summary> /// Detects operation /// </summary> /// <param name="s">First symbol of the formula</param> /// <returns>Acceptor of operation</returns> public override IOperationAcceptor Detect(MathSymbol s) { //Double a = 0; if (s.Symbol == '~') { return(new BitwiseOperation()); } if (s.Symbol == '¬') { return(NegationOperation.Object); } if (s.Symbol == '-') { return(Minus); } if (s.Symbol == '\u03B4') { return(new DeltaFunction()); } if (s is SeriesSymbol) { SeriesSymbol ss = s as SeriesSymbol; if (ss.Acceptor is IUnary) { return(new ElementaryUnaryOperation(ss.Acceptor as IUnary, ss.Index)); } return(ss.Acceptor); } if (s is TernaryFunctionSymbol) { if (s.Symbol == '3') { return(TernaryBrackets.Singleton); } } if (s is BinaryFunctionSymbol) { if (s.Symbol == '2') { return(BinaryBrackets.Singleton); } return(ElementaryAtan2.Object); } if (s is RootSymbol) { return(new ElementaryRoot()); } if (s is FractionSymbol) { return(ElementaryFraction.Object); } if (s is BracketsSymbol) { return(Brakets); } if (s is SubscriptedSymbol) { SubscriptedSymbol sym = s as SubscriptedSymbol; if (table != null) { } return(new ElementaryObjectVariable(sym.Pair, table)); } if (s.SymbolType == (byte)FormulaConstants.Variable) { if (s.Symbol == '%') { return(new TranscredentRealConstant('p')); } if (s.Symbol == 'e') { return(new TranscredentRealConstant('e')); } if (s.String.Equals("True")) { return(new BooleanConstant(true)); } if (s.String.Equals("False")) { return(new BooleanConstant(false)); } IOperationAcceptor var = detector.Detect(s); if (var != null) { return(var); } else { return(null); } } if (s.SymbolType == (byte)FormulaConstants.Number) { if (s.Symbol == '?') { return(new ElementaryRealConstant(s.DoubleValue)); } else { return(new ElementaryULongConstant(s.ULongValue)); } } if (s.SymbolType == (byte)FormulaConstants.Unary & s.Symbol != '\u2211' & !(s.Symbol + "").Equals("'")) { string str = s.Symbol + ""; if (str.Equals(str.ToLower())) { if (s.Symbol == 'w') { return(new TimeOperation()); } if (s.Symbol == 'o') { return(TimeToDoubleOperation.Object); } return(new ElementaryFunctionOperation(s.Symbol)); } return(new ElementaryIntegerOperation(s.Symbol)); } return(null); }
/// <summary> /// Processes ordinary operation /// </summary> /// <param name="formula">Formula</param> /// <param name="creator">Formula creator</param> /// <returns>True if operation exists and false otherwise</returns> protected bool processOperation(MathFormula formula, IFormulaObjectCreator creator) { int braCount = 0; ObjectFormulaTree tree = null; for (int i = 0; i < creator.OperationCount; i++) { IOperationDetector detector = creator.GetDetector(i); IOperationAcceptor acceptor = detector.Detect(formula[braCount]); if (acceptor == null) { continue; } TypeInfo dt = detector.ToTypeInfo(); TreeTransformationAttribute attr = detector.GetAttribute <TreeTransformationAttribute>(); if (attr != null) { ITreeTransformation trans = acceptor as ITreeTransformation; if (tree == null) { tree = CreateTree(new MathFormula(formula, 2 * braCount + 1, formula.Count - 1), creator); } if (tree != null) { ObjectFormulaTree tr = trans.Transform(tree); if (tr != null) { operation = tr.operation; children = tr.children; y = tr.y; return(true); } } } object type = null; if (formula.Count > 1) { if (tree == null) { tree = CreateTree(new MathFormula(formula, 2 * braCount + 1, formula.Count - 1), creator); } type = tree.ReturnType; } if (acceptor is IMultiVariableOperationAcceptor) { IMultiVariableOperationAcceptor ma = acceptor as IMultiVariableOperationAcceptor; IMultiVariableOperation multiOp = ma.AcceptOperation(formula[0]); MathSymbol s = formula[0]; ObjectFormulaTree[] trees = null; object[] types = null; if (s.HasChildren) { int n = 0; for (int j = 0; j < s.Count; j++) { if (s[j] != null) { if (!s[j].IsEmpty) { ++n; } } } trees = new ObjectFormulaTree[n]; types = new object[n]; n = 0; for (int j = 0; j < s.Count; j++) { if (s[j] != null) { if (!s[j].IsEmpty) { ObjectFormulaTree tr = CreateTree(s[j], creator); if (tr == null) { operation = null; goto mo; } trees[j] = tr; types[j] = trees[j].ReturnType; ++n; } } } } operation = multiOp.Accept(types); mo: if (operation == null) { continue; } y = new object[types.Length]; if (trees != null) { foreach (ObjectFormulaTree t in trees) { if (t != null) { children.Add(t); } } } return(true); } IObjectOperation op = acceptor.Accept(type); if (op != null) { if (op.IsPowered()) { if (formula.First.HasChildren) { ObjectFormulaTree pow = CreateTree(formula.First[0], creator); ObjectFormulaTree val = new ObjectFormulaTree(); val.operation = op; val.y = new object[op.InputTypes.Length]; val.CreateResult(); if (tree != null) { val.children.Add(tree); } IObjectOperation powOp = creator.GetPowerOperation(val.ReturnType, pow.ReturnType); if (powOp == null) { return(false); } operation = powOp; children.Add(val); children.Add(pow); y = new object[2]; return(true); } } operation = op; if (tree != null) { children.Add(tree); y = new object[1]; } return(true); } } return(false); }
/// <summary> /// Implements the Visitor design pattern. /// </summary> /// <param name="acceptor"> /// The object accepting this operation. /// </param> public abstract void Visit(IOperationAcceptor acceptor);