public ActionResult EditPost(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Repairer repairerToUpdate = db.Repairers.Find(id);
repairerToUpdate.Wage = DoubleExtension.ConvertInput(Request.Form["WageTextbox"]);
if (TryUpdateModel(repairerToUpdate, "", new string[] { "RepairerId", "FirstName", "LastName", "DoB", "Wage" }))
{
try
{
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (DataException Dex)
{
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
return(View("Error", new HandleErrorInfo(Dex, "Repairer", "EditPost")));
}
}
return(View(repairerToUpdate));
}
public void BinaryTest1()
{
double x = -255.255;
string ExpectedResult = "1100000001101111111010000010100011110101110000101000111101011100";
string actual = DoubleExtension.Binary(x);
Assert.AreEqual(ExpectedResult, actual);
}
public void BinaryTest2()
{
double x = 255.255;
string ExpectedResult = "0100000001101111111010000010100011110101110000101000111101011100";
string result = DoubleExtension.Binary(x);
Assert.AreEqual(result, ExpectedResult);
}
public void BinaryTest3()
{
double x = 4294967295.0;
string ExpectedResult = "0100000111101111111111111111111111111111111000000000000000000000";
string result = DoubleExtension.Binary(x);
Assert.AreEqual(result, ExpectedResult);
}
public void BinaryTest5()
{
double x = double.MaxValue;
string ExpectedResult = "0111111111101111111111111111111111111111111111111111111111111111";
string result = DoubleExtension.Binary(x);
Assert.AreEqual(result, ExpectedResult);
}
public void BinaryTest6()
{
double x = double.Epsilon;
string ExpectedResult = "0000000000000000000000000000000000000000000000000000000000000001";
string result = DoubleExtension.Binary(x);
Assert.AreEqual(result, ExpectedResult);
}
public void BinaryTest7()
{
double x = double.NaN;
string ExpectedResult = "1111111111111000000000000000000000000000000000000000000000000000";
string result = DoubleExtension.Binary(x);
Assert.AreEqual(result, ExpectedResult);
}
public void BinaryTest9()
{
double x = double.PositiveInfinity;
string ExpectedResult = "0111111111110000000000000000000000000000000000000000000000000000";
string result = DoubleExtension.Binary(x);
Assert.AreEqual(result, ExpectedResult);
}
public AboveLineTrainingEntry(double x, double y, string lbl)
{
// Test example; "Valid line" is x=y
Labels.Add(DoubleExtension.BoolToDouble(y >= x));
Inputs.Add(x);
Inputs.Add(y);
}
public void BinaryTest11()
{
double x = 0.0;
string ExpectedResult = "0000000000000000000000000000000000000000000000000000000000000000";
string result = DoubleExtension.Binary(x);
Assert.AreEqual(result, ExpectedResult);
}
public void AlmostEqualsWithAbsOrUlpsTolerance_WithFloatingPointValues_ShouldBeCorrect_Test()
{
DoubleExtension.AlmostEqualsWithAbsOrUlpsTolerance(0.00000001, 0.000000010000000000000002, 0, 1).Should().Be(true);
DoubleExtension.AlmostEqualsWithAbsOrUlpsTolerance(0.00000001, 0.000000010000000000000004, 0, 1).Should().Be(false);
DoubleExtension.AlmostEqualsWithAbsOrUlpsTolerance(1000000.00, 1000000.0000000001, 0, 1).Should().Be(true);
DoubleExtension.AlmostEqualsWithAbsOrUlpsTolerance(1000000.00, 1000000.0000000002, 0, 1).Should().Be(false);
}
public TrainingSet(int entriesCount, IList <string> labels)
{
for (var i = 0;
i < entriesCount;
i++) // TODO Training set is now statically set to very simple problem (x, y, is it above the line) and thus it's constructor is garbage
{
TrainingEntries.Add(new AboveLineTrainingEntry(DoubleExtension.GetRandomNumber(-10, 10),
DoubleExtension.GetRandomNumber(-10, 10), labels[0]));
}
}
/// <summary>
/// Doubles to string.
/// </summary>
/// <param name="number">The number.</param>
/// <returns>String binary representations of the double</returns>
public static string DoubleToString(this double number)
{
DoubleExtension numberStruct = new DoubleExtension
{
numberBit = number
};
string resultString = ConverterToString(numberStruct.longBits);
return(resultString);
}
public override DataPoint calculatePoint(DoubleExtension doubleExtension)
{
Debug.Assert(interval.IsBetweenBordersCloseInterval(doubleExtension), "Invalid argument for BSplineCurve.calculatePoint()");
DoubleExtension xVal = new DoubleExtension(0);
DoubleExtension yVal = new DoubleExtension(0);
DoubleExtension basisFunction;
for (int i = 0; i < pointList.Count; i++)
{
basisFunction = basisFunctions[i].calculate(doubleExtension);
xVal += basisFunction * pointList[i].X;
yVal += basisFunction * pointList[i].Y;
}
return new DataPoint(xVal, yVal);
}
public ActionResult Create([Bind(Include = "ProductId,Name,Price")] Product product)
{
if (ModelState.IsValid)
{
Assignment assignment = db.Assignments.Find(Request.Form["AssignmentId"]);
product.Assignment = assignment;
product.Price = DoubleExtension.ConvertInput(Request.Form["PriceTextbox"]);
db.Products.Add(product);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(product));
}
private static double GetInitialWeight()
{
return(DoubleExtension.GetRandomNumber(-5, 5));
}
public string FindNthRootTest_Number_Degree_Precision_ReturnsResult(double number)
{
return DoubleExtension.ConvertToIEEE754(number);
}
public void AlmostEqualsWithAbsOrRelativeTolerance_WithZeroAndInfinityAndAbsoluteToleranceZeroAndRelativeToleranceZero_ShouldBeFalse_Test()
{
var result = DoubleExtension.AlmostEqualsWithAbsOrRelativeTolerance(0, double.PositiveInfinity, 0, 0);
result.Should().Be(false);
}
public void AlmostEqualsWithAbsTolerance_WithOneAndFloatingPointNumberNearOneAndValidAbsoluteTolerance_ShouldBeTrue_Test()
{
var result = DoubleExtension.AlmostEqualsWithAbsTolerance(1, 0.9999, 0.0002);
result.Should().Be(true);
}
public void AlmostEqualsWithAbsTolerance_WithOneAndZeroAndAbsoluteToleranceZero_ShouldBeFalse_Test()
{
var result = DoubleExtension.AlmostEqualsWithAbsTolerance(1, 0, 0);
result.Should().Be(false);
}
public void AlmostEqualsWithAbsOrUlpsTolerance_WithFloatingPointNumbersAndValidUlpsAndZeroAbsoluteTolerance_ShouldBeTrue_Test()
{
var result = DoubleExtension.AlmostEqualsWithAbsOrUlpsTolerance(67329.243d, 67329.242d, 0.01d, 1);
result.Should().Be(true, "these numbers are within 0.01 difference");
}
public void AlmostEqualsWithAbsOrUlpsTolerance_WithZeroAndZeroAndZeroUlpsAndZeroAbsoluteTolerance_ShouldBeTrue_Test()
{
var result = DoubleExtension.AlmostEqualsWithAbsOrUlpsTolerance(0, 0, 0, 0);
result.Should().Be(true);
}
public void AlmostEqualsWithAbsOrUlpsTolerances_WithZeroAndNaNAndZeroUlpsAndZeroAbsoluteTolerance_ShouldBeFalse_Test()
{
var result = DoubleExtension.AlmostEqualsWithAbsOrUlpsTolerance(0, double.NaN, 0, 0);
result.Should().Be(false);
}
public string ConvertToIEEETest_WithCorrectDouble(double number) => DoubleExtension.ConvertToIEEE(number);
public string Transform(double number)
{
return(DoubleExtension.ConvertToIEEE(number));
}
public void FindNthRootTest_ThrowsArgumentOutOfRangeException(double number, int degree, double precision)
{
Assert.Throws <ArgumentOutOfRangeException>(() => DoubleExtension.FindNthRoot(number, degree, precision));
}
public int SortedIndexOf(DoubleExtension item)
{
return sortedPointList.IndexOfKey(item);
}
/// <summary>
/// 要求的：N+1 = curveParam.PointList.Count;
/// 要求的： k = curveParam.Degree;
/// k = i
/// i = j
/// t - t[j] t[i + j + 1] - t
/// N[i, j](t) = ----------------- * N[i - 1, j](t) + ------------------------- * N[i - 1, j + 1](t)
/// t[i + j] - t[j] t[i + j + 1] - t[j + 1]
/// numerator11 * t + numerator10 numerator21 * t + numerator20
/// = ------------------------------- * N[i - 1, j](t) + ------------------------------- * N[i - 1, j + 1](t)
/// denominator10 denominator20
/// numerator11 = 1
/// numerator10 = -t[j]
/// numerator21 = -1
/// numerator20 = t[i + j + 1]
/// denominator10 = t[i + j] - t[j]
/// denominator20 = t[i + j + 1] - t[j + 1]
/// </summary>
/// <param name="curveParam"></param>
/// <returns></returns>
protected virtual void calculateBasisFunction(ICurveParam curveParam)
{
if (curveParam.getCurveType() == InterpolationCurveType.bsCurve)
{
BSplineCurveParam param = (BSplineCurveParam)curveParam;
Dynamic2DArray<PiecewiseIntervalPolynomialCurveElement> basisFunctions = new Dynamic2DArray<PiecewiseIntervalPolynomialCurveElement>();
int total = param.Degree + param.PointList.Count;
DoubleExtension denominator10, denominator20, numerator11, numerator10, numerator21, numerator20;
PiecewiseIntervalPolynomialCurveElement curve1, curve2;
numerator11 = new DoubleExtension(1);
numerator21 = new DoubleExtension(-1);
for (int i = 0; i < total; i++)
{
basisFunctions.SetArrayElement(0, i, new PiecewiseIntervalPolynomialCurveElement(i, param.Interval));
}
for (int i = 1; i <= param.Degree; i++)
{
for (int j = 0; j < total - i; j++)
{
denominator10 = param.Interval.CutPoints[i + j] - param.Interval.CutPoints[j];
denominator20 = param.Interval.CutPoints[i + j + 1] - param.Interval.CutPoints[j + 1];
numerator10 = 0 - param.Interval.CutPoints[j];
numerator20 = param.Interval.CutPoints[i + j + 1];
curve1 = basisFunctions.GetArrayElement(i - 1, j).DivideByNumber(denominator10).MultiplyByLinear(numerator11, numerator10);
curve2 = basisFunctions.GetArrayElement(i - 1, j + 1).DivideByNumber(denominator20).MultiplyByLinear(numerator21, numerator20);
basisFunctions.SetArrayElement(i, j, curve1 + curve2);
}
}
this.basisFunctions = basisFunctions[param.Degree];
}
else
{
throw new UnmatchedCurveParamTypeException(InterpolationCurveType.bsCurve, curveParam.getCurveType());
}
}
public void TwosCompliment_WithPoint0001_ShouldBeCorrect_Test()
{
var result = DoubleExtension.AlmostEqualsWithAbsOrUlpsTolerance(0, 0, 0, 0);
result.Should().Be(true);
}
public string DoubleToBinaryStringTest(double number) => DoubleExtension.DoubleToBinaryString(number);
public void AlmostEqualsWithAbsOrUlpsTolerance_WithZeroAndInfinityAndTenUlpsAndZeroAbsoluteTolerance_ShouldBeFalse_Test()
{
var result = DoubleExtension.AlmostEqualsWithAbsOrUlpsTolerance(0, double.PositiveInfinity, 0, 10);
result.Should().Be(false);
}
/// <summary>
/// Transform double value to string.
/// </summary>
/// <param name="value">Input double value.</param>
/// <returns>Transformed double value to string.</returns>
public string Transform(double value)
{
return(DoubleExtension.TransformToIEEE754(value));
}
public void FindNthRootTest(double number, int degree, double precision, double expected) => Assert.AreEqual(DoubleExtension.FindNthRoot(number, degree, precision), expected, precision);
