public static BigRational ArcTan(BigRational x, int digits, int maxNumberOfIterations) { iterations = 0; // Later needed variable: int digitCheck = digits * 100; bool subtract = true; BigRational result = x; int iteration = 0; var divisor = new BigInteger(3); while (iteration < maxNumberOfIterations) { var dividend = BigRational.Pow(x, divisor); result = (subtract) ? (result - (dividend / divisor)) : (result + (dividend / divisor)); // Optimation hack: // Check only every two calls if end is reached. if (!subtract && (result / digitCheck > 100)) { iterations = iteration; break; } divisor += 2; subtract = !subtract; iteration++; } return result; }
/// <summary> /// Возводить текущее число в квадрат /// </summary> public void t_sqr() { BigRational i = Imagine; Imagine *= Real * _twice; Real *= Real; Real -= i * i; }
public static BigRational[] RemoveUselessZeros(BigRational[] source) { int numOfLeadingZero = 0; Array.Reverse(source); foreach (var i in source) { if (i == 0 ) { numOfLeadingZero++; } else { break; } } if (numOfLeadingZero == 0) { Array.Reverse(source); return source; } BigRational[] arrayBuffer = new BigRational[source.Length - numOfLeadingZero]; Array.Copy(source, numOfLeadingZero, arrayBuffer, 0, arrayBuffer.Length); Array.Reverse(arrayBuffer); return arrayBuffer; }
internal override ParsedSyntax CombineForPlus(PowerSyntax other, BigRational thisValue) { if(Left.CompareTo(other.Left) == 0 && Right.CompareTo(other.Right) == 0) return Times(thisValue + 1); return null; }
public Value(BigRational realPart, BigRational imaginaryPart, NumberType type) { switch (type) { case NumberType.imaginary: InitComplexNum(realPart, imaginaryPart); break; } }
public Value(BigRational baseVal, BigRational exponent, NumberType type, Restrictions restrictions) { switch (type) { case NumberType.exponent: InitExp(baseVal, exponent, restrictions); break; } }
public BigNumber(double val) { if (val == Math.Floor(val)) { integerVal = new BigInt((int)val); Type = NumberType2.integer; } else { rationalVal = new BigRational(val); Type = NumberType2.rational; } }
public static BigRational[] ArraySubtrInts(BigRational[] from, BigRational[] subAmount) { BigRational[] result = new BigRational[from.Length]; for (int i = 0; i < from.Length - 1; i++) { result[i] = from[i] - subAmount[i]; } return result; }
public void CheckModBigIntegerConsistency(int left, int right) { var leftInt = (BigInteger)left; var rightInt = (BigInteger)right; var expected = new BigRational(leftInt % rightInt); var leftRational = new BigRational(leftInt); var rightRational = new BigRational(rightInt); var actual = leftRational % rightRational; AssertEqual(expected, actual); }
public void CastToDoubleRoundToInfinity() { BigRational toRound = BigInteger.Pow(2, 1024) - BigInteger.One; Assert.AreEqual( double.PositiveInfinity, (double)toRound); Assert.AreEqual( double.NegativeInfinity, (double)-toRound); }
public void RoundWithRuleWithDecimals(MidpointRounding decimalMode, RationalRounding rationalMode) { for (int d = 0; d < 4; d++) { for (var v = -2.5M; v <= 2.5M; v += 0.0001M) { Compare( Math.Round(v, d, decimalMode), BigRational.Round(v, d, rationalMode)); } } }
public void Sqrt_Test() { var r = new BigRational(2, 1); Assert.AreEqual(r, BigRational.Sqrt(4)); r = new BigRational(3, 1); Assert.AreEqual(r, BigRational.Sqrt(9)); r = new BigRational(BigInteger.Parse("2168488286494085478154297235187389205761"), BigInteger.Parse("685736206471705483022831680917430579904")); Assert.AreEqual(r, BigRational.Sqrt(10)); }
public void RoundWithDecimals() { for (var v = -2.5M; v <= 2.5M; v += 0.0001M) { for (int d = 0; d < 4; d++) { Compare( Math.Round(v, d), BigRational.Round(v, d)); } } }
private static string FormatBigRational(BigRational x, int digits) { // Let the magic begin: BigInteger shiftedBigInteger = x.Numerator * BigInteger.Pow(10, digits); string formatString = (shiftedBigInteger / x.Denominator).ToString(); var sb = new StringBuilder(digits); sb.Append(x.GetWholePart().ToString()); int wholePart = sb.Length; sb.Append('.'); sb.Append(formatString.Substring(1, formatString.Length - wholePart)); return sb.ToString(); }
static string InternalToString(BigRational r, int precision) { var fraction = r.GetFractionPart(); // Case where the rational number is a whole number // Niko: Incorrect check? F**k it... This works... if (fraction.Numerator == 0 && fraction.Denominator == 1) { return(r.GetWholePart().ToString()); } BigInteger adjustedNumerator = fraction.Numerator * BigInteger.Pow(10, precision); // Abs fixes decimals having minuses in front of them BigInteger decimalPlaces = BigInteger.Abs(adjustedNumerator / fraction.Denominator); // Case where precision wasn't large enough. if (decimalPlaces == 0) { return(null); } // Give it the capacity for around what we should need for // the whole part and total precision // (this is kinda sloppy, but does the trick) var sb = new StringBuilder(precision + r.ToString().Length); bool noMoreTrailingZeros = false; for (int i = precision; i > 0; i--) { if (!noMoreTrailingZeros) { if ((decimalPlaces % 10) == 0) { decimalPlaces /= 10; continue; } noMoreTrailingZeros = true; } // Add the right most decimal to the string sb.Insert(0, decimalPlaces % 10); decimalPlaces /= 10; } // Insert the whole part and decimal sb.Insert(0, ","); sb.Insert(0, r.GetWholePart()); return(sb.ToString()); }
public bool Intersects(Line2BR other, out Point2BR?intersection, out bool parallel) { if (this.direction.IsZero) { parallel = false; bool flag; if (flag = other.Contains(this.origin)) { intersection = new Point2BR?(this.origin); } else { intersection = new Point2BR?(); } return(flag); } if (other.Direction.IsZero) { parallel = false; bool flag; if (flag = this.Contains(other.origin)) { intersection = new Point2BR?(other.origin); } else { intersection = new Point2BR?(); } return(flag); } BigRational bigRational1 = this.direction.X * other.direction.Y - this.direction.Y * other.direction.X; if (bigRational1.IsZero) { parallel = true; bool flag; if (flag = other.Contains(this.origin)) { intersection = new Point2BR?(this.origin); } else { intersection = new Point2BR?(); } return(flag); } parallel = false; BigRational bigRational2 = Vector2BR.CrossProduct(other.Origin - this.origin, other.Direction) / bigRational1; intersection = new Point2BR?(this.origin + bigRational2 * this.direction); return(true); }
public override byte[] Split(byte[] secretClear, int shareCount, int threshold) { // var primeArr = ComputeRandomePrime(); // var prime = new BigInteger(primeArr); var primeMinusOne = _prime - 1; var number = new BigInteger(secretClear); var coef = new BigInteger[threshold]; coef[0] = number; // TODO: rewrite this to use cryptographically-secure RNG var rng = new Random(); var pmo = new BigRational(primeMinusOne); for (int c = 1; c < threshold; ++c) { coef[c] = BigRational.Multiply(pmo, new BigRational(rng.NextDouble())).GetWholePart(); } var shares = new Tuple <int, BigInteger> [shareCount]; for (var x = 1; x <= shareCount; ++x) { System.Console.WriteLine("X: " + x); var accum = coef[0]; for (int exp = 1; exp < threshold; ++exp) { // accum = (accum + (coef[exp] * (Math.pow(x, exp) % prime) % prime)) % prime; var a = new BigInteger(Math.Pow(x, exp)) % _prime; // (Math.pow(x, exp) % prime) var b = (coef[exp] * a) % _prime; // (coef[exp] * a % prime) var c = (accum + b) % _prime; // (accum + b) % prime; accum = c; } shares[x - 1] = Tuple.Create(x, accum); } Shares = shares.Select(x => { var index = BitConverter.GetBytes(x.Item1); var biarr = x.Item2.ToByteArray(); var bytes = new byte[INT_ARR_LEN + biarr.Length]; Array.Copy(index, 0, bytes, 0, INT_ARR_LEN); Array.Copy(biarr, 0, bytes, INT_ARR_LEN, biarr.Length); return(bytes); }); // The original secret value is fully encoded in the distributed shares so there // is no need to return any version of the original secreted in encrypted form return(new byte[0]); }
public static void Inverse() { rational *= -1; calculation.Set(rational); calculationString = calculationString.RemovePrefix("-"); if (rational < 0) { calculationString = calculationString.Insert(0, "-"); } UpdateText(); }
public void TestConvertFromWholeNumberDecimal() { decimal seven = 7.0m; BigRational expectedValue = new BigRational(7, new Fraction(0, 1)); BigRational result1 = new BigRational(seven); BigRational result2 = (BigRational)seven; Assert.AreEqual(expectedValue, result1); Assert.AreEqual(expectedValue, result2); }
public bool ContainsProjection(Point2BR point) { Vector2BR delta = this.GetDelta(); BigRational bigRational = Vector2BR.DotProduct(point - this.point2BR_0, delta); if (bigRational.IsNegative) { return(false); } BigRational lengthSquared = delta.GetLengthSquared(); return(!(bigRational.Square() > lengthSquared)); }
public static BigRational[,] As2DArray(BigRational[][] Array2D, int leftSize, int rightSize) { var newArray = new BigRational[leftSize, rightSize]; for (int i = 0; i < Array2D.Length; i++) { for (int j = 0; j < Array2D[i].Length; j++) { newArray[i, j] = Array2D[i][j]; } } return(newArray); }
public void Constructor_AllowsValidVectors(int value1, int value2) { var values = new BigRational[] { value1, value2, }; var vector = new ImmutableVector2D(values); Assert.Equal(value1, vector.UnderlyingVector[0]); Assert.Equal(value2, vector.UnderlyingVector[1]); }
public void TestConstruction() { BigRational result1 = new BigRational(BigInteger.Zero, new Fraction(182, 26)); BigRational result1_2 = new BigRational(new Fraction(182, 26)); BigRational result2 = new BigRational(BigInteger.Zero, new Fraction(-7, 5)); BigRational expected1 = new BigRational(7); BigRational expected2 = new BigRational(-1, 2, 5); Assert.AreEqual(expected1, result1); Assert.AreEqual(expected1, result1_2); Assert.AreEqual(expected2, result2); }
public void TestToDecimalOutOfRange() { decimal dummy; BigRational rational = BigInteger.Pow(10, 30); Assert.Throws <OverflowException>( () => dummy = (decimal)rational); BigRational negative = -rational; Assert.Throws <OverflowException>( () => dummy = (decimal)negative); }
public void TestXmlDeserialise(int n, int d) { var expected = new BigRational(n, d); var serializer = new XmlSerializer(typeof(BigRational)); var text = $"<BigRational>{expected.Numerator}/{expected.Denominator}</BigRational>"; using (var textReader = new StringReader(text)) using (var reader = XmlReader.Create(textReader)) { var actual = (BigRational)serializer.Deserialize(reader); Assert.AreEqual(expected, actual); } }
public void Determinant_FindsDeterminant() { var values = new BigRational[2, 2] { { 2, 5 }, { 1, 4 } }; var matrix = new ImmutableMatrix2x2(values); var determinant = matrix.Determinant(); Assert.Equal(3, determinant); }
public void RoundWithDecimals2() { for (int d = -4; d <= 4; d++) { var scale = TenPow(d); for (var v = -2.5M; v <= 2.5M; v += 0.0001M) { Compare( Math.Round(v * scale) / scale, BigRational.Round(v, d)); } } }
public void RoundWithRuleWithDecimals2(MidpointRounding decimalMode, RationalRounding rationalMode) { for (int d = -4; d <= 4; d++) { var scale = TenPow(d); for (var v = -2.5M; v <= 2.5M; v += 0.0001M) { Compare( Math.Round(v * scale, decimalMode) / scale, BigRational.Round(v, d, rationalMode)); } } }
public static string ToDecimalString(this BigRational r, int precision) { var fraction = r.GetFractionPart(); // Case where the rational number is a whole number if (fraction.Numerator == 0 && fraction.Denominator == 1) { return(r.GetWholePart() + ".0"); } var adjustedNumerator = (fraction.Numerator * BigInteger.Pow(10, precision)); var decimalPlaces = adjustedNumerator / fraction.Denominator; // Case where precision wasn't large enough. if (decimalPlaces == 0) { return("0.0"); } // Give it the capacity for around what we should need for // the whole part and total precision // (this is kinda sloppy, but does the trick) var sb = new StringBuilder(precision + r.ToString().Length); bool noMoreTrailingZeros = false; for (int i = precision; i > 0; i--) { if (!noMoreTrailingZeros) { if ((decimalPlaces % 10) == 0) { decimalPlaces = decimalPlaces / 10; continue; } noMoreTrailingZeros = true; } // Add the right most decimal to the string sb.Insert(0, decimalPlaces % 10); decimalPlaces = decimalPlaces / 10; } // Insert the whole part and decimal sb.Insert(0, "."); sb.Insert(0, r.GetWholePart()); return(sb.ToString()); }
public void ConvertMatrixToUseTAndSGeneratorMatrices_ConvertsCorrectly() { var matrixValues = new BigRational[2, 2] { { 437, 202 }, { 543, 251 } }; var matrix = new ImmutableMatrix2x2(matrixValues); var expectedIdentifierList = new[] { GeneratorMatrixIdentifier.X, GeneratorMatrixIdentifier.SInverse, // -1 GeneratorMatrixIdentifier.TInverse, // S Switch GeneratorMatrixIdentifier.SInverse, // 4 GeneratorMatrixIdentifier.T, GeneratorMatrixIdentifier.T, GeneratorMatrixIdentifier.T, GeneratorMatrixIdentifier.T, // S Switch GeneratorMatrixIdentifier.SInverse, // -8 GeneratorMatrixIdentifier.TInverse, GeneratorMatrixIdentifier.TInverse, GeneratorMatrixIdentifier.TInverse, GeneratorMatrixIdentifier.TInverse, GeneratorMatrixIdentifier.TInverse, GeneratorMatrixIdentifier.TInverse, GeneratorMatrixIdentifier.TInverse, GeneratorMatrixIdentifier.TInverse, // S Switch GeneratorMatrixIdentifier.SInverse, // 6 GeneratorMatrixIdentifier.T, GeneratorMatrixIdentifier.T, GeneratorMatrixIdentifier.T, GeneratorMatrixIdentifier.T, GeneratorMatrixIdentifier.T, GeneratorMatrixIdentifier.T, // S Switch GeneratorMatrixIdentifier.SInverse, // -2 GeneratorMatrixIdentifier.TInverse, GeneratorMatrixIdentifier.TInverse, // S Switch GeneratorMatrixIdentifier.SInverse }; var matrixIdentifierList = MathematicalHelper.ConvertMatrixToUseTAndSGeneratorMatrices(matrix); Assert.Equal(expectedIdentifierList, matrixIdentifierList); }
protected override string AddConstrain(SimplexTable inputTable, out SimplexTable outputTable, out bool success) { outputTable = new SimplexTable(inputTable); success = true; ReevaluateBasisAndDeltas(outputTable); var bFracts = FormBFractVector(outputTable); int selectedI = FindIndexOfMin(bFracts); int nwI = outputTable.NumOfConstrains; outputTable.NumOfConstrains += 1; var result = $"Let's use {outputTable.cLables[curBasis[selectedI]].Value} row to form new constrain.<br>"; var bFract = outputTable.bVector[selectedI].value.Fract(); for (int j = 0; j < outputTable.NumOfVariables; j++) { BigRational tarA = outputTable.aMatrix[selectedI][j].value; if (!outputTable.cLables[j].IsSelected) { if (tarA.Sign >= 0) { outputTable.aMatrix[nwI][j].value = -tarA; } else { outputTable.aMatrix[nwI][j].value = -((bFract / (BigRational.One - bFract)) * (-tarA)); } } else { if (tarA.Fract() <= bFract) { outputTable.aMatrix[nwI][j].value = -tarA.Fract(); } else { outputTable.aMatrix[nwI][j].value = -((bFract / (BigRational.One - bFract)) * (BigRational.One - tarA)); } } } outputTable.bVector[nwI].value = -bFract; outputTable.NumOfVariables += 1; outputTable.aMatrix[nwI][outputTable.NumOfVariables - 1].value = BigRational.One; return(result); }
public void BigRational_Constructor_TwoBigInteger_SimplifiesFraction() { var value1 = new BigRational((BigInteger)20, (BigInteger)10); Assert.Equal("2/1", value1.ToString("B", null)); var value2 = new BigRational((BigInteger)10, (BigInteger)10); Assert.Equal("1/1", value2.ToString("B", null)); var value3 = new BigRational((BigInteger)4, (BigInteger)6); Assert.Equal("2/3", value3.ToString("B", null)); }
public void BigRational_Divide_DividesBigRationals() { Assert.Equal("0/1", (BigRational.Create(0).Divide(BigRational.Create(2))).ToString("B", null)); Assert.Equal("0/1", (BigRational.Create(0).Divide(BigRational.Create(-2))).ToString("B", null)); Assert.Equal("2/3", (BigRational.Create(2).Divide(BigRational.Create(3))).ToString("B", null)); Assert.Equal("3/2", (BigRational.Create(3).Divide(BigRational.Create(2))).ToString("B", null)); Assert.Equal("-3/2", (BigRational.Create(3).Divide(BigRational.Create(-2))).ToString("B", null)); Assert.Equal("-1/1", (BigRational.Create(-3).Divide(BigRational.Create(3))).ToString("B", null)); Assert.Equal("1/1", (BigRational.Create(-3).Divide(BigRational.Create(-3))).ToString("B", null)); Assert.Equal($"1/1", (BigRational.Create(VeryBigNumber).Divide(BigRational.Create(VeryBigNumber))).ToString("B", null)); Assert.Equal($"{VeryBigNumber}/1", (BigRational.Create($"{DoubleVeryBig}").Divide(BigRational.Create(2))).ToString("B", null)); Assert.Equal($"-2/1", (BigRational.Create($"{DoubleVeryBig}").Divide(BigRational.Create($"-{VeryBigNumber}"))).ToString("B", null)); }
public void TestConvertFromDecimalPointFloat() { float negativeOneAndOneHalf = -3f / 2f; float oneThird = 1f / 3f; BigRational expectedValue1 = new BigRational(-1, new Fraction(1, 2)); BigRational result1 = (BigRational)negativeOneAndOneHalf; BigRational expectedValue2 = new BigRational(0, new Fraction(1, 3)); BigRational result2 = (BigRational)oneThird; Assert.AreEqual(expectedValue1, result1); Assert.AreEqual(expectedValue2, result2); }
public static string ToString(this BigRational r, bool allowRational, ushort precisionLimit) { string output = InternalToString(r, precisionLimit + (allowRational ? 1 : 0)); if (!allowRational) { return(output); } if (string.IsNullOrEmpty(output) || (output.Length > precisionLimit && !r.Denominator.IsOne)) { return(r.ToString()); } return(output); }
public BigRational GetVendorValue() { if (cachedVendorValue < 0) { int v = StatisticsTracker.moneyMagnitude.value; v -= (v % 3); v /= 3; v = Math.Max(v - 1, 0); UpgradeValueWrapper vendorSellEffectiveness; upgrades.TryGetValue(UpgradeType.VENDOR_SELL_VALUE, out vendorSellEffectiveness); cachedVendorValue = (((UpgradeFloatValue)vendorSellEffectiveness).value + (0.05f * v)) * (1 + SkillList.VendorEffectiveness.getMultiplier()) + currentGuildmaster.vendorSellMultiplier(); } return(cachedVendorValue); }
public void Constructor_Throws_IfWrongSizeMatrixSupplied(int sizeX, int sizeY) { var values = new BigRational[sizeX, sizeY]; for (int i = 0; i < sizeX; i++) { for (int j = 0; j < sizeY; j++) { values[i, j] = 0; } } Assert.Throws <ArgumentException>(() => new ImmutableMatrix2x2(values)); }
public void SqrtAsRational() { var expected = new BigRational[] { new(1, 1), new(3, 2), new(7, 5), new(17, 12), new(41, 29), }; var actual = BigRational.SqrtAsRationals(new BigInteger(2)).Take(5); Assert.True(expected.SequenceEqual(actual)); }
public BigNumber(double val, NumberType2 type) { Type = type; switch (type) { case NumberType2.integer: integerVal = new BigInt((int)val); break; case NumberType2.rational: rationalVal = new BigRational(val); break; case NumberType2.irrational: irrationalVal = new BigIrrational(val); break; } }
public CalculationOptions(int width, int height, uint iter) { this.width = xMax = width; this.height = yMax = height; this.xSkip = 1; this.ySkip = 1; this.iteration_count = iter; this.orbit_length = iter; this.skip_primary_bulbs = 0U; this.minRe = new BigRational(-5, 2); // -2.5 to this.maxRe = new BigRational(3, 2); // 1.5 this.minIm = new BigRational(-3, 2); // -1.5 to this.maxIm = new BigRational(3, 2); // 1.5 }
static ExprList MergeArgs( CoreBuilder b, IEnumerable<Expr> args, Func<Expr, ExprList?> getArgs, BigRational aggregateSeed, Func<BigRational, BigRational, BigRational> aggregate, Func<IEnumerable<Expr>, IEnumerable<Expr>> group) { var mergedArgs = args .SelectMany(x => getArgs(x) ?? x.Yield()); var @const = mergedArgs .Select(x => x.AsConst()) .Where(x => x != null) .Select(x => x.Value) .Aggregate(aggregateSeed, aggregate); var other = group(mergedArgs.Where(x => !x.IsConst())); return (@const == aggregateSeed && other.Any() ? other : Const(@const).Yield().Concat(other)).ToExprList(); }
public static DivideResult PolyLongDivision(BigRational[] dividend, BigRational[] divisor) { DivideResult divideResult = new DivideResult(); BigRational[] bufferDividend = dividend; int divisorMaxPower = divisor.Length - 1; BigRational divisorMaxCoeff = divisor.Last(); BigRational[] result = new BigRational[dividend.Length]; while (true) { long dividentMaxPower = bufferDividend.Length - 1; long resultXPower = dividentMaxPower - divisorMaxPower; if (resultXPower < 0) { divideResult.Quotient = RemoveUselessZeros(result); divideResult.Remainder = RemoveUselessZeros(bufferDividend); return divideResult; } BigRational dividentCoeff = bufferDividend.Last(); BigRational resultCoeff = dividentCoeff/divisorMaxCoeff; result[resultXPower] = resultCoeff; BigRational[] buffSubtract = new BigRational[bufferDividend.Length].Select(h => new BigRational(0,1)).ToArray(); Array.Copy(divisor, 0, buffSubtract, resultXPower, divisor.Length); Parallel.For(0, buffSubtract.Length, i => buffSubtract[i] *= resultCoeff); bufferDividend = ArraySubtrInts(bufferDividend, buffSubtract); bufferDividend = RemoveUselessZeros(bufferDividend); } }
public static StringBuilder BigRationalToStringBuilder(BigRational[] bigRationals) { StringBuilder resultSb = new StringBuilder(); for (int i = 0; i < bigRationals.Length; i++) { if (bigRationals[i].Equals(0)) { continue; } resultSb.Insert(0, bigRationals[i]); switch (i) { case 0: break; case 1: resultSb.Insert(bigRationals[i].ToString().Length, "x "); break; default: resultSb.Insert(bigRationals[i].ToString().Length, "x^" + i + " "); break; } if (bigRationals[i].Sign.Equals(1)) { resultSb.Insert(0, "+"); } } if (resultSb[0].Equals('+')) { resultSb.Remove(0, 1); } return resultSb; }
public static bool CanShrink(BigRational d) { return (d.Denominator == 1); }
public Value(BigRational doubleVal, Restrictions restrictions) { InitDouble(doubleVal, restrictions); }
public static object Shrink(BigRational d) { if (CanShrink(d)) { return Shrink(d.Numerator); } else { return d; } }
public override double[] GetDoubleFirstInserts(BigInteger[] args) { BigRational absciss_start = _2df_get_br_abciss_start(), absciss_interval = _2df_get_br_abciss_interval_length(); BigRational[] be_Result = new BigRational[4]; be_Result[0] = absciss_start+ (absciss_interval * new BigRational(args[0], BigInteger.One)); be_Result[1] = absciss_start + (absciss_interval * new BigRational(args[1], BigInteger.One)); BigRational ordinate_start=_2df_get_br_ordinate_start(),ordinate_interval=_2df_get_br_ordinate_interval_length(); be_Result[2]=ordinate_start+(ordinate_interval * new BigRational(args[2], BigInteger.One)); be_Result[3] = ordinate_start + (ordinate_interval * new BigRational(args[3], BigInteger.One)); double[] Result=new double[4]; Result[0] = ((double)be_Result[0].Numerator) / ((double)be_Result[0].Denominator); Result[1] = ((double)be_Result[1].Numerator) / ((double)be_Result[1].Denominator); Result[2] = ((double)be_Result[2].Numerator) / ((double)be_Result[2].Denominator); Result[3] = ((double)be_Result[3].Numerator) / ((double)be_Result[3].Denominator); return Result; }
public Value(BigRational doubleVal, Factors factors, Restrictions restrictions) { InitDouble(doubleVal, restrictions); this.factors = factors; }
public KoeffMultInfo(BigRational _Koeff, ExprList _Mult) { Koeff = _Koeff; Mult = _Mult; }
protected void _2df_safe_set_scale(int _Width, int _Height, int n_left, int n_top, int width, int height) { if (_2df_imagine_width == null) { _2df_imagine_width = new BigInteger(width); _2df_imagine_height = new BigInteger(height); _2df_imagine_left = BigInteger.Zero; _2df_imagine_top = BigInteger.Zero; return; } if (_Width == width && _Height == height && n_left == 0 && n_top == 0) return; _2df_push_fractal_state(); if(_Width<width||_Height<height) { _2df_set_scale(_Width, _Height, n_left, n_top, width, height); return; } BigRational width_dif = new BigRational(_Width, width); BigRational height_dif = new BigRational(_Height, height); BigRational safe_dif = width_dif > height_dif ? height_dif : width_dif; BigRational im_left = new BigRational(_2df_imagine_left + (BigInteger)n_left) * safe_dif; BigRational im_top = new BigRational(_2df_imagine_top + (BigInteger)n_top) * safe_dif; BigRational im_width = new BigRational(_2df_imagine_width) * safe_dif; BigRational im_height = new BigRational(_2df_imagine_height) * safe_dif; _2df_imagine_left = im_left.Numerator / im_left.Denominator; _2df_imagine_top = im_top.Numerator / im_top.Denominator; _2df_imagine_width = im_width.Numerator / im_width.Denominator; _2df_imagine_height = im_height.Numerator / im_height.Denominator; }
//Let's format any BigRational (e.g. Pi) to a string with specified significant figures public static string Format(BigRational pi, int numberOfDigits) { var numeratorShiftedToEnoughDigits = (pi.Numerator * BigInteger.Pow(new BigInteger(10), numberOfDigits)); var test = pi.Numerator%pi.Denominator; var bigInteger = numeratorShiftedToEnoughDigits / pi.Denominator; string piToBeFormatted = bigInteger.ToString(); int len = piToBeFormatted.Length-numberOfDigits; var builder = new StringBuilder(); builder.Append(piToBeFormatted.Substring(0,len)); builder.Append("."); builder.Append(piToBeFormatted.Substring(len, numberOfDigits - len)); return builder.ToString(); }
internal override ParsedSyntax CombineForPlus(ParsedSyntax other, BigRational otherValue) => other.CombineForPlus(this, otherValue);
public BigRational Calculate(BigRational x, int maxNumberOfIterations, int precision) { bool doASubtract = true; var runningTotal = x; int count = 0; var divisor = 3; while (count < maxNumberOfIterations) { var current = BigRational.Pow(x, divisor); current = current/BigRational.FromInt(divisor); if (doASubtract) { runningTotal = runningTotal - current; } else { runningTotal = runningTotal + current; } doASubtract = !doASubtract; count++; divisor = divisor + 2; if (!WeHaveEnoughPrecision(current, precision)) continue; Iterations = count; break; } return runningTotal; }
private static bool WeHaveEnoughPrecision(BigRational current, int precision) { var fractionPart = (current.Numerator%current.Denominator); var thing = BigRational.FromBigInt(fractionPart)/BigRational.FromBigInt(current.Denominator); return thing.ToString().Length > precision + 2; //extra 2 digits to ensure enough precision }
internal void Add(BigRational re, BigRational im) { if (currentindex == points.LongLength) // Have to expand array { long newsize = points.LongLength == 0 ? 1 : points.LongLength * 2; BigComplex[] newarr = new BigComplex[newsize]; Array.Copy(points, newarr, currentindex); points = newarr; } points[currentindex++] = new BigComplex(re, im); }
public BigComplex() { Real = Imagine = BigRational.Zero; }
public BigComplex(BigRational r, BigRational i) { Real = r; Imagine = i; }
public BigComplex(double Re, double Im) { Real = BigRational.ConvertToBigRational(Re); Imagine = BigRational.ConvertToBigRational(Im); }
public BigComplex(long value) { Real = new BigRational(value, 1); Imagine = BigRational.Zero; }