/// <summary> /// Activate record zone /// </summary> /// <param name="sender">origin</param> /// <param name="e">args</param> private void Owner_Fetch(object sender, EventArgs e) { RecordZone <Weight> recordZone = sender as RecordZone <Weight>; int h = this[hashCodeName]; foreach (Weight w in recordZone.Records) { if (w == this) { h = w.GetHashCode(); break; } } if (!recordZone.Exists(h)) { recordZone.Add(h, this); } else { Weight recorded = recordZone.Ask(h); if (recorded != this) { throw new InvalidCastException(String.Format("Weight {0} is not equals to Weight {1}", recorded.ToString(), this.ToString())); } else { this.ownerObject = recorded.ownerObject; this[hashCodeName] = h; } } }
public LoanService(ICustomerRepository repository, IPlan plan, IArithmetic arithmetic) { _arithmetic = arithmetic; _repository = repository; _plan = plan; }
/// <summary> /// Converts all sub-variables into an equation /// or into its value /// </summary> /// <returns>output new equation</returns> public override IArithmetic Converting() { if (this.IsVariableExists(this.Name)) { IArithmetic f = this.GetVariable(this.Name); if (f is Function) { Function fe = f as Function; for (int index = 0; index < fe.Parameters.Count; ++index) { if (fe.Parameters[index] is Coefficient) { Coefficient coeff = fe.Parameters[index] as Coefficient; this.AddVariable(coeff.Name, this.Parameters[index].Converting()); } if (fe.Parameters[index] is UnknownTerm) { UnknownTerm xt = fe.Parameters[index] as UnknownTerm; this.AddVariable(xt.Name, this.Parameters[index].Converting()); } if (fe.Parameters[index] is Function) { Function fun = fe.Parameters[index] as Function; this.AddVariable(fun.Name, this.Parameters[index].Converting()); } } return(fe.RightOperand.Converting()); } } return(this); }
/// <summary> /// Sum /// </summary> /// <param name="b">b coeff</param> /// <param name="xLeft">xLeft</param> /// <param name="xRight">xright</param> /// <returns>sum</returns> public double Sum(double b, double xLeft, double xRight) { IArithmetic function = ("(2*X0 + b + 1) * (1)").ToArithmetic(); function.Let("b", b); double sum = 0; function.Let("Zero", xLeft); // si b est pair double start; if (b % 2 == 0) { start = ("-(b+1)/2").ToArithmetic().Converting().ToDouble(); } else { start = ("-b/2").ToArithmetic().Converting().ToDouble(); } for (double x = start; x < xRight; ++x) { function.Let("X0", x); sum = sum + function.Converting().ToDouble(); } return(sum); }
/// <summary> /// Create an equation /// with a given operator /// and one operand /// </summary> /// <param name="op">operator name</param> /// <param name="e">operand</param> public MathematicEquation(string op, IEquation e) { if (op == OperatorPositive) { IArithmetic eqTemp = Arithmetic.EnsureSign(e.Equation); this.eq = new Positive(eqTemp); } else if (op == OperatorNegative) { IArithmetic eqTemp = Arithmetic.EnsureSign(e.Equation); this.eq = new Negative(eqTemp); } else if (op == OperatorInverse) { IArithmetic eqTemp = Arithmetic.EnsureInverse(e.Equation); this.eq = new Inverse(eqTemp); } else if (op == OperatorMultipleAdd) { this.eq = Arithmetic.EnsureSum(e.Equation, 1); } else if (op == OperatorMultipleProduct) { this.eq = Arithmetic.EnsureProduct(e.Equation, 1); } else { throw new NotSupportedException(); } }
private static T GreatestCommonDivisor <T>(T one, T two, IArithmetic <T> arithmetic) { T big = arithmetic.Max(arithmetic.Abs(one), arithmetic.Abs(two)); T small = arithmetic.Min(arithmetic.Abs(one), arithmetic.Abs(two)); T remainder = arithmetic.Modulo(big, small); return(arithmetic.Equals(remainder, arithmetic.Zero) ? small : AdvancedMath.GreatestCommonDivisor(small, remainder, arithmetic)); }
/// <summary> /// Differential DY /// </summary> /// <param name="y">y</param> /// <param name="y0">y0</param> /// <returns>value</returns> public double Differential(double y, double y0) { IArithmetic function = Polynome2.functions["DY"]; function.Let("Y", y); function.Let("Y_0", y0); return(function.Converting().ToDouble()); }
/// <summary> /// Replace an element to an another /// </summary> /// <param name="old">old element</param> /// <param name="n">new element</param> public void Replace(IArithmetic old, IArithmetic n) { int p = this.List.IndexOf(old); if (p != -1) { this.List[p] = n; } }
/// <summary> /// Gets Base X /// </summary> /// <param name="size">size of X</param> /// <returns>arithmetic function</returns> public IArithmetic GetBaseX(int size) { Base X = new Base(10, size); // creates a polynome for X GrobnerPolynome p = new GrobnerPolynome(X.Dimension - 1); IArithmetic a = p.PolynomeAsBase("n", "B"); return(a); }
/// <summary> /// Construction of elements /// with a dynamic element (not working in constructor's function) /// </summary> /// <param name="type">value type</param> /// <param name="op">operator</param> /// <param name="value">value</param> /// <param name="owner">owner object</param> protected void Construct(byte type, char op, dynamic value, IArithmetic owner) { this[typeValueName] = type; this[arithmeticOperatorName] = op; this[valueName] = value; this[hashCodeName] = owner.GetHashCode(); this.ownerObject = owner; owner.Fetch += Owner_Fetch; owner.Unfetch += Owner_Unfetch; }
/// <summary> /// Compute Y0 value /// </summary> /// <param name="x0">X0 value input</param> /// <returns>Y0 value output</returns> public double ComputeY0(double x0) { IArithmetic function = Polynome2.functions["Y_0"]; this.TermX0 = x0; function.Let("b", this.CoefficientB); function.Let("c", this.CoefficientC); function.Let("X_0", this.TermX0); return(function.Converting().Compute().ToDouble()); }
/// <summary> /// Differential DX /// </summary> /// <param name="dx">dx</param> /// <param name="x0">x0</param> /// <returns>value</returns> public double DifferentialDX(double dx, double x0) { IArithmetic function = ("DX*[DX+Y']").ToArithmetic(); IArithmetic yPrime = ("2*X_0 + b").ToArithmetic(); function.Let("b", this.CoefficientB); function.Let("c", this.CoefficientC); function.Let("Y'", yPrime); function.Let("X_0", x0); return(function.Converting().ToDouble()); }
/// <summary> /// Select all terms accordingly with model /// </summary> /// <param name="model">model to search</param> /// <returns>list of elements</returns> public override IEnumerable <IArithmetic> Select(IArithmetic model) { if (this.Value.ToString() == model.ToString()) { yield return(model); } else { yield break; } }
/// <summary> /// Differential DY /// </summary> /// <param name="y">y</param> /// <param name="y0">y0</param> /// <param name="b">coefficient b</param> /// <param name="c">coefficient c</param> /// <returns>value</returns> public double Differential(double y, double y0, double b, double c) { IArithmetic function = Polynome2.functions["DY"]; this.CoefficientB = b; this.CoefficientC = c; function.Let("b", this.CoefficientB); function.Let("c", this.CoefficientC); function.Let("Y", y); function.Let("Y_0", y0); return(function.Converting().ToDouble()); }
/// <summary> /// 分别随机符号位作成左边关系式和右边关系式 /// </summary> /// <param name="maximumLimit">最大值</param> /// <param name="signFunc">運算符取得用的表達式</param> /// <returns>計算式</returns> private Formula GetFormulaForRandomNumber(int maximumLimit, Func <SignOfOperation> signFunc) { // 對四則運算符實例進行cache管理 IArithmetic strategy = CalculateManager(signFunc()); return(strategy.CreateFormula(new ArithmeticParameter() { MaximumLimit = maximumLimit, QuestionType = QuestionType.Default, MinimumLimit = 0 })); }
/// <summary> /// Gets Base Y /// </summary> /// <param name="y">y value</param> /// <returns>arithmetic function</returns> public IArithmetic GetBaseY(double y) { Base Y = new Base(10, Base.ConvertToReadable(y, 10)); // creates a polynome for X GrobnerPolynome p = new GrobnerPolynome(Y.Dimension - 1); IArithmetic a = p.PolynomeAsBase("p", "X"); // gestion variables Dictionary <string, IArithmetic> variables = new Dictionary <string, IArithmetic>(); Arithmetic.EventAddVariable += new EventHandler <KeyValuePair <string, IArithmetic> >((o, e) => { if (e.Value != null) { if (variables.ContainsKey(e.Key)) { variables[e.Key] = e.Value; } else { variables.Add(e.Key, e.Value); } } else { if (variables.ContainsKey(e.Key)) { variables.Remove(e.Key); } } }); Arithmetic.EventGetVariable = new Func <string, IArithmetic>((s) => { if (variables.ContainsKey(s)) { return(variables[s]); } else { return(null); } }); for (int index = Y.Dimension - 1; index >= 0; --index) { a.Let("p_" + index.ToString(), Y.Vector.ElementAt(index)); } a.Let("X", this.GetBaseX(3)); return(a.Converting()); }
/// <summary> /// Calculate the result of this equation /// terms that are valued are operated with its numeric value /// </summary> /// <param name="clean">true if calculate again</param> /// <returns>string representation number or algebraic</returns> public string Calculate(bool clean) { IArithmetic output = this.eq.Compute(); if (output.IsDouble()) { return(output.ToDouble().ToString()); } else { return(output.ToString()); } }
public static void InitializeArithmetic(IArithmetic <T> implementation) { if (Implementation != null) { throw new InvalidOperationException("Arithmetic for type " + typeof(T).FullName + " has already been initialized."); } if (implementation == null) { throw new InvalidOperationException("Cannot initalize arithmetic for type " + typeof(T).FullName + " with null."); } Implementation = implementation; }
/// <summary> /// 利用算法进行异步计算 /// </summary> /// <param name="arithIden">算法标识</param> /// <param name="rawData">原始数据</param> /// <returns>带计算结果返回值的异步任务</returns> private Task <IList <Data> > CalcViaArithmeticAsyn(string arithIden, IList <Data> rawData) { Task <IList <Data> > t = new Task <IList <Data> >(() => { // 获取算法 IArithmetic arith = ArithmeticFactory.CreateArithmetic(arithIden); // 计算 IList <Data> calculatedData = null /*arith.Calculate(rawData)*/; return(calculatedData); }); return(t); }
/// <summary> /// 右側計算式集合作成并返回當前新作成的計算式 /// </summary> /// <param name="maximumLimit">計算結果最大值</param> /// <param name="leftFormulaAnswer">左側新作成計算式的結果值</param> /// <param name="signFunc">運算符取得用的表達式</param> /// <returns>新作成的計算式</returns> private Formula MakeRightFormulas(int maximumLimit, int leftFormulaAnswer, Func <SignOfOperation> signFunc) { IArithmetic strategy = CalculateManager(signFunc()); // 計算式作成(依據左邊算式的答案推算右邊的算式) Formula formula = strategy.CreateFormulaWithAnswer(new ArithmeticParameter() { MaximumLimit = maximumLimit, QuestionType = QuestionType.Default, MinimumLimit = 0 }, leftFormulaAnswer); return(formula); }
/// <summary> /// 左側計算式集合作成并返回當前新作成的計算式 /// </summary> /// <param name="maximumLimit">計算結果最大值</param> /// <param name="signFunc">運算符取得用的表達式</param> /// <returns>新作成的計算式</returns> private Formula MakeLeftFormulas(int maximumLimit, Func <SignOfOperation> signFunc) { IArithmetic strategy = CalculateManager(signFunc()); // 計算式作成 Formula formula = strategy.CreateFormula(new ArithmeticParameter() { MaximumLimit = maximumLimit, QuestionType = QuestionType.Default, MinimumLimit = 0 }); return(formula); }
/// <summary> /// Select all terms accordingly with model /// </summary> /// <param name="model">model to search</param> /// <returns>list of elements</returns> public override IEnumerable <IArithmetic> Select(IArithmetic model) { if (model.ToString() == this.InnerOperand.ToString()) { yield return(this.InnerOperand); } else { foreach (IArithmetic s in this.InnerOperand.Select(model)) { yield return(s); } } }
/// <summary> /// Compute Y0 value /// </summary> /// <param name="x0">X0 value input</param> /// <param name="b">b coefficient input</param> /// <param name="c">c coefficient input</param> /// <param name="d">d coefficient input</param> /// <returns>Y0 value output</returns> public double ComputeY0(double x0, double b, double c, double d) { IArithmetic function = Polynome3.functions["Y_0"]; this.TermX0 = x0; this.CoefficientB = b; this.CoefficientC = c; this.CoefficientD = d; function.Let("b", this.CoefficientB); function.Let("c", this.CoefficientC); function.Let("d", this.CoefficientD); function.Let("X_0", this.TermX0); return(function.Converting().Compute().ToDouble()); }
/// <summary> /// Initializes a new instance of the <see cref="CalculatorBot"/> class. /// </summary> /// <param name="configuration">The current configuration.</param> /// <param name="arithmetic">Arithmetic operations DI.</param> /// <param name="calcChatBot">Calculator Chat Bot methods DI.</param> /// <param name="telemetryClient">ApplicationInsights DI.</param> /// <param name="statistics">Statistic operations DI.</param> /// <param name="geometrics">Geometric operations DI.</param> public CalculatorBot( IConfiguration configuration, IArithmetic arithmetic, ICalcChatBot calcChatBot, TelemetryClient telemetryClient, IStatistic statistics, IGeometric geometrics) { this.configuration = configuration; this.arithmetic = arithmetic; this.telemetryClient = telemetryClient; this.calcChatBot = calcChatBot; this.statistics = statistics; this.geometrics = geometrics; }
/// <summary> /// Compute R1 /// </summary> /// <returns>return R1</returns> public double ComputeR1() { IArithmetic function = Polynome3.functions["R_1"]; function.Let("b", this.CoefficientB); function.Let("c", this.CoefficientC); function.Let("d", this.CoefficientD); function.Let("X_1", this.TermX1); function.Let("X_2", this.TermX2); function.Let("V", this.TermV); function.Let("Y", this.TermY); function.Let("A", Polynome3.functions["A"].Converting()); function.Let("U", Polynome3.functions["U"].Converting()); return(function.Converting().Compute().ToDouble()); }
/// <summary> /// 算式作成 /// </summary> /// <param name="p">題型參數</param> /// <param name="signFunc">運算符取得用的表達式</param> private void MarkFormulaList(ComputingConnectionParameter p, Func <SignOfOperation> signFunc) { // 當前反推判定次數(一次推算內次數累加) int defeated = 0; // 按照指定數量作成相應的數學計算式 for (int i = 0; i < p.NumberOfQuestions; i++) { Formula previousFormula = null; IList <Formula> formulas = new List <Formula>(); // 随机获取接龙层数 for (int j = 0; j < p.SectionNumber; j++) { // 指定運算符實例作成 IArithmetic strategy = CalculateManager(signFunc()); Formula formula = strategy.CreateFormula(new ArithmeticParameter() { MaximumLimit = p.MaximumLimit, QuestionType = QuestionType.Default, MinimumLimit = 0 }, previousFormula); if (CheckIsNeedInverseMethod(p.Formulas, formula, p.MaximumLimit)) { defeated++; // 如果大於五次則認為此題無法作成繼續下一題 if (defeated == INVERSE_NUMBER) { // 當前反推判定次數復原 defeated = 0; continue; } j--; continue; } previousFormula = formula; formulas.Add(formula); } // 當前反推判定次數復原 defeated = 0; p.Formulas.Add(new ConnectionFormula() { ConfixFormulas = formulas, ConfixNumber = formulas.Count }); } }
/// <summary> /// 算式作成 /// </summary> /// <param name="p">題型參數</param> /// <param name="signFunc">運算符取得用的表達式</param> private void MarkFormulaList(ArithmeticOperationsParameter p, Func <SignOfOperation> signFunc) { // 當前反推判定次數(一次推算內次數累加) int defeated = 0; // 按照指定數量作成相應的數學計算式 for (var i = 0; i < p.NumberOfQuestions; i++) { IArithmetic strategy = CalculateManager(signFunc()); Formula formula = strategy.CreateFormula(new ArithmeticParameter() { MaximumLimit = p.MaximumLimit, QuestionType = p.QuestionType, MinimumLimit = 0, LeftScope = p.LeftScope, RightScope = p.RightScope }); // 填空項目設定 formula.Gap = CommonUtil.GetRandomNumber(GapFilling.Left, GapFilling.Right); // 判定是否需要反推并重新作成計算式 if (CheckIsNeedInverseMethod(p, formula)) { defeated++; // 如果大於五次則認為此題無法作成繼續下一題 if (defeated == INVERSE_NUMBER) { // 當前反推判定次數復原 defeated = 0; continue; } i--; continue; } // 計算式作成 p.Formulas.Add(new ArithmeticOperationsFormula { // 四則運算式 Arithmetic = formula, // 等式值是不是出現在右邊(如果未指定則隨機產生) AnswerIsRight = p.AnswerIsRight ?? IsRight }); defeated = 0; } }
/// <summary> /// 创建算法对象 /// </summary> /// <param name="arithIden">算法标记</param> /// <returns>算法对象</returns> public static IArithmetic CreateArithmetic(string arithIden) { IArithmetic arith = null; // switch (arithIden.ToLower()) // { // case "group": // arith = new CxGroupArithmetic(); // break; // case "average": // arith = new AverageArithmetic(); // break; // } return(arith); }
/// <summary> /// Compute A value /// </summary> /// <param name="y">y search input</param> /// <param name="x1">x1 input value</param> /// <param name="x2">x2 input value</param> /// <param name="v">v input value</param> /// <returns>A value</returns> public double ComputeA(double y, double x1, double x2, double v) { IArithmetic function = Polynome3.functions["A"]; this.TermY = y; this.TermX1 = x1; this.TermX2 = x2; this.TermV = v; function.Let("b", this.CoefficientB); function.Let("c", this.CoefficientC); function.Let("d", this.CoefficientD); function.Let("X_1", this.TermX1); function.Let("X_2", this.TermX2); function.Let("V", this.TermV); return(function.Converting().Compute().ToDouble()); }
/// <summary> /// Initializes new instance of this type. /// </summary> /// <param name="implementation"><see cref="MethodCacheBase{TImplementation}.Implementation"/> property value.</param> public Arithmetic(IArithmetic <T> implementation) : base(implementation) { Provider = Implementation.Provider; Zero = Implementation.Zero; One = Implementation.One; MaxValue = Implementation.MaxValue; MinValue = Implementation.MinValue; IsSigned = Implementation.IsSigned; Add = Implementation.Add; Subtract = Implementation.Subtract; Multiply = Implementation.Multiply; Divide = Implementation.Divide; Negation = Implementation.Negation; ApplyRules = Implementation.ApplyRules; }