// METHODE /// <summary> /// Calcule la valeur des fonctions y et z pour la valeur de x spécifiée /// </summary> /// <param name="a_x">Valeur de x pour laquelle les fonctions doivent être calculées</param> /// <param name="a_isIterationDetailsAsked">Flag pour spécifier la sortie des itérations des calculs dans la propriété ComputationDetails</param> /// <returns>Valeurs des fonctions y et z ou null si le calcul n'est pas possible avec les paramètres définis</returns> public override double[] ComputeForGivenX(double a_x, bool a_isIterationDetailsAsked = false) { if (CheckIfComputationPossible(a_x)) { ComputationDetails = null; int index = 0; if (a_isIterationDetailsAsked) { ComputationDetails = new double[IterationNumber + 1, 3]; } double[] values = new double[3]; for (int i = 0; i < values.Length; i++) { values[i] = startingPoints[i]; } double k10, k20, k30, k40; double k11, k21, k31, k41; if (a_isIterationDetailsAsked) { for (int i = 0; i < values.Length; i++) { ComputationDetails[index, i] = values[i]; } index++; } while (values[0] < a_x) { double increment = ComputeStep; if (a_x - values[0] < ComputeStep) { increment = a_x - values[0]; } k10 = increment * Equations[0](values[0], values[1], values[2]); k20 = increment * Equations[0](values[0] + 0.5 * increment, values[1] + 0.5 * k10, values[2] + 0.5 * k10); k30 = increment * Equations[0](values[0] + 0.5 * increment, values[1] + 0.5 * k20, values[2] + 0.5 * k20); k40 = increment * Equations[0](values[0] + increment, values[1] + k30, values[2] + k30); k11 = increment * Equations[1](values[0], values[1], values[2]); k21 = increment * Equations[1](values[0] + 0.5 * increment, values[1] + 0.5 * k11, values[2] + 0.5 * k11); k31 = increment * Equations[1](values[0] + 0.5 * increment, values[1] + 0.5 * k21, values[2] + 0.5 * k21); k41 = increment * Equations[1](values[0] + increment, values[1] + k31, values[2] + k31); values[0] += increment; values[1] += (k10 + 2 * k20 + 2 * k30 + k40) / 6; values[2] += (k11 + 2 * k21 + 2 * k31 + k41) / 6; if (a_isIterationDetailsAsked && index <= IterationNumber) { for (int i = 0; i < values.Length; i++) { ComputationDetails[index, i] = values[i]; } index++; } } return(values); } return(null); }
// METHODE /// <summary> /// Calcule la valeur des fonctions y et z pour la valeur de x spécifiée /// </summary> /// <param name="a_x">Valeur de x pour laquelle les fonctions doivent être calculées</param> /// <param name="a_isIterationDetailsAsked">Flag pour spécifier la sortie des itérations des calculs dans la propriété ComputationDetails</param> /// <returns>Valeurs des fonctions y et z ou null si le calcul n'est pas possible avec les paramètres définis</returns> public override double[] ComputeForGivenX(double a_x, bool a_isIterationDetailsAsked = false) { if (CheckIfComputationPossible(a_x)) { ComputationDetails = null; int index = 0; if (a_isIterationDetailsAsked) { ComputationDetails = new double[IterationNumber + 1, 3]; } double[] values = new double[3]; for (int i = 0; i < values.Length; i++) { values[i] = startingPoints[i]; } double[] predValues = new double[3]; if (a_isIterationDetailsAsked) { for (int i = 0; i < values.Length; i++) { ComputationDetails[index, i] = values[i]; } index++; } while (values[0] < a_x) { double increment = ComputeStep; if (a_x - values[0] < ComputeStep) { increment = a_x - values[0]; } predValues[0] = values[0] + increment; predValues[1] = values[1] + increment * Equations[0](values[0], values[1], values[2]); predValues[2] = values[2] + increment * Equations[1](values[0], values[1], values[2]); double previousX = values[0]; double previousY = values[1]; double previousZ = values[2]; values[0] += increment; values[1] += 0.5 * increment * (Equations[0](previousX, previousY, previousZ) + Equations[0](predValues[0], predValues[1], predValues[2])); values[2] += 0.5 * increment * (Equations[1](previousX, previousY, previousZ) + Equations[1](predValues[0], predValues[1], predValues[2])); if (a_isIterationDetailsAsked && index <= IterationNumber) { for (int i = 0; i < values.Length; i++) { ComputationDetails[index, i] = values[i]; } index++; } } return(values); } return(null); }
public void Abs() { var abs = Equations.CreateEquation <int>("abs(x)"); Assert.AreEqual(3, abs.GetValue(-3)); Assert.AreEqual(3, abs.GetValue(3)); }
/// <summary> /// Returns a parsed equation from a string, validating that it appears to be a legitimate nth-child equation /// </summary> /// <param name="equationText"></param> /// <returns></returns> private IEquation <int> GetEquation(string equationText) { IEquation <int> equation; try { equation = Equations.CreateEquation <int>(equationText); } catch (InvalidCastException e) { throw new ArgumentException(String.Format("The equation {{0}} could not be parsed.", equationText), e); } IVariable variable; try { variable = equation.Variables.Single(); } catch (InvalidOperationException e) { throw new ArgumentException(String.Format("The equation {{0}} must contain a single variable 'n'.", equation), e); } if (variable.Name != "n") { throw new ArgumentException(String.Format("The equation {{0}} does not have a variable 'n'.", equation)); } return(equation); }
public string Solve() { Equations = Equations.OrderBy(i => i.TotalNumberOfVariables).ToList(); //Populate the Variable List List <string> variablesList = new List <string>(); foreach (var equation in Equations) { equation.PopulateVariableList(variablesList); } //Validate the Number of Variables and Number of Equations if ((variablesList.Count() - 1) < Equations.Count()) { throw new Exception("Number of Equations and Variables should be same for Linear Equation Solver"); } double[,] gaussMatrix = new double[Equations.Count(), variablesList.Count()]; //+1 for Vector //Populate Matrix for (int i = 0; i < Equations.Count(); i++) { var equation = Equations[i]; for (int j = 0; j < variablesList.Count(); j++) { gaussMatrix[i, j] = equation[variablesList[j]]; } } //Solve it by Gaussian Elimination Method return(ToString()); }
static void Main(string[] args) { Mass m = new Mass(); m.Set(100); AccelerationDueToGravity g = new AccelerationDueToGravity(); g.Set(9.81); LiftCoefficient Cl = new LiftCoefficient(); Cl.Set(.5); Density rho = new Density(); rho.Set(1.225); SurfaceArea S = new SurfaceArea(); S.Set(100); DragCoefficient Cd = new DragCoefficient(); Cd.Set(.05); var vel = Equations.GetVelocity(m, g, Cl, rho, S); Console.WriteLine(vel.Latex); var thr = Equations.GetThrust(Cd, rho, S, vel.Data); Console.WriteLine(thr.Latex); var pow1 = Equations.GetPowerForStraightLevelFlight(thr.Data, vel.Data); Console.WriteLine(pow1.Latex); var pow2 = Equations.GetPowerForStraightLevelFlight(Cd, Cl, m, g, S, rho); Console.WriteLine(pow2.Latex); Console.WriteLine(pow1.Data.Get() + " " + pow2.Data.Get()); }
public void DividedByZeroTest() { var equation = new Equations("3/0+3-4*9"); var exception = Assert.Throws <DivideByZeroException>(() => equation.Result); Assert.Equal("Can't divide by zero", exception.Message); }
public Tween(Equations type, double from, double to, Duration duration) { Equation = type; From = from; To = to; Duration = duration; }
public void ParseExpression_SimpleValidExpression_WithConstants_ShouldPass() { var exp = "2 * x - 6"; Equations.parseExpr(exp); Assert.IsTrue(true); }
public void Handle(WizardEvent <BudgetEquationWizardVM> message) { if (EquationToEdit != null && message.Status == WizardStatus.OK) { SuppressEvent = true; SaveEquation(message.Model.Equation); var equation = Equations.FirstOrDefault(x => x.Id == message.Model.Equation.Id); if (equation != null) { equation.Name = message.Model.Equation.Name; equation.IsVisible = message.Model.Equation.IsVisible; equation.Items.Clear(); equation.Items.AddRange(message.Model.Equation.Items); BudgetCalculatorEvaluator.Refresh(equation); equation.Refresh(); } else { Equations.Add(message.Model.Equation); } BudgetCalculatorEvaluator.Refresh(message.Model.Equation); SuppressEvent = false; } }
public GroupElementVector SimulatePublicNonces(Scalar challenge, IEnumerable <ScalarVector> allGivenResponses) { // The responses matrix should match the generators in the equations and Equations.CheckDimensions(allGivenResponses); return(new GroupElementVector(Enumerable.Zip(Equations, allGivenResponses, (e, r) => e.Simulate(challenge, r)))); }
public (long[][], long[][]) GetLinEqSetMatrixFast() { long m = EquationsCount; long n = VarsCount; long[][] A_p = AppHelper.CreateAmnMatrix <long>(m, n + 1); long[][] A_q = AppHelper.CreateAmnMatrix <long>(m, n + 1); for (int i = 0; i < m; i++) { for (int j = 0; j < n + 1; j++) { A_p[i][j] = 0; A_q[i][j] = 1; } } Equations.ForEach(r1 => r1.Value.ForEach( r2 => { A_p[r1.Key][r2.Key] = r2.Value.ToLong(); A_q[r1.Key][r2.Key] = 1; })); VectorB.ForEach(r => { A_p[r.Key][n] = r.Value.Value.ToLong(); A_q[r.Key][n] = 1; }); return(A_p, A_q); }
//kasseiLevel 0.0-1.0 cautiouslevel=0.0f -1.0f public void Init(float size, Vector3 pos, BassRange bassRange, int kasseiLevel, int cautiousLevel, EatType eatType, Baits[] bate) { this.parameters.bate = bate; isVisible = false; if (pos.y < Constants.Params.bassVisibleInDepth) { isVisible = true; } VisibleBass(isVisible); bassState = BassState.Back; this.parameters.eatType = eatType; moveFrequency_still = Equations.EaseInQuad(kasseiLevel, 0.07f, 0.4f, 1.0f); parameters.KASSEILEVEL = kasseiLevel; parameters.SURELEVEL = cautiousLevel; transform.localScale = new Vector3(size * Constants.BassBihaviour.sizeScallingFactor, size * Constants.BassBihaviour.sizeScallingFactor, size * Constants.BassBihaviour.sizeScallingFactor); parameters.range = bassRange; transform.position = pos; sizeNanido = Equations.EaseInQuad(transform.localScale.x, 0.0f, 2.0f, 1.0f); if (bassRange == BassRange.Top) { transform.localRotation = Quaternion.Euler(new Vector3(0.0f, 0.0f, 0.0f)); } else { transform.localRotation = Quaternion.Euler(new Vector3(0.0f, 0.0f, Random.Range(-25.0f, 25.0f))); } ChangeState(BassState.Stay); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> Constructor. </summary> /// /// <remarks> Galarist, 18/09/2018. </remarks> /// /// <param name="equation"> The equation. </param> //////////////////////////////////////////////////////////////////////////////////////////////////// public BinaryTreeNode(Equations equation) { treeEquation = equation; top = null; left = null; right = null; }
public PennerDoubleAnimation(Equations type, double from, double to, Duration duration) { Equation = type; From = from; To = to; Duration = duration; }
private void PutToLeft(PopCell cell, Equations equation) { MoveToX(cell, -cell.Width + OffsetScreenWidth, equation); cell.Y = (this.Height - cell.Height) / 2.0; MoveToScaleOpacity(cell, 0.9d, 0.7d); cell.IsHitTestVisible = false;; }
private void PutToCenter(PopCell cell, Equations equation) { MoveToX(cell, (this.Width - cell.Width) / 2.0, equation); MoveToScaleOpacity(cell, 1d, 1d); cell.Y = (this.Height - cell.Height) / 2.0; cell.IsHitTestVisible = true; }
public void FocusEquationTextBox(EquationViewModel equation) { int index = Equations.IndexOf(equation); if (index < 0) { return; } var container = (UIElement)EquationInputList.ContainerFromIndex(index); if (container != null) { container.StartBringIntoView(); var equationInput = VisualTree.FindDescendantByName(container, "EquationInputButton"); if (equationInput == null) { return; } var equationTextBox = equationInput as EquationTextBox; if (equationTextBox != null) { equationTextBox.FocusTextBox(); } } }
public void ResolveEquation_1Plus1Equals2_ShouldResolveAsManySolutions() { var exp = "1+1=2"; var actual = Equations.resolve(exp); Assert.IsTrue(actual.Item1.IsManySolutions); }
// Even if not supported by the resolver (yet), parsing should still work public void ParseEquation_SimpleEquation_WithXAndYVariable_ShouldReturnTwoComponents() { var equation = "y+1*x=1-3*x"; var actual = Equations.parse(equation); Assert.IsTrue(!actual.Item1.IsUndefined && !actual.Item2.IsUndefined); }
private void EquationTextBox_Loaded(object sender, RoutedEventArgs e) { var tb = (EquationTextBox)sender; var colorChooser = (EquationStylePanelControl)tb.ColorChooserFlyout.Content; colorChooser.AvailableColors = AvailableColors; if (m_equationToFocus != null && tb.DataContext == m_equationToFocus) { var copyEquationToFocus = m_equationToFocus; m_equationToFocus = null; tb.FocusTextBox(); int index = Equations.IndexOf(copyEquationToFocus); if (index >= 0) { var container = (UIElement)EquationInputList.ContainerFromIndex(index); if (container != null) { container.StartBringIntoView(); } } } }
public void ParseEquation_SimpleEquation_ShouldReturnTwoComponents() { var equation = "1*x+1=3"; var actual = Equations.parse(equation); Assert.IsTrue(!actual.Item1.IsUndefined && !actual.Item2.IsUndefined); }
public void ParseEquation_SimpleEquation_WithComplexContent_ShouldReturnTwoComponents() { var equation = "1+3*(x/(2 + 1))=1 * ((x+1+3) * 4) / 2"; var actual = Equations.parse(equation); Assert.IsTrue(!actual.Item1.IsUndefined && !actual.Item2.IsUndefined); }
public RationalNumber[][] GetLinEqSetMatrixOrd() { long m = EquationsCount; long n = VarsCount; RationalNumber[][] A = AppHelper.CreateAmnMatrix <RationalNumber>(m, n + 1); RationalNumber[][] A_local = A; for (int i = 0; i < m; i++) { for (int j = 0; j < n + 1; j++) { A[i][j] = new RationalNumber(0, 1); } } Equations.ForEach(r1 => r1.Value.ForEach( r2 => { A_local[r1.Key][r2.Key] = new RationalNumber(r2.Value); })); VectorB.ForEach(r => { A_local[r.Key][n] = new RationalNumber(r.Value.Value); }); return(A); }
// Even if not supported by the resolver (yet), parsing should still work public void ParseExpression_ComplexValidExpression_WithVariables_ShouldPass() { var exp = "1+1*2+x-z"; Equations.parseExpr(exp); Assert.IsTrue(true); }
public void ResolveEquation_1Equals2_ShouldResolveAsNoSolutions() { var exp = "1=2"; var actual = Equations.resolve(exp); Assert.IsTrue(actual.Item1.IsNoSolution); }
public void AddConstraints(params Equation[] constr) { foreach (var constraint in constr) { Equations.Add(constraint); } }
public void ResolveEquation_3XMinus6Equals9_ShouldResolveAs5() { var expected = 5.0d; var actual = Equations.resolve("3*x-6=9"); Assert.AreEqual(expected, actual.Item2.Value); Assert.IsTrue(actual.Item1.IsUniqueSolution); }
public void ResolveEquation_2EqualsX_ShouldResolveAs2() { var expected = 2.0d; var actual = Equations.resolve("2=x"); Assert.AreEqual(expected, actual.Item2.Value); Assert.IsTrue(actual.Item1.IsUniqueSolution); }
public void NumericEvaluate_8Div8_ShouldReturn1() { var exp = Equations.parseExpr("(2*3+2)/2"); var expected = 4.0d; var actual = Equations.evaluateExpr(exp); Assert.AreEqual(expected, actual); }
public NativeOperation(string name, params IConvertible[] operands) : base(name) { foreach (var operand in operands) { AddOperand(Equations.CreateOperand(operand)); } }
private void MoveToX(PopCell Cell, double toX, Equations equation) { isAnimating = true; PennerDoubleAnimation daX = new PennerDoubleAnimation() { To = toX, Equation = equation, FillBehavior = FillBehavior.Stop, Duration = TimeSpan.FromSeconds(0.7) }; if (equation == Equations.QuadEaseOut) { daX.Duration = TimeSpan.FromSeconds(1); } daX.Completed += delegate { Cell.X = toX; isAnimating = false; }; Cell.BeginAnimation(Canvas.LeftProperty, daX); }
public PennerDoubleAnimation(Equations type, double from, double to) { Equation = type; From = from; To = to; }
private void PutToRight(PopCell cell, Equations equation) { MoveToX(cell, this.Width - OffsetScreenWidth, equation); cell.Y = (this.Height - cell.Height) / 2.0; MoveToScaleOpacity(cell, 0.9d, 0.7d); cell.IsHitTestVisible = false; }
/// <summary> /// Returns the Equation Function based on Type /// </summary> /// <param name="EquationType">Equation Type</param> /// <returns>Returns the Equation Function</returns> private EquationFunction GetEquationFunction(Equations EquationType) { EquationFunction ResultFunction = null; switch (EquationType) { case Equations.Linear: ResultFunction = new EquationFunction(Linear); break; case Equations.QuadEaseOut: ResultFunction = new EquationFunction(QuadEaseOut); break; case Equations.QuadEaseIn: ResultFunction = new EquationFunction(QuadEaseIn); break; case Equations.QuadEaseInOut: ResultFunction = new EquationFunction(QuadEaseInOut); break; case Equations.QuadEaseOutIn: ResultFunction = new EquationFunction(QuadEaseOutIn); break; case Equations.ExpoEaseOut: ResultFunction = new EquationFunction(ExpoEaseOut); break; case Equations.ExpoEaseIn: ResultFunction = new EquationFunction(ExpoEaseIn); break; case Equations.ExpoEaseInOut: ResultFunction = new EquationFunction(ExpoEaseInOut); break; case Equations.ExpoEaseOutIn: ResultFunction = new EquationFunction(ExpoEaseOutIn); break; case Equations.CubicEaseOut: ResultFunction = new EquationFunction(CubicEaseOut); break; case Equations.CubicEaseIn: ResultFunction = new EquationFunction(CubicEaseIn); break; case Equations.CubicEaseInOut: ResultFunction = new EquationFunction(CubicEaseInOut); break; case Equations.CubicEaseOutIn: ResultFunction = new EquationFunction(CubicEaseOutIn); break; case Equations.QuartEaseOut: ResultFunction = new EquationFunction(QuartEaseOut); break; case Equations.QuartEaseIn: ResultFunction = new EquationFunction(QuartEaseIn); break; case Equations.QuartEaseInOut: ResultFunction = new EquationFunction(QuartEaseInOut); break; case Equations.QuartEaseOutIn: ResultFunction = new EquationFunction(QuartEaseOutIn); break; case Equations.QuintEaseOut: ResultFunction = new EquationFunction(QuintEaseOut); break; case Equations.QuintEaseIn: ResultFunction = new EquationFunction(QuintEaseIn); break; case Equations.QuintEaseInOut: ResultFunction = new EquationFunction(QuintEaseInOut); break; case Equations.QuintEaseOutIn: ResultFunction = new EquationFunction(QuintEaseOutIn); break; case Equations.CircEaseOut: ResultFunction = new EquationFunction(CircEaseOut); break; case Equations.CircEaseIn: ResultFunction = new EquationFunction(CircEaseIn); break; case Equations.CircEaseInOut: ResultFunction = new EquationFunction(CircEaseInOut); break; case Equations.CircEaseOutIn: ResultFunction = new EquationFunction(CircEaseOutIn); break; case Equations.SineEaseOut: ResultFunction = new EquationFunction(SineEaseOut); break; case Equations.SineEaseIn: ResultFunction = new EquationFunction(SineEaseIn); break; case Equations.SineEaseInOut: ResultFunction = new EquationFunction(SineEaseInOut); break; case Equations.SineEaseOutIn: ResultFunction = new EquationFunction(SineEaseOutIn); break; case Equations.ElasticEaseOut: ResultFunction = new EquationFunction(ElasticEaseOut); break; case Equations.ElasticEaseIn: ResultFunction = new EquationFunction(ElasticEaseIn); break; case Equations.ElasticEaseInOut: ResultFunction = new EquationFunction(ElasticEaseInOut); break; case Equations.ElasticEaseOutIn: ResultFunction = new EquationFunction(ElasticEaseOutIn); break; case Equations.BounceEaseOut: ResultFunction = new EquationFunction(BounceEaseOut); break; case Equations.BounceEaseIn: ResultFunction = new EquationFunction(BounceEaseIn); break; case Equations.BounceEaseInOut: ResultFunction = new EquationFunction(BounceEaseInOut); break; case Equations.BounceEaseOutIn: ResultFunction = new EquationFunction(BounceEaseOutIn); break; case Equations.BackEaseOut: ResultFunction = new EquationFunction(BackEaseOut); break; case Equations.BackEaseIn: ResultFunction = new EquationFunction(BackEaseIn); break; case Equations.BackEaseInOut: ResultFunction = new EquationFunction(BackEaseInOut); break; case Equations.BackEaseOutIn: ResultFunction = new EquationFunction(BackEaseOutIn); break; default: break; } return ResultFunction; }
public VCAnimationInfo() { AnimMethod = VCAnimationMethod.AnimFunction; CurveX = AnimationCurve.EaseInOut(0, 0, 1, 1); CurveY = AnimationCurve.EaseInOut(0, 0, 1, 1); CurveZ = AnimationCurve.EaseInOut(0, 0, 1, 1); XEquation = Equations.None; YEquation = Equations.None; Duration = 1; Delay = 0; }
public Tween(Equations type, double from, double to) { Equation = type; From = from; To = to; }
public VCColorInfo() { Curve = AnimationCurve.EaseInOut(0, 0, 1, 1); Equation = Equations.None; Duration = 1; Delay = 0; Start = Color.white; End = Color.white; }
private static Interpolator GetInterpolator(Equations equation) { switch (equation) { case Equations.Linear: return PennerInterpolator.Linear; case Equations.QuadEaseOut: return PennerInterpolator.QuadEaseOut; case Equations.QuadEaseIn: return PennerInterpolator.QuadEaseIn; case Equations.ExpoEaseOut: return PennerInterpolator.ExpoEaseOut; case Equations.ExpoEaseIn: return PennerInterpolator.ExpoEaseIn; case Equations.CubicEaseOut: return PennerInterpolator.CubicEaseOut; case Equations.CubicEaseIn: return PennerInterpolator.CubicEaseIn; case Equations.QuartEaseOut: return PennerInterpolator.QuarticEaseOut; case Equations.QuartEaseIn: return PennerInterpolator.QuarticEaseIn; case Equations.QuintEaseOut: return PennerInterpolator.QuinticEaseOut; case Equations.QuintEaseIn: return PennerInterpolator.QuinticEaseIn; case Equations.CircEaseOut: return PennerInterpolator.CircularEaseOut; case Equations.CircEaseIn: return PennerInterpolator.CircularEaseIn; case Equations.SineEaseOut: return PennerInterpolator.SineEaseOut; case Equations.SineEaseIn: return PennerInterpolator.SineEaseIn; case Equations.ElasticEaseOut: return PennerInterpolator.ElasticEaseOut; case Equations.ElasticEaseIn: return PennerInterpolator.ElasticEaseIn; case Equations.BounceEaseOut: return PennerInterpolator.BounceEaseOut; case Equations.BounceEaseIn: return PennerInterpolator.BounceEaseIn; case Equations.SlightBounceEaseOut: return PennerInterpolator.SlightBounceEaseOut; case Equations.SlightBounceEaseIn: return PennerInterpolator.SlightBounceEaseIn; case Equations.BackEaseOut: return PennerInterpolator.BackEaseOut; case Equations.BackEaseIn: return PennerInterpolator.BackEaseIn; } return PennerInterpolator.Linear; }