// 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 PennerDoubleAnimation(Equations type, double from, double to, Duration duration)
{
Equation = type;
From = from;
To = to;
Duration = duration;
}
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;
}
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;
}
