/// <summary> /// Calculates y from y^2 = x^3 + ax + b (mod p) by having x and the first byte indicating whether y is odd or even. /// Return value indicates success. /// </summary> /// <param name="x">X coordinate</param> /// <param name="firstByte">The first byte indicating whether y is odd or even (must be 2 or 3)</param> /// <param name="y">Calculated y (0 if fails to calculate)</param> /// <returns>True if y was found, otherwise false.</returns> public bool TryFindY(BigInteger x, byte firstByte, out BigInteger y) { if (firstByte != 2 && firstByte != 3) { return(false); } if (x.Sign < 1) { return(false); } // Curve.A is zero BigInteger right = (BigInteger.Pow(x, 3) + curve.B) % curve.P; if (SquareRoot.TryFind(right, curve.P, out y)) { if (firstByte == 2 && !y.IsEven) { // We know point is already on curve y = PointNegChecked(new EllipticCurvePoint(x, y)).Y; } else if (firstByte == 3 && y.IsEven) { y = PointNegChecked(new EllipticCurvePoint(x, y)).Y; } return(true); } else { return(false); } }
public void CheckExpressions() { // Arrange Expression opr1 = new TerminalExpression(3.5); Expression opr2 = new TerminalExpression(2); Expression add = new Addition(opr1, opr2); Expression subs = new Substraction(opr1, opr2); Expression mult = new Multiplication(opr1, opr2); Expression div = new Division(opr1, opr2); Expression pow = new Power(opr1, opr2); Expression sqrt = new SquareRoot(opr1); Expression mod = new Modulus(opr1, opr2); // Act double addRes = add.solve(); double subsRes = subs.solve(); double multRes = mult.solve(); double divRes = div.solve(); double powRes = pow.solve(); double sqrtRes = sqrt.solve(); double modRes = mod.solve(); // Assert Assert.AreEqual(3.5 + 2, addRes); Assert.AreEqual(3.5 - 2, subsRes); Assert.AreEqual(3.5 * 2, multRes); Assert.AreEqual(3.5 / 2, divRes); Assert.AreEqual(Math.Pow(3.5, 2), powRes); Assert.AreEqual(Math.Pow(3.5, 0.5), sqrtRes); Assert.AreEqual(3.5 % 2, modRes); }
public void ValidSquareRootNumber() { var variant = new SquareRoot(new Number(81)); Assert.That(variant.Integer, Is.EqualTo(9)); Assert.That(variant.Description, Is.EqualTo("sqrt(81)")); }
public static ICalculable GetOperationClass(ModelCalculator.Operators selectedOperator) { ICalculable calculateClass = default(ICalculable); switch (selectedOperator) { case ModelCalculator.Operators.Addition: calculateClass = new Addition(); break; case ModelCalculator.Operators.Division: calculateClass = new Division(); break; case ModelCalculator.Operators.Multiplication: calculateClass = new Multiplication(); break; case ModelCalculator.Operators.Subtraction: calculateClass = new Subtraction(); break; case ModelCalculator.Operators.SquareRoot: calculateClass = new SquareRoot(); break; } return(calculateClass); }
public void CalculateTest() { var calculator = new SquareRoot(); var actual = calculator.CalculateTwo(36); Assert.AreEqual(1296, actual, 0.25); }
static void Main(string[] args) { // 1. SORTED ARRAY SMALLEST TO HIGHEST int[] nums = new int[] { 9, 12, 4, 7, 8, 11 }; var a = new SortArray(); var ar = a.SortedArrayByLowestNumber(nums); foreach (var i in ar) { Console.WriteLine(i); } // 2. FIBONNACI CALCULATE NTH SEQUENCE var f = Fibonacci.CalculateNthFibonacci(13); Console.WriteLine(f); // 3. PALINDROME var p = new Palindromes(); var ps = p.IsPalindromes("A man a plan a canal Panama"); Console.WriteLine(ps); // 4. SQUARE ROOT var r = new SquareRoot(); var sq = r.SquareRootNumber(60); Console.WriteLine(sq); }
public void NegativeValueTest() { var x = -5; var solver = new SquareRoot(); Assert.Throws <ArgumentOutOfRangeException>(() => solver.FindSqrt(x)); }
public void GetSquareRoot(string latex, IList <Element> container, Marker marker) { if (marker.Position < latex.Length - 8) { if (latex.Substring(marker.Position, 5) == "\\sqrt") { marker.Position += 5; var squareRoot = new SquareRoot(); var subsection1 = GetSubsection(latex, container, marker); if (subsection1 != null) { var line1 = new MathematicsLine(); line1.Elements = subsection1.Item2; squareRoot.InnerExpression = line1; marker.Position += subsection1.Item1; container.Add(squareRoot); } } } }
public void SquareRootOfANumber() { var result = new SquareRoot(new Number(1)); Assert.That(result.TechnicalDescription, Is.EqualTo("sqrt(1)")); Assert.That(result.Description, Is.EqualTo("sqrt(1)")); Assert.That(result.InnerDescription, Is.EqualTo("sqrt(1)")); }
public void SquareRootOf60() { var r = new SquareRoot(); var sq = r.SquareRootNumber(60); var actual = 7.745966692414834; Assert.Equal(sq, actual); }
public void NormalBehaviourMultiTest(double x) { //AAA var solver = new SquareRoot(); var result = solver.FindSqrt(x); Assert.AreEqual(result, Math.Sqrt(x), 0.0000001); }
public void SquareRootOfAnAdditionResult() { var subResult = new Addition(new Number(1), new Number(2)); var result = new SquareRoot(subResult); Assert.That(result.TechnicalDescription, Is.EqualTo("sqrt(add(1, 2))")); Assert.That(result.Description, Is.EqualTo("sqrt(1 + 2)")); Assert.That(result.InnerDescription, Is.EqualTo("sqrt(1 + 2)")); }
public void SquareRootOfNine() { var r = new SquareRoot(); var sq = r.SquareRootNumber(9); var actual = 3; Assert.Equal(sq, actual); }
public void SqrRootDoubleArrayTest() { double[] x = { 1.2, 2.5, 6.2 }; double[] c = SquareRoot.Root(arrayC); for (int i = 0; i < c.Length; i++) { Assert.AreEqual(x[i], c[i]); } }
public void NegativeRootExceptions() { // Assign Expression neg = new TerminalExpression(-25); Expression negRoot = new SquareRoot(neg); // Act double negRootRes = negRoot.solve(); }
public override object Clone() { var returnObject = new SquareRoot { FunctionName = string.Copy(FunctionName), Middle = Middle }; return(returnObject); }
public void Newton_NegativeRootDegree_NanAnswer() { //Arrange var expectedAnswer = double.NaN; //Act var target = SquareRoot.Newton(number: 3, rootDegree: -1); //Assert Assert.AreEqual(expectedAnswer, target); }
public void CalculateTest( double firstValue, double expected) { var calculator = new SquareRoot(); var actualResult = calculator.Calculate(firstValue); Assert.AreEqual(expected, actualResult, 0.001); }
public void Newton_ZeroNumber_ZeroAnswer() { //Arrange var expectedAnswer = 0d; //Act var target = SquareRoot.Newton(number: 0, rootDegree: 2); //Assert Assert.AreEqual(expectedAnswer, target); }
public void Newton_NormalInput_CorrectAnswer() { //Arrange var expectedAnswer = 3d; //Act var target = SquareRoot.Newton(number: 9, rootDegree: 2); //Assert Assert.AreEqual(expectedAnswer, target); }
public double Execute_WhenValueIsNotNegative_ThenReturnSquareRoot(double value) { //Arrange var squareRoot = new SquareRoot(); //Act var result = squareRoot.Execute(value); //Assert return(result); }
public void RootDoubleArrayTest() { double[] y = SquareRoot.Root(e); int i = 0; foreach (double w in y) { Assert.AreEqual(SquareRoot.Root(e[i]), w); i++; } }
public void GetExecutableInfo_WhenValueIsNegative_ThenCannotExecuteAndReturnErrorMessage() { //Arrange var squareRoot = new SquareRoot(); //Act var executableInfo = squareRoot.GetExecutableInfo(-1); //Assert Assert.That(executableInfo.Message, Is.EqualTo(ErrorMessages.InvalidInput)); }
public void GetExecutableInfo_WhenValueIsNotNegative_ThenCanExecute(double value) { //Arrange var squareRoot = new SquareRoot(); //Act var executableInfo = squareRoot.GetExecutableInfo(value); //Assert Assert.That(executableInfo.CanBeExecuted, Is.True); }
public void SimplifyZero() { var sqrt = new SquareRoot(new ConstantInt64(3)); var c = sqrt + Constant.Factory.Create(0); var baseForm = c.GetBaseForm(); Assert.AreEqual(sqrt, baseForm); c = new ConstantInt64(0) + sqrt; baseForm = c.GetBaseForm(); Assert.AreEqual(sqrt, baseForm); }
public void RootIntArrayTest() { double[] d = SquareRoot.Root(f); int i = 0; foreach (double z in d) { Assert.AreEqual(SquareRoot.Root(f[i]), z); i++; } }
static void Main() { SquareRoot sq = new SquareRoot(); int startNum = 1; int endNum = 100; for (int i = 0; i < 10; i++) { startNum = ReadNumber(startNum, endNum); } }
public void SquareRoot_SqrtRoot2_WithRealNumerInput_ShouldFindTheSquare() { //Arrange var input = 5d; var expectedResult = Math.Sqrt(input); //Act var actualResult = SquareRoot.SqrtRoot2(input); //Assert Assert.Equal(expectedResult, actualResult); }
/// <summary> /// Calculates y from y^2 = x^3 + ax + b (mod p) by having x for Schnorr encoding. /// Return value indicates success. /// </summary> /// <param name="x">X coordinate</param> /// <param name="y">Calculated y (0 if fails to calculate)</param> /// <returns>True if y was found, otherwise false.</returns> public bool TryFindYSchnorr(BigInteger x, out BigInteger y) { if (x.Sign < 1 || x > curve.P) { return(false); } // Curve.A is zero BigInteger right = (BigInteger.Pow(x, 3) + curve.B) % curve.P; return(SquareRoot.TryFind(right, curve.P, out y)); }
public static double StandardDev(dynamic values) { double mean = StatisticMean.Mean(values); double difference = 0; double variance = 0; foreach (int a in values) { difference = Subtraction.Subtract((int)mean, a); difference = Math.Pow(difference, 2); variance = addition.Sum(variance, (int)difference); } int ValueCount = Helpers.Arrays.Length(values); variance = Division.Quotient(variance, ValueCount); double standardDev = SquareRoot.Root(variance); return(standardDev); }
internal IntegerMath(MainForm UseForm, int UsePrimeArrayLength) { MForm = UseForm; PrimeArrayLength = UsePrimeArrayLength; if (PrimeArrayLength < 100) { PrimeArrayLength = 100; } Divider = new Division(MForm, this); SquareRt = new SquareRoot(MForm, this); Multiplier = new Multiplication(MForm); ModReduction = new ModularReduction(MForm, this); StdAlgorithms = new StandardAlgorithms(MForm, this); SignedD = new long[Integer.DigitArraySize]; MakePrimeArray(); }
public static void Test() { int n = 5; SquareRoot sr = new SquareRoot(); Console.Write(sr.FindRoot(n)); }