public RatingStars() : base()
{
Grid grid = new Grid();
grid.ColumnSpacing = 28;
//Create Star Image Placeholders
StarImages = new List <CachedImage>();
for (int i = 0; i < 5; i++)
{
StarImages.Add(new CachedImage()
{
HorizontalOptions = LayoutOptions.Start
});
// add image
grid.Children.Add(StarImages[i], i + 1, 0);
}
// add slider for pan gesture
Slider = new TransparentSlider();
Slider.Maximum = Precision.Equals(PrecisionType.Half) ? 10 : 5;
Slider.Opacity = Device.OnPlatform(1, 0, 0);
Slider.ValueChanged += OnRatingValueChanged;
Grid.SetColumnSpan(Slider, 6);
grid.Children.Add(Slider);
this.Content = grid;
}
/// <summary>
/// Show a message if the specified value is 0.
/// </summary>
/// <param name="value">The value to check.</param>
/// <param name="precision">The acceptable difference when comparing the floating point value.</param>
/// <param name="message">The message to show.</param>
/// <param name="args">The arguments to the message to display.</param>
/// <returns>
/// True only if the assert condition passed. Otherwise false.
/// </returns>
public bool IsNotZero(double value, double precision, string message, params object[] args)
{
return(this.Check(
AssertType.IsNotZero,
!Precision.Equals(value, 0, precision),
message,
args,
"IsNotZero check failed."));
}
/// <summary>
/// Show a message if the specified values are equal.
/// </summary>
/// <param name="a">The first value to compare.</param>
/// <param name="b">The second value to compare.</param>
/// <param name="precision">The acceptable difference when comparing the floating point value.</param>
/// <param name="message">The message to show.</param>
/// <param name="args">The arguments to the message to display.</param>
/// <returns>
/// True only if the assert condition passed. Otherwise false.
/// </returns>
public bool AreNotEqual(double a, double b, double precision, string message, params object[] args)
{
return(this.Check(
AssertType.AreNotEqual,
!Precision.Equals(a, b, precision),
message,
args,
"AreNotEqual check failed. [{0}, {1}]",
a,
b));
}
/// <summary>
/// Show a message if the specified values are not equal.
/// </summary>
/// <param name="a">The first value to compare.</param>
/// <param name="b">The second value to compare.</param>
/// <param name="precision">The acceptable difference when comparing the floating point value.</param>
/// <param name="message">The message to show.</param>
/// <param name="args">The arguments to the message to display.</param>
/// <returns>
/// True only if the assert condition passed. Otherwise false.
/// </returns>
public bool AreEqual(float a, float b, float precision, string message, params object[] args)
{
return(this.Check(
AssertType.AreEqual,
Precision.Equals(a, b, precision),
message,
args,
"AreEqual check failed. [{0}, {1}]",
a,
b));
}
/// <summary>
/// Solves Phase 1 of the Simplex method.
/// </summary>
/// <param name="tableau"></param>
protected void SolvePhase1(SimplexTableau <T, TPolicy> tableau)
{
// make sure we're in Phase 1
if (tableau.NumArtificialVariables == 0)
{
return;
}
while (!tableau.IsOptimal())
{
DoIteration(tableau);
}
// if W is not zero then we have no feasible solution
if (!Precision <T, TPolicy> .Equals(tableau.GetEntry(0, tableau.RhsOffset), Policy.Zero(), epsilon))
{
throw new NoFeasibleSolutionException();
}
}
private ImageSource GetStarSource(int position)
{
int currentStarMaxRating = (position + 1);
if (Precision.Equals(PrecisionType.Half))
{
currentStarMaxRating *= 2;
}
if (Rating >= currentStarMaxRating)
{
return(ImageFullStar);
}
else if (Rating >= currentStarMaxRating - 1 && Precision.Equals(PrecisionType.Half))
{
return(ImageHalfStar);
}
else
{
return(ImageEmptyStar);
}
}
public static bool Compare(this CompareOperation operation, float a, float b, float precision)
{
switch (operation)
{
case CompareOperation.Equal:
return(Precision.Equals(a, b, precision));
case CompareOperation.Greater:
return(Precision.CompareTo(a, b, precision) > 0);
case CompareOperation.GreaterEqual:
return(Precision.CompareTo(a, b, precision) >= 0);
case CompareOperation.Less:
return(Precision.CompareTo(a, b, precision) < 0);
case CompareOperation.LessEqual:
return(Precision.CompareTo(a, b, precision) <= 0);
default:
throw new ArgumentOutOfRangeException(nameof(operation), operation, null);
}
}
/// <summary>
/// {@inheritDoc}
/// </summary>
protected internal override double DoSolve()
{
// prepare arrays with the first points
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double[] x = new double[maximalOrder + 1];
double[] x = new double[maximalOrder + 1];
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double[] y = new double[maximalOrder + 1];
double[] y = new double[maximalOrder + 1];
x[0] = GetMin();
x[1] = GetStartValue();
x[2] = GetMax();
VerifySequence(x[0], x[1], x[2]);
// evaluate initial guess
y[1] = ComputeObjectiveValue(x[1]);
if (Precision.Equals(y[1], 0.0, 1))
{
// return the initial guess if it is a perfect root.
return(x[1]);
}
// evaluate first endpoint
y[0] = ComputeObjectiveValue(x[0]);
if (Precision.Equals(y[0], 0.0, 1))
{
// return the first endpoint if it is a perfect root.
return(x[0]);
}
int nbPoints;
int signChangeIndex;
if (y[0] * y[1] < 0)
{
// reduce interval if it brackets the root
nbPoints = 2;
signChangeIndex = 1;
}
else
{
// evaluate second endpoint
y[2] = ComputeObjectiveValue(x[2]);
if (Precision.Equals(y[2], 0.0, 1))
{
// return the second endpoint if it is a perfect root.
return(x[2]);
}
if (y[1] * y[2] < 0)
{
// use all computed point as a start sampling array for solving
nbPoints = 3;
signChangeIndex = 2;
}
else
{
throw new NoBracketingException(x[0], x[2], y[0], y[2]);
}
}
// prepare a work array for inverse polynomial interpolation
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double[] tmpX = new double[x.length];
double[] tmpX = new double[x.Length];
// current tightest bracketing of the root
double xA = x[signChangeIndex - 1];
double yA = y[signChangeIndex - 1];
double absYA = FastMath.Abs(yA);
int agingA = 0;
double xB = x[signChangeIndex];
double yB = y[signChangeIndex];
double absYB = FastMath.Abs(yB);
int agingB = 0;
// search loop
while (true)
{
// check convergence of bracketing interval
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double xTol = getAbsoluteAccuracy() + getRelativeAccuracy() * org.apache.commons.math3.util.FastMath.max(org.apache.commons.math3.util.FastMath.abs(xA), org.apache.commons.math3.util.FastMath.abs(xB));
double xTol = GetAbsoluteAccuracy() + GetRelativeAccuracy() * FastMath.Max(FastMath.Abs(xA), FastMath.Abs(xB));
if (((xB - xA) <= xTol) || (FastMath.Max(absYA, absYB) < GetFunctionValueAccuracy()))
{
switch (allowed)
{
case org.apache.commons.math3.analysis.solvers.AllowedSolution.ANY_SIDE:
return(absYA < absYB ? xA : xB);
case org.apache.commons.math3.analysis.solvers.AllowedSolution.LEFT_SIDE:
return(xA);
case org.apache.commons.math3.analysis.solvers.AllowedSolution.RIGHT_SIDE:
return(xB);
case org.apache.commons.math3.analysis.solvers.AllowedSolution.BELOW_SIDE:
return((yA <= 0) ? xA : xB);
case org.apache.commons.math3.analysis.solvers.AllowedSolution.ABOVE_SIDE:
return((yA < 0) ? xB : xA);
default:
// this should never happen
throw new MathInternalError();
}
}
// target for the next evaluation point
double targetY;
if (agingA >= MAXIMAL_AGING)
{
// we keep updating the high bracket, try to compensate this
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int p = agingA - MAXIMAL_AGING;
int p = agingA - MAXIMAL_AGING;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double weightA = (1 << p) - 1;
double weightA = (1 << p) - 1;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double weightB = p + 1;
double weightB = p + 1;
targetY = (weightA * yA - weightB * REDUCTION_FACTOR * yB) / (weightA + weightB);
}
else if (agingB >= MAXIMAL_AGING)
{
// we keep updating the low bracket, try to compensate this
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int p = agingB - MAXIMAL_AGING;
int p = agingB - MAXIMAL_AGING;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double weightA = p + 1;
double weightA = p + 1;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double weightB = (1 << p) - 1;
double weightB = (1 << p) - 1;
targetY = (weightB * yB - weightA * REDUCTION_FACTOR * yA) / (weightA + weightB);
}
else
{
// bracketing is balanced, try to find the root itself
targetY = 0;
}
// make a few attempts to guess a root,
double nextX;
int start = 0;
int end = nbPoints;
do
{
// guess a value for current target, using inverse polynomial interpolation
Array.Copy(x, start, tmpX, start, end - start);
nextX = GuessX(targetY, tmpX, y, start, end);
if (!((nextX > xA) && (nextX < xB)))
{
// the guessed root is not strictly inside of the tightest bracketing interval
// the guessed root is either not strictly inside the interval or it
// is a NaN (which occurs when some sampling points share the same y)
// we try again with a lower interpolation order
if (signChangeIndex - start >= end - signChangeIndex)
{
// we have more points before the sign change, drop the lowest point
++start;
}
else
{
// we have more points after sign change, drop the highest point
--end;
}
// we need to do one more attempt
nextX = Double.NaN;
}
} while (double.IsNaN(nextX) && (end - start > 1));
if (double.IsNaN(nextX))
{
// fall back to bisection
nextX = xA + 0.5 * (xB - xA);
start = signChangeIndex - 1;
end = signChangeIndex;
}
// evaluate the function at the guessed root
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double nextY = computeObjectiveValue(nextX);
double nextY = ComputeObjectiveValue(nextX);
if (Precision.Equals(nextY, 0.0, 1))
{
// we have found an exact root, since it is not an approximation
// we don't need to bother about the allowed solutions setting
return(nextX);
}
if ((nbPoints > 2) && (end - start != nbPoints))
{
// we have been forced to ignore some points to keep bracketing,
// they are probably too far from the root, drop them from now on
nbPoints = end - start;
Array.Copy(x, start, x, 0, nbPoints);
Array.Copy(y, start, y, 0, nbPoints);
signChangeIndex -= start;
}
else if (nbPoints == x.Length)
{
// we have to drop one point in order to insert the new one
nbPoints--;
// keep the tightest bracketing interval as centered as possible
if (signChangeIndex >= (x.Length + 1) / 2)
{
// we drop the lowest point, we have to shift the arrays and the index
Array.Copy(x, 1, x, 0, nbPoints);
Array.Copy(y, 1, y, 0, nbPoints);
--signChangeIndex;
}
}
// insert the last computed point
//(by construction, we know it lies inside the tightest bracketing interval)
Array.Copy(x, signChangeIndex, x, signChangeIndex + 1, nbPoints - signChangeIndex);
x[signChangeIndex] = nextX;
Array.Copy(y, signChangeIndex, y, signChangeIndex + 1, nbPoints - signChangeIndex);
y[signChangeIndex] = nextY;
++nbPoints;
// update the bracketing interval
if (nextY * yA <= 0)
{
// the sign change occurs before the inserted point
xB = nextX;
yB = nextY;
absYB = FastMath.Abs(yB);
++agingA;
agingB = 0;
}
else
{
// the sign change occurs after the inserted point
xA = nextX;
yA = nextY;
absYA = FastMath.Abs(yA);
agingA = 0;
++agingB;
// update the sign change index
signChangeIndex++;
}
}
}
public void Equals_double(double a, double b, double precision, int ulp, bool expected)
{
Validate.Value.AreEqual(Precision.Equals(a, b, precision), expected);
Validate.Value.AreEqual(Precision.Equals(a, b, ulp), expected);
}
public void Equals_float(float a, float b, float precision, int ulp, bool expected)
{
Validate.Value.AreEqual(Precision.Equals(a, b, precision), expected);
Validate.Value.AreEqual(Precision.Equals(a, b, ulp), expected);
}
/// <summary>
/// Solve for a zero in the given interval, start at {@code startValue}.
/// A solver may require that the interval brackets a single zero root.
/// Solvers that do require bracketing should be able to handle the case
/// where one of the endpoints is itself a root.
/// </summary>
/// <param name="maxEval"> Maximum number of evaluations. </param>
/// <param name="f"> Function to solve. </param>
/// <param name="min"> Lower bound for the interval. </param>
/// <param name="max"> Upper bound for the interval. </param>
/// <param name="startValue"> Start value to use. </param>
/// <param name="allowedSolution"> The kind of solutions that the root-finding algorithm may
/// accept as solutions. </param>
/// <returns> a value where the function is zero. </returns>
/// <exception cref="NullArgumentException"> if f is null. </exception>
/// <exception cref="NoBracketingException"> if root cannot be bracketed </exception>
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: public T solve(final int maxEval, final org.apache.commons.math3.analysis.RealFieldUnivariateFunction<T> f, final T min, final T max, final T startValue, final AllowedSolution allowedSolution) throws org.apache.commons.math3.exception.NullArgumentException, org.apache.commons.math3.exception.NoBracketingException
public virtual T Solve(int maxEval, RealFieldUnivariateFunction <T> f, T min, T max, T startValue, AllowedSolution allowedSolution)
{
// Checks.
MathUtils.CheckNotNull(f);
// Reset.
evaluations = evaluations.WithMaximalCount(maxEval).withStart(0);
T zero = field.GetZero();
T nan = zero.add(Double.NaN);
// prepare arrays with the first points
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final T[] x = org.apache.commons.math3.util.MathArrays.buildArray(field, maximalOrder + 1);
T[] x = MathArrays.BuildArray(field, maximalOrder + 1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final T[] y = org.apache.commons.math3.util.MathArrays.buildArray(field, maximalOrder + 1);
T[] y = MathArrays.BuildArray(field, maximalOrder + 1);
x[0] = min;
x[1] = startValue;
x[2] = max;
// evaluate initial guess
evaluations.Increment();
y[1] = f.Value(x[1]);
if (Precision.Equals(y[1].getReal(), 0.0, 1))
{
// return the initial guess if it is a perfect root.
return(x[1]);
}
// evaluate first endpoint
evaluations.Increment();
y[0] = f.Value(x[0]);
if (Precision.Equals(y[0].getReal(), 0.0, 1))
{
// return the first endpoint if it is a perfect root.
return(x[0]);
}
int nbPoints;
int signChangeIndex;
if (y[0].multiply(y[1]).getReal() < 0)
{
// reduce interval if it brackets the root
nbPoints = 2;
signChangeIndex = 1;
}
else
{
// evaluate second endpoint
evaluations.Increment();
y[2] = f.Value(x[2]);
if (Precision.Equals(y[2].getReal(), 0.0, 1))
{
// return the second endpoint if it is a perfect root.
return(x[2]);
}
if (y[1].multiply(y[2]).getReal() < 0)
{
// use all computed point as a start sampling array for solving
nbPoints = 3;
signChangeIndex = 2;
}
else
{
throw new NoBracketingException(x[0].getReal(), x[2].getReal(), y[0].getReal(), y[2].getReal());
}
}
// prepare a work array for inverse polynomial interpolation
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final T[] tmpX = org.apache.commons.math3.util.MathArrays.buildArray(field, x.length);
T[] tmpX = MathArrays.BuildArray(field, x.Length);
// current tightest bracketing of the root
T xA = x[signChangeIndex - 1];
T yA = y[signChangeIndex - 1];
T absXA = xA.abs();
T absYA = yA.abs();
int agingA = 0;
T xB = x[signChangeIndex];
T yB = y[signChangeIndex];
T absXB = xB.abs();
T absYB = yB.abs();
int agingB = 0;
// search loop
while (true)
{
// check convergence of bracketing interval
T maxX = absXA.subtract(absXB).getReal() < 0 ? absXB : absXA;
T maxY = absYA.subtract(absYB).getReal() < 0 ? absYB : absYA;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final T xTol = absoluteAccuracy.add(relativeAccuracy.multiply(maxX));
T xTol = absoluteAccuracy.add(relativeAccuracy.multiply(maxX));
if (xB.subtract(xA).subtract(xTol).getReal() <= 0 || maxY.subtract(functionValueAccuracy).getReal() < 0)
{
switch (allowedSolution)
{
case org.apache.commons.math3.analysis.solvers.AllowedSolution.ANY_SIDE:
return(absYA.subtract(absYB).getReal() < 0 ? xA : xB);
case org.apache.commons.math3.analysis.solvers.AllowedSolution.LEFT_SIDE:
return(xA);
case org.apache.commons.math3.analysis.solvers.AllowedSolution.RIGHT_SIDE:
return(xB);
case org.apache.commons.math3.analysis.solvers.AllowedSolution.BELOW_SIDE:
return(yA.getReal() <= 0 ? xA : xB);
case org.apache.commons.math3.analysis.solvers.AllowedSolution.ABOVE_SIDE:
return(yA.getReal() < 0 ? xB : xA);
default:
// this should never happen
throw new MathInternalError(null);
}
}
// target for the next evaluation point
T targetY;
if (agingA >= MAXIMAL_AGING)
{
// we keep updating the high bracket, try to compensate this
targetY = yB.divide(16).negate();
}
else if (agingB >= MAXIMAL_AGING)
{
// we keep updating the low bracket, try to compensate this
targetY = yA.divide(16).negate();
}
else
{
// bracketing is balanced, try to find the root itself
targetY = zero;
}
// make a few attempts to guess a root,
T nextX;
int start = 0;
int end = nbPoints;
do
{
// guess a value for current target, using inverse polynomial interpolation
Array.Copy(x, start, tmpX, start, end - start);
nextX = GuessX(targetY, tmpX, y, start, end);
if (!((nextX.subtract(xA).getReal() > 0) && (nextX.subtract(xB).getReal() < 0)))
{
// the guessed root is not strictly inside of the tightest bracketing interval
// the guessed root is either not strictly inside the interval or it
// is a NaN (which occurs when some sampling points share the same y)
// we try again with a lower interpolation order
if (signChangeIndex - start >= end - signChangeIndex)
{
// we have more points before the sign change, drop the lowest point
++start;
}
else
{
// we have more points after sign change, drop the highest point
--end;
}
// we need to do one more attempt
nextX = nan;
}
} while (double.IsNaN(nextX.getReal()) && (end - start > 1));
if (double.IsNaN(nextX.getReal()))
{
// fall back to bisection
nextX = xA.add(xB.subtract(xA).divide(2));
start = signChangeIndex - 1;
end = signChangeIndex;
}
// evaluate the function at the guessed root
evaluations.Increment();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final T nextY = f.value(nextX);
T nextY = f.Value(nextX);
if (Precision.Equals(nextY.getReal(), 0.0, 1))
{
// we have found an exact root, since it is not an approximation
// we don't need to bother about the allowed solutions setting
return(nextX);
}
if ((nbPoints > 2) && (end - start != nbPoints))
{
// we have been forced to ignore some points to keep bracketing,
// they are probably too far from the root, drop them from now on
nbPoints = end - start;
Array.Copy(x, start, x, 0, nbPoints);
Array.Copy(y, start, y, 0, nbPoints);
signChangeIndex -= start;
}
else if (nbPoints == x.Length)
{
// we have to drop one point in order to insert the new one
nbPoints--;
// keep the tightest bracketing interval as centered as possible
if (signChangeIndex >= (x.Length + 1) / 2)
{
// we drop the lowest point, we have to shift the arrays and the index
Array.Copy(x, 1, x, 0, nbPoints);
Array.Copy(y, 1, y, 0, nbPoints);
--signChangeIndex;
}
}
// insert the last computed point
//(by construction, we know it lies inside the tightest bracketing interval)
Array.Copy(x, signChangeIndex, x, signChangeIndex + 1, nbPoints - signChangeIndex);
x[signChangeIndex] = nextX;
Array.Copy(y, signChangeIndex, y, signChangeIndex + 1, nbPoints - signChangeIndex);
y[signChangeIndex] = nextY;
++nbPoints;
// update the bracketing interval
if (nextY.multiply(yA).getReal() <= 0)
{
// the sign change occurs before the inserted point
xB = nextX;
yB = nextY;
absYB = yB.abs();
++agingA;
agingB = 0;
}
else
{
// the sign change occurs after the inserted point
xA = nextX;
yA = nextY;
absYA = yA.abs();
agingA = 0;
++agingB;
// update the sign change index
signChangeIndex++;
}
}
}
/// <summary>
/// Returns the row with the minimum ratio as given by the minimum ratio test (MRT).
/// </summary>
/// <param name="tableau"></param>
/// <param name="col"></param>
/// <returns></returns>
private int?GetPivotRow(SimplexTableau <T, TPolicy> tableau, int col)
{
// create a list of all the rows that tie for the lowest score in the minimum ratio test
List <int?> minRatioPositions = new List <int?>();
T minRatio = default(T);
bool minRationUnassigned = true;
for (int i = tableau.NumObjectiveFunctions; i < tableau.Height; i++)
{
T rhs = tableau.GetEntry(i, tableau.Width - 1);
T entry = tableau.GetEntry(i, col);
// only consider pivot elements larger than the cutOff threshold
// selecting others may lead to degeneracy or numerical instabilities
if (Precision <T, TPolicy> .CompareTo(entry, Policy.Zero(), cutOff) > 0)
{
T ratio = Policy.Abs(Policy.Div(rhs, entry));
// check if the entry is strictly equal to the current min ratio
// do not use a ulp/epsilon check
int cmp;
if (minRationUnassigned)
{
cmp = -1;
}
else
{
cmp = Policy.Compare(ratio, minRatio);
}
if (cmp == 0)
{
minRatioPositions.Add(i);
}
else if (cmp < 0)
{
minRatio = ratio;
minRationUnassigned = false;
minRatioPositions.Clear();
minRatioPositions.Add(i);
}
}
}
if (minRatioPositions.Count == 0)
{
return(null);
}
else if (minRatioPositions.Count > 1)
{
// there's a degeneracy as indicated by a tie in the minimum ratio test
// 1. check if there's an artificial variable that can be forced out of the basis
if (tableau.NumArtificialVariables > 0)
{
foreach (int?row in minRatioPositions)
{
for (int i = 0; i < tableau.NumArtificialVariables; i++)
{
int column = i + tableau.ArtificialVariableOffset;
T entry = tableau.GetEntry(row.Value, column);
if (Precision <T, TPolicy> .Equals(entry, Policy.One(), epsilon) && row.Equals(tableau.GetBasicRow(column)))
{
return(row);
}
}
}
}
// 2. apply Bland's rule to prevent cycling:
// take the row for which the corresponding basic variable has the smallest index
//
// see http://www.stanford.edu/class/msande310/blandrule.pdf
// see http://en.wikipedia.org/wiki/Bland%27s_rule (not equivalent to the above paper)
int?minRow = null;
int minIndex = tableau.Width;
foreach (int?row in minRatioPositions)
{
int basicVar = tableau.GetBasicVariable(row.Value);
if (basicVar < minIndex)
{
minIndex = basicVar;
minRow = row;
}
}
return(minRow);
}
return(minRatioPositions[0]);
}
/// <summary>
/// Returns true if CoinInfo instances are equal
/// </summary>
/// <param name="other">Instance of CoinInfo to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(CoinInfo other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
CoinType == other.CoinType ||
CoinType != null &&
CoinType.Equals(other.CoinType)
) &&
(
WalletName == other.WalletName ||
WalletName != null &&
WalletName.Equals(other.WalletName)
) &&
(
Name == other.Name ||
Name != null &&
Name.Equals(other.Name)
) &&
(
Symbol == other.Symbol ||
Symbol != null &&
Symbol.Equals(other.Symbol)
) &&
(
WalletSymbol == other.WalletSymbol ||
WalletSymbol != null &&
WalletSymbol.Equals(other.WalletSymbol)
) &&
(
WalletType == other.WalletType ||
WalletType != null &&
WalletType.Equals(other.WalletType)
) &&
(
TransactionFee == other.TransactionFee ||
TransactionFee != null &&
TransactionFee.Equals(other.TransactionFee)
) &&
(
Precision == other.Precision ||
Precision != null &&
Precision.Equals(other.Precision)
) &&
(
BackingCoinType == other.BackingCoinType ||
BackingCoinType != null &&
BackingCoinType.Equals(other.BackingCoinType)
) &&
(
SupportsOutputMemos == other.SupportsOutputMemos ||
SupportsOutputMemos != null &&
SupportsOutputMemos.Equals(other.SupportsOutputMemos)
) &&
(
Restricted == other.Restricted ||
Restricted != null &&
Restricted.Equals(other.Restricted)
) &&
(
Authorized == other.Authorized ||
Authorized != null &&
Authorized.Equals(other.Authorized)
) &&
(
NotAuthorizedReasons == other.NotAuthorizedReasons ||
NotAuthorizedReasons != null &&
NotAuthorizedReasons.SequenceEqual(other.NotAuthorizedReasons)
));
}
/// <inheritdoc />
public bool Equals(WbGlobeCoordinate other)
{
return(Latitude.Equals(other.Latitude) && Longitude.Equals(other.Longitude) &&
Precision.Equals(other.Precision) && Globe == other.Globe);
}
