[
{
"path": ".gitignore",
"content": "# gradle stuff\n\n.gradle\nbuild\ngradle.properties\n\n# Eclipse IDE stuff\n\n.project\n.classpath\nbin\nout\n.settings\n\n# IntelliJ IDEA stuff\n\n*.iml\n.idea\n\n"
},
{
"path": ".travis.yml",
"content": "env:\n - BIGDECIMALTEST_LEVEL=Medium\n\ndist: trusty\nlanguage: java\njdk:\n - oraclejdk11\n\nbefore_install:\n - chmod +x gradlew\n\naddons:\n sonarcloud:\n organization: \"eobermuhlner\"\n token:\n secure: rsfHxDskN6m18xYPNdG6CZIES7D98Dekv2ZtNOU1BxeuQGqTZjn/gm/LjzK99alzmrd2gsO8EK67EGMRFM+cPqHGRJaFsNm2WgqU3UmwoVSe6wvFkDazZAHySRNeEcdmtxHUlUeQZXZvdI+gXpgiJlYxrfxh3zhDLIW5Iha2wOTTDjp/DM+VvMLo5YLDe/uKMj638QgwjJi4GFUHrkMwOx6YOm16JDOn+5BUfkjAkTDwnQF3enmiHtySXufat6hI0w1gUbUvUB5VW3HOdHdwXf2FE5VuDraWPzWkquytM0kzaFaCRDcjvXF8OXQR3aq0Jdb0cV+niY+6y6vNBPldk1rSBJr5Hn4nDFdClxb6Q1Dq5f2YvakUq9hTInluxTyPvQh5FmJZh7pq1bM8gBUIPN6ZwuicqMDtlGff4UiXKzI/waV42xUj7ZnXWWrHYrgBxcmC3HPuNGpXOifnyduVsDx4MuwHyVAGIXLzVFNDhRhykR2YJLBz3+JEL+MyoW/6UX1Jmxw9isxP6ALYe8SNtae46UVVNB8AOCg3DAdcEiCVMnCRx8gJxCFpdZ0fd1Tvm54/OoGDWh0W5rja2X+1y4yRlZc8jlp3dqyJrZBwM7ufO6rg1uNw1kzT8bslIhxjN5GAxH8nIrBl7VzKk6UynXiqmsvQvYx9M7giee9abRA=\n\nscript:\n - ./gradlew sonarqube\n\nafter_success:\n - bash <(curl -s https://codecov.io/bash)\n\n# set sudo to required, because this setup gets more memory\nsudo: required\n\n# keep gradle cache\nbefore_cache:\n - rm -f $HOME/.gradle/caches/modules-2/modules-2.lock\n - rm -fr $HOME/.gradle/caches/*/plugin-resolution/\ncache:\n directories:\n - $HOME/.gradle/caches/\n - $HOME/.gradle/wrapper/\n"
},
{
"path": "LICENSE.txt",
"content": "MIT License\n\nCopyright (c) 2017 Eric Obermühlner\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
},
{
"path": "README.md",
"content": "[](https://travis-ci.org/eobermuhlner/big-math)\n[](https://codecov.io/gh/eobermuhlner/big-math)\n[](https://sonarcloud.io/dashboard?id=big-math)\n[](https://github.com/eobermuhlner/big-math/issues)\n[](https://github.com/eobermuhlner/big-math/issues)\n[](https://search.maven.org/artifact/ch.obermuhlner/big-math)\n[](https://github.com/eobermuhlner/big-math/graphs/commit-activity)\n[](https://gitter.im/eobermuhlner-big-math/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)\n\n
\n\t\n
\n\nAdvanced Java `BigDecimal` math functions (`pow`, `sqrt`, `log`, `sin`, ...) using arbitrary precision.\n\nSee also the official [Big-Math Documentation](http://eobermuhlner.github.io/big-math/).\n\n## BigDecimalMath\n\nThe class `BigDecimalMath` provides efficient and accurate implementations for:\n\n* `log(BigDecimal, MathContext)`\n* `exp(BigDecimal, MathContext)`\n* `pow(BigDecimal, BigDecimal, MathContext)` calculates x^y\n* `sqrt(BigDecimal, MathContext)`\n* `root(BigDecimal, BigDecimal, MathContext)` calculates the n'th root of x\n* `sin(BigDecimal, MathContext)`\n* `cos(BigDecimal, MathContext)`\n* `tan(BigDecimal, MathContext)`\n* `asin(BigDecimal, MathContext)`\n* `acos(BigDecimal, MathContext)`\n* `atan(BigDecimal, MathContext)`\n* `atan2(BigDecimal, BigDecimal, MathContext)`\n* `sinh(BigDecimal, MathContext)`\n* `cosh(BigDecimal, MathContext)`\n* `tanh(BigDecimal, MathContext)`\n* `asinh(BigDecimal, MathContext)`\n* `acosh(BigDecimal, MathContext)`\n* `atanh(BigDecimal, MathContext)`\n* `toDegrees(BigDecimal, MathContext)` converts from radians to degrees\n* `toRadians(BigDecimal, MathContext)` converts from degrees to radians\n* `pow(BigDecimal, long, MathContext)` calculates x^y for `long` y\n* `factorial(int)` calculates n!\n* `bernoulli(int)` calculates Bernoulli numbers\n* `pi(MathContext)` calculates pi to an arbitrary precision\n* `e(MathContext)` calculates e to an arbitrary precision\n* `toBigDecimal(String)` creates a `BigDecimal` from string representation (faster than `BigDecimal(String)`)\n* `mantissa(BigDecimal)` extracts the mantissa from a `BigDecimal` (mantissa * 10^exponent)\n* `exponent(BigDecimal)` extracts the exponent from a `BigDecimal` (mantissa * 10^exponent)\n* `integralPart(BigDecimal)` extracts the integral part from a `BigDecimal` (everything before the decimal point) \n* `fractionalPart(BigDecimal)` extracts the fractional part from a `BigDecimal` (everything after the decimal point)\n* `isIntValue(BigDecimal)` checks whether the `BigDecimal` can be represented as an `int` value\n* `isDoubleValue(BigDecimal)` checks whether the `BigDecimal` can be represented as a `double` value\n* `roundWithTrailingZeroes(BigDecimal, MathContext)` rounds a `BigDecimal` to an arbitrary precision with trailing zeroes.\n\n\n### Usage\n\n#### Mathematical calculations for `BigDecimal`\n\nFor calculations with arbitrary precision you need to specify how precise you want a calculated result.\nFor `BigDecimal` calculations this is done using the `MathContext`.\n\n```java\nMathContext mathContext = new MathContext(100);\nSystem.out.println(\"sqrt(2) = \" + BigDecimalMath.sqrt(BigDecimal.valueOf(2), mathContext));\nSystem.out.println(\"log10(2) = \" + BigDecimalMath.log10(BigDecimal.valueOf(2), mathContext));\nSystem.out.println(\"exp(2) = \" + BigDecimalMath.exp(BigDecimal.valueOf(2), mathContext));\nSystem.out.println(\"sin(2) = \" + BigDecimalMath.sin(BigDecimal.valueOf(2), mathContext));\n```\nwill produce the following output on the console:\n```\nsqrt(2) = 1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641573\nlog10(2) = 0.3010299956639811952137388947244930267681898814621085413104274611271081892744245094869272521181861720\nexp(2) = 7.389056098930650227230427460575007813180315570551847324087127822522573796079057763384312485079121795\nsin(2) = 0.9092974268256816953960198659117448427022549714478902683789730115309673015407835446201266889249593803\n```\n\nSince many mathematical constants have an infinite number of digits you need to specfiy the desired precision for them as well:\n```java\nMathContext mathContext = new MathContext(100);\nSystem.out.println(\"pi = \" + BigDecimalMath.pi(mathContext));\nSystem.out.println(\"e = \" + BigDecimalMath.e(mathContext));\n```\nwill produce the following output on the console:\n```\npi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068\ne = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n```\n\n#### Convenience methods for `BigDecimal`\n\nAdditional `BigDecimalMath` provides several useful methods (that are plain missing for `BigDecimal`):\n```java\nMathContext mathContext = new MathContext(100);\nSystem.out.println(\"mantissa(1.456E99) = \" + BigDecimalMath.mantissa(BigDecimal.valueOf(1.456E99)));\nSystem.out.println(\"exponent(1.456E99) = \" + BigDecimalMath.exponent(BigDecimal.valueOf(1.456E99)));\nSystem.out.println(\"integralPart(123.456) = \" + BigDecimalMath.integralPart(BigDecimal.valueOf(123.456)));\nSystem.out.println(\"fractionalPart(123.456) = \" + BigDecimalMath.fractionalPart(BigDecimal.valueOf(123.456)));\nSystem.out.println(\"isIntValue(123) = \" + BigDecimalMath.isIntValue(BigDecimal.valueOf(123)));\nSystem.out.println(\"isIntValue(123.456) = \" + BigDecimalMath.isIntValue(BigDecimal.valueOf(123.456)));\nSystem.out.println(\"isDoubleValue(123.456) = \" + BigDecimalMath.isDoubleValue(BigDecimal.valueOf(123.456)));\nSystem.out.println(\"isDoubleValue(1.23E999) = \" + BigDecimalMath.isDoubleValue(new BigDecimal(\"1.23E999\")));\n```\nwill produce the following output on the console:\n```\nmantissa(1.456E99) = 1.456\nexponent(1.456E99) = 99\nintegralPart(123.456) = 123\nfractionalPart(123.456) = 0.456\nisIntValue(123) = true\nisIntValue(123.456) = false\nisDoubleValue(123.456) = true\nisDoubleValue(1.23E999) = false\n```\n\nThe `BigDecimalMath` class is thread-safe and can be used in concurrent use cases.\n\n#### Streams of `BigDecimal`\n\nThe class `BigDecimalStream` provides factory methods for streams of `BigDecimal` elements.\n\nOverloaded variants of `range(start, end, step)` provide sequential elements equivalent to `IntStream.range(start, end)` but with configurable step (exclusive the end value).\n\nSimilar methods for the `rangeClosed()` (inclusive the end value) are available.\n\nThe streams are well behaved when used in parallel mode. \n\nThe following code snippet:\n```java\nSystem.out.println(\"Range [0, 10) step 1 (using BigDecimal as input parameters)\");\nBigDecimalStream.range(BigDecimal.valueOf(0), BigDecimal.valueOf(10), BigDecimal.valueOf(1), mathContext)\n\t.forEach(System.out::println);\n\nSystem.out.println(\"Range [0, 10) step 3 (using long as input parameters)\");\nBigDecimalStream.range(0, 10, 3, mathContext)\n\t.forEach(System.out::println);\n```\n\nproduces this output:\n```\nRange [0, 10) step 1 (using BigDecimal as input parameters)\n0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n\nRange [0, 12] step 3 (using long as input parameters)\n0\n3\n6\n9\n12\n```\n\n### FAQ\n\n#### Why do I have to pass `MathContext` to most functions?\n\nMany mathematical functions have results that have many digits (often an infinite number of digits).\nWhen calculating these functions you need to specify the number of digits you want in the result,\nbecause calculating an infinite number of digits would take literally forever and consume an infinite amount of memory.\n\nThe `MathContext` contains a precision and information on how to round the last digits, so it is an obvious choice to specify the desired precision of mathematical functions.\n\n\n#### What if I really do not want to pass the `MathContext` everytime?\n\nThe convenience class `DefaultBigDecimalMath` was added that provides mathematical functions\nwhere the `MathContext` must not be passed every time.\n\nPlease refer to the chapter [DefaultBigDecimalMath](#defaultbigdecimalmath)\n\n\n#### I specified a precision of `n` digits, but the results have completely different number of digits after the decimal point. Why?\n\nIt is a common misconception that the precision defines the number of digits after the decimal point.\n\nInstead the precision defines the number of relevant digits, independent of the decimal point.\nThe following numbers all have a precision of 3 digits:\n* 12300\n* 1230\n* 123\n* 12.3\n* 1.23\n* 0.123\n* 0.0123\n\nTo specify the number of digits after the decimal point use `BigDecimal.setScale(scale, mathContext)`.\n\n\n#### Why are `BigDecimalMath` functions so slow?\n\nThe mathematical functions in `BigDecimalMath` are heavily optimized to calculate the result in the specified precision, but in order to calculate them often tens or even hundreds of basic operations (+, -, *, /) using `BigDecimal` are necessary.\n\nIf the calculation of your function is too slow for your purpose you should verify whether you really need the full precision in your particular use case. Sometimes you can adapt the precision depending on input factors of your calculation.\n\n\n#### How are the mathematical functions in `BigDecimalMath` calculated?\n\nFor the mathematical background and performance analysis please refer to this article:\n*\t[BigDecimalMath](http://obermuhlner.ch/wordpress/2016/06/02/bigdecimalmath/)\n\nSome of the implementation details are explained here: \n*\t[Adaptive precision in Newton’s Method](http://obermuhlner.ch/wordpress/2016/06/07/adaptive-precision-in-newtons-method/)\n\n\n#### Why is there `BigDecimalMath.toBigDecimal(String)` if Java already has a `BigDecimal(String)` constructor?\n\nThe `BigDecimal(String)` constructor as provided by Java gets increasingly slower if you pass longer strings to it.\nThe implementation in Java 11 and before is O(n^2).\n\nIf you want to convert very long strings (10000 characters or longer) then this slow constructor may become an issue.\n\n`BigDecimalMath.toBigDecimal(String)` is a drop-in replacement with the same functionality\n(converting a string representation into a `BigDecimal`) but it is using a faster recursive implementation.\n\nThe following chart shows the time necessary to create a `BigDecimal` from a string representation of increasing length:\n\n \n\n#### I only need a `sqrt` function - should I use this library?\n\nSince Java 9 the `BigDecimal` class has a new function `sqrt(BigDecimal, MathContext)`.\nIf you only need the square root function then by all means use the provided standard function instead of this library.\n\nIf you need any other high level function then you should still consider using this library.\n\nFor high precision (above 150 digits) the current implementation of\nJava 9 `BigDecimal.sqrt()` becomes increasingly slower than `BigDecimalMath.sqrt()`.\nYou should consider whether the increased performance is worth having an additional dependency. \n\nThe following charts shows the time needed to calculate the square root of 3.1 with increasing precision.\n\n\n\n\n\n### Performance\n\nThe following charts show the time needed to calculate the functions over a range of values with a precision of 300 digits.\n\n\n\n\n\n\n\n\n\n## BigComplex\n\nThe class `BigComplex` represents complex numbers in the form `(a + bi)`.\nIt follows the design of `BigDecimal` with some convenience improvements like overloaded operator methods.\n\nA big difference to `BigDecimal` is that `BigComplex.equals()` implements the *mathematical* equality\nand *not* the strict technical equality.\nThis was a difficult decision because it means that `BigComplex` behaves slightly different than `BigDecimal`\nbut considering that the strange equality of `BigDecimal` is a major source of bugs we\ndecided it was worth the slight inconsistency.\n\nIf you need the strict equality use `BigComplex.strictEquals()`.\n\n* `re`\n* `im`\n* `add(BigComplex)`\n* `add(BigComplex, MathContext)`\n* `add(BigDecimal)`\n* `add(BigDecimal, MathContext)`\n* `add(double)`\n* `subtract(BigComplex)`\n* `subtract(BigComplex, MathContext)`\n* `subtract(BigDecimal)`\n* `subtract(BigDecimal, MathContext)`\n* `subtract(double)`\n* `multiply(BigComplex)`\n* `multiply(BigComplex, MathContext)`\n* `multiply(BigDecimal)`\n* `multiply(BigDecimal, MathContext)`\n* `multiply(double)`\n* `divide(BigComplex)`\n* `divide(BigComplex, MathContext)`\n* `divide(BigDecimal)`\n* `divide(BigDecimal, MathContext)`\n* `divide(double)`\n* `reciprocal(MathContext)`\n* `conjugate()`\n* `negate()`\n* `abs(MathContext)`\n* `angle(MathContext)`\n* `absSquare(MathContext)`\n* `isReal()`\n* `re()`\n* `im()`\n* `round(MathContext)`\n* `hashCode()`\n* `equals(Object)`\n* `strictEquals(Object)`\n* `toString()`\n* `valueOf(BigDecimal)`\n* `valueOf(double)`\n* `valueOf(BigDecimal, BigDecimal)`\n* `valueOf(double, double)`\n* `valueOfPolar(BigDecimal, BigDecimal, MathContext)`\n* `valueOfPolar(double, double, MathContext`\n\n\n## BigComplexMath\n\nThe class `BigComplexMath` is the equivalent of `BigDecimalMath` and contains mathematical functions in the complex domain.\n\n* `sin(BigComplex, MathContext)` \n* `cos(BigComplex, MathContext)` \n* `tan(BigComplex, MathContext)` \n* `asin(BigComplex, MathContext)`\n* `acos(BigComplex, MathContext)`\n* `atan(BigComplex, MathContext)`\n* `acot(BigComplex, MathContext)`\n* `exp(BigComplex, MathContext)`\n* `log(BigComplex, MathContext)`\n* `pow(BigComplex, long, MathContext)` \n* `pow(BigComplex, BigDecimal, MathContext)` \n* `pow(BigComplex, BigComplex, MathContext)` \n* `sqrt(BigComplex, MathContext)` \n* `root(BigComplex, BigDecimal, MathContext)` \n* `root(BigComplex, BigComplex, MathContext)` \n\n\n## DefaultBigDecimalMath\n\nThe class `DefaultBigDecimalMath` is a wrapper around `BigDecimalMath` that passes always the current `MathContext` to the\nfunctions that need a `MathContext` argument.\n\nThe initial default `MathContext` is equivalent to `MathContext.DECIMAL128` but this can be overridden by setting the following system properties:\n- `ch.obermuhlner.math.big.default.precision` to a positive integer precision (default=34)\n- `ch.obermuhlner.math.big.default.rounding` to a RoundingMode name (default=HALF_UP)\n\nIt is also possible to programmatically set the default `MathContext` using `setDefaultMathContext(MathContext)`.\nIt is recommended to set the desired precision in the `MathContext` very early in the startup of the application and to not change it afterwards.\n\n**Important**: Avoid the pitfall of setting the precision temporarily using `setDefaultMathContext(MathContext)` for a calculation.\nThis can lead to race conditions and calculations with the wrong precision if other threads in your application do the same thing.\n\nTo set a temporary `MathContext` you have to choice to use either:\n- `DefaultBigDecimalMath.createLocalMathContext()` in a try-with-resources statement \n- `DefaultBigDecimalMath.withLocalMathContext()` with a lambda function \n\nExample code using `DefaultBigDecimalMath.createLocalMathContext()`:\n```java\nSystem.out.println(\"Pi[default]: \" + DefaultBigDecimalMath.pi());\ntry (DefaultBigDecimalMath.LocalMathContext context = DefaultBigDecimalMath.createLocalMathContext(5)) {\n System.out.println(\"Pi[5]: \" + DefaultBigDecimalMath.pi());\n try (DefaultBigDecimalMath.LocalMathContext context2 = DefaultBigDecimalMath.createLocalMathContext(10)) {\n System.out.println(\"Pi[10]: \" + DefaultBigDecimalMath.pi());\n };\n System.out.println(\"Pi[5]: \" + DefaultBigDecimalMath.pi());\n};\nSystem.out.println(\"Pi[default]: \" + DefaultBigDecimalMath.pi());\n```\n\nExample code using `DefaultBigDecimalMath.withLocalMathContext()`:\n```java\nSystem.out.println(\"Pi[default]: \" + DefaultBigDecimalMath.pi());\nDefaultBigDecimalMath.withLocalMathContext(5, () -> {\n System.out.println(\"Pi[5]: \" + DefaultBigDecimalMath.pi());\n DefaultBigDecimalMath.withLocalMathContext(10, () -> {\n System.out.println(\"Pi[10]: \" + DefaultBigDecimalMath.pi());\n });\n System.out.println(\"Pi[5]: \" + DefaultBigDecimalMath.pi());\n});\nSystem.out.println(\"Pi[default]: \" + DefaultBigDecimalMath.pi());\n```\n\nBoth snippets will give the following output:\n```console\nPi[default]: 3.141592653589793238462643383279503\nPi[5]: 3.1416\nPi[10]: 3.141592654\nPi[5]: 3.1416\nPi[default]: 3.141592653589793238462643383279503\n```\n\nThe temporary `MathContext` are stored in `ThreadLocal` variables\nand will therefore not conflict with each other when used in multi-threaded use case.\n\n**Important**: Due to the `ThreadLocal` variables the temporary `MathContext` will\n _not_ be available in other threads.\nThis includes streams using `parallel()`, thread pools and manually started threads.\nIf you need temporary `MathContext` for calculations then you _must_ \nset the local `MathContext` inside _every_ separate thread.\n\n```java\ntry (DefaultBigDecimalMath.LocalMathContext context = DefaultBigDecimalMath.createLocalMathContext(5)) {\n BigDecimalStream.range(0.0, 1.0, 0.01, DefaultBigDecimalMath.currentMathContext())\n .map(b -> DefaultBigDecimalMath.cos(b))\n .map(b -> \"sequential \" + Thread.currentThread().getName() + \" [5]: \" + b)\n .forEach(System.out::println);\n\n BigDecimalStream.range(0.0, 1.0, 0.01, DefaultBigDecimalMath.currentMathContext())\n .parallel()\n .map(b -> {\n try (DefaultBigDecimalMath.LocalMathContext context2 = DefaultBigDecimalMath.createLocalMathContext(5)) {\n return DefaultBigDecimalMath.cos(b);\n }\n })\n .map(b -> \"parallel \" + Thread.currentThread().getName() + \" [5]: \" + b)\n .forEach(System.out::println);\n}\n```\n\n## BigFloat\n\nThe class `BigFloat` is an experimental wrapper around `BigDecimal` which simplifies the consistent usage of the `MathContext` and provides a simpler API for calculations. \n\nThe API for calculations is simplified and more consistent with the typical mathematical usage.\n* Factory methods on the `Context` class for values:\n\t* `valueOf(BigFloat)`\n\t* `valueOf(BigDecimal)`\n\t* `valueOf(int)`\n\t* `valueOf(long)`\n\t* `valueOf(double)`\n\t* `valueOf(String)`\n\t* `pi()`\n\t* `e()`\n\n* All standard operators:\n\t* `add(x)`\n\t* `subtract(x)`\n\t* `multiply(x)`\n\t* `divide(x)`\n\t* `remainder(x)`\n\t* `pow(y)`\n\t* `root(y)`\n\n* Calculation methods are overloaded for different value types:\n \t* `add(BigFloat)`\n\t* `add(BigDecimal)`\n\t* `add(int)`\n\t* `add(long)`\n\t* `add(double)`\n\t* ...\n\n* Mathematical functions are written in the traditional form:\n \t* `abs(x)`\n\t* `log(x)`\n\t* `sin(x)`\n\t* `min(x1, x2, ...)`\n\t* `max(x1, x2, ...)`\n\t* ...\n\n* Support for advanced mathematical functions:\n \t* `sqrt(x)`\n\t* `log(x)`\n\t* `exp(x)`\n\t* `sin(x)`\n\t* `cos(x)`\n\t* `tan(x)`\n\t* ...\n\n* Methods to access parts of a value:\n \t* `getMantissa()`\n\t* `getExponent()`\n\t* `getIntegralPart()`\n\t* `getFractionalPart()`\n\n* Methods to verify value type conversions:\n \t* `isIntValue()`\n \t* `isDoubleValue()`\n\n* Equals and Hashcode methods:\n\t* `equals(Object)` returns whether two `BigFloat` values are mathematically the same\n\t* `hashCode()` consistent with `equals(Object)`\n\n* Comparison methods:\n \t* `isEqual(BigFloat)`\n\t* `isLessThan(BigFloat)`\n\t* `isLessThanOrEqual(BigFloat)`\n\t* `isGreaterThan(BigFloat)`\n\t* `isGreaterThanOrEqual(BigFloat)`\n\n* Sign methods:\n\t* `signum()`\n\t* `isNegative()`\n\t* `isZero()`\n\t* `isPositive()`\n\n### Usage\n\nBefore doing any calculations you need to create a `Context` specifying the precision used for all calculations.\n```java\nContext context = BigFloat.context(100); // precision of 100 digits\nContext anotherContext = BigFloat.context(new MathContext(10, RoundingMode.HALF_UP); // precision of 10 digits, rounding half up\n```\n\nThe `Context` can then be used to create the first value of the calculation:\n```java\nBigFloat value1 = context.valueOf(640320);\n```\n\nThe `BigFloat` instance holds a reference to the `Context`. This context is then passed from calculation to calculation.\n```java\nBigFloat value2 = context.valueOf(640320).pow(3).divide(24);\nBigFloat value3 = BigFloat.sin(value2);\n```\n\n\nThe `BigFloat` result can be converted to other numerical types:\n```java\nBigDecimal bigDecimalValue = value3.toBigDecimal();\ndouble doubleValue = value3.toDouble();\nlong longValue = value3.toLong();\nint intValue = value3.toInt();\n```\n\nThe `BigFloatStream` provides similar stream factories as `BigDecimalStream` that will produce streams of `BigFloat` elements.\n\n### Usage in Java Module Systems (Jigsaw and OSGi)\n\nSince release 2.0.1 the deployed big-math Jar file contains now a module name for the Jigsaw module system (Java 9 and later).\n\nThis allows it to be used as automatic module with a well defined module name instead\nof deriving the name magically from the Jar file name.\n\nThe module name follows the reverse domain convention and is: `ch.obermuhlner.math.big`\n\nThe big-math Jar file is also OSGi compatible.\n\nThe `MANIFEST.MF` contains all the necessary headers and exports the public packages:\n- `ch.obermuhlner.math.big`\n- `ch.obermuhlner.math.big.stream`\n\n### Usage in Kotlin\n\nIf you want to use big-math library in Kotlin you may do so directly, or you use the \n[kotlin-big-math](https://github.com/eobermuhlner/kotlin-big-math) library that provides additional features, like operators.\n\n\n## Using big-math in your projects\n\nTo use the Java library you can either download the newest version of the .jar file from the\n[published releases on Github](https://github.com/eobermuhlner/big-math/releases/)\nor use the following dependency to\n[Maven Central](https://search.maven.org/#search%7Cga%7C1%7Cbig-math)\nin your build script (please verify the version number to be the newest release):\n\n### Use big-math in Maven Build\n\n```xml\n\n ch.obermuhlner\n big-math\n 2.3.2\n\n```\n\n### Use big-math in Gradle Build\n\n```gradle\nrepositories {\n mavenCentral()\n}\n\ndependencies {\n compile 'ch.obermuhlner:big-math:2.3.2'\n}\n```\n"
},
{
"path": "build.gradle",
"content": "buildscript {\r\n ext.kotlin_version = '1.1.3'\r\n ext.dokka_version = '0.9.15'\r\n\r\n repositories {\r\n mavenCentral()\r\n jcenter()\r\n }\r\n\r\n dependencies {\r\n classpath \"org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version\"\r\n classpath \"org.jetbrains.dokka:dokka-gradle-plugin:${dokka_version}\"\r\n }\r\n}\r\n"
},
{
"path": "ch.obermuhlner.math.big/build.gradle",
"content": "\nplugins {\n id 'org.sonarqube' version '2.7'\n id 'java'\n id 'eclipse'\n id 'maven'\n id 'signing'\n id 'jacoco'\n}\n\ngroup = 'ch.obermuhlner'\nversion = '2.3.2'\narchivesBaseName = 'big-math'\n\next {\n moduleName = \"ch.obermuhlner.math.big\"\n\n if (!project.hasProperty(\"ossrhUsername\")) {\n ossrhUsername = \"undefined\"\n }\n if (!project.hasProperty(\"ossrhPassword\")) {\n ossrhPassword=\"undefined\"\n }\n}\n\nrepositories {\n mavenLocal()\n mavenCentral()\n}\n\ncompileJava {\n sourceCompatibility = '1.8'\n targetCompatibility = '1.8'\n}\n\ndependencies {\n testCompile 'junit:junit:4.12'\n}\n\ntest {\n testLogging {\n events \"failed\"\n exceptionFormat \"full\"\n }\n}\n\nsonarqube {\n properties {\n property \"sonar.projectKey\", \"big-math\"\n }\n}\n\njacocoTestReport {\n reports {\n xml.enabled = true\n html.enabled = true\n }\n}\n\ncheck.dependsOn jacocoTestReport\n\njar {\n manifest {\n attributes(\n \"Automatic-Module-Name\": moduleName,\n \"Bundle-ManifestVersion\": 2,\n \"Bundle-Name\": archivesBaseName,\n \"Bundle-SymbolicName\": moduleName,\n \"Bundle-Version\": version,\n \"Export-Package\": \"ch.obermuhlner.math.big, ch.obermuhlner.math.big.stream\")\n }\n}\n\ntask sourcesJar(type: Jar, dependsOn: classes) {\n classifier = 'sources'\n from sourceSets.main.allSource\n}\n\ntask javadocJar(type: Jar, dependsOn: javadoc) {\n classifier = 'javadoc'\n from javadoc.destinationDir\n}\n\nartifacts {\n //archives jar // no longer needed tp add - will lead to duplicate\n archives sourcesJar\n archives javadocJar\n}\n\nsigning {\n required {\n gradle.taskGraph.hasTask(\"uploadArchives\")\n }\n\n sign configurations.archives\n}\n\nuploadArchives {\n\trepositories {\n\t mavenDeployer {\n\t beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }\n\t\n\t repository(url: \"https://oss.sonatype.org/service/local/staging/deploy/maven2/\") {\n\t authentication(userName: ossrhUsername, password: ossrhPassword)\n\t }\n\t\n\t snapshotRepository(url: \"https://oss.sonatype.org/content/repositories/snapshots/\") {\n\t authentication(userName: ossrhUsername, password: ossrhPassword)\n\t }\n\t\n\t pom.project {\n\t name 'Big Math'\n\t packaging 'jar'\n\t // optionally artifactId can be defined here \n\t description 'Math functions for BigDecimal.'\n\t url 'https://github.com/eobermuhlner/big-math'\n\t\n\t scm {\n\t connection 'scm:git:git://github.com/big-math.git'\n\t developerConnection 'scm:ssh://github.com:eobermuhlner/big-math.git'\n\t url 'https://github.com/eobermuhlner/big-math/'\n\t }\n\t\n\t licenses {\n\t license {\n\t name 'MIT License'\n\t url 'https://raw.githubusercontent.com/eobermuhlner/big-math/master/LICENSE.txt'\n\t }\n\t }\n\t\n\t developers {\n\t developer {\n\t id 'eobermuhlner'\n\t name 'Eric Obermuhlner'\n\t email 'eobermuhlner@gmail.com'\n\t }\n\t }\n\t }\n\t }\n\t}\n}\n\n// See http://central.sonatype.org/pages/gradle.html\n"
},
{
"path": "ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/BigComplex.java",
"content": "package ch.obermuhlner.math.big;\n\nimport java.math.BigDecimal;\nimport java.math.MathContext;\nimport java.util.Objects;\n\n/**\n * Represents a complex number consisting of a real and an imaginary {@link BigDecimal} part in the form {@code a + bi}.\n *\n *
It generally follows the design of {@link BigDecimal} with some convenience improvements like overloaded operator methods.
\n *\n *
The biggest difference to {@link BigDecimal} is that {@link BigComplex#equals(Object) BigComplex.equals(Object)} implements the mathematical equality\n * and not the strict technical equality.\n * This was a difficult decision because it means that {@code BigComplex} behaves slightly different than {@link BigDecimal}\n * but considering that the strange equality of {@link BigDecimal} is a major source of bugs we\n * decided it was worth the slight inconsistency.\n * If you need the strict equality use {@link BigComplex#strictEquals(Object)}`.
\n *\n *
This class is immutable and therefore inherently thread safe.
\n */\npublic final class BigComplex {\n\n\t/**\n\t * Zero represented as complex number.\n\t */\n\tpublic static final BigComplex ZERO = new BigComplex(BigDecimal.ZERO, BigDecimal.ZERO);\n\n\t/**\n\t * Real 1 represented as complex number.\n\t */\n\tpublic static final BigComplex ONE = new BigComplex(BigDecimal.ONE, BigDecimal.ZERO);\n\n\t/**\n\t * Imaginary 1 represented as complex number.\n\t */\n\tpublic static final BigComplex I = new BigComplex(BigDecimal.ZERO, BigDecimal.ONE);\n\n\t/**\n\t * The real {@link BigDecimal} part of this complex number.\n\t */\n\tpublic final BigDecimal re;\n\n\t/**\n\t * The imaginary {@link BigDecimal} part of this complex number.\n\t */\n\tpublic final BigDecimal im;\n\n\tprivate BigComplex(BigDecimal re, BigDecimal im) {\n\t\tthis.re = re;\n\t\tthis.im = im;\n\t}\n\n\t/**\n\t * Calculates the addition of the given complex value to this complex number.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the {@link BigComplex} value to add\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex add(BigComplex value) {\n\t\treturn valueOf(\n\t\t\t\tre.add(value.re),\n\t\t\t\tim.add(value.im));\n\t}\n\n\t/**\n\t * Calculates the addition of the given complex value to this complex number using the specified {@link MathContext}.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the {@link BigComplex} value to add\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex add(BigComplex value, MathContext mathContext) {\n\t\treturn valueOf(\n\t\t\t\tre.add(value.re, mathContext),\n\t\t\t\tim.add(value.im, mathContext));\n\t}\n\n\t/**\n\t * Calculates the addition of the given real {@link BigDecimal} value to this complex number using the specified {@link MathContext}.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the real {@link BigDecimal} value to add\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex add(BigDecimal value, MathContext mathContext) {\n\t\treturn valueOf(\n\t\t\t\tre.add(value, mathContext),\n\t\t\t\tim);\n\t}\n\n\t/**\n\t * Calculates the addition of the given real {@link BigDecimal} value to this complex number.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the real {@link BigDecimal} value to add\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex add(BigDecimal value) {\n\t\treturn valueOf(\n\t\t\t\tre.add(value),\n\t\t\t\tim);\n\t}\n\n\t/**\n\t * Calculates the addition of the given real {@code double} value to this complex number.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the real {@code double} value to add\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex add(double value) {\n\t\treturn add(BigDecimal.valueOf(value));\n\t}\n\n\t/**\n\t * Calculates the subtraction of the given complex value from this complex number.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the {@link BigComplex} value to subtract\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex subtract(BigComplex value) {\n\t\treturn valueOf(\n\t\t\t\tre.subtract(value.re),\n\t\t\t\tim.subtract(value.im));\n\t}\n\n\t/**\n\t * Calculates the subtraction of the given complex value from this complex number using the specified {@link MathContext}.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the {@link BigComplex} value to subtract\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex subtract(BigComplex value, MathContext mathContext) {\n\t\treturn valueOf(\n\t\t\t\tre.subtract(value.re, mathContext),\n\t\t\t\tim.subtract(value.im, mathContext));\n\t}\n\n\t/**\n\t * Calculates the subtraction of the given real {@link BigDecimal} value from this complex number using the specified {@link MathContext}.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the real {@link BigDecimal} value to add\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex subtract(BigDecimal value, MathContext mathContext) {\n\t\treturn valueOf(\n\t\t\t\tre.subtract(value, mathContext),\n\t\t\t\tim);\n\t}\n\n\t/**\n\t * Calculates the subtraction of the given real {@link BigDecimal} value from this complex number.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the real {@link BigDecimal} value to subtract\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex subtract(BigDecimal value) {\n\t\treturn valueOf(\n\t\t\t\tre.subtract(value),\n\t\t\t\tim);\n\t}\n\n\t/**\n\t * Calculates the subtraction of the given real {@code double} value from this complex number.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the real {@code double} value to subtract\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex subtract(double value) {\n\t\treturn subtract(BigDecimal.valueOf(value));\n\t}\n\n\t/**\n\t * Calculates the multiplication of the given complex value to this complex number.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the {@link BigComplex} value to multiply\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex multiply(BigComplex value) {\n\t\treturn valueOf(\n\t\t\t\tre.multiply(value.re).subtract(im.multiply(value.im)),\n\t\t\t\tre.multiply(value.im).add(im.multiply(value.re)));\n\t}\n\n\t/**\n\t * Calculates the multiplication of the given complex value with this complex number using the specified {@link MathContext}.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the {@link BigComplex} value to multiply\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex multiply(BigComplex value, MathContext mathContext) {\n\t\treturn valueOf(\n\t\t\t\tre.multiply(value.re, mathContext).subtract(im.multiply(value.im, mathContext), mathContext),\n\t\t\t\tre.multiply(value.im, mathContext).add(im.multiply(value.re, mathContext), mathContext));\n\t}\n\n\t/**\n\t * Calculates the multiplication of the given real {@link BigDecimal} value with this complex number using the specified {@link MathContext}.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the real {@link BigDecimal} value to multiply\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex multiply(BigDecimal value, MathContext mathContext) {\n\t\treturn valueOf(\n\t\t\t\tre.multiply(value, mathContext),\n\t\t\t\tim.multiply(value, mathContext));\n\t}\n\n\t/**\n\t * Calculates the multiplication of the given real {@link BigDecimal} value with this complex number.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the real {@link BigDecimal} value to multiply\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex multiply(BigDecimal value) {\n\t\treturn valueOf(\n\t\t\t\tre.multiply(value),\n\t\t\t\tim.multiply(value));\n\t}\n\n\t/**\n\t * Calculates the multiplication of the given real {@code double} value with this complex number.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the real {@code double} value to multiply\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex multiply(double value) {\n\t\treturn multiply(BigDecimal.valueOf(value));\n\t}\n\n\t/**\n\t * Calculates this complex number divided by the given complex value using the specified {@link MathContext}.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the {@link BigComplex} value to divide by\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex divide(BigComplex value, MathContext mathContext) {\n\t\treturn multiply(value.reciprocal(mathContext), mathContext);\n\t}\n\n\t/**\n\t * Calculates this complex number divided by the given real {@link BigDecimal} value using the specified {@link MathContext}.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the {@link BigDecimal} value to divide by\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex divide(BigDecimal value, MathContext mathContext) {\n\t\treturn valueOf(\n\t\t\t\tre.divide(value, mathContext),\n\t\t\t\tim.divide(value, mathContext));\n\t}\n\n\t/**\n\t * Calculates this complex number divided by the given real {@code double} value using the specified {@link MathContext}.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param value the {@code double} value to divide by\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex divide(double value, MathContext mathContext) {\n\t\treturn divide(BigDecimal.valueOf(value), mathContext);\n\t}\n\n\t/**\n\t * Calculates the reciprocal of this complex number using the specified {@link MathContext}.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex reciprocal(MathContext mathContext) {\n\t\tBigDecimal scale = absSquare(mathContext);\n\t\treturn valueOf(\n\t\t\t\tre.divide(scale, mathContext),\n\t\t\t\tim.negate().divide(scale, mathContext));\n\t}\n\n\t/**\n\t * Calculates the conjugate {@code a - bi} of this complex number.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex conjugate() {\n\t\treturn valueOf(re, im.negate());\n\t}\n\n\t/**\n\t * Calculates the negation {@code -a - bi} of this complex number.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigComplex negate() {\n\t\treturn valueOf(re.negate(), im.negate());\n\t}\n\n\t/**\n\t * Calculates the absolute value (also known as magnitude, length or radius) of this complex number.\n\t *\n\t *
This method is slower than {@link #absSquare(MathContext)} since it needs to calculate the {@link BigDecimalMath#sqrt(BigDecimal, MathContext)}.
\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t * @see #absSquare(MathContext)\n\t */\n\tpublic BigDecimal abs(MathContext mathContext) {\n\t\treturn BigDecimalMath.sqrt(absSquare(mathContext), mathContext);\n\t}\n\n\t/**\n\t * Calculates the angle in radians (also known as argument) of this complex number.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t */\n\tpublic BigDecimal angle(MathContext mathContext) {\n\t\treturn BigDecimalMath.atan2(im, re, mathContext);\n\t}\n\n\t/**\n\t * Calculates the square of the absolute value of this complex number.\n\t *\n\t *
This method is faster than {@link #abs(MathContext)} since it does not need to calculate the {@link BigDecimalMath#sqrt(BigDecimal, MathContext)}.
\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t * @see #abs(MathContext)\n\t */\n\tpublic BigDecimal absSquare(MathContext mathContext) {\n\t\treturn re.multiply(re, mathContext).add(im.multiply(im, mathContext), mathContext);\n\t}\n\n\t/**\n\t * Returns whether this complex number only has a real part (the imaginary part is 0).\n\t *\n\t * @return {@code true} if this complex number only has a real part, {@code false} if the imaginary part is not 0\n\t */\n\tpublic boolean isReal() {\n\t\treturn im.signum() == 0;\n\t}\n\n\t/**\n\t * Returns the real part of this complex number as {@link BigComplex} number.\n\t *\n\t * @return the real part as as {@link BigComplex} number\n\t */\n\tpublic BigComplex re() {\n\t\treturn valueOf(re, BigDecimal.ZERO);\n\t}\n\n\t/**\n\t * Returns the imaginary part of this complex number as {@link BigComplex} number.\n\t *\n\t * @return the imaginary part as as {@link BigComplex} number\n\t */\n\tpublic BigComplex im() {\n\t\treturn valueOf(BigDecimal.ZERO, im);\n\t}\n\n\t/**\n\t * Returns this complex nuber rounded to the specified precision.\n\t *\n\t *
This methods does not modify this instance.
\n\t *\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the rounded {@link BigComplex} result\n\t */\n\tpublic BigComplex round(MathContext mathContext) {\n\t\treturn valueOf(re.round(mathContext), im.round(mathContext));\n\t}\n\n\t@Override\n\tpublic int hashCode() {\n\t\treturn Objects.hash(re, im);\n\t}\n\n\t/**\n\t * {@inheritDoc}\n\t *\n\t *
Contrary to {@link BigDecimal#equals(Object)} this method implements mathematical equality\n\t * (by calling {@link BigDecimal#compareTo(BigDecimal)} on the real and imaginary parts)\n\t * instead of strict equality.
\n\t *\n\t * @see #strictEquals(Object)\n\t */\n\t@Override\n\tpublic boolean equals(Object obj) {\n\t\tif (this == obj)\n\t\t\treturn true;\n\t\tif (obj == null)\n\t\t\treturn false;\n\t\tif (getClass() != obj.getClass())\n\t\t\treturn false;\n\t\tBigComplex other = (BigComplex) obj;\n\n\t\treturn re.compareTo(other.re) == 0 && im.compareTo(other.im) == 0;\n\t}\n\n\t/**\n\t * Returns whether the real and imaginary parts of this complex number are strictly equal.\n\t *\n\t *
This method uses the strict equality as defined by {@link BigDecimal#equals(Object)} on the real and imaginary parts.
\n\t *
Please note that {@link #equals(Object) BigComplex.equals(Object)} implements mathematical equality instead\n\t * (by calling {@link BigDecimal#compareTo(BigDecimal) on the real and imaginary parts}).
\n\t *\n\t * @param obj the object to compare for strict equality\n\t * @return {@code true} if the specified object is strictly equal to this complex number\n\t * @see #equals(Object)\n\t */\n\tpublic boolean strictEquals(Object obj) {\n\t\tif (this == obj)\n\t\t\treturn true;\n\t\tif (obj == null)\n\t\t\treturn false;\n\t\tif (getClass() != obj.getClass())\n\t\t\treturn false;\n\t\tBigComplex other = (BigComplex) obj;\n\n\t\treturn re.equals(other.re) && im.equals(other.im);\n\t}\n\n\t@Override\n\tpublic String toString() {\n\t\tif (im.signum() >= 0) {\n\t\t\treturn \"(\" + re + \" + \" + im + \" i)\";\n\t\t} else {\n\t\t\treturn \"(\" + re + \" - \" + im.negate() + \" i)\";\n\t\t}\n\t}\n\n\t/**\n\t * Returns a complex number with the specified real {@link BigDecimal} part.\n\t *\n\t * @param real the real {@link BigDecimal} part\n\t * @return the complex number\n\t */\n\tpublic static BigComplex valueOf(BigDecimal real) {\n\t\treturn valueOf(real, BigDecimal.ZERO);\n\t}\n\n\t/**\n\t * Returns a complex number with the specified real {@code double} part.\n\t *\n\t * @param real the real {@code double} part\n\t * @return the complex number\n\t */\n\tpublic static BigComplex valueOf(double real) {\n\t\treturn valueOf(BigDecimal.valueOf(real), BigDecimal.ZERO);\n\t}\n\n\t/**\n\t * Returns a complex number with the specified real and imaginary {@code double} parts.\n\t *\n\t * @param real the real {@code double} part\n\t * @param imaginary the imaginary {@code double} part\n\t * @return the complex number\n\t */\n\tpublic static BigComplex valueOf(double real, double imaginary) {\n\t\treturn valueOf(BigDecimal.valueOf(real), BigDecimal.valueOf(imaginary));\n\t}\n\n\t/**\n\t * Returns a complex number with the specified real and imaginary {@link BigDecimal} parts.\n\t *\n\t * @param real the real {@link BigDecimal} part\n\t * @param imaginary the imaginary {@link BigDecimal} part\n\t * @return the complex number\n\t */\n\tpublic static BigComplex valueOf(BigDecimal real, BigDecimal imaginary) {\n\t\tif (real.signum() == 0) {\n\t\t\tif (imaginary.signum() == 0) {\n\t\t\t\treturn ZERO;\n\t\t\t}\n\t\t\tif (imaginary.compareTo(BigDecimal.ONE) == 0) {\n\t\t\t\treturn I;\n\t\t\t}\n\t\t}\n\t\tif (imaginary.signum() == 0 && real.compareTo(BigDecimal.ONE) == 0) {\n\t\t\treturn ONE;\n\t\t}\n\n\t\treturn new BigComplex(real, imaginary);\n\t}\n\n\t/**\n\t * Returns a complex number with the specified polar {@link BigDecimal} radius and angle using the specified {@link MathContext}.\n\t *\n\t * @param radius the {@link BigDecimal} radius of the polar representation\n\t * @param angle the {@link BigDecimal} angle in radians of the polar representation\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the complex number\n\t */\n\tpublic static BigComplex valueOfPolar(BigDecimal radius, BigDecimal angle, MathContext mathContext) {\n\t\tif (radius.signum() == 0) {\n\t\t\treturn ZERO;\n\t\t}\n\n\t\treturn valueOf(\n\t\t\t\tradius.multiply(BigDecimalMath.cos(angle, mathContext), mathContext),\n\t\t\t\tradius.multiply(BigDecimalMath.sin(angle, mathContext), mathContext));\n\t}\n\n\tpublic static BigComplex valueOfPolar(double radius, double angle, MathContext mathContext) {\n\t\treturn valueOfPolar(BigDecimal.valueOf(radius), BigDecimal.valueOf(angle), mathContext);\n\t}\n}\n"
},
{
"path": "ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/BigComplexMath.java",
"content": "package ch.obermuhlner.math.big;\n\nimport static ch.obermuhlner.math.big.BigComplex.I;\n\nimport java.math.BigDecimal;\nimport java.math.MathContext;\nimport java.util.List;\n\n/**\n * Provides advanced functions operating on {@link BigComplex}s.\n */\npublic class BigComplexMath {\n\n\tprivate static final BigDecimal TWO = BigDecimal.valueOf(2);\n\n\t/**\n\t * Calculates the reciprocal of the given complex number using the specified {@link MathContext}.\n\t *\n\t * @param x the complex number to calculate the reciprocal\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t * @see BigComplex#reciprocal(MathContext)\n\t */\n\tpublic static BigComplex reciprocal(BigComplex x, MathContext mathContext) {\n\t\treturn x.reciprocal(mathContext);\n\t}\n\n\t/**\n\t * Calculates the conjugate of the given complex number using the specified {@link MathContext}.\n\t *\n\t * @param x the complex number to calculate the conjugate\n\t * @return the calculated {@link BigComplex} result\n\t * @see BigComplex#conjugate()\n\t */\n\tpublic static BigComplex conjugate(BigComplex x) {\n\t\treturn x.conjugate();\n\t}\n\n\t/**\n\t * Calculates the absolute value (also known as magnitude, length or radius) of the given complex number using the specified {@link MathContext}.\n\t *\n\t * @param x the complex number to calculate the absolute value\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t * @see BigComplex#abs(MathContext)\n\t */\n\tpublic static BigDecimal abs(BigComplex x, MathContext mathContext) {\n\t\treturn x.abs(mathContext);\n\t}\n\n\t/**\n\t * Calculates the square of the absolute value (also known as magnitude, length or radius) of the given complex number using the specified {@link MathContext}.\n\t *\n\t * @param x the complex number to calculate the square of the absolute value\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} result\n\t * @see BigComplex#absSquare(MathContext)\n\t */\n\tpublic static BigDecimal absSquare(BigComplex x, MathContext mathContext) {\n\t\treturn x.absSquare(mathContext);\n\t}\n\n\t/**\n\t * Calculates the angle in radians of the given complex number using the specified {@link MathContext}.\n\t *\n\t * @param x the complex number to calculate the angle\n\t * @param mathContext the {@link MathContext} used to calculate the result\n\t * @return the calculated {@link BigComplex} angle in radians\n\t * @see BigComplex#angle(MathContext)\n\t */\n\tpublic static BigDecimal angle(BigComplex x, MathContext mathContext) {\n\t\treturn x.angle(mathContext);\n\t}\n\n\t/**\n\t * Calculates the factorial of the specified {@link BigComplex}.\n\t *\n\t *
This implementation uses\n\t * Spouge's approximation\n\t * to calculate the factorial for non-integer values.
\n\t *\n\t *
This involves calculating a series of constants that depend on the desired precision.\n\t * Since this constant calculation is quite expensive (especially for higher precisions),\n\t * the constants for a specific precision will be cached\n\t * and subsequent calls to this method with the same precision will be much faster.
\n\t *\n\t *
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n\t * and to avoid calling it with many different precisions.
\n\t *\n\t * @param x the {@link BigComplex}\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the factorial {@link BigComplex}\n\t * @throws ArithmeticException if x is a negative integer value (-1, -2, -3, ...)\n\t * @see BigDecimalMath#factorial(BigDecimal, MathContext)\n\t * @see #gamma(BigComplex, MathContext)\n\t */\n\tpublic static BigComplex factorial(BigComplex x, MathContext mathContext) {\n\t\tif (x.isReal() && BigDecimalMath.isIntValue(x.re) && x.re.intValueExact() > 0) {\n\t\t\treturn BigComplex.valueOf(BigDecimalMath.factorial(x.re.intValueExact()).round(mathContext));\n\t\t}\n\n\t\t// https://en.wikipedia.org/wiki/Spouge%27s_approximation\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() * 2, mathContext.getRoundingMode());\n\n\t\tint a = mathContext.getPrecision() * 13 / 10;\n\t\tList constants = BigDecimalMath.getSpougeFactorialConstants(a);\n\n\t\tBigDecimal bigA = BigDecimal.valueOf(a);\n\n\t\tboolean negative = false;\n\t\tBigComplex factor = BigComplex.valueOf(constants.get(0));\n\t\tfor (int k = 1; k < a; k++) {\n\t\t\tBigDecimal bigK = BigDecimal.valueOf(k);\n\t\t\tfactor = factor.add(BigComplex.valueOf(constants.get(k)).divide(x.add(bigK), mc), mc);\n\t\t\tnegative = !negative;\n\t\t}\n\n\t\tBigComplex result = pow(x.add(bigA, mc), x.add(BigDecimal.valueOf(0.5), mc), mc);\n\t\tresult = result.multiply(exp(x.negate().subtract(bigA, mc), mc), mc);\n\t\tresult = result.multiply(factor, mc);\n\n\t\treturn result.round(mathContext);\n\t}\n\n\t/**\n\t * Calculates the gamma function of the specified {@link BigComplex}.\n\t *\n\t *
This implementation uses {@link #factorial(BigComplex, MathContext)} internally,\n\t * therefore the performance implications described there apply also for this method.\n\t *\n\t *
\n\t *\n\t * @param x the {@link BigComplex}\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the gamma {@link BigComplex}\n\t * @throws ArithmeticException if x-1 is a negative integer value (-1, -2, -3, ...)\n\t * @see BigDecimalMath#gamma(BigDecimal, MathContext)\n\t * @see #factorial(BigComplex, MathContext)\n\t */\n\tpublic static BigComplex gamma(BigComplex x, MathContext mathContext) {\n\t\treturn factorial(x.subtract(BigComplex.ONE), mathContext);\n\t}\n\n\n\t/**\n\t * Calculates the natural exponent of {@link BigComplex} x (ex) in the complex domain.\n\t *\n\t *
\n\t *\n\t * @param x the {@link BigComplex} to calculate the exponent for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated exponent {@link BigComplex} with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex exp(BigComplex x, MathContext mathContext) {\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\n\t\tBigDecimal expRe = BigDecimalMath.exp(x.re, mc);\n\t\treturn BigComplex.valueOf(\n\t\t\t\texpRe.multiply(BigDecimalMath.cos(x.im, mc), mc).round(mathContext),\n\t\t\t\texpRe.multiply(BigDecimalMath.sin(x.im, mc), mc)).round(mathContext);\n\t}\n\n\t/**\n\t * Calculates the sine (sinus) of {@link BigComplex} x in the complex domain.\n\t *\n\t *
\n\t *\n\t * @param x the {@link BigComplex} to calculate the sine for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated sine {@link BigComplex} with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex sin(BigComplex x, MathContext mathContext) {\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\t\t\n\t\treturn BigComplex.valueOf(\n\t\t\t\tBigDecimalMath.sin(x.re, mc).multiply(BigDecimalMath.cosh(x.im, mc), mc).round(mathContext),\n\t\t\t\tBigDecimalMath.cos(x.re, mc).multiply(BigDecimalMath.sinh(x.im, mc), mc).round(mathContext));\n\t}\n\n\t/**\n\t * Calculates the cosine (cosinus) of {@link BigComplex} x in the complex domain.\n\t *\n\t * @param x the {@link BigComplex} to calculate the cosine for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated cosine {@link BigComplex} with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex cos(BigComplex x, MathContext mathContext) {\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\n\t\treturn BigComplex.valueOf(\n\t\t\t\tBigDecimalMath.cos(x.re, mc).multiply(BigDecimalMath.cosh(x.im, mc), mc).round(mathContext),\n\t\t\t\tBigDecimalMath.sin(x.re, mc).multiply(BigDecimalMath.sinh(x.im, mc), mc).negate().round(mathContext));\n\t}\n\t\n\t// \n\t// http://scipp.ucsc.edu/~haber/archives/physics116A10/arc_10.pdf\n\n\t/**\n\t * Calculates the tangens of {@link BigComplex} x in the complex domain.\n\t *\n\t * @param x the {@link BigComplex} to calculate the tangens for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated tangens {@link BigComplex} with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex tan(BigComplex x, MathContext mathContext) {\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\n\t\treturn sin(x, mc).divide(cos(x, mc), mc).round(mathContext);\n\t}\n\n\t/**\n\t * Calculates the arc tangens (inverted tangens) of {@link BigComplex} x in the complex domain.\n\t *\n\t *
\n\t *\n\t * @param x the {@link BigComplex} to calculate the arc tangens for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated arc tangens {@link BigComplex} with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex atan(BigComplex x, MathContext mathContext) {\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\n\t\treturn log(I.subtract(x, mc).divide(I.add(x, mc), mc), mc).divide(I, mc).divide(TWO, mc).round(mathContext);\n\t}\n\n\t/**\n\t * Calculates the arc cotangens (inverted cotangens) of {@link BigComplex} x in the complex domain.\n\t *\n\t *
\n\t *\n\t * @param x the {@link BigComplex} to calculate the arc cotangens for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated arc cotangens {@link BigComplex} with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex acot(BigComplex x, MathContext mathContext) {\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\n\t\treturn log(x.add(I, mc).divide(x.subtract(I, mc), mc), mc).divide(I, mc).divide(TWO, mc).round(mathContext);\n\t}\n\t\n\t/**\n\t * Calculates the arc sine (inverted sine) of {@link BigComplex} x in the complex domain.\n\t *\n\t *
\n\t *\n\t * @param x the {@link BigComplex} to calculate the arc sine for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated arc sine {@link BigComplex} with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex asin(BigComplex x, MathContext mathContext) {\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\n\t\treturn I.negate().multiply(log(I.multiply(x, mc).add(sqrt(BigComplex.ONE.subtract(x.multiply(x, mc), mc), mc), mc), mc), mc).round(mathContext);\n\t}\n\n\t/**\n\t * Calculates the arc cosine (inverted cosine) of {@link BigComplex} x in the complex domain.\n\t *\n\t *
\n\t *\n\t * @param x the {@link BigComplex} to calculate the arc cosine for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated arc cosine {@link BigComplex} with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex acos(BigComplex x, MathContext mathContext) {\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\n\t\treturn I.negate().multiply(log(x.add(sqrt(x.multiply(x, mc).subtract(BigComplex.ONE, mc), mc), mc), mc), mc).round(mathContext);\n\t}\n\t\n\t/**\n\t * Calculates the square root of {@link BigComplex} x in the complex domain (√x).\n\t *\n\t *
\n\t *\n\t * @param x the {@link BigComplex} to calculate the square root for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated square root {@link BigComplex} with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex sqrt(BigComplex x, MathContext mathContext) {\n\t\t// https://math.stackexchange.com/questions/44406/how-do-i-get-the-square-root-of-a-complex-number\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\n\t\tBigDecimal magnitude = x.abs(mc);\n\n\t\tBigComplex a = x.add(magnitude, mc);\n\t\treturn a.divide(a.abs(mc), mc).multiply(BigDecimalMath.sqrt(magnitude, mc), mc).round(mathContext);\n\t}\n\n\t/**\n\t * Calculates the natural logarithm of {@link BigComplex} x in the complex domain.\n\t *\n\t *
\n\t *\n\t * @param x the {@link BigComplex} to calculate the natural logarithm for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated natural logarithm {@link BigComplex} with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex log(BigComplex x, MathContext mathContext) {\n\t\t// https://en.wikipedia.org/wiki/Complex_logarithm\n\t\tMathContext mc1 = new MathContext(mathContext.getPrecision() + 20, mathContext.getRoundingMode());\n\t\tMathContext mc2 = new MathContext(mathContext.getPrecision() + 5, mathContext.getRoundingMode());\n\n\t\treturn BigComplex.valueOf(\n\t\t\t\tBigDecimalMath.log(x.abs(mc1), mc1).round(mathContext),\n\t\t\t\tx.angle(mc2)).round(mathContext);\n\t}\n\n\t/**\n\t * Calculates {@link BigComplex} x to the power of long y (xy).\n\t *\n\t *
The implementation tries to minimize the number of multiplications of {@link BigComplex x} (using squares whenever possible).
\n\t *\n\t * @param x the {@link BigComplex} value to take to the power\n\t * @param y the long value to serve as exponent\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated x to the power of y with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex pow(BigComplex x, long y, MathContext mathContext) {\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 10, mathContext.getRoundingMode());\n\n\t\tif (y < 0) {\n\t\t\treturn BigComplex.ONE.divide(pow(x, -y, mc), mc).round(mathContext);\n\t\t}\n\t\t\n\t\tBigComplex result = BigComplex.ONE;\n\t\twhile (y > 0) {\n\t\t\tif ((y & 1) == 1) {\n\t\t\t\t// odd exponent -> multiply result with x\n\t\t\t\tresult = result.multiply(x, mc);\n\t\t\t\ty -= 1;\n\t\t\t}\n\t\t\t\n\t\t\tif (y > 0) {\n\t\t\t\t// even exponent -> square x\n\t\t\t\tx = x.multiply(x, mc);\n\t\t\t}\n\t\t\t\n\t\t\ty >>= 1;\n\t\t}\n\n\t\treturn result.round(mathContext);\n\t}\n\n\t/**\n\t * Calculates {@link BigComplex} x to the power of {@link BigDecimal} y (xy).\n\t *\n\t * @param x the {@link BigComplex} value to take to the power\n\t * @param y the {@link BigDecimal} value to serve as exponent\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated x to the power of y with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex pow(BigComplex x, BigDecimal y, MathContext mathContext) {\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\n\t\tBigDecimal angleTimesN = x.angle(mc).multiply(y, mc);\n\t\treturn BigComplex.valueOf(\n\t\t\t\tBigDecimalMath.cos(angleTimesN, mc),\n\t\t\t\tBigDecimalMath.sin(angleTimesN, mc)).multiply(BigDecimalMath.pow(x.abs(mc), y, mc), mc).round(mathContext);\n\t}\n\n\t/**\n\t * Calculates {@link BigComplex} x to the power of {@link BigComplex} y (xy).\n\t *\n\t * @param x the {@link BigComplex} value to take to the power\n\t * @param y the {@link BigComplex} value to serve as exponent\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated x to the power of y with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex pow(BigComplex x, BigComplex y, MathContext mathContext) {\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\n\t\treturn exp(y.multiply(log(x, mc), mc), mc).round(mathContext);\n\t}\n\n\t/**\n\t * Calculates the {@link BigDecimal} n'th root of {@link BigComplex} x (n√x).\n\t *\n\t *
\n\t * @param x the {@link BigComplex} value to calculate the n'th root\n\t * @param n the {@link BigDecimal} defining the root\n\t * @param mathContext the {@link MathContext} used for the result\n\t *\n\t * @return the calculated n'th root of x with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex root(BigComplex x, BigDecimal n, MathContext mathContext) {\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\n\t\treturn pow(x, BigDecimal.ONE.divide(n, mc), mc).round(mathContext);\n\t}\n\n\t/**\n\t * Calculates the {@link BigComplex} n'th root of {@link BigComplex} x (n√x).\n\t *\n\t *
\n\t * @param x the {@link BigComplex} value to calculate the n'th root\n\t * @param n the {@link BigComplex} defining the root\n\t * @param mathContext the {@link MathContext} used for the result\n\t *\n\t * @return the calculated n'th root of x with the precision specified in the mathContext\n\t */\n\tpublic static BigComplex root(BigComplex x, BigComplex n, MathContext mathContext) {\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\n\t\treturn pow(x, BigComplex.ONE.divide(n, mc), mc).round(mathContext);\n\t}\n\t\n\t// TODO add root() for the k'th root - https://math.stackexchange.com/questions/322481/principal-nth-root-of-a-complex-number \n}\n"
},
{
"path": "ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/BigDecimalMath.java",
"content": "package ch.obermuhlner.math.big;\n\nimport static java.math.BigDecimal.ONE;\nimport static java.math.BigDecimal.TEN;\nimport static java.math.BigDecimal.ZERO;\nimport static java.math.BigDecimal.valueOf;\n\nimport java.math.BigDecimal;\nimport java.math.MathContext;\nimport java.util.*;\n\nimport ch.obermuhlner.math.big.internal.AsinCalculator;\nimport ch.obermuhlner.math.big.internal.CosCalculator;\nimport ch.obermuhlner.math.big.internal.CoshCalculator;\nimport ch.obermuhlner.math.big.internal.ExpCalculator;\nimport ch.obermuhlner.math.big.internal.SinCalculator;\nimport ch.obermuhlner.math.big.internal.SinhCalculator;\n\n/**\n * Provides advanced functions operating on {@link BigDecimal}s.\n */\npublic class BigDecimalMath {\n\n\tprivate static final BigDecimal TWO = valueOf(2);\n\tprivate static final BigDecimal THREE = valueOf(3);\n\tprivate static final BigDecimal MINUS_ONE = valueOf(-1);\n\tprivate static final BigDecimal ONE_HALF = valueOf(0.5);\n\n\tprivate static final BigDecimal ONE_HUNDRED_EIGHTY = valueOf(180);\n\n\tprivate static final BigDecimal DOUBLE_MAX_VALUE = BigDecimal.valueOf(Double.MAX_VALUE);\n\n\tprivate static volatile BigDecimal log2Cache;\n\tprivate static final Object log2CacheLock = new Object();\n\n\tprivate static volatile BigDecimal log3Cache;\n\tprivate static final Object log3CacheLock = new Object();\n\n\tprivate static volatile BigDecimal log10Cache;\n\tprivate static final Object log10CacheLock = new Object();\n\n\tprivate static volatile BigDecimal piCache;\n\tprivate static final Object piCacheLock = new Object();\n\n\tprivate static volatile BigDecimal eCache;\n\tprivate static final Object eCacheLock = new Object();\n\n\tprivate static final BigDecimal ROUGHLY_TWO_PI = new BigDecimal(\"3.141592653589793\").multiply(TWO);\n\n\tprivate static final int EXPECTED_INITIAL_PRECISION = 15;\n\n\tprivate static BigDecimal[] factorialCache = new BigDecimal[100];\n\n\tstatic {\n\t\tBigDecimal result = ONE;\n\t\tfactorialCache[0] = result;\n\t\tfor (int i = 1; i < factorialCache.length; i++) {\n\t\t\tresult = result.multiply(valueOf(i));\n\t\t\tfactorialCache[i] = result;\n\t\t}\n\t}\n\n\tprivate static final Map> spougeFactorialConstantsCache = new HashMap<>();\n\tprivate static final Object spougeFactorialConstantsCacheLock = new Object();\n\n\tprivate BigDecimalMath() {\n\t\t// prevent instances\n\t}\n\n\t/**\n\t * Creates a {@link BigDecimal} from the specified String representation.\n\t *\n\t *
This method is equivalent to the String constructor {@link BigDecimal#BigDecimal(String)}\n\t * but has been optimized for large strings (several thousand digits).
\n\t *\n\t * @param string the String representation\n\t * @return the created {@link BigDecimal}\n\t * @throws NumberFormatException if string is not a valid representation of a {@link BigDecimal}\n\t * @see BigDecimal#BigDecimal(String)\n\t * @see #toBigDecimal(String, MathContext)\n\t */\n\tpublic static BigDecimal toBigDecimal(String string) {\n\t\treturn toBigDecimal(string, MathContext.UNLIMITED);\n\t}\n\n\t/**\n\t * Creates a {@link BigDecimal} from the specified String representation.\n\t *\n\t *
This method is equivalent to the String constructor {@link BigDecimal#BigDecimal(String, MathContext)}\n\t * but has been optimized for large strings (several thousand digits).
\n\t *\n\t * @param string the string representation\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the created {@link BigDecimal}\n\t * @throws NumberFormatException if string is not a valid representation of a {@link BigDecimal}\n\t * @throws ArithmeticException if the result is inexact but the rounding mode is {@code UNNECESSARY}\n\t * @see BigDecimal#BigDecimal(String, MathContext)\n\t * @see #toBigDecimal(String)\n\t */\n\tpublic static BigDecimal toBigDecimal(String string, MathContext mathContext) {\n\t\tint len = string.length();\n\t\tif (len < 600) {\n\t\t\treturn new BigDecimal(string, mathContext);\n\t\t}\n\n\t\tint splitLength = len / (len >= 10000 ? 8 : 5);\n\t\treturn toBigDecimal(string, mathContext, splitLength);\n\t}\n\n\tstatic BigDecimal toBigDecimal(String string, MathContext mathContext, int splitLength) {\n\t\tint len = string.length();\n\n\t\tif (len < splitLength) {\n\t\t\treturn new BigDecimal(string, mathContext);\n\t\t}\n\n\t\tchar[] chars = string.toCharArray();\n\n\t\tboolean numberHasSign = false;\n\t\tboolean negative = false;\n\t\tint numberIndex = 0;\n\t\tint dotIndex = -1;\n\t\tint expIndex = -1;\n\t\tboolean expHasSign = false;\n\t\tint scale = 0;\n\n\t\tfor (int i = 0; i < len; i++) {\n\t\t\tchar c = chars[i];\n\t\t\tswitch (c) {\n\t\t\t\tcase '+':\n\t\t\t\t\tif (expIndex >= 0) {\n\t\t\t\t\t\tif (expHasSign) {\n\t\t\t\t\t\t\tthrow new NumberFormatException(\"Multiple signs in exponent\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\texpHasSign = true;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tif (numberHasSign) {\n\t\t\t\t\t\t\tthrow new NumberFormatException(\"Multiple signs in number\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\tnumberHasSign = true;\n\t\t\t\t\t\tnumberIndex = i + 1;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase '-':\n\t\t\t\t\tif (expIndex >= 0) {\n\t\t\t\t\t\tif (expHasSign) {\n\t\t\t\t\t\t\tthrow new NumberFormatException(\"Multiple signs in exponent\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\texpHasSign = true;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tif (numberHasSign) {\n\t\t\t\t\t\t\tthrow new NumberFormatException(\"Multiple signs in number\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\tnumberHasSign = true;\n\t\t\t\t\t\tnegative = true;\n\t\t\t\t\t\tnumberIndex = i + 1;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase 'e':\n\t\t\t\tcase 'E':\n\t\t\t\t\tif (expIndex >= 0) {\n\t\t\t\t\t\tthrow new NumberFormatException(\"Multiple exponent markers\");\n\t\t\t\t\t}\n\t\t\t\t\texpIndex = i;\n\t\t\t\t\tbreak;\n\t\t\t\tcase '.':\n\t\t\t\t\tif (dotIndex >= 0) {\n\t\t\t\t\t\tthrow new NumberFormatException(\"Multiple decimal points\");\n\t\t\t\t\t}\n\t\t\t\t\tdotIndex = i;\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tif (dotIndex >= 0 && expIndex == -1) {\n\t\t\t\t\t\tscale++;\n\t\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tint numberEndIndex;\n\t\tint exp = 0;\n\t\tif (expIndex >= 0) {\n\t\t\tnumberEndIndex = expIndex;\n\t\t\tString expString = new String(chars, expIndex + 1, len - expIndex - 1);\n\t\t\texp = Integer.parseInt(expString);\n\t\t\tscale = adjustScale(scale, exp);\n\t\t} else {\n\t\t\tnumberEndIndex = len;\n\t\t}\n\n\t\tBigDecimal result;\n\n\t\tif (dotIndex >= 0) {\n\t\t\tint leftLength = dotIndex - numberIndex;\n\t\t\tBigDecimal bigDecimalLeft = toBigDecimalRecursive(chars, numberIndex, leftLength, exp, splitLength);\n\t\t\tint rightLength = numberEndIndex - dotIndex - 1;\n\t\t\tBigDecimal bigDecimalRight = toBigDecimalRecursive(chars, dotIndex + 1, rightLength, exp-rightLength, splitLength);\n\t\t\tresult = bigDecimalLeft.add(bigDecimalRight);\n\t\t} else {\n\t\t\tresult = toBigDecimalRecursive(chars, numberIndex, numberEndIndex - numberIndex, exp, splitLength);\n\t\t}\n\n\t\tif (scale != 0) {\n\t\t\tresult = result.setScale(scale);\n\t\t}\n\n\t\tif (negative) {\n\t\t\tresult = result.negate();\n\t\t}\n\n\t\tif (mathContext.getPrecision() != 0) {\n\t\t\tresult = result.round(mathContext);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\tprivate static int adjustScale(int scale, long exp) {\n\t\tlong adjustedScale = scale - exp;\n\t\tif (adjustedScale > Integer.MAX_VALUE || adjustedScale < Integer.MIN_VALUE)\n\t\t\tthrow new NumberFormatException(\"Scale out of range: \" + adjustedScale + \" while adjusting scale \" + scale + \" to exponent \" + exp);\n\t\treturn (int) adjustedScale;\n\t}\n\n\tprivate static BigDecimal toBigDecimalRecursive(char[] chars, int offset, int length, int scale, int splitLength) {\n\t\tif (length > splitLength) {\n\t\t\tint mid = length / 2;\n\t\t\tBigDecimal bigDecimalLeft = toBigDecimalRecursive(chars, offset, mid, scale + length - mid, splitLength);\n\t\t\tBigDecimal bigDecimalRight = toBigDecimalRecursive(chars, offset + mid, length - mid, scale, splitLength);\n\t\t\treturn bigDecimalLeft.add(bigDecimalRight);\n\t\t}\n\t\tif (length == 0) {\n\t\t\treturn BigDecimal.ZERO;\n\t\t}\n\t\treturn new BigDecimal(chars, offset, length).movePointRight(scale);\n\t}\n\n\t/**\n\t * Returns whether the specified {@link BigDecimal} value can be represented as int.\n\t *\n\t *
If this returns true you can call {@link BigDecimal#intValueExact()} without fear of an {@link ArithmeticException}.
\n\t *\n\t * @param value the {@link BigDecimal} to check\n\t * @return true if the value can be represented as int value\n\t */\n\tpublic static boolean isIntValue(BigDecimal value) {\n\t\t// TODO impl isIntValue() without exceptions\n\t\ttry {\n\t\t\tvalue.intValueExact();\n\t\t\treturn true;\n\t\t} catch (ArithmeticException ex) {\n\t\t\t// ignored\n\t\t}\n\t\treturn false;\n\t}\n\n\t/**\n\t * Returns whether the specified {@link BigDecimal} value can be represented as long.\n\t *\n\t *
If this returns true you can call {@link BigDecimal#longValueExact()} without fear of an {@link ArithmeticException}.
\n\t *\n\t * @param value the {@link BigDecimal} to check\n\t * @return true if the value can be represented as long value\n\t */\n\tpublic static boolean isLongValue(BigDecimal value) {\n\t\t// TODO impl isLongValue() without exceptions\n\t\ttry {\n\t\t\tvalue.longValueExact();\n\t\t\treturn true;\n\t\t} catch (ArithmeticException ex) {\n\t\t\t// ignored\n\t\t}\n\t\treturn false;\n\t}\n\n\t/**\n\t * Returns whether the specified {@link BigDecimal} value can be represented as double.\n\t *\n\t *
If this returns true you can call {@link BigDecimal#doubleValue()}\n\t * without fear of getting {@link Double#POSITIVE_INFINITY} or {@link Double#NEGATIVE_INFINITY} as result.
\n\t *\n\t *
Example: BigDecimalMath.isDoubleValue(new BigDecimal(\"1E309\")) returns false,\n\t * because new BigDecimal(\"1E309\").doubleValue() returns Infinity.
\n\t *\n\t *
Note: This method does not check for possible loss of precision.
\n\t *\n\t *
For example BigDecimalMath.isDoubleValue(new BigDecimal(\"1.23400000000000000000000000000000001\")) will return true,\n\t * because new BigDecimal(\"1.23400000000000000000000000000000001\").doubleValue() returns a valid double value,\n\t * although it loses precision and returns 1.234.
\n\t *\n\t *
BigDecimalMath.isDoubleValue(new BigDecimal(\"1E-325\")) will return true\n\t * although this value is smaller than {@link Double#MIN_VALUE} (and therefore outside the range of values that can be represented as double)\n\t * because new BigDecimal(\"1E-325\").doubleValue() returns 0 which is a legal value with loss of precision.
\n\t *\n\t * @param value the {@link BigDecimal} to check\n\t * @return true if the value can be represented as double value\n\t */\n\tpublic static boolean isDoubleValue(BigDecimal value) {\n\t\tif (value.compareTo(DOUBLE_MAX_VALUE) > 0) {\n\t\t\treturn false;\n\t\t}\n\t\tif (value.compareTo(DOUBLE_MAX_VALUE.negate()) < 0) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t}\n\n\t/**\n\t * Returns the mantissa of the specified {@link BigDecimal} written as mantissa * 10exponent.\n\t *\n\t *
The mantissa is defined as having exactly 1 digit before the decimal point.
\n\t *\n\t * @param value the {@link BigDecimal}\n\t * @return the mantissa\n\t * @see #exponent(BigDecimal)\n\t */\n\tpublic static BigDecimal mantissa(BigDecimal value) {\n\t\tint exponent = exponent(value);\n\t\tif (exponent == 0) {\n\t\t\treturn value;\n\t\t}\n\n\t\treturn value.movePointLeft(exponent);\n\t}\n\n\t/**\n\t * Returns the exponent of the specified {@link BigDecimal} written as mantissa * 10exponent.\n\t *\n\t *
The mantissa is defined as having exactly 1 digit before the decimal point.
\n\t *\n\t * @param value the {@link BigDecimal}\n\t * @return the exponent\n\t * @see #mantissa(BigDecimal)\n\t */\n\tpublic static int exponent(BigDecimal value) {\n\t\treturn value.precision() - value.scale() - 1;\n\t}\n\n\t/**\n\t * Returns the number of significant digits of the specified {@link BigDecimal}.\n\t *\n\t *
The result contains the number of all digits before the decimal point and\n\t * all digits after the decimal point excluding trailing zeroes.
\n\t *\n\t * @param value the {@link BigDecimal}\n\t * @return the number of significant digits\n\t * @see BigDecimal#stripTrailingZeros()\n\t * @see BigDecimal#precision()\n\t */\n\tpublic static int significantDigits(BigDecimal value) {\n\t\tBigDecimal stripped = value.stripTrailingZeros();\n\t\tif (stripped.scale() >= 0) {\n\t\t\treturn stripped.precision();\n\t\t} else {\n\t\t\treturn stripped.precision() - stripped.scale();\n\t\t}\n\t}\n\n\t/**\n\t * Returns the integral part of the specified {@link BigDecimal} (left of the decimal point).\n\t *\n\t * @param value the {@link BigDecimal}\n\t * @return the integral part\n\t * @see #fractionalPart(BigDecimal)\n\t */\n\tpublic static BigDecimal integralPart(BigDecimal value) {\n\t\treturn value.setScale(0, BigDecimal.ROUND_DOWN);\n\t}\n\n\t/**\n\t * Returns the fractional part of the specified {@link BigDecimal} (right of the decimal point).\n\t *\n\t * @param value the {@link BigDecimal}\n\t * @return the fractional part\n\t * @see #integralPart(BigDecimal)\n\t */\n\tpublic static BigDecimal fractionalPart(BigDecimal value) {\n\t\treturn value.subtract(integralPart(value));\n\t}\n\n /**\n * Rounds the specified {@link BigDecimal} to the precision of the specified {@link MathContext}.\n *\n *
This method calls {@link BigDecimal#round(MathContext)}.
\n *\n * @param value the {@link BigDecimal} to round\n * @param mathContext the {@link MathContext} used for the result\n * @return the rounded {@link BigDecimal} value\n * @see BigDecimal#round(MathContext)\n * @see BigDecimalMath#roundWithTrailingZeroes(BigDecimal, MathContext)\n */\n public static BigDecimal round(BigDecimal value, MathContext mathContext) {\n\t return value.round(mathContext);\n }\n\n\t/**\n\t * Rounds the specified {@link BigDecimal} to the precision of the specified {@link MathContext} including trailing zeroes.\n\t *\n\t *
This method is similar to {@link BigDecimal#round(MathContext)} but does not remove the trailing zeroes.
\n\t *\n\t * @param value the {@link BigDecimal} to round\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the rounded {@link BigDecimal} value including trailing zeroes\n\t * @see BigDecimal#round(MathContext)\n * @see BigDecimalMath#round(BigDecimal, MathContext)\n\t */\n\tpublic static BigDecimal roundWithTrailingZeroes(BigDecimal value, MathContext mathContext) {\n\t\tif (value.precision() == mathContext.getPrecision()) {\n\t\t\treturn value;\n\t\t}\n\t\tif (value.signum() == 0) {\n\t\t\treturn BigDecimal.ZERO.setScale(mathContext.getPrecision() - 1);\n\t\t}\n\n\t\ttry {\n BigDecimal stripped = value.stripTrailingZeros();\n int exponentStripped = exponent(stripped); // value.precision() - value.scale() - 1;\n\n BigDecimal zero;\n if (exponentStripped < -1) {\n zero = BigDecimal.ZERO.setScale(mathContext.getPrecision() - exponentStripped);\n } else {\n zero = BigDecimal.ZERO.setScale(mathContext.getPrecision() + exponentStripped + 1);\n }\n return stripped.add(zero, mathContext);\n } catch (ArithmeticException ex) {\n\t\t return value.round(mathContext);\n }\n\t}\n\n\t/**\n\t * Calculates the reciprocal of the specified {@link BigDecimal}.\n\t *\n\t * @param x the {@link BigDecimal}\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the reciprocal {@link BigDecimal}\n\t * @throws ArithmeticException if x = 0\n\t * @throws ArithmeticException if the result is inexact but the\n\t * rounding mode is {@code UNNECESSARY} or\n\t * {@code mc.precision == 0} and the quotient has a\n\t * non-terminating decimal expansion.\n\t */\n\tpublic static BigDecimal reciprocal(BigDecimal x, MathContext mathContext) {\n\t\treturn BigDecimal.ONE.divide(x, mathContext);\n\t}\n\n\t/**\n\t * Calculates the factorial of the specified integer argument.\n\t *\n\t *
factorial = 1 * 2 * 3 * ... n
\n\t *\n\t * @param n the {@link BigDecimal}\n\t * @return the factorial {@link BigDecimal}\n\t * @throws ArithmeticException if x < 0\n\t */\n\tpublic static BigDecimal factorial(int n) {\n\t\tif (n < 0) {\n\t\t\tthrow new ArithmeticException(\"Illegal factorial(n) for n < 0: n = \" + n);\n\t\t}\n\t\tif (n < factorialCache.length) {\n\t\t\treturn factorialCache[n];\n\t\t}\n\n\t\tBigDecimal result = factorialCache[factorialCache.length - 1];\n\t\treturn result.multiply(factorialRecursion(factorialCache.length, n));\n\t}\n\n private static BigDecimal factorialLoop(int n1, final int n2) {\n\t\tfinal long limit = Long.MAX_VALUE / n2;\n long accu = 1;\n BigDecimal result = BigDecimal.ONE;\n while (n1 <= n2) {\n if (accu <= limit) {\n accu *= n1;\n } else {\n result = result.multiply(BigDecimal.valueOf(accu));\n accu = n1;\n }\n n1++;\n }\n return result.multiply(BigDecimal.valueOf(accu));\n }\n\n private static BigDecimal factorialRecursion(final int n1, final int n2) {\n\t\tint threshold = n1 > 200 ? 80 : 150;\n if (n2 - n1 < threshold) {\n return factorialLoop(n1, n2);\n }\n final int mid = (n1 + n2) >> 1;\n return factorialRecursion(mid + 1, n2).multiply(factorialRecursion(n1, mid));\n }\n\n\t/**\n\t * Calculates the factorial of the specified {@link BigDecimal}.\n\t *\n\t *
This implementation uses\n\t * Spouge's approximation\n\t * to calculate the factorial for non-integer values.
\n\t *\n\t *
This involves calculating a series of constants that depend on the desired precision.\n\t * Since this constant calculation is quite expensive (especially for higher precisions),\n\t * the constants for a specific precision will be cached\n\t * and subsequent calls to this method with the same precision will be much faster.
\n\t *\n\t *
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n\t * and to avoid calling it with many different precisions.
\n\t *\n\t * @param x the {@link BigDecimal}\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the factorial {@link BigDecimal}\n\t * @throws ArithmeticException if x is a negative integer value (-1, -2, -3, ...)\n\t * @throws UnsupportedOperationException if x is a non-integer value and the {@link MathContext} has unlimited precision\n\t * @see #factorial(int)\n\t * @see #gamma(BigDecimal, MathContext)\n\t */\n\tpublic static BigDecimal factorial(BigDecimal x, MathContext mathContext) {\n\t\tif (isIntValue(x)) {\n\t\t\treturn round(factorial(x.intValueExact()), mathContext);\n\t\t}\n\n\t\t// https://en.wikipedia.org/wiki/Spouge%27s_approximation\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() << 1, mathContext.getRoundingMode());\n\n\t\tint a = mathContext.getPrecision() * 13 / 10;\n\t\tList constants = getSpougeFactorialConstants(a);\n\n\t\tBigDecimal bigA = BigDecimal.valueOf(a);\n\n\t\tboolean negative = false;\n\t\tBigDecimal factor = constants.get(0);\n\t\tfor (int k = 1; k < a; k++) {\n\t\t\tBigDecimal bigK = BigDecimal.valueOf(k);\n\t\t\tfactor = factor.add(constants.get(k).divide(x.add(bigK), mc));\n\t\t\tnegative = !negative;\n\t\t}\n\n\t\tBigDecimal result = pow(x.add(bigA), x.add(BigDecimal.valueOf(0.5)), mc);\n\t\tresult = result.multiply(exp(x.negate().subtract(bigA), mc));\n\t\tresult = result.multiply(factor);\n\n\t\treturn round(result, mathContext);\n\t}\n\n\tstatic List getSpougeFactorialConstants(int a) {\n\t\tsynchronized (spougeFactorialConstantsCacheLock) {\n\t\t\treturn spougeFactorialConstantsCache.computeIfAbsent(a, key -> {\n\t\t\t\tList constants = new ArrayList<>(a);\n\t\t\t\tMathContext mc = new MathContext(a * 15 / 10);\n\n\t\t\t\tBigDecimal c0 = sqrt(pi(mc).multiply(TWO, mc), mc);\n\t\t\t\tconstants.add(c0);\n\n\t\t\t\tboolean negative = false;\n\t\t\t\tfor (int k = 1; k < a; k++) {\n\t\t\t\t\tBigDecimal bigK = BigDecimal.valueOf(k);\n\t\t\t\t\tlong deltaAK = (long)a - k;\n\t\t\t\t\tBigDecimal ck = pow(BigDecimal.valueOf(deltaAK), bigK.subtract(ONE_HALF), mc);\n\t\t\t\t\tck = ck.multiply(exp(BigDecimal.valueOf(deltaAK), mc), mc);\n\t\t\t\t\tck = ck.divide(factorial(k - 1), mc);\n\t\t\t\t\tif (negative) {\n\t\t\t\t\t\tck = ck.negate();\n\t\t\t\t\t}\n\t\t\t\t\tconstants.add(ck);\n\n\t\t\t\t\tnegative = !negative;\n\t\t\t\t}\n\n\t\t\t\treturn Collections.unmodifiableList(constants);\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Calculates the gamma function of the specified {@link BigDecimal}.\n\t *\n\t *
This implementation uses {@link #factorial(BigDecimal, MathContext)} internally,\n\t * therefore the performance implications described there apply also for this method.\n\t *\n\t *
\n\t *\n\t * @param x the {@link BigDecimal}\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the gamma {@link BigDecimal}\n\t * @throws ArithmeticException if x-1 is a negative integer value (-1, -2, -3, ...)\n\t * @throws UnsupportedOperationException if x is a non-integer value and the {@link MathContext} has unlimited precision\n\t * @see #factorial(BigDecimal, MathContext)\n\t */\n\tpublic static BigDecimal gamma(BigDecimal x, MathContext mathContext) {\n\t\treturn factorial(x.subtract(ONE), mathContext);\n\t}\n\n\t/**\n\t * Calculates the Bernoulli number for the specified index.\n\t *\n\t *
This function calculates the first Bernoulli numbers and therefore bernoulli(1) returns -0.5
\n\t *
Note that bernoulli(x) for all odd x > 1 returns 0
\n\t *\n\t * @param n the index of the Bernoulli number to be calculated (starting at 0)\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the Bernoulli number for the specified index\n\t * @throws ArithmeticException if x < 0\n\t * @throws ArithmeticException if the result is inexact but the\n\t * rounding mode is {@code UNNECESSARY} or\n\t * {@code mc.precision == 0} and the quotient has a\n\t * non-terminating decimal expansion.\n\t */\n\tpublic static BigDecimal bernoulli(int n, MathContext mathContext) {\n\t\tif (n < 0) {\n\t\t\tthrow new ArithmeticException(\"Illegal bernoulli(n) for n < 0: n = \" + n);\n\t\t}\n\t\t\n\t\tBigRational b = BigRational.bernoulli(n);\n\t\treturn b.toBigDecimal(mathContext);\n\t}\n\n\t/**\n\t * Calculates {@link BigDecimal} x to the power of {@link BigDecimal} y (xy).\n\t * \n\t * @param x the {@link BigDecimal} value to take to the power\n\t * @param y the {@link BigDecimal} value to serve as exponent\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated x to the power of y with the precision specified in the mathContext\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t * @see #pow(BigDecimal, long, MathContext)\n\t */\n\tpublic static BigDecimal pow(BigDecimal x, BigDecimal y, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tif (x.signum() == 0) {\n\t\t\tswitch (y.signum()) {\n\t\t\t\tcase 0 : return round(ONE, mathContext);\n\t\t\t\tcase 1 : return round(ZERO, mathContext);\n\t\t\t}\n\t\t}\n\n\t\t// TODO optimize y=0, y=1, y=10^k, y=-1, y=-10^k\n\n\t\ttry {\n\t\t\tlong longValue = y.longValueExact();\n\t\t\treturn pow(x, longValue, mathContext);\n\t\t} catch (ArithmeticException ex) {\n\t\t\t// ignored\n\t\t}\n\t\t\n\t\tif (fractionalPart(y).signum() == 0) {\n\t\t\treturn powInteger(x, y, mathContext);\n\t\t}\n\n\t\t// x^y = exp(y*log(x))\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 6, mathContext.getRoundingMode());\n\t\tBigDecimal result = exp(y.multiply(log(x, mc), mc), mc);\n\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates {@link BigDecimal} x to the power of long y (xy).\n\t * \n\t *
The implementation tries to minimize the number of multiplications of {@link BigDecimal x} (using squares whenever possible).
\n\t * \n\t * @param x the {@link BigDecimal} value to take to the power\n\t * @param y the long value to serve as exponent\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated x to the power of y with the precision specified in the mathContext\n\t * @throws ArithmeticException if y is negative and the result is inexact but the\n\t * rounding mode is {@code UNNECESSARY} or\n\t * {@code mc.precision == 0} and the quotient has a\n\t * non-terminating decimal expansion.\n\t * @throws ArithmeticException if the rounding mode is\n\t * {@code UNNECESSARY} and the\n\t * {@code BigDecimal} operation would require rounding.\n\t */\n\tpublic static BigDecimal pow(BigDecimal x, long y, MathContext mathContext) {\n\t\tMathContext mc = mathContext.getPrecision() == 0 ? mathContext : new MathContext(mathContext.getPrecision() + 10, mathContext.getRoundingMode());\n\n\t\t// TODO optimize y=0, y=1, y=10^k, y=-1, y=-10^k\n\n\t\tif (y < 0) {\n\t\t\tBigDecimal value = reciprocal(pow(x, -y, mc), mc);\n\t\t\treturn round(value, mathContext);\n\t\t}\n\t\t\n\t\tBigDecimal result = ONE;\n\t\twhile (y > 0) {\n\t\t\tif ((y & 1) == 1) {\n\t\t\t\t// odd exponent -> multiply result with x\n\t\t\t\tresult = result.multiply(x, mc);\n\t\t\t\ty -= 1;\n\t\t\t}\n\t\t\t\n\t\t\tif (y > 0) {\n\t\t\t\t// even exponent -> square x\n\t\t\t\tx = x.multiply(x, mc);\n\t\t\t}\n\t\t\t\n\t\t\ty >>= 1;\n\t\t}\n\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates {@link BigDecimal} x to the power of the integer value y (xy).\n\t * \n\t *
The value y MUST be an integer value.
\n\t * \n\t * @param x the {@link BigDecimal} value to take to the power\n\t * @param integerY the {@link BigDecimal} integer value to serve as exponent\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated x to the power of y with the precision specified in the mathContext\n\t * @see #pow(BigDecimal, long, MathContext)\n\t */\n\tprivate static BigDecimal powInteger(BigDecimal x, BigDecimal integerY, MathContext mathContext) {\n\t\tif (fractionalPart(integerY).signum() != 0) {\n\t\t\tthrow new IllegalArgumentException(\"Not integer value: \" + integerY);\n\t\t}\n\t\t\n\t\tif (integerY.signum() < 0) {\n\t\t\treturn ONE.divide(powInteger(x, integerY.negate(), mathContext), mathContext);\n\t\t}\n\n\t\tMathContext mc = new MathContext(Math.max(mathContext.getPrecision(), -integerY.scale()) + 30, mathContext.getRoundingMode());\n\n\t\tBigDecimal result = ONE;\n\t\twhile (integerY.signum() > 0) {\n\t\t\tBigDecimal halfY = integerY.divide(TWO, mc);\n\n\t\t\tif (fractionalPart(halfY).signum() != 0) {\n\t\t\t\t// odd exponent -> multiply result with x\n\t\t\t\tresult = result.multiply(x, mc);\n\t\t\t\tintegerY = integerY.subtract(ONE);\n\t\t\t\thalfY = integerY.divide(TWO, mc);\n\t\t\t}\n\t\t\t\n\t\t\tif (halfY.signum() > 0) {\n\t\t\t\t// even exponent -> square x\n\t\t\t\tx = x.multiply(x, mc);\n\t\t\t}\n\t\t\t\n\t\t\tintegerY = halfY;\n\t\t}\n\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates the square root of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} value to calculate the square root\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated square root of x with the precision specified in the mathContext\n\t * @throws ArithmeticException if x < 0\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal sqrt(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tswitch (x.signum()) {\n\t\tcase 0:\n\t\t\treturn ZERO;\n\t\tcase -1:\n\t\t\tthrow new ArithmeticException(\"Illegal sqrt(x) for x < 0: x = \" + x);\n\t\t}\n\n\t\tint maxPrecision = mathContext.getPrecision() + 6;\n\t\tBigDecimal acceptableError = ONE.movePointLeft(mathContext.getPrecision() + 1);\n\n\t\tBigDecimal result;\n\t\tint adaptivePrecision;\n\t\tif (isDoubleValue(x)) {\n\t\t\tresult = BigDecimal.valueOf(Math.sqrt(x.doubleValue()));\n\t\t\tadaptivePrecision = EXPECTED_INITIAL_PRECISION;\n\t\t} else {\n\t\t\tresult = x.multiply(ONE_HALF, mathContext);\n\t\t\tadaptivePrecision = 1;\n\t\t}\n\t\t\n\t\tBigDecimal last;\n\n\t\tif (adaptivePrecision < maxPrecision) {\n\t\t\tif (result.multiply(result).compareTo(x) == 0) {\n\t\t\t\treturn round(result, mathContext); // early exit if x is a square number\n\t\t\t}\n\n\t\t\tdo {\n\t\t\t\tlast = result;\n\t\t\t\tadaptivePrecision <<= 1;\n\t\t\t\tif (adaptivePrecision > maxPrecision) {\n\t\t\t\t\tadaptivePrecision = maxPrecision;\n\t\t\t\t}\n\t\t\t\tMathContext mc = new MathContext(adaptivePrecision, mathContext.getRoundingMode());\n\t\t\t\tresult = x.divide(result, mc).add(last).multiply(ONE_HALF, mc);\n\t\t\t}\n\t\t\twhile (adaptivePrecision < maxPrecision || result.subtract(last).abs().compareTo(acceptableError) > 0);\n\t\t}\n\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates the n'th root of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the sine for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated sine {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal sin(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 6, mathContext.getRoundingMode());\n\n\t\tif (x.abs().compareTo(ROUGHLY_TWO_PI) > 0) {\n\t\t\tMathContext mc2 = new MathContext(mc.getPrecision() + 4, mathContext.getRoundingMode());\n\t\t\tBigDecimal twoPi = TWO.multiply(pi(mc2));\n\t\t\tx = x.remainder(twoPi, mc2);\n\t\t}\n\n\t\tBigDecimal result = SinCalculator.INSTANCE.calculate(x, mc);\n\t\treturn round(result, mathContext);\n\t}\n\t\n\t/**\n\t * Calculates the arc sine (inverted sine) of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the arc sine for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated arc sine {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws ArithmeticException if x > 1 or x < -1\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal asin(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tif (x.compareTo(ONE) > 0) {\n\t\t\tthrow new ArithmeticException(\"Illegal asin(x) for x > 1: x = \" + x);\n\t\t}\n\t\tif (x.compareTo(MINUS_ONE) < 0) {\n\t\t\tthrow new ArithmeticException(\"Illegal asin(x) for x < -1: x = \" + x);\n\t\t}\n\t\t\n\t\tif (x.signum() == -1) {\n\t\t\treturn asin(x.negate(), mathContext).negate();\n\t\t}\n\t\t\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 6, mathContext.getRoundingMode());\n\n\t\tif (x.compareTo(BigDecimal.valueOf(0.707107)) >= 0) {\n\t\t\tBigDecimal xTransformed = sqrt(ONE.subtract(x.multiply(x)), mc);\n\t\t\treturn acos(xTransformed, mathContext);\n\t\t}\n\n\t\tBigDecimal result = AsinCalculator.INSTANCE.calculate(x, mc);\n\t\treturn round(result, mathContext);\n\t}\n\t\n\t/**\n\t * Calculates the cosine (cosinus) of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the cosine for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated cosine {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal cos(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 6, mathContext.getRoundingMode());\n\n\t\tif (x.abs().compareTo(ROUGHLY_TWO_PI) > 0) {\n\t\t\tMathContext mc2 = new MathContext(mc.getPrecision() + 4, mathContext.getRoundingMode());\n\t\t\tBigDecimal twoPi = TWO.multiply(pi(mc2), mc2);\n\t\t\tx = x.remainder(twoPi, mc2);\n\t\t}\n\t\t\n\t\tBigDecimal result = CosCalculator.INSTANCE.calculate(x, mc);\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates the arc cosine (inverted cosine) of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the arc cosine for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated arc sine {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws ArithmeticException if x > 1 or x < -1\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal acos(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tif (x.compareTo(ONE) > 0) {\n\t\t\tthrow new ArithmeticException(\"Illegal acos(x) for x > 1: x = \" + x);\n\t\t}\n\t\tif (x.compareTo(MINUS_ONE) < 0) {\n\t\t\tthrow new ArithmeticException(\"Illegal acos(x) for x < -1: x = \" + x);\n\t\t}\n\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 6, mathContext.getRoundingMode());\n\n\t\tBigDecimal result = pi(mc).divide(TWO, mc).subtract(asin(x, mc));\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates the tangens of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the tangens for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated tangens {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal tan(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tif (x.signum() == 0) {\n\t\t\treturn ZERO;\n\t\t}\n\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\t\tBigDecimal result = sin(x, mc).divide(cos(x, mc), mc);\n\t\treturn round(result, mathContext);\n\t}\n\t\n\t/**\n\t * Calculates the arc tangens (inverted tangens) of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the arc tangens for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated arc tangens {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal atan(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 6, mathContext.getRoundingMode());\n\n\t\tx = x.divide(sqrt(ONE.add(x.multiply(x, mc)), mc), mc);\n\n\t\tBigDecimal result = asin(x, mc);\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates the arc tangens (inverted tangens) of {@link BigDecimal} y / x in the range -pi to pi.\n\t *\n\t *
This is useful to calculate the angle theta from the conversion of rectangular\n * coordinates (x, y) to polar coordinates (r, theta).
\n\t * \n\t * @param y the {@link BigDecimal}\n\t * @param x the {@link BigDecimal}\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated arc tangens {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws ArithmeticException if x = 0 and y = 0\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal atan2(BigDecimal y, BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 3, mathContext.getRoundingMode());\n\n\t\tif (x.signum() > 0) { // x > 0\n\t\t\treturn atan(y.divide(x, mc), mathContext);\n\t\t} else if (x.signum() < 0) {\n\t\t\tif (y.signum() > 0) { // x < 0 && y > 0\n\t\t\t\treturn atan(y.divide(x, mc), mc).add(pi(mc), mathContext);\n\t\t\t} else if (y.signum() < 0) { // x < 0 && y < 0\n\t\t\t\treturn atan(y.divide(x, mc), mc).subtract(pi(mc), mathContext);\n\t\t\t} else { // x < 0 && y = 0\n\t\t\t\treturn pi(mathContext);\n\t\t\t}\n\t\t} else {\n\t\t\tif (y.signum() > 0) { // x == 0 && y > 0\n\t\t\t\treturn pi(mc).divide(TWO, mathContext);\n\t\t\t} else if (y.signum() < 0) { // x == 0 && y < 0\n\t\t\t\treturn pi(mc).divide(TWO, mathContext).negate();\t\t\t\t\n\t\t\t} else {\n\t\t\t\tthrow new ArithmeticException(\"Illegal atan2(y, x) for x = 0; y = 0\");\n\t\t\t}\n\t\t}\n\t}\n\t\n\t/**\n\t * Calculates the cotangens of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the cotangens for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated cotanges {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws ArithmeticException if x = 0\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal cot(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tif (x.signum() == 0) {\n\t\t\tthrow new ArithmeticException(\"Illegal cot(x) for x = 0\");\n\t\t}\n\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\t\tBigDecimal result = cos(x, mc).divide(sin(x, mc), mc);\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates the inverse cotangens (arc cotangens) of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the arc cotangens for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated arc cotangens {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal acot(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\t\tBigDecimal result = pi(mc).divide(TWO, mc).subtract(atan(x, mc));\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates the hyperbolic sine of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the hyperbolic sine for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated hyperbolic sine {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal sinh(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\t\tBigDecimal result = SinhCalculator.INSTANCE.calculate(x, mc);\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates the hyperbolic cosine of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the hyperbolic cosine for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated hyperbolic cosine {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal cosh(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\n\t\tBigDecimal result = CoshCalculator.INSTANCE.calculate(x, mc);\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates the hyperbolic tangens of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the hyperbolic tangens for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated hyperbolic tangens {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal tanh(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 6, mathContext.getRoundingMode());\n\t\tBigDecimal result = sinh(x, mc).divide(cosh(x, mc), mc);\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates the hyperbolic cotangens of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the hyperbolic cotangens for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated hyperbolic cotangens {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal coth(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 6, mathContext.getRoundingMode());\n\t\tBigDecimal result = cosh(x, mc).divide(sinh(x, mc), mc);\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates the arc hyperbolic sine (inverse hyperbolic sine) of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the arc hyperbolic sine for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated arc hyperbolic sine {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal asinh(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 10, mathContext.getRoundingMode());\n\t\tBigDecimal result = log(x.add(sqrt(x.multiply(x, mc).add(ONE, mc), mc)), mc);\n\t\treturn round(result, mathContext);\n\t}\n\t\n\t/**\n\t * Calculates the arc hyperbolic cosine (inverse hyperbolic cosine) of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the arc hyperbolic cosine for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated arc hyperbolic cosine {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal acosh(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 6, mathContext.getRoundingMode());\n\t\tBigDecimal result = log(x.add(sqrt(x.multiply(x).subtract(ONE), mc)), mc);\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates the arc hyperbolic tangens (inverse hyperbolic tangens) of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the arc hyperbolic tangens for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated arc hyperbolic tangens {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal atanh(BigDecimal x, MathContext mathContext) {\n if (x.compareTo(BigDecimal.ONE) >= 0) {\n throw new ArithmeticException(\"Illegal atanh(x) for x >= 1: x = \" + x);\n }\n if (x.compareTo(MINUS_ONE) <= 0) {\n throw new ArithmeticException(\"Illegal atanh(x) for x <= -1: x = \" + x);\n }\n\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 6, mathContext.getRoundingMode());\n\t\tBigDecimal result = log(ONE.add(x).divide(ONE.subtract(x), mc), mc).multiply(ONE_HALF);\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Calculates the arc hyperbolic cotangens (inverse hyperbolic cotangens) of {@link BigDecimal} x.\n\t * \n\t *
\n\t * \n\t * @param x the {@link BigDecimal} to calculate the arc hyperbolic cotangens for\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return the calculated arc hyperbolic cotangens {@link BigDecimal} with the precision specified in the mathContext\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal acoth(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 6, mathContext.getRoundingMode());\n\t\tBigDecimal result = log(x.add(ONE).divide(x.subtract(ONE), mc), mc).multiply(ONE_HALF);\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t * Converts an angle measured in radians to an approximately equivalent angle measured in degrees.\n\t * The conversion from radians to degrees is generally inexact, it uses the number PI with the precision specified in the mathContext.\n\t * @param x An angle in radians.\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return The angle in degrees.\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal toDegrees(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 6, mathContext.getRoundingMode());\n\t\tBigDecimal result = x.multiply(ONE_HUNDRED_EIGHTY.divide(pi(mc), mc), mc);\n\t\treturn round(result, mathContext);\n\t}\n\n\t/**\n\t /**\n\t * Converts an angle measured in degrees to an approximately equivalent angle measured in radians.\n\t * The conversion from degrees to radians is generally inexact, it uses the number PI with the precision specified in the mathContext.\n\t *\n\t * @param x An angle in degrees.\n\t * @param mathContext the {@link MathContext} used for the result\n\t * @return The angle in radians.\n\t * @throws UnsupportedOperationException if the {@link MathContext} has unlimited precision\n\t */\n\tpublic static BigDecimal toRadians(BigDecimal x, MathContext mathContext) {\n\t\tcheckMathContext(mathContext);\n\t\tMathContext mc = new MathContext(mathContext.getPrecision() + 6, mathContext.getRoundingMode());\n\t\tBigDecimal result = x.multiply(pi(mc).divide(ONE_HUNDRED_EIGHTY, mc), mc);\n\t\treturn round(result, mathContext);\n\t}\n\n\tprivate static void checkMathContext (MathContext mathContext) {\n\t\tif (mathContext.getPrecision() == 0) {\n\t\t\tthrow new UnsupportedOperationException(\"Unlimited MathContext not supported\");\n\t\t}\n\t}\n}\n"
},
{
"path": "ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/BigFloat.java",
"content": "package ch.obermuhlner.math.big;\n\nimport java.io.Serializable;\nimport java.math.BigDecimal;\nimport java.math.MathContext;\nimport java.math.RoundingMode;\nimport java.util.Objects;\n\n/**\n * A wrapper around {@link BigDecimal} which simplifies the consistent usage of the {@link MathContext}\n * and provides a simpler API for calculations.\n *\n *
Overview
\n *\n *
Every {@link BigFloat} instance has a reference to a {@link Context} that specifies the {@link MathContext} to be used for all calculations and values.
\n *\n *
The API for calculations is simplified and more consistent with the typical mathematical usage.
\n *
\n *
Factory methods for values:\n *
\n *
valueOf(BigFloat)
\n *
valueOf(BigDecimal)
\n *
valueOf(int)
\n *
valueOf(long)
\n *
valueOf(double)
\n *
valueOf(String)
\n *
pi()
\n *
e()
\n *
\n *
\n *
All standard operators:\n *
\n *
add(x)
\n *
subtract(x)
\n *
multiply(x)
\n *
remainder(x)
\n *
pow(y)
\n *
root(y)
\n *
\n *
\n *
Calculation methods are overloaded for different value types:\n *
\n *
add(BigFloat)
\n *
add(BigDecimal)
\n *
add(int)
\n *
add(long)
\n *
add(double)
\n *
...
\n *
\n *
\n *
Mathematical functions are written as they are traditionally are written:\n *
\n *
abs(x)
\n *
log(x)
\n *
sin(x)
\n *
min(x1, x2, ...)
\n *
max(x1, x2, ...)
\n *
...
\n *
\n *
\n *
Support for advanced mathematical functions:\n *
\n *
sqrt(x)
\n *
log(x)
\n *
exp(x)
\n *
sin(x)
\n *
cos(x)
\n *
tan(x)
\n *
...
\n *
\n *
\n *
Methods to access parts of a value:\n *
\n *
getMantissa()
\n *
getExponent()
\n *
getIntegralPart()
\n *
getFractionalPart()
\n *
\n *
\n *
Equals and Hashcode methods:\n *
\n *
equals(Object) that returns whether two BigFloat values are mathematically the same
\n *
hashCode() consistent with equals(Object)
\n *
\n *
\n *
Comparison methods:\n *
\n *
isEqual(BigFloat)
\n *
isLessThan(BigFloat)
\n *
isLessThanOrEqual(BigFloat)
\n *
isGreaterThan(BigFloat)
\n *
isGreaterThanOrEqual(BigFloat)
\n *
\n *
\n *
\n *\n *
Usage
\n *\n *
Before doing any calculations you need to create a Context specifying the precision used for all calculations.
\n */\n@SuppressWarnings(\"WeakerAccess\")\npublic class BigFloat implements Comparable, Serializable {\n private static final long serialVersionUID = -7323679117445486894L;\n\n\t/**\n\t * Represents a value that is not a number.\n\t * @see Double#NaN\n\t */\n\tpublic static final BigFloat NaN = new SpecialBigFloat(SpecialBigFloat.Type.NaN);\n\n\t/**\n\t * Represents the positive infinity.\n\t * @see Double#POSITIVE_INFINITY\n\t */\n\tpublic static final BigFloat POSITIVE_INFINITY = new SpecialBigFloat(SpecialBigFloat.Type.POSITIVE_INFINITY);\n\n\t/**\n\t * Represents the positive infinity.\n\t * @see Double#NEGATIVE_INFINITY\n\t */\n\tpublic static final BigFloat NEGATIVE_INFINITY = new SpecialBigFloat(SpecialBigFloat.Type.NEGATIVE_INFINITY);\n\n\tprivate final BigDecimal value;\n\tprivate final Context context;\n\n\tprivate BigFloat(BigDecimal value, Context context) {\n\t\tthis.value = value;\n\t\tthis.context = context;\n\t}\n\n\t/**\n\t * Creates a {@link Context} with the specified precision and {@link RoundingMode#HALF_UP} rounding.\n\t *\n\t * @param precision the precision\n\t *\n\t * @return the {@link Context}\n\t */\n\tpublic static Context context(int precision) {\n\t\treturn new Context(new MathContext(precision));\n\t}\n\n\t/**\n\t * Creates a {@link Context} with the specified {@link MathContext}.\n\t *\n\t * @param mathContext the {@link MathContext}\n\t *\n\t * @return the {@link Context}\n\t */\n\tpublic static Context context(MathContext mathContext) {\n\t\treturn new Context(mathContext);\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this + x.\n\t *\n\t *
If the two values do not have the same {@link Context}, the result will contain the {@link Context} with the larger precision.
\n\t *\n\t * @param x the value to add\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#add(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat add(BigFloat x) {\n\t\tif (x.isSpecial())\n\t\t\treturn x.add(this);\n\t\tContext c = max(context, x.context);\n\t\treturn c.valueOf(value.add(x.value, c.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this + x.\n\t *\n\t * @param x the value to add\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#add(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat add(BigDecimal x) {\n\t\treturn add(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this + x.\n\t *\n\t * @param x the value to add\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#add(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat add(int x) {\n\t\treturn add(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this + x.\n\t *\n\t * @param x the value to add\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#add(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat add(long x) {\n\t\treturn add(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this + x.\n\t *\n\t * @param x the value to add\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#add(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat add(double x) {\n\t\treturn add(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this - x.\n\t *\n\t *
If the two values do not have the same {@link Context}, the result will contain the {@link Context} with the larger precision.
\n\t *\n\t * @param x the value to subtract\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#subtract(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat subtract(BigFloat x) {\n\t\tif (x.isSpecial())\n\t\t\treturn negate(x).add(this);\n\t\tContext c = max(context, x.context);\n\t\treturn c.valueOf(value.subtract(x.value, c.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this - x.\n\t *\n\t * @param x the value to subtract\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#subtract(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat subtract(BigDecimal x) {\n\t\treturn subtract(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this - x.\n\t *\n\t * @param x the value to subtract\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#subtract(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat subtract(int x) {\n\t\treturn subtract(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this - x.\n\t *\n\t * @param x the value to subtract\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#subtract(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat subtract(long x) {\n\t\treturn subtract(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this - x.\n\t *\n\t * @param x the value to subtract\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#subtract(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat subtract(double x) {\n\t\treturn subtract(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this * x.\n\t *\n\t *
If the two values do not have the same {@link Context}, the result will contain the {@link Context} with the larger precision.
\n\t *\n\t * @param x the value to multiply\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#multiply(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat multiply(BigFloat x) {\n\t\tif (x.isSpecial())\n\t\t\treturn x.multiply(this);\n\t\tContext c = max(context, x.context);\n\t\treturn c.valueOf(value.multiply(x.value, c.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this * x.\n\t *\n\t * @param x the value to multiply\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#multiply(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat multiply(BigDecimal x) {\n\t\treturn multiply(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this * x.\n\t *\n\t * @param x the value to multiply\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#multiply(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat multiply(int x) {\n\t\treturn multiply(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this * x.\n\t *\n\t * @param x the value to multiply\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#multiply(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat multiply(long x) {\n\t\treturn multiply(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this * x.\n\t *\n\t * @param x the value to multiply\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#multiply(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat multiply(double x) {\n\t\treturn multiply(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this / x.\n\t *\n\t *
If the two values do not have the same {@link Context},\n\t * the result will contain the {@link Context} with the larger precision.
\n\t *\n\t * @param x the value to divide with\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#divide(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat divide(BigFloat x) {\n\t\tif (x.isSpecial()) {\n\t\t\tif (x == NaN) {\n\t\t\t\treturn NaN;\n\t\t\t} else {\n\t\t\t\treturn context.valueOf(0);\n\t\t\t}\n\t\t}\n\t\tif (this.isZero() && !x.isZero()) {\n\t\t\treturn context.valueOf(0);\n\t\t}\n\t\tif (x.isZero()) {\n\t\t\tif (this.isZero()) {\n\t\t\t\treturn NaN; // 0 or -0 / 0 = NaN\n\t\t\t} else if (this.isNegative()) {\n\t\t\t\treturn NEGATIVE_INFINITY;// -N / 0 = -INF\n\t\t\t} else {\n\t\t\t\treturn POSITIVE_INFINITY;// N / 0 = +INF\n\t\t\t}\n\t\t}\n\n\t\tContext c = max(context, x.context);\n\t\treturn c.valueOf(value.divide(x.value, c.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this / x.\n\t *\n\t * @param x the value to divide with\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#divide(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat divide(BigDecimal x) {\n\t\treturn divide(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this / x.\n\t *\n\t * @param x the value to divide with\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#divide(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat divide(int x) {\n\t\treturn divide(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this / x.\n\t *\n\t * @param x the value to divide with\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#divide(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat divide(long x) {\n\t\treturn divide(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this / x.\n\t *\n\t * @param x the value to divide with\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#divide(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat divide(double x) {\n\t\treturn divide(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is the remainder when dividing this by x.\n\t *\n\t *
If the two values do not have the same {@link Context}, the result will contain the {@link Context} with the larger precision.
\n\t *\n\t * @param x the value to divide with\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#remainder(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat remainder(BigFloat x) {\n\t\tif (x.isSpecial()) {\n\t\t\tif (x == NaN) {\n\t\t\t\treturn NaN;\n\t\t\t} else {\n\t\t\t\treturn this;\n\t\t\t}\n\t\t}\n\t\tif (this.isZero() && !x.isZero()) {\n\t\t\treturn context.valueOf(0);\n\t\t}\n\t\tif (x.isZero()) {\n\t\t\treturn NaN;\n\t\t}\n\n\t\tContext c = max(context, x.context);\n\t\treturn c.valueOf(value.remainder(x.value, c.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is the remainder when dividing this by x.\n\t *\n\t * @param x the value to divide with\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#remainder(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat remainder(BigDecimal x) {\n\t\treturn remainder(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is the remainder when dividing this by x.\n\t *\n\t * @param x the value to divide with\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#remainder(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat remainder(int x) {\n\t\treturn remainder(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is the remainder when dividing this by x.\n\t *\n\t * @param x the value to divide with\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#remainder(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat remainder(long x) {\n\t\treturn remainder(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is the remainder when dividing this by x.\n\t *\n\t * @param x the value to divide with\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#remainder(BigDecimal, MathContext)\n\t */\n\tpublic BigFloat remainder(double x) {\n\t\treturn remainder(context.valueOf(x));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this to the power of y.\n\t *\n\t *
If the two values do not have the same {@link Context}, the result will contain the {@link Context} with the larger precision.
\n\t *\n\t * @param y the value of the power\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#pow(BigDecimal, BigDecimal, MathContext)\n\t */\n\tpublic BigFloat pow(BigFloat y) {\n\t\tif (y.isSpecial()) {\n\t\t\tif (this.isZero()) {\n\t\t\t\tif (y == POSITIVE_INFINITY) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t\tif (y == NEGATIVE_INFINITY) {\n\t\t\t\t\treturn POSITIVE_INFINITY;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (y == NEGATIVE_INFINITY) {\n\t\t\t\treturn context.ZERO;\n\t\t\t}\n\t\t\treturn y;\n\t\t}\n\t\tif (this.isZero()) {\n\t\t\tif (y.isNegative()) {\n\t\t\t\treturn POSITIVE_INFINITY;\n\t\t\t}\n\t\t}\n\n\t\tContext c = max(context, y.context);\n\t\treturn c.valueOf(BigDecimalMath.pow(this.value, y.value, c.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this to the power of y.\n\t *\n\t * @param y the value of the power\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#pow(BigDecimal, BigDecimal, MathContext)\n\t */\n\tpublic BigFloat pow(BigDecimal y) {\n\t\treturn pow(context.valueOf(y));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this to the power of y.\n\t *\n\t * @param y the value of the power\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#pow(BigDecimal, BigDecimal, MathContext)\n\t */\n\tpublic BigFloat pow(int y) {\n\t\treturn pow(context.valueOf(y));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this to the power of y.\n\t *\n\t * @param y the value of the power\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#pow(BigDecimal, BigDecimal, MathContext)\n\t */\n\tpublic BigFloat pow(long y) {\n\t\treturn pow(context.valueOf(y));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is this to the power of y.\n\t *\n\t * @param y the value of the power\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#pow(BigDecimal, BigDecimal, MathContext)\n\t */\n\tpublic BigFloat pow(double y) {\n\t\treturn pow(context.valueOf(y));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is the yth root of this.\n\t *\n\t *
If the two values do not have the same {@link Context}, the result will contain the {@link Context} with the larger precision.
\n\t *\n\t * @param y the value of the root\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#root(BigDecimal, BigDecimal, MathContext)\n\t */\n\tpublic BigFloat root(BigFloat y) {\n\t\tif (y.isSpecial())\n\t\t\treturn y;\n\t\tContext c = max(context, y.context);\n\t\treturn c.valueOf(BigDecimalMath.root(this.value, y.value, c.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is the yth root of this.\n\t *\n\t * @param y the value of the root\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#root(BigDecimal, BigDecimal, MathContext)\n\t */\n\tpublic BigFloat root(BigDecimal y) {\n\t\treturn root(context.valueOf(y));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is the yth root of this.\n\t *\n\t * @param y the value of the root\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#root(BigDecimal, BigDecimal, MathContext)\n\t */\n\tpublic BigFloat root(int y) {\n\t\treturn root(context.valueOf(y));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is the yth root of this.\n\t *\n\t * @param y the value of the root\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#root(BigDecimal, BigDecimal, MathContext)\n\t */\n\tpublic BigFloat root(long y) {\n\t\treturn root(context.valueOf(y));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is the yth root of this.\n\t *\n\t * @param y the value of the root\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#root(BigDecimal, BigDecimal, MathContext)\n\t */\n\tpublic BigFloat root(double y) {\n\t\treturn root(context.valueOf(y));\n\t}\n\n\t@Override\n\tpublic int hashCode() {\n\t\treturn value.stripTrailingZeros().hashCode();\n\t}\n\n\t@Override\n\tpublic boolean equals(Object obj) {\n\t\tif (this == obj)\n\t\t\treturn true;\n\t\tif (obj == null)\n\t\t\treturn false;\n\t\tif (getClass() != obj.getClass())\n\t\t\treturn false;\n\t\tBigFloat other = (BigFloat) obj;\n\n\t\treturn value.compareTo(other.value) == 0;\n\t\t//return Objects.equals(value, other.value) && Objects.equals(context, other.context);\n\t}\n\n\t/**\n\t * Returns the signum function of this {@link BigFloat}.\n\t *\n\t * @return -1, 0, or 1 as the value of this {@link BigDecimal} is negative, zero, or positive.\n\t */\n\tpublic int signum() {\n\t\treturn value.signum();\n\t}\n\n\t/**\n\t * Returns whether this {@link BigFloat} is negative.\n\t *\n\t * @return true if negative, false if 0 or positive\n\t */\n\tpublic boolean isNegative() {\n\t\treturn value.signum() < 0;\n\t}\n\n\t/**\n\t * Returns whether this {@link BigFloat} is 0.\n\t *\n\t * @return true if 0, false if negative or positive\n\t */\n\tpublic boolean isZero() {\n\t\treturn value.signum() == 0;\n\t}\n\n\t/**\n\t * Returns whether this {@link BigFloat} is positive.\n\t *\n\t * @return true if positive, false if 0 or negative\n\t */\n\tpublic boolean isPositive() {\n\t\treturn value.signum() > 0;\n\t}\n\n\t@Override\n\tpublic int compareTo(BigFloat other) {\n\t\tif (other.isSpecial()) {\n\t\t\treturn -other.compareTo(this);\n\t\t}\n\t\treturn value.compareTo(other.value);\n\t}\n\n\t/**\n\t * Returns whether this value is mathematically equal to the other value.\n\t *\n\t * @param other the other {@link BigFloat} to compare with\n\t *\n\t * @return true if both values are mathematically equal (equivalent to this.compareTo(other) == 0\n\t *\n\t * @see #compareTo(BigFloat)\n\t */\n\tpublic boolean isEqual(BigFloat other) {\n\t\tif (this == NaN || other == NaN) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn compareTo(other) == 0;\n\t}\n\n\t/**\n\t * Returns whether this value is mathematically less than to the other value.\n\t *\n\t * @param other the other {@link BigFloat} to compare with\n\t *\n\t * @return truethis value is mathematically less than to the other value (equivalent to this.compareTo(other) < 0\n\t *\n\t * @see #compareTo(BigFloat)\n\t */\n\tpublic boolean isLessThan(BigFloat other) {\n\t\tif (this == NaN || other == NaN) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn compareTo(other) < 0;\n\t}\n\n\t/**\n\t * Returns whether this value is mathematically greater than to the other value.\n\t *\n\t * @param other the other {@link BigFloat} to compare with\n\t *\n\t * @return truethis value is mathematically greater than to the other value (equivalent to this.compareTo(other) > 0\n\t *\n\t * @see #compareTo(BigFloat)\n\t */\n\tpublic boolean isGreaterThan(BigFloat other) {\n\t\tif (this == NaN || other == NaN) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn compareTo(other) > 0;\n\t}\n\n\t/**\n\t * Returns whether this value is mathematically less than or equal to the other value.\n\t *\n\t * @param other the other {@link BigFloat} to compare with\n\t *\n\t * @return truethis value is mathematically less than or equal to the other value (equivalent to this.compareTo(other) <= 0\n\t *\n\t * @see #compareTo(BigFloat)\n\t * @see #isLessThan(BigFloat)\n\t * @see #isEqual(BigFloat)\n\t */\n\tpublic boolean isLessThanOrEqual(BigFloat other) {\n\t\tif (this == NaN || other == NaN) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn compareTo(other) <= 0;\n\t}\n\n\t/**\n\t * Returns whether this value is mathematically greater than or equal to the other value.\n\t *\n\t * @param other the other {@link BigFloat} to compare with\n\t *\n\t * @return truethis value is mathematically greater than or equal to the other value (equivalent to this.compareTo(other) >= 0\n\t *\n\t * @see #compareTo(BigFloat)\n\t * @see #isGreaterThan(BigFloat)\n\t * @see #isEqual(BigFloat)\n\t */\n\tpublic boolean isGreaterThanOrEqual(BigFloat other) {\n\t\tif (this == NaN || other == NaN) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn compareTo(other) >= 0;\n\t}\n\n\t/**\n\t * Returns whether this value can be represented as int.\n\t *\n\t * @return true if the value can be represented as int value\n\t *\n\t * @see BigDecimalMath#isIntValue(BigDecimal)\n\t */\n\tpublic boolean isIntValue() {\n\t\treturn BigDecimalMath.isIntValue(value);\n\t}\n\n\t/**\n\t * Returns whether this specified {@link BigDecimal} value can be represented as double.\n\t *\n\t * @return true if the value can be represented as double value\n\t *\n\t * @see BigDecimalMath#isDoubleValue(BigDecimal)\n\t */\n\tpublic boolean isDoubleValue() {\n\t\treturn BigDecimalMath.isDoubleValue(value);\n\t}\n\n\t/**\n\t * Returns the mantissa of this value written as mantissa * 10exponent.\n\t *\n\t *
The mantissa is defined as having exactly 1 digit before the decimal point.
\n\t *\n\t * @return the mantissa\n\t *\n\t * @see #getExponent()\n\t * @see BigDecimalMath#mantissa(BigDecimal)\n\t */\n\tpublic BigFloat getMantissa() {\n\t\treturn context.valueOf(BigDecimalMath.mantissa(value));\n\t}\n\n\t/**\n\t * Returns the exponent of this value written as mantissa * 10exponent.\n\t *\n\t *
The mantissa is defined as having exactly 1 digit before the decimal point.
\n\t *\n\t * @return the exponent\n\t *\n\t * @see #getMantissa()\n\t * @see BigDecimalMath#exponent(BigDecimal)\n\t */\n\tpublic BigFloat getExponent() {\n\t\treturn context.valueOf(BigDecimalMath.exponent(value));\n\t}\n\n\t/**\n\t * Returns the integral part of this value (left of the decimal point).\n\t *\n\t * @return the integral part\n\t *\n\t * @see #getFractionalPart()\n\t * @see BigDecimalMath#fractionalPart(BigDecimal)\n\t */\n\tpublic BigFloat getIntegralPart() {\n\t\treturn context.valueOf(BigDecimalMath.integralPart(value));\n\t}\n\n\t/**\n\t * Returns the fractional part of this value (right of the decimal point).\n\t *\n\t * @return the fractional part\n\t *\n\t * @see #getIntegralPart()\n\t * @see BigDecimalMath#fractionalPart(BigDecimal)\n\t */\n\tpublic BigFloat getFractionalPart() {\n\t\treturn context.valueOf(BigDecimalMath.fractionalPart(value));\n\t}\n\n\t/**\n\t * Returns the {@link Context} of this value.\n\t *\n\t * @return the {@link Context}\n\t */\n\tpublic Context getContext() {\n\t\treturn context;\n\t}\n\n\t/**\n\t * Returns this value as a {@link BigDecimal} value.\n\t *\n\t * @return the {@link BigDecimal} value\n\t */\n\tpublic BigDecimal toBigDecimal() {\n\t\treturn value;\n\t}\n\n\t/**\n\t * Returns this value as a double value.\n\t *\n\t * @return the double value\n\t *\n\t * @see BigDecimal#doubleValue()\n\t */\n\tpublic double toDouble() {\n\t\treturn value.doubleValue();\n\t}\n\n\t/**\n\t * Returns this value as a long value.\n\t *\n\t * @return the long value\n\t *\n\t * @see BigDecimal#longValue()\n\t */\n\tpublic long toLong() {\n\t\treturn value.longValue();\n\t}\n\n\t/**\n\t * Returns this value as a int value.\n\t *\n\t * @return the int value\n\t *\n\t * @see BigDecimal#intValue()\n\t */\n\tpublic int toInt() {\n\t\treturn value.intValue();\n\t}\n\n\t@Override\n\tpublic String toString() {\n\t\treturn value.toString();\n\t}\n\n protected boolean isSpecial() {\n\t\treturn false;\n\t}\n\n\t/**\n\t * return special type of a value\n\t * @return {@link SpecialBigFloat.Type}\n\t */\n protected SpecialBigFloat.Type type() {\n\t\treturn SpecialBigFloat.Type.NORMAL;\n\t}\n\n\tpublic boolean isNaN() {\n\t\treturn this == NaN;\n\t}\n\n\tpublic boolean isInfinity() {\n\t\treturn this == POSITIVE_INFINITY || this == NEGATIVE_INFINITY;\n\t}\n\n\t/**\n\t * this class handle unrepresentable value in floating-point arithmetic\n\t *\n\t * @author Wireless4024\n\t */\n\tprivate static final class SpecialBigFloat extends BigFloat {\n\n\t private static final Context DUMMY_CONTEXT = BigFloat.context(MathContext.DECIMAL32);\n\n\t\tprivate final Type type;\n\n\t\tprivate SpecialBigFloat(Type type) {\n\t\t\tsuper(null, DUMMY_CONTEXT);\n\t\t\tthis.type = type;\n\t\t}\n\n\t\t@Override\n protected boolean isSpecial() {\n\t\t\treturn true;\n\t\t}\n\n\t\t@Override\n\t\tprotected Type type() {\n\t\t\treturn type;\n\t\t}\n\n @Override\n\t\tpublic BigFloat add(BigFloat x) {\n\t\t\tif (!x.isSpecial()) {\n\t\t\t\treturn this;\n\t\t\t}\n\t\t\tif (this == POSITIVE_INFINITY && x == POSITIVE_INFINITY) {\n\t\t\t\treturn POSITIVE_INFINITY;\n\t\t\t}\n\t\t\tif (this == NEGATIVE_INFINITY && x == NEGATIVE_INFINITY) {\n\t\t\t\treturn NEGATIVE_INFINITY;\n\t\t\t}\n\t\t\treturn NaN;\n\t\t}\n\n\t\t@Override\n\t\tpublic BigFloat subtract(BigFloat x) {\n\t\t\tif (!x.isSpecial()) {\n\t\t\t\treturn this;\n\t\t\t}\n\t\t\tif (this == POSITIVE_INFINITY && x == NEGATIVE_INFINITY) {\n\t\t\t\treturn POSITIVE_INFINITY;\n\t\t\t}\n\t\t\tif (this == NEGATIVE_INFINITY && x == POSITIVE_INFINITY) {\n\t\t\t\treturn NEGATIVE_INFINITY;\n\t\t\t}\n\t\t\treturn NaN;\n\t\t}\n\n\t\t@Override\n\t\tpublic BigFloat subtract(BigDecimal x) {\n\t\t\treturn this;\n\t\t}\n\n\t\t@Override\n\t\tpublic BigFloat multiply(BigFloat x) {\n\t\t\tif (x.isZero() || x == NaN) {\n\t\t\t\treturn NaN;\n\t\t\t} else if (x.isNegative()) {\n\t\t\t\treturn negate(this);\n\t\t\t} else {\n\t\t\t\treturn this;\n\t\t\t}\n\t\t}\n\n\t\t@Override\n\t\tpublic BigFloat divide(BigFloat x) {\n\t\t\tif (x == NaN || (this.isInfinity() && x.isInfinity())) {\n\t\t\t\treturn NaN;\n\t\t\t} else if (x.isNegative()) {\n\t\t\t\treturn negate(this);\n\t\t\t} else {\n\t\t\t\treturn this;\n\t\t\t}\n\t\t}\n\n\t\t@Override\n\t\tpublic BigFloat remainder(BigFloat x) {\n\t\t\treturn NaN;\n\t\t}\n\n\t\t@Override\n\t\tpublic BigFloat pow(BigFloat y) {\n\t\t\tif (y.isZero()) {\n\t\t\t\treturn y.context.ONE;\n\t\t\t}\n\t\t\tif (y == NaN) {\n\t\t\t\treturn NaN;\n\t\t\t}\n\t\t\tif (this.isInfinity() && y.isNegative()) {\n\t\t\t\treturn y.context.ZERO;\n\t\t\t}\n\t\t\tif (this == NEGATIVE_INFINITY && y.isPositive()) {\n\t\t\t\treturn POSITIVE_INFINITY;\n\t\t\t}\n\t\t\treturn this;\n\t\t}\n\n\t\t@Override\n\t\tpublic BigFloat root(BigFloat y) {\n\t\t\treturn this;\n\t\t}\n\n\t\t@Override\n\t\tpublic int hashCode() {\n\t\t\treturn type.hashCode;\n\t\t}\n\n\t\t@Override\n\t\tpublic boolean equals(Object obj) {\n\t\t\tif (this == obj)\n\t\t\t\treturn true;\n\t\t\treturn obj instanceof BigFloat && ((BigFloat) obj).isSpecial() && ((BigFloat) obj).type() == this.type;\n\t\t}\n\n\t\t@Override\n\t\tpublic int signum() {\n\t\t\treturn type == Type.POSITIVE_INFINITY ? 1 : -1;\n\t\t}\n\n\t\t@Override\n\t\tpublic boolean isNegative() {\n\t\t\treturn signum() < 0;\n\t\t}\n\n\t\t@Override\n\t\tpublic boolean isZero() {\n\t\t\treturn false;//nan or infinity is not a zero\n\t\t}\n\n\t\t@Override\n\t\tpublic boolean isPositive() {\n\t\t\treturn signum() > 0;\n\t\t}\n\n\t\t@Override\n\t\tpublic int compareTo(BigFloat other) {\n\t\t\treturn Type.compare(type, other.type());\n\t\t}\n\n\t\t@Override\n\t\tpublic boolean isIntValue() {\n\t\t\treturn false;\n\t\t}\n\n\t\t@Override\n\t\tpublic boolean isDoubleValue() {\n\t\t\treturn false;\n\t\t}\n\n\t\t@Override\n\t\tpublic BigFloat getMantissa() {\n\t\t\treturn this;\n\t\t}\n\n\t\t@Override\n\t\tpublic BigFloat getExponent() {\n\t\t\treturn this;\n\t\t}\n\n\t\t@Override\n\t\tpublic BigFloat getIntegralPart() {\n\t\t\treturn this;\n\t\t}\n\n\t\t@Override\n\t\tpublic BigFloat getFractionalPart() {\n\t\t\treturn this;\n\t\t}\n\n\t\t@Override\n\t\tpublic Context getContext() {\n\t\t\tthrow new UnsupportedOperationException(type + \" has no context\");\n\t\t}\n\n\t\t@Override\n\t\tpublic BigDecimal toBigDecimal() {\n throw new UnsupportedOperationException(type + \" has no corresponding BigDecimal representation\");\n\t\t}\n\n\t\t@Override\n\t\tpublic double toDouble() {\n\t\t\treturn type.toDouble();\n\t\t}\n\n\t\t@Override\n\t\tpublic long toLong() {\n\t\t\treturn (long) toDouble();\n\t\t}\n\n\t\t@Override\n\t\tpublic int toInt() {\n\t\t\treturn (int) toDouble();\n\t\t}\n\n\t\t@Override\n\t\tpublic String toString() {\n\t\t\treturn type.toString();\n\t\t}\n\n\t\t//optional static\n\t\tenum Type {\n\t\t\tNaN(Objects.hashCode(Double.NaN)),\n\t\t\tPOSITIVE_INFINITY(Objects.hashCode(Double.POSITIVE_INFINITY)),\n\t\t\tNORMAL(Objects.hashCode(0)),\n\t\t\tNEGATIVE_INFINITY(Objects.hashCode(Double.NEGATIVE_INFINITY));\n\n\t\t\tfinal int hashCode;\n\n\t\t\tType(int hashCode){\n\t\t\t\tthis.hashCode=hashCode;\n\t\t\t}\n\n\t\t\tpublic static int compare(Type a, Type b) {\n\t\t\t\t//we can use double to compare\n\t\t\t\t//if (a == NaN && b == NaN)\n\t\t\t\t//\treturn 0;//cuz NaN equals nothing even itself\n\t\t\t\treturn Double.compare(a.toDouble(),b.toDouble());\n\t\t\t}\n\n\t\t\t/**\n\t\t\t * convert type to double\n\t\t\t * @return double value that equivalent to {@link Type}\n\t\t\t */\n\t\t\tpublic double toDouble() {\n\t\t\t\tswitch (this) {\n\t\t\t\t\tcase POSITIVE_INFINITY:\n\t\t\t\t\t\treturn Double.POSITIVE_INFINITY;\n\t\t\t\t\tcase NEGATIVE_INFINITY:\n\t\t\t\t\t\treturn Double.NEGATIVE_INFINITY;\n\t\t\t\t\tcase NaN:\n\t\t\t\t\t\treturn Double.NaN;\n\t\t\t\t\tdefault:\n\t\t\t\t\t\treturn 0;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Manages the {@link MathContext} and provides factory methods for {@link BigFloat} values.\n\t */\n\tpublic static class Context implements Serializable{\n\t\tprivate static final long serialVersionUID = -5787473786808803161L;\n\t\tpublic final BigFloat NEGATIVE_ONE;\n\t\tpublic final BigFloat ZERO;\n\t\tpublic final BigFloat ONE;\n\n\t\tprivate final MathContext mathContext;\n\n\t\tprivate Context(MathContext mathContext) {\n\t\t\tthis.mathContext = mathContext;\n\t\t\tNEGATIVE_ONE = this.valueOf(-1);\n\t\t\tZERO = this.valueOf(0);\n\t\t\tONE = this.valueOf(1);\n\t\t}\n\n\t\t/**\n\t\t * Returns the {@link MathContext} of this context.\n\t\t *\n\t\t * @return the {@link MathContext}\n\t\t */\n\t\tpublic MathContext getMathContext() {\n\t\t\treturn mathContext;\n\t\t}\n\n\t\t/**\n\t\t * Returns the precision of this context.\n\t\t *
\n\t\t * This is equivalent to calling getMathContext().getPrecision().\n\t\t *\n\t\t * @return the precision\n\t\t */\n\t\tpublic int getPrecision() {\n\t\t\treturn mathContext.getPrecision();\n\t\t}\n\n\t\t/**\n\t\t * Returns the {@link RoundingMode} of this context.\n\t\t *
\n\t\t * This is equivalent to calling getMathContext().getRoundingMode().\n\t\t *\n\t\t * @return the {@link RoundingMode}\n\t\t */\n\t\tpublic RoundingMode getRoundingMode() {\n\t\t\treturn mathContext.getRoundingMode();\n\t\t}\n\n\t\t/**\n\t\t * Creates a {@link BigFloat} value with this context.\n\t\t *\n\t\t * @param value the source {@link BigFloat} value\n\t\t *\n\t\t * @return the {@link BigFloat} value with this context (rounded to the precision of this context)\n\t\t */\n\t\tpublic BigFloat valueOf(BigFloat value) {\n\t\t\treturn value.isSpecial() ? value : new BigFloat(value.value.round(mathContext), this);//they are final\n\t\t}\n\n\t\t/**\n\t\t * Creates a {@link BigFloat} value with this context.\n\t\t *\n\t\t * @param value the source {@link BigDecimal} value\n\t\t *\n\t\t * @return the {@link BigFloat} value with this context (rounded to the precision of this context)\n\t\t */\n\t\tpublic BigFloat valueOf(BigDecimal value) {\n\t\t\treturn new BigFloat(value.round(mathContext), this);\n\t\t}\n\n\t\t/**\n\t\t * Creates a {@link BigFloat} value with this context.\n\t\t *\n\t\t * @param value the source int value\n\t\t *\n\t\t * @return the {@link BigFloat} value with this context (rounded to the precision of this context)\n\t\t */\n\t\tpublic BigFloat valueOf(int value) {\n\t\t\treturn new BigFloat(new BigDecimal(value, mathContext), this);\n\t\t}\n\n\t\t/**\n\t\t * parse unsigned value with this logic
value & 4294967295
\n\t\t * @param value an int value\n\t\t * @param unsigned if true value will parse as unsigned integer\n\t\t * @return the {@link BigFloat} value with this context (rounded to the precision of this context)\n\t\t */\n\t\tpublic BigFloat valueOf(int value, boolean unsigned) {\n\t\t\tif (!unsigned) {\n\t\t\t\treturn new BigFloat(new BigDecimal(value, mathContext), this);\n\t\t\t} else {\n\t\t\t\tif (value > -1)\n\t\t\t\t\treturn valueOf(value, false);\n\t\t\t\treturn new BigFloat(new BigDecimal(Integer.MAX_VALUE)\n\t\t\t\t\t\t.add(new BigDecimal(value & Integer.MAX_VALUE))\n\t\t\t\t\t\t.add(BigDecimal.ONE), this);\n\t\t\t}\n\t\t}\n\n\t\t/**\n\t\t * Creates a {@link BigFloat} value with this context.\n\t\t *\n\t\t * @param value the source long value\n\t\t *\n\t\t * @return the {@link BigFloat} value with this context (rounded to the precision of this context)\n\t\t */\n\t\tpublic BigFloat valueOf(long value) {\n\t\t\treturn new BigFloat(new BigDecimal(value, mathContext), this);\n\t\t}\n\n\t\t/**\n\t\t * parse unsigned value with this logic
value & 18446744073709551615
\n\t\t * @param value an int value\n\t\t * @param unsigned if true value will parse as unsigned integer\n\t\t * @return the {@link BigFloat} value with this context (rounded to the precision of this context)\n\t\t */\n\t\tpublic BigFloat valueOf(long value, boolean unsigned) {\n\t\t\tif (!unsigned) {\n\t\t\t\treturn new BigFloat(new BigDecimal(value, mathContext), this);\n\t\t\t} else {\n\t\t\t\tif (value > -1)\n\t\t\t\t\treturn valueOf(value, false);\n\t\t\t\treturn new BigFloat(new BigDecimal(Long.MAX_VALUE)\n\t\t\t\t\t\t.add(new BigDecimal(value & Long.MAX_VALUE))\n\t\t\t\t\t\t.add(BigDecimal.ONE), this);\n\t\t\t}\n\t\t}\n\n\t\t/**\n\t\t * Creates a {@link BigFloat} value with this context.\n\t\t *\n\t\t * @param value the source double value\n\t\t *\n\t\t * @return the {@link BigFloat} value with this context (rounded to the precision of this context)\n\t\t */\n\t\tpublic BigFloat valueOf(double value) {\n\t\t\tif (Double.isInfinite(value))\n\t\t\t\treturn value == Double.POSITIVE_INFINITY ? POSITIVE_INFINITY : NEGATIVE_INFINITY;\n\t\t\telse if (Double.isNaN(value))\n\t\t\t\treturn NaN;\n\t\t\treturn new BigFloat(new BigDecimal(String.valueOf(value), mathContext), this);\n\t\t}\n\n\t\t/**\n\t\t * Creates a {@link BigFloat} value with this context.\n\t\t *\n\t\t * @param value the source String value\n\t\t *\n\t\t * @return the {@link BigFloat} value with this context (rounded to the precision of this context)\n\t\t *\n\t\t * @throws NumberFormatException if the value is not a valid number.\n\t\t */\n\t\tpublic BigFloat valueOf(String value) {\n\t\t\treturn new BigFloat(new BigDecimal(value, mathContext), this);\n\t\t}\n\n\t\t/**\n\t\t * Returns the constant pi with this context.\n\t\t *\n\t\t * @return pi with this context (rounded to the precision of this context)\n\t\t *\n\t\t * @see BigDecimalMath#pi(MathContext)\n\t\t */\n\t\tpublic BigFloat pi() {\n\t\t\treturn valueOf(BigDecimalMath.pi(mathContext));\n\t\t}\n\n\t\t/**\n\t\t * Returns the constant e with this context.\n\t\t *\n\t\t * @return e with this context (rounded to the precision of this context)\n\t\t *\n\t\t * @see BigDecimalMath#e(MathContext)\n\t\t */\n\t\tpublic BigFloat e() {\n\t\t\treturn valueOf(BigDecimalMath.e(mathContext));\n\t\t}\n\n\t\t/**\n\t\t * Returns the factorial of n with this context.\n\t\t *\n\t\t * @param n the value to calculate\n\t\t *\n\t\t * @return the factorial of n with this context (rounded to the precision of this context)\n\t\t *\n\t\t * @see BigDecimalMath#factorial(int)\n\t\t */\n\t\tpublic BigFloat factorial(int n) {\n\t\t\treturn valueOf(BigDecimalMath.factorial(n));\n\t\t}\n\n\t\t@Override\n\t\tpublic int hashCode() {\n\t\t\treturn mathContext.hashCode();\n\t\t}\n\n\t\t@Override\n\t\tpublic boolean equals(Object obj) {\n\t\t\tif (this == obj)\n\t\t\t\treturn true;\n\t\t\tif (obj == null)\n\t\t\t\treturn false;\n\t\t\tif (getClass() != obj.getClass())\n\t\t\t\treturn false;\n\t\t\tContext other = (Context) obj;\n\t\t\treturn mathContext.equals(other.mathContext);\n\t\t}\n\n\t\t@Override\n\t\tpublic String toString() {\n\t\t\treturn mathContext.toString();\n\t\t}\n\t}\n\t/**\n\t * Returns the {@link BigFloat} that is - this.\n\t *\n\t * @param x the value to negate\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#negate(MathContext)\n\t */\n\tpublic static BigFloat negate(BigFloat x) {\n\t\tif (x.isSpecial())\n\t\t\tif (x.isInfinity())\n\t\t\t\treturn x == POSITIVE_INFINITY ? NEGATIVE_INFINITY : POSITIVE_INFINITY;\n\t\t\telse\n\t\t\t\treturn NaN;\n\t\treturn x.context.valueOf(x.value.negate());\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is the abs(this) (absolute value).\n\t *\n\t * @param x the value to make absolute\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimal#abs(MathContext)\n\t */\n\tpublic static BigFloat abs(BigFloat x) {\n\t\tif (x.isSpecial())\n\t\t\treturn x.isInfinity() ? POSITIVE_INFINITY : NaN;\n\t\treturn x.context.valueOf(x.value.abs());\n\t}\n\n\t/**\n\t * Returns the the maximum of two {@link BigFloat} values.\n\t *\n\t * @param value1 the first {@link BigFloat} value to compare\n\t * @param value2 the second {@link BigFloat} value to compare\n\t *\n\t * @return the maximum {@link BigFloat} value\n\t */\n\tpublic static BigFloat max(BigFloat value1, BigFloat value2) {\n\t\treturn value1.compareTo(value2) >= 0 ? value1 : value2;\n\t}\n\n\t/**\n\t * Returns the the maximum of n {@link BigFloat} values.\n\t *\n\t * @param value1 the first {@link BigFloat} value to compare\n\t * @param values the other {@link BigFloat}s value to compare\n\t *\n\t * @return the maximum {@link BigFloat} value\n\t */\n\tpublic static BigFloat max(BigFloat value1, BigFloat... values) {\n\t\tBigFloat result = value1;\n\n\t\tfor (BigFloat other : values) {\n\t\t\tresult = max(result, other);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/**\n\t * Returns the the minimum of two {@link BigFloat} values.\n\t *\n\t * @param value1 the first {@link BigFloat} value to compare\n\t * @param value2 the second {@link BigFloat} value to compare\n\t *\n\t * @return the minimum {@link BigFloat} value\n\t */\n\tpublic static BigFloat min(BigFloat value1, BigFloat value2) {\n\t\treturn value1.compareTo(value2) < 0 ? value1 : value2;\n\t}\n\n\t/**\n\t * Returns the the minimum of n {@link BigFloat} values.\n\t *\n\t * @param value1 the first {@link BigFloat} value to compare\n\t * @param values the other {@link BigFloat}s value to compare\n\t *\n\t * @return the minimum {@link BigFloat} value\n\t */\n\tpublic static BigFloat min(BigFloat value1, BigFloat... values) {\n\t\tBigFloat result = value1;\n\n\t\tfor (BigFloat other : values) {\n\t\t\tresult = min(result, other);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\tprivate static BigFloat logSpecial(BigFloat val){\n\t\tif (val.isNaN() || val.isNegative())\n\t\t\treturn NaN;\n\t\tif (val == POSITIVE_INFINITY)\n\t\t\treturn POSITIVE_INFINITY;\n\t\tif (val.isZero())\n\t\t\treturn NEGATIVE_INFINITY;\n\t\treturn null;\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is log(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#log(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat log(BigFloat x) {\n\t\tBigFloat temp = logSpecial(x);\n\t\treturn temp != null ? temp : x.context.valueOf(BigDecimalMath.log(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is log2(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#log2(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat log2(BigFloat x) {\n\t\tBigFloat temp = logSpecial(x);\n\t\treturn temp != null ? temp : x.context.valueOf(BigDecimalMath.log2(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is log10(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#log10(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat log10(BigFloat x) {\n\t\tBigFloat temp = logSpecial(x);\n\t\treturn temp != null ? temp : x.context.valueOf(BigDecimalMath.log10(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is exp(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#exp(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat exp(BigFloat x) {\n\t\tif(x.isSpecial())\n\t\t\treturn x != NEGATIVE_INFINITY ? x : x.context.ZERO;\n\t\treturn x.context.valueOf(BigDecimalMath.exp(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is sqrt(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#sqrt(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat sqrt(BigFloat x) {\n\t\tif (x.isNaN() || x.isNegative())\n\t\t\treturn NaN;\n\t\tif (x.isZero() || x.isInfinity())\n\t\t\treturn x;\n\t\treturn x.context.valueOf(BigDecimalMath.sqrt(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is pow(x, y).\n\t *\n\t *
If the two values do not have the same {@link Context}, the result will contain the {@link Context} with the larger precision.
\n\t *\n\t * @param x the {@link BigFloat} value to take to the power\n\t * @param y the {@link BigFloat} value to serve as exponent\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#pow(BigDecimal, BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat pow(BigFloat x, BigFloat y) {\n\t\tContext c = max(x.context, y.context);\n\t\treturn c.valueOf(BigDecimalMath.pow(x.value, y.value, c.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is root(x, y).\n\t *\n\t *
If the two values do not have the same {@link Context}, the result will contain the {@link Context} with the larger precision.
\n\t *\n\t * @param x the {@link BigFloat} value to calculate the n'th root\n\t * @param y the {@link BigFloat} defining the root\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#pow(BigDecimal, BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat root(BigFloat x, BigFloat y) {\n\t\tContext c = max(x.context, y.context);\n\t\treturn c.valueOf(BigDecimalMath.root(x.value, y.value, c.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is sin(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#sin(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat sin(BigFloat x) {\n\t\tif(x.isSpecial())\n\t\t\treturn NaN;\n\t\tif(x.isZero())\n\t\t\treturn x;\n\t\treturn x.context.valueOf(BigDecimalMath.sin(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is cos(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#cos(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat cos(BigFloat x) {\n\t\tif(x.isSpecial())\n\t\t\treturn NaN;\n\t\treturn x.context.valueOf(BigDecimalMath.cos(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is tan(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#tan(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat tan(BigFloat x) {\n\t\tif(x.isSpecial())\n\t\t\treturn NaN;\n\t\tif(x.isZero())\n\t\t\treturn x;\n\t\treturn x.context.valueOf(BigDecimalMath.tan(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is cot(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#cot(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat cot(BigFloat x) {\n\t\tif(x.isSpecial())\n\t\t\treturn x;\n\t\tif(x.isZero())\n\t\t\treturn POSITIVE_INFINITY;\n\t\treturn x.context.valueOf(BigDecimalMath.cot(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is asin(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#asin(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat asin(BigFloat x) {\n\t\tif (x.isZero())\n\t\t\treturn x;\n\t\treturn x.isNaN() || (!isRangeAbs1(x)) ? NaN :\n\t\t\t\tx.context.valueOf(BigDecimalMath.asin(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is acos(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#acos(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat acos(BigFloat x) {\n\t\treturn x.isNaN() || (!isRangeAbs1(x)) ? NaN :\n\t\t\t\tx.context.valueOf(BigDecimalMath.acos(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * @param x a bigfloat\n\t * @return if abs(x) <= 1\n\t */\n\tprivate static boolean isRangeAbs1(BigFloat x) {\n\t\treturn isBetween(x.context.NEGATIVE_ONE, x.context.ONE, x);\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is atan(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#atan(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat atan(BigFloat x) {\n\t\treturn x.isSpecial() || x.isZero() ? x : x.context.valueOf(BigDecimalMath.atan(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is acot(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#acot(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat acot(BigFloat x) {\n\t\treturn x.isSpecial() ? x : x.context.valueOf(BigDecimalMath.acot(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is sinh(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#sinh(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat sinh(BigFloat x) {\n\t\tif (x.isSpecial() || x.isZero())\n\t\t\treturn x;\n\t\treturn x.context.valueOf(BigDecimalMath.sinh(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is cosh(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#cosh(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat cosh(BigFloat x) {\n\t\tif (x.isNaN())\n\t\t\treturn NaN;\n\t\tif (x.isInfinity())\n\t\t\treturn POSITIVE_INFINITY;\n\t\tif (x.isZero())\n\t\t\treturn x.context.ONE;\n\t\treturn x.context.valueOf(BigDecimalMath.cosh(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is tanh(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#tanh(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat tanh(BigFloat x) {\n\t\tif (x.isNaN() || x.isZero())\n\t\t\treturn x;\n\t\tif (x.isInfinity())\n\t\t\treturn x == POSITIVE_INFINITY ? x.context.ONE : x.context.NEGATIVE_ONE;\n\t\treturn x.context.valueOf(BigDecimalMath.tanh(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is coth(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#coth(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat coth(BigFloat x) {\n\t\tif(x.isSpecial())\n\t\t\treturn x;\n\t\treturn x.context.valueOf(BigDecimalMath.coth(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is asinh(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#asinh(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat asinh(BigFloat x) {\n\t\tif(x.isSpecial())\n\t\t\treturn x;\n\t\treturn x.context.valueOf(BigDecimalMath.asinh(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is acosh(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#acosh(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat acosh(BigFloat x) {\n\t\treturn x.context.valueOf(BigDecimalMath.acosh(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is atanh(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#atanh(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat atanh(BigFloat x) {\n\t\tif(x.isSpecial())\n\t\t\treturn x;\n\t\treturn x.context.valueOf(BigDecimalMath.atanh(x.value, x.context.mathContext));\n\t}\n\n\t/**\n\t * Returns the {@link BigFloat} that is acoth(x).\n\t *\n\t * @param x the value\n\t *\n\t * @return the resulting {@link BigFloat}\n\t *\n\t * @see BigDecimalMath#acoth(BigDecimal, MathContext)\n\t */\n\tpublic static BigFloat acoth(BigFloat x) {\n\t\tif(x.isSpecial())\n\t\t\treturn x;\n\t\treturn x.context.valueOf(BigDecimalMath.acoth(x.value, x.context.mathContext));\n\t}\n\n\tpublic static boolean isBetween(BigFloat min, BigFloat max, BigFloat value) {\n\t\treturn value.compareTo(min) >= 0 && value.compareTo(max) <= 0;\n\t}\n\n\tprivate static Context max(Context left, Context right) {\n\t\treturn left.mathContext.getPrecision() > right.mathContext.getPrecision() ? left : right;\n\t}\n}\n"
},
{
"path": "ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/BigRational.java",
"content": "package ch.obermuhlner.math.big;\r\n\r\nimport java.io.Serializable;\r\nimport java.math.BigDecimal;\r\nimport java.math.BigInteger;\r\nimport java.math.MathContext;\r\nimport java.math.RoundingMode;\r\nimport java.util.ArrayList;\r\nimport java.util.List;\r\nimport java.util.stream.IntStream;\r\n\r\n/**\r\n * A rational number represented as a quotient of two values.\r\n * \r\n *
Basic calculations with rational numbers (+ - * /) have no loss of precision.\r\n * This allows to use {@link BigRational} as a replacement for {@link BigDecimal} if absolute accuracy is desired.
The values are internally stored as {@link BigDecimal} (for performance optimizations) but represented\r\n * as {@link BigInteger} (for mathematical correctness)\r\n * when accessed with {@link #getNumeratorBigInteger()} and {@link #getDenominatorBigInteger()}.
\r\n * \r\n *
The following basic calculations have no loss of precision:
\r\n *
\r\n *
{@link #add(BigRational)}
\r\n *
{@link #subtract(BigRational)}
\r\n *
{@link #multiply(BigRational)}
\r\n *
{@link #divide(BigRational)}
\r\n *
{@link #pow(int)}
\r\n *
\r\n * \r\n *
The following calculations are special cases of the ones listed above and have no loss of precision:
\r\n *
\r\n *
{@link #negate()}
\r\n *
{@link #reciprocal()}
\r\n *
{@link #increment()}
\r\n *
{@link #decrement()}
\r\n *
\r\n * \r\n *
Any {@link BigRational} value can be converted into an arbitrary {@link #withPrecision(int) precision} (number of significant digits)\r\n * or {@link #withScale(int) scale} (number of digits after the decimal point).
\r\n */\r\npublic class BigRational extends Number implements Comparable, Serializable {\r\n\r\n\t/**\r\n\t * The value 0 as {@link BigRational}.\r\n\t */\r\n\tpublic static final BigRational ZERO = new BigRational(0);\r\n\t/**\r\n\t * The value 1 as {@link BigRational}.\r\n\t */\r\n\tpublic static final BigRational ONE = new BigRational(1);\r\n\t/**\r\n\t * The value 2 as {@link BigRational}.\r\n\t */\r\n\tpublic static final BigRational TWO = new BigRational(2);\r\n\t/**\r\n\t * The value 10 as {@link BigRational}.\r\n\t */\r\n\tpublic static final BigRational TEN = new BigRational(10);\r\n\r\n\tprivate final BigDecimal numerator;\r\n\r\n\tprivate final BigDecimal denominator;\r\n\r\n\tprivate BigRational(int value) {\r\n\t\tthis(BigDecimal.valueOf(value), BigDecimal.ONE);\r\n\t}\r\n\r\n\tprivate BigRational(BigDecimal num, BigDecimal denom) {\r\n\t\tBigDecimal n = num;\r\n\t\tBigDecimal d = denom;\r\n\r\n\t\tif (d.signum() == 0) {\r\n\t\t\tthrow new ArithmeticException(\"Divide by zero\");\r\n\t\t}\r\n\r\n\t\tif (d.signum() < 0) {\r\n\t\t\tn = n.negate();\r\n\t\t\td = d.negate();\r\n\t\t}\r\n\r\n\t\tnumerator = n;\r\n\t\tdenominator = d;\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the numerator of this rational number as BigInteger.\r\n\t * \r\n\t * @return the numerator as BigInteger\r\n\t */\r\n\tpublic BigInteger getNumeratorBigInteger() {\r\n\t\treturn numerator.toBigInteger();\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the numerator of this rational number as BigDecimal.\r\n\t * \r\n\t * @return the numerator as BigDecimal\r\n\t */\r\n\tpublic BigDecimal getNumerator() {\r\n\t\treturn numerator;\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the denominator of this rational number as BigInteger.\r\n\t * \r\n\t *
Guaranteed to not be 0.
\r\n\t *
Guaranteed to be positive.
\r\n\t * \r\n\t * @return the denominator as BigInteger\r\n\t */\r\n\tpublic BigInteger getDenominatorBigInteger() {\r\n\t\treturn denominator.toBigInteger();\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the denominator of this rational number as BigDecimal.\r\n\t * \r\n\t *
Guaranteed to not be 0.
\r\n\t *
Guaranteed to be positive.
\r\n\t * \r\n\t * @return the denominator as BigDecimal\r\n\t */\r\n\tpublic BigDecimal getDenominator() {\r\n\t\treturn denominator;\r\n\t}\r\n\r\n\t/**\r\n\t * Reduces this rational number to the smallest numerator/denominator with the same value.\r\n\t * \r\n\t * @return the reduced rational number\r\n\t */\r\n\tpublic BigRational reduce() {\r\n\t\tBigInteger n = numerator.toBigInteger();\r\n\t\tBigInteger d = denominator.toBigInteger();\r\n\r\n\t\tBigInteger gcd = n.gcd(d);\r\n\t\tn = n.divide(gcd);\r\n\t\td = d.divide(gcd);\r\n\r\n\t\treturn valueOf(n, d);\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the integer part of this rational number.\r\n\t * \r\n\t *
\r\n\t * \r\n\t * @return the integer part of this rational number\r\n\t */\r\n\tpublic BigRational integerPart() {\r\n\t\treturn of(numerator.subtract(numerator.remainder(denominator)), denominator);\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the fraction part of this rational number.\r\n\t * \r\n\t *
\r\n\t * \r\n\t * @return the fraction part of this rational number\r\n\t */\r\n\tpublic BigRational fractionPart() {\r\n\t\treturn of(numerator.remainder(denominator), denominator);\r\n\t}\r\n\t\r\n\t/**\r\n\t * Negates this rational number (inverting the sign).\r\n\t * \r\n\t *
\r\n\t * \r\n\t * @return the reciprocal rational number\r\n\t * @throws ArithmeticException if this number is 0 (division by zero)\r\n\t */\r\n\tpublic BigRational reciprocal() {\r\n\t\treturn of(denominator, numerator);\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the absolute value of this rational number.\r\n\t * \r\n\t *
\r\n\t * \r\n\t * @return the absolute rational number (positive, or 0 if this rational is 0)\r\n\t */\r\n\tpublic BigRational abs() {\r\n\t\treturn isPositive() ? this : negate();\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the signum function of this rational number.\r\n\t *\r\n\t * @return -1, 0 or 1 as the value of this rational number is negative, zero or positive.\r\n\t */\r\n\tpublic int signum() {\r\n\t\treturn numerator.signum();\r\n\t}\r\n\r\n\t/**\r\n\t * Calculates the increment of this rational number (+ 1).\r\n\t * \r\n\t *
This is functionally identical to\r\n\t * this.add(BigRational.ONE)\r\n\t * but slightly faster.
\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t * \r\n\t * @return the incremented rational number\r\n\t */\r\n\tpublic BigRational increment() {\r\n\t\treturn of(numerator.add(denominator), denominator);\r\n\t}\r\n\r\n\t/**\r\n\t * Calculates the decrement of this rational number (- 1).\r\n\t * \r\n\t *
This is functionally identical to\r\n\t * this.subtract(BigRational.ONE)\r\n\t * but slightly faster.
\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t * \r\n\t * @return the decremented rational number\r\n\t */\r\n\tpublic BigRational decrement() {\r\n\t\treturn of(numerator.subtract(denominator), denominator);\r\n\t}\r\n\r\n\t/**\r\n\t * Calculates the addition (+) of this rational number and the specified argument.\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t * \r\n\t * @param value the rational number to add\r\n\t * @return the resulting rational number\r\n\t */\r\n\tpublic BigRational add(BigRational value) {\r\n\t\tif (denominator.compareTo(value.denominator) == 0) {\r\n\t\t\treturn of(numerator.add(value.numerator), denominator);\r\n\t\t}\r\n\r\n\t\tBigDecimal n = numerator.multiply(value.denominator).add(value.numerator.multiply(denominator));\r\n\t\tBigDecimal d = denominator.multiply(value.denominator);\r\n\t\treturn of(n, d);\r\n\t}\r\n\r\n\tprivate BigRational add(BigDecimal value) {\r\n\t\treturn of(numerator.add(value.multiply(denominator)), denominator);\r\n\t}\r\n\t\r\n\t/**\r\n\t * Calculates the addition (+) of this rational number and the specified argument.\r\n\t * \r\n\t *
This is functionally identical to\r\n\t * this.add(BigRational.valueOf(value))\r\n\t * but slightly faster.
\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t * \r\n\t * @param value the {@link BigInteger} to add\r\n\t * @return the resulting rational number\r\n\t */\r\n\tpublic BigRational add(BigInteger value) {\r\n\t\tif (value.equals(BigInteger.ZERO)) {\r\n\t\t\treturn this;\r\n\t\t}\r\n\t\treturn add(new BigDecimal(value));\r\n\t}\r\n\r\n\t/**\r\n\t * Calculates the addition (+) of this rational number and the specified argument.\r\n\t * \r\n\t *
This is functionally identical to\r\n\t * this.add(BigRational.valueOf(value))\r\n\t * but slightly faster.
\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t * \r\n\t * @param value the int value to add\r\n\t * @return the resulting rational number\r\n\t */\r\n\tpublic BigRational add(int value) {\r\n\t\tif (value == 0) {\r\n\t\t\treturn this;\r\n\t\t}\r\n\t\treturn add(BigInteger.valueOf(value));\r\n\t}\r\n\r\n\t/**\r\n\t * Calculates the subtraction (-) of this rational number and the specified argument.\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t * \r\n\t * @param value the rational number to subtract\r\n\t * @return the resulting rational number\r\n\t */\r\n\tpublic BigRational subtract(BigRational value) {\r\n\t\tif (denominator.compareTo(value.denominator) == 0) {\r\n\t\t\treturn of(numerator.subtract(value.numerator), denominator);\r\n\t\t}\r\n\r\n\t\tBigDecimal n = numerator.multiply(value.denominator).subtract(value.numerator.multiply(denominator));\r\n\t\tBigDecimal d = denominator.multiply(value.denominator);\r\n\t\treturn of(n, d);\r\n\t}\r\n\r\n\tprivate BigRational subtract(BigDecimal value) {\r\n\t\treturn of(numerator.subtract(value.multiply(denominator)), denominator);\r\n\t}\r\n\t\r\n\t/**\r\n\t * Calculates the subtraction (-) of this rational number and the specified argument.\r\n\t * \r\n\t *
This is functionally identical to\r\n\t * this.subtract(BigRational.valueOf(value))\r\n\t * but slightly faster.
\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t * \r\n\t * @param value the {@link BigInteger} to subtract\r\n\t * @return the resulting rational number\r\n\t */\r\n\tpublic BigRational subtract(BigInteger value) {\r\n\t\tif (value.equals(BigInteger.ZERO)) {\r\n\t\t\treturn this;\r\n\t\t}\r\n\t\treturn subtract(new BigDecimal(value));\r\n\t}\r\n\r\n\t/**\r\n\t * Calculates the subtraction (-) of this rational number and the specified argument.\r\n\t * \r\n\t *
This is functionally identical to\r\n\t * this.subtract(BigRational.valueOf(value))\r\n\t * but slightly faster.
\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t * \r\n\t * @param value the int value to subtract\r\n\t * @return the resulting rational number\r\n\t */\r\n\tpublic BigRational subtract(int value) {\r\n\t\tif (value == 0) {\r\n\t\t\treturn this;\r\n\t\t}\r\n\t\treturn subtract(BigInteger.valueOf(value));\r\n\t}\r\n\r\n\t/**\r\n\t * Calculates the multiplication (*) of this rational number and the specified argument.\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t * \r\n\t * @param value the rational number to multiply\r\n\t * @return the resulting rational number\r\n\t */\r\n\tpublic BigRational multiply(BigRational value) {\r\n\t\tif (isZero() || value.isZero()) {\r\n\t\t\treturn ZERO;\r\n\t\t}\r\n\t\tif (equals(ONE)) {\r\n\t\t\treturn value;\r\n\t\t}\r\n\t\tif (value.equals(ONE)) {\r\n\t\t\treturn this;\r\n\t\t}\r\n\r\n\t\tBigDecimal n = numerator.multiply(value.numerator);\r\n\t\tBigDecimal d = denominator.multiply(value.denominator);\r\n\t\treturn of(n, d);\r\n\t}\r\n\r\n\t// private, because we want to hide that we use BigDecimal internally\r\n\tprivate BigRational multiply(BigDecimal value) {\r\n\t\tBigDecimal n = numerator.multiply(value);\r\n\t\tBigDecimal d = denominator;\r\n\t\treturn of(n, d);\r\n\t}\r\n\t\r\n\t/**\r\n\t * Calculates the multiplication (*) of this rational number and the specified argument.\r\n\t * \r\n\t *
This is functionally identical to\r\n\t * this.multiply(BigRational.valueOf(value))\r\n\t * but slightly faster.
\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t * \r\n\t * @param value the {@link BigInteger} to multiply\r\n\t * @return the resulting rational number\r\n\t */\r\n\tpublic BigRational multiply(BigInteger value) {\r\n\t\tif (isZero() || value.signum() == 0) {\r\n\t\t\treturn ZERO;\r\n\t\t}\r\n\t\tif (equals(ONE)) {\r\n\t\t\treturn valueOf(value);\r\n\t\t}\r\n\t\tif (value.equals(BigInteger.ONE)) {\r\n\t\t\treturn this;\r\n\t\t}\r\n\r\n\t\treturn multiply(new BigDecimal(value));\r\n\t}\r\n\r\n\t/**\r\n\t * Calculates the multiplication (*) of this rational number and the specified argument.\r\n\t * \r\n\t *
This is functionally identical to\r\n\t * this.multiply(BigRational.valueOf(value))\r\n\t * but slightly faster.
\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t * \r\n\t * @param value the int value to multiply\r\n\t * @return the resulting rational number\r\n\t */\r\n\tpublic BigRational multiply(int value) {\r\n\t\treturn multiply(BigInteger.valueOf(value));\r\n\t}\r\n\r\n\t/**\r\n\t * Calculates the division (/) of this rational number and the specified argument.\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t * \r\n\t * @param value the rational number to divide (0 is not allowed)\r\n\t * @return the resulting rational number\r\n\t * @throws ArithmeticException if the argument is 0 (division by zero)\r\n\t */\r\n\tpublic BigRational divide(BigRational value) {\r\n\t\tif (value.equals(ONE)) {\r\n\t\t\treturn this;\r\n\t\t}\r\n\r\n\t\tBigDecimal n = numerator.multiply(value.denominator);\r\n\t\tBigDecimal d = denominator.multiply(value.numerator);\r\n\t\treturn of(n, d);\r\n\t}\r\n\r\n\tprivate BigRational divide(BigDecimal value) {\r\n\t\tBigDecimal n = numerator;\r\n\t\tBigDecimal d = denominator.multiply(value);\r\n\t\treturn of(n, d);\r\n\t}\r\n\t\r\n\t/**\r\n\t * Calculates the division (/) of this rational number and the specified argument.\r\n\t * \r\n\t *
This is functionally identical to\r\n\t * this.divide(BigRational.valueOf(value))\r\n\t * but slightly faster.
\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t * \r\n\t * @param value the {@link BigInteger} to divide (0 is not allowed)\r\n\t * @return the resulting rational number\r\n\t * @throws ArithmeticException if the argument is 0 (division by zero)\r\n\t */\r\n\tpublic BigRational divide(BigInteger value) {\r\n\t\tif (value.equals(BigInteger.ONE)) {\r\n\t\t\treturn this;\r\n\t\t}\r\n\r\n\t\treturn divide(new BigDecimal(value));\r\n\t}\r\n\r\n\t/**\r\n\t * Calculates the division (/) of this rational number and the specified argument.\r\n\t * \r\n\t *
This is functionally identical to\r\n\t * this.divide(BigRational.valueOf(value))\r\n\t * but slightly faster.
\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t * \r\n\t * @param value the int value to divide (0 is not allowed)\r\n\t * @return the resulting rational number\r\n\t * @throws ArithmeticException if the argument is 0 (division by zero)\r\n\t */\r\n\tpublic BigRational divide(int value) {\r\n\t\treturn divide(BigInteger.valueOf(value));\r\n\t}\r\n\r\n\t/**\r\n\t * Returns whether this rational number is zero.\r\n\t * \r\n\t * @return true if this rational number is zero (0), false if it is not zero\r\n\t */\r\n\tpublic boolean isZero() {\r\n\t\treturn numerator.signum() == 0;\r\n\t}\r\n\r\n\tprivate boolean isPositive() {\r\n\t\treturn numerator.signum() > 0;\r\n\t}\r\n\r\n\t/**\r\n\t * Returns whether this rational number is an integer number without fraction part.\r\n\t * \r\n\t * @return true if this rational number is an integer number, false if it has a fraction part\r\n\t */\r\n\tpublic boolean isInteger() {\r\n\t\treturn isIntegerInternal() || reduce().isIntegerInternal();\r\n\t}\r\n\r\n\t/**\r\n\t * Returns whether this rational number is an integer number without fraction part.\r\n\t * \r\n\t *
Will return false if this number is not reduced to the integer representation yet (e.g. 4/4 or 4/2)
\r\n\t * \r\n\t * @return true if this rational number is an integer number, false if it has a fraction part\r\n\t * @see #isInteger()\r\n\t */\r\n\tprivate boolean isIntegerInternal() {\r\n\t\treturn denominator.compareTo(BigDecimal.ONE) == 0;\r\n\t}\r\n\r\n\t/**\r\n\t * Calculates this rational number to the power (xy) of the specified argument.\r\n\t * \r\n\t *
The result has no loss of precision.
\r\n\t *\r\n\t * @param exponent exponent to which this rational number is to be raised\r\n\t * @return the resulting rational number\r\n\t */\r\n\tpublic BigRational pow(int exponent) {\r\n\t\tif (exponent == 0) {\r\n\t\t\treturn ONE;\r\n\t\t}\r\n\t\tif (exponent == 1) {\r\n\t\t\treturn this;\r\n\t\t}\r\n\r\n\t\tfinal BigInteger n;\r\n\t\tfinal BigInteger d;\r\n\t\tif (exponent > 0) {\r\n\t\t\tn = numerator.toBigInteger().pow(exponent);\r\n\t\t\td = denominator.toBigInteger().pow(exponent);\r\n\t\t}\r\n\t\telse {\r\n\t\t\tn = denominator.toBigInteger().pow(-exponent);\r\n\t\t\td = numerator.toBigInteger().pow(-exponent);\r\n\t\t}\r\n\t\treturn valueOf(n, d);\r\n\t}\r\n\r\n\t/**\r\n\t * Finds the minimum (smaller) of two rational numbers.\r\n\t * \r\n\t * @param value the rational number to compare with\r\n\t * @return the minimum rational number, either this or the argument value\r\n\t */\r\n\tprivate BigRational min(BigRational value) {\r\n\t\treturn compareTo(value) <= 0 ? this : value;\r\n\t}\r\n\r\n\t/**\r\n\t * Finds the maximum (larger) of two rational numbers.\r\n\t * \r\n\t * @param value the rational number to compare with\r\n\t * @return the minimum rational number, either this or the argument value\r\n\t */\r\n\tprivate BigRational max(BigRational value) {\r\n\t\treturn compareTo(value) >= 0 ? this : value;\r\n\t}\r\n\r\n\t/**\r\n\t * Returns a rational number with approximatively this value and the specified precision.\r\n\t * \r\n\t * @param precision the precision (number of significant digits) of the calculated result, or 0 for unlimited precision\r\n\t * @return the calculated rational number with the specified precision\r\n\t */\r\n\tpublic BigRational withPrecision(int precision) {\r\n\t\treturn valueOf(toBigDecimal(new MathContext(precision)));\r\n\t}\r\n\r\n\t/**\r\n\t * Returns a rational number with approximatively this value and the specified scale.\r\n\t * \r\n\t * @param scale the scale (number of digits after the decimal point) of the calculated result\r\n\t * @return the calculated rational number with the specified scale\r\n\t */\r\n\tpublic BigRational withScale(int scale) {\r\n\t\treturn valueOf(toBigDecimal().setScale(scale, RoundingMode.HALF_UP));\r\n\t}\r\n\r\n\tprivate static int countDigits(BigInteger number) {\r\n\t\tdouble factor = Math.log(2) / Math.log(10);\r\n\t\tint digitCount = (int) (factor * number.bitLength() + 1);\r\n\t\tif (BigInteger.TEN.pow(digitCount - 1).compareTo(number) > 0) {\r\n\t\t\treturn digitCount - 1;\r\n\t\t}\r\n\t\treturn digitCount;\r\n\t}\r\n\r\n\t// TODO what is precision of a rational?\r\n\tprivate int precision() {\r\n\t\treturn countDigits(numerator.toBigInteger()) + countDigits(denominator.toBigInteger());\r\n\t}\r\n\r\n\t/**\r\n\t * Returns this rational number as a double value.\r\n\t *\r\n\t *
If the rational number cannot be represented as double then one of the following results will be returned:
\r\n\t *\r\n\t * @return the double value\r\n\t */\r\n\tpublic double toDouble() {\r\n\t\treturn toBigDecimal().doubleValue();\r\n\t}\r\n\r\n\t/**\r\n\t * Returns this rational number as a float value.\r\n\t *\r\n\t *
If the rational number cannot be represented as float then one of the following results will be returned:
\r\n\t * \r\n\t * @return the rational number string representation in the form \"numerator/denominator\", or \"0\" if the rational number is 0.\r\n\t * @see #valueOf(String) \r\n\t * @see #valueOf(int, int) \r\n\t */\r\n\tpublic String toRationalString() {\r\n\t\tif (isZero()) {\r\n\t\t\treturn \"0\";\r\n\t\t}\r\n\t\tif (isIntegerInternal()) {\r\n\t\t\treturn numerator.toString();\r\n\t\t}\r\n\t\treturn numerator + \"/\" + denominator;\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".\r\n\t * \r\n\t *
The integer part is omitted if it is 0 (when this absolute rational number is smaller than 1).
\r\n\t *
The fraction part is omitted it it is 0 (when this rational number is an integer).
\r\n\t *
If this rational number is 0, then \"0\" is returned.
\r\n\t * \r\n\t * @return the integer and fraction rational string representation\r\n\t * @see #valueOf(int, int, int)\r\n\t */\r\n\tpublic String toIntegerRationalString() {\r\n\t\tBigDecimal fractionNumerator = numerator.remainder(denominator);\r\n\t\tBigDecimal integerNumerator = numerator.subtract(fractionNumerator);\r\n\t\tBigDecimal integerPart = integerNumerator.divide(denominator);\r\n\r\n\t\tStringBuilder result = new StringBuilder();\r\n\t\tif (integerPart.signum() != 0) {\r\n\t\t\tresult.append(integerPart);\r\n\t\t}\r\n\t\tif (fractionNumerator.signum() != 0) {\r\n\t\t\tif (result.length() > 0) {\r\n\t\t\t\tresult.append(' ');\r\n\t\t\t\tresult.append(fractionNumerator.abs());\r\n\t\t\t} else {\r\n\t\t\t\tresult.append(fractionNumerator);\r\n\t\t\t}\r\n\t\t\tresult.append('/');\r\n\t\t\tresult.append(denominator);\r\n\t\t}\r\n\t\tif (result.length() == 0) {\r\n\t\t\tresult.append('0');\r\n\t\t}\r\n\t\t\r\n\t\treturn result.toString();\r\n\t}\r\n\t\r\n\t/**\r\n\t * Creates a rational number of the specified int value.\r\n\t * \r\n\t * @param value the int value\r\n\t * @return the rational number\r\n\t */\r\n\tpublic static BigRational valueOf(int value) {\r\n\t\tif (value == 0) {\r\n\t\t\treturn ZERO;\r\n\t\t}\r\n\t\tif (value == 1) {\r\n\t\t\treturn ONE;\r\n\t\t}\r\n\t\treturn new BigRational(value);\r\n\t}\r\n\r\n\t/**\r\n\t * Creates a rational number of the specified numerator/denominator int values.\r\n\t * \r\n\t * @param numerator the numerator int value\r\n\t * @param denominator the denominator int value (0 not allowed)\r\n\t * @return the rational number\r\n\t * @throws ArithmeticException if the denominator is 0 (division by zero)\r\n\t */\r\n\tpublic static BigRational valueOf(int numerator, int denominator) {\r\n\t\treturn of(BigDecimal.valueOf(numerator), BigDecimal.valueOf(denominator));\r\n\t}\r\n\r\n\t/**\r\n\t * Creates a rational number of the specified integer and fraction parts.\r\n\t * \r\n\t *
Useful to create numbers like 3 1/2 (= three and a half = 3.5) by calling\r\n\t * BigRational.valueOf(3, 1, 2).
\r\n\t *
To create a negative rational only the integer part argument is allowed to be negative:\r\n\t * to create -3 1/2 (= minus three and a half = -3.5) call BigRational.valueOf(-3, 1, 2).
\r\n\t * \r\n\t * @param integer the integer part int value\r\n\t * @param fractionNumerator the fraction part numerator int value (negative not allowed)\r\n\t * @param fractionDenominator the fraction part denominator int value (0 or negative not allowed)\r\n\t * @return the rational number\r\n\t * @throws ArithmeticException if the fraction part denominator is 0 (division by zero),\r\n\t * or if the fraction part numerator or denominator is negative\r\n\t */\r\n\tpublic static BigRational valueOf(int integer, int fractionNumerator, int fractionDenominator) {\r\n\t\tif (fractionNumerator < 0 || fractionDenominator < 0) {\r\n\t\t\tthrow new ArithmeticException(\"Negative value\");\r\n\t\t}\r\n\t\t\r\n\t\tBigRational integerPart = valueOf(integer);\r\n\t\tBigRational fractionPart = valueOf(fractionNumerator, fractionDenominator);\r\n\t\treturn integerPart.isPositive() ? integerPart.add(fractionPart) : integerPart.subtract(fractionPart);\r\n\t}\r\n\r\n\t/**\r\n\t * Creates a rational number of the specified numerator/denominator BigInteger values.\r\n\t * \r\n\t * @param numerator the numerator {@link BigInteger} value\r\n\t * @param denominator the denominator {@link BigInteger} value (0 not allowed)\r\n\t * @return the rational number\r\n\t * @throws ArithmeticException if the denominator is 0 (division by zero)\r\n\t */\r\n\tpublic static BigRational valueOf(BigInteger numerator, BigInteger denominator) {\r\n\t\treturn of(new BigDecimal(numerator), new BigDecimal(denominator));\r\n\t}\r\n\r\n\t/**\r\n\t * Creates a rational number of the specified {@link BigInteger} value.\r\n\t * \r\n\t * @param value the {@link BigInteger} value\r\n\t * @return the rational number\r\n\t */\r\n\tpublic static BigRational valueOf(BigInteger value) {\r\n\t\tif (value.compareTo(BigInteger.ZERO) == 0) {\r\n\t\t\treturn ZERO;\r\n\t\t}\r\n\t\tif (value.compareTo(BigInteger.ONE) == 0) {\r\n\t\t\treturn ONE;\r\n\t\t}\r\n\t\treturn valueOf(value, BigInteger.ONE);\r\n\t}\r\n\r\n\t/**\r\n\t * Creates a rational number of the specified double value.\r\n\t * \r\n\t * @param value the double value\r\n\t * @return the rational number\r\n\t * @throws NumberFormatException if the double value is Infinite or NaN.\r\n\t */\r\n\tpublic static BigRational valueOf(double value) {\r\n\t\tif (value == 0.0) {\r\n\t\t\treturn ZERO;\r\n\t\t}\r\n\t\tif (value == 1.0) {\r\n\t\t\treturn ONE;\r\n\t\t}\r\n\t\tif (Double.isInfinite(value)) {\r\n\t\t\tthrow new NumberFormatException(\"Infinite\");\r\n\t\t}\r\n\t\tif (Double.isNaN(value)) {\r\n\t\t\tthrow new NumberFormatException(\"NaN\");\r\n\t\t}\r\n\t\treturn valueOf(new BigDecimal(String.valueOf(value)));\r\n\t}\r\n\r\n\t/**\r\n\t * Creates a rational number of the specified {@link BigDecimal} value.\r\n\t * \r\n\t * @param value the double value\r\n\t * @return the rational number\r\n\t */\r\n\tpublic static BigRational valueOf(BigDecimal value) {\r\n\t\tif (value.compareTo(BigDecimal.ZERO) == 0) {\r\n\t\t\treturn ZERO;\r\n\t\t}\r\n\t\tif (value.compareTo(BigDecimal.ONE) == 0) {\r\n\t\t\treturn ONE;\r\n\t\t}\r\n\t\t\r\n\t\tint scale = value.scale();\r\n\t\tif (scale == 0) {\r\n\t\t\treturn new BigRational(value, BigDecimal.ONE);\r\n\t\t} else if (scale < 0) {\r\n\t\t\tBigDecimal n = new BigDecimal(value.unscaledValue()).multiply(BigDecimal.ONE.movePointLeft(value.scale()));\r\n\t\t\treturn new BigRational(n, BigDecimal.ONE);\r\n\t\t}\r\n\t\telse {\r\n\t\t\tBigDecimal n = new BigDecimal(value.unscaledValue());\r\n\t\t\tBigDecimal d = BigDecimal.ONE.movePointRight(value.scale());\r\n\t\t\treturn new BigRational(n, d);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Creates a rational number of the specified string representation.\r\n\t * \r\n\t *
The accepted string representations are:
\r\n\t *
\r\n\t *
Output of {@link BigRational#toString()} : \"integerPart.fractionPart\"
\r\n\t *
Output of {@link BigRational#toRationalString()} : \"numerator/denominator\"
\r\n\t *
Output of toString() of {@link BigDecimal}, {@link BigInteger}, {@link Integer}, ...
\r\n\t *
Output of toString() of {@link Double}, {@link Float} - except \"Infinity\", \"-Infinity\" and \"NaN\"
\r\n\t *
\r\n\t * \r\n\t * @param string the string representation to convert\r\n\t * @return the rational number\r\n\t * @throws ArithmeticException if the denominator is 0 (division by zero)\r\n\t */\r\n\tpublic static BigRational valueOf(String string) {\r\n\t\tString[] strings = string.split(\"/\");\r\n\t\tBigRational result = valueOfSimple(strings[0]);\r\n\t\tfor (int i = 1; i < strings.length; i++) {\r\n\t\t\tresult = result.divide(valueOfSimple(strings[i]));\r\n\t\t}\r\n\t\treturn result;\r\n\t}\r\n\r\n\tprivate static BigRational valueOfSimple(String string) {\r\n\t\treturn valueOf(new BigDecimal(string));\r\n\t}\r\n\r\n\tpublic static BigRational valueOf(boolean positive, String integerPart, String fractionPart, String fractionRepeatPart, String exponentPart) {\r\n\t\tBigRational result = ZERO;\r\n\r\n\t\tif (fractionRepeatPart != null && fractionRepeatPart.length() > 0) {\r\n\t\t\tBigInteger lotsOfNines = BigInteger.TEN.pow(fractionRepeatPart.length()).subtract(BigInteger.ONE);\r\n\t\t\tresult = valueOf(new BigInteger(fractionRepeatPart), lotsOfNines);\r\n\t\t}\r\n\r\n\t\tif (fractionPart != null && fractionPart.length() > 0) {\r\n\t\t\tresult = result.add(valueOf(new BigInteger(fractionPart)));\r\n\t\t\tresult = result.divide(BigInteger.TEN.pow(fractionPart.length()));\r\n\t\t}\r\n\r\n\t\tif (integerPart != null && integerPart.length() > 0) {\r\n\t\t\tresult = result.add(new BigInteger(integerPart));\r\n\t\t}\r\n\r\n\t\tif (exponentPart != null && exponentPart.length() > 0) {\r\n\t\t\tint exponent = Integer.parseInt(exponentPart);\r\n\t\t\tBigInteger powerOfTen = BigInteger.TEN.pow(Math.abs(exponent));\r\n\t\t\tresult = exponent >= 0 ? result.multiply(powerOfTen) : result.divide(powerOfTen);\r\n\t\t}\r\n\r\n\t\tif (!positive) {\r\n\t\t\tresult = result.negate();\r\n\t\t}\r\n\r\n\t\treturn result;\r\n\t}\r\n\r\n\t/**\r\n\t * Creates a rational number of the specified numerator/denominator BigDecimal values.\r\n\t * \r\n\t * @param numerator the numerator {@link BigDecimal} value\r\n\t * @param denominator the denominator {@link BigDecimal} value (0 not allowed)\r\n\t * @return the rational number\r\n\t * @throws ArithmeticException if the denominator is 0 (division by zero)\r\n\t */\r\n\tpublic static BigRational valueOf(BigDecimal numerator, BigDecimal denominator) {\r\n\t\treturn valueOf(numerator).divide(valueOf(denominator));\r\n\t}\r\n\t\r\n\tprivate static BigRational of(BigDecimal numerator, BigDecimal denominator) {\r\n\t\tif (numerator.signum() == 0 && denominator.signum() != 0) {\r\n\t\t\treturn ZERO;\r\n\t\t}\r\n\t\tif (numerator.compareTo(BigDecimal.ONE) == 0 && denominator.compareTo(BigDecimal.ONE) == 0) {\r\n\t\t\treturn ONE;\r\n\t\t}\r\n\t\treturn new BigRational(numerator, denominator);\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the smallest of the specified rational numbers.\r\n\t * \r\n\t * @param values the rational numbers to compare\r\n\t * @return the smallest rational number, 0 if no numbers are specified\r\n\t */\r\n\tpublic static BigRational min(BigRational... values) {\r\n\t\tif (values.length == 0) {\r\n\t\t\treturn BigRational.ZERO;\r\n\t\t}\r\n\t\tBigRational result = values[0];\r\n\t\tfor (int i = 1; i < values.length; i++) {\r\n\t\t\tresult = result.min(values[i]);\r\n\t\t}\r\n\t\treturn result;\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the largest of the specified rational numbers.\r\n\t * \r\n\t * @param values the rational numbers to compare\r\n\t * @return the largest rational number, 0 if no numbers are specified\r\n\t * @see #max(BigRational)\r\n\t */\r\n\tpublic static BigRational max(BigRational... values) {\r\n\t\tif (values.length == 0) {\r\n\t\t\treturn BigRational.ZERO;\r\n\t\t}\r\n\t\tBigRational result = values[0];\r\n\t\tfor (int i = 1; i < values.length; i++) {\r\n\t\t\tresult = result.max(values[i]);\r\n\t\t}\r\n\t\treturn result;\r\n\t}\r\n\r\n\tprivate static List bernoulliCache = new ArrayList<>();\r\n\t\r\n\t/**\r\n\t * Calculates the Bernoulli number for the specified index.\r\n\t * \r\n\t *
This function calculates the first Bernoulli numbers and therefore bernoulli(1) returns -0.5
\r\n\t *
Note that bernoulli(x) for all odd x > 1 returns 0
\r\n\t * \r\n\t * @param n the index of the Bernoulli number to be calculated (starting at 0)\r\n\t * @return the Bernoulli number for the specified index\r\n\t * @throws ArithmeticException if x is lesser than 0\r\n\t */\r\n public static BigRational bernoulli(int n) {\r\n\t\tif (n < 0) {\r\n\t\t\tthrow new ArithmeticException(\"Illegal bernoulli(n) for n < 0: n = \" + n);\r\n\t\t}\r\n \tif (n == 1) {\r\n \t\treturn valueOf(-1, 2);\r\n \t} else if (n % 2 == 1) {\r\n \t\treturn ZERO;\r\n \t}\r\n \t\r\n \tsynchronized (bernoulliCache) {\r\n \t\tint index = n / 2;\r\n \t\t\r\n \t\tif (bernoulliCache.size() <= index) {\r\n \t\t\tfor (int i = bernoulliCache.size(); i <= index; i++) {\r\n \t\t\t\tBigRational b = calculateBernoulli(i * 2);\r\n\t\t\t\t\tbernoulliCache.add(b);\r\n\t\t\t\t}\r\n \t\t}\r\n \t\t\r\n \t\treturn bernoulliCache.get(index);\r\n\t\t}\r\n }\r\n \r\n private static BigRational calculateBernoulli(int n) {\r\n \treturn IntStream.rangeClosed(0, n).parallel().mapToObj(k -> {\r\n BigRational jSum = ZERO ;\r\n BigRational bin = ONE ;\r\n for(int j=0 ; j <= k ; j++) {\r\n BigRational jPowN = valueOf(j).pow(n);\r\n if (j % 2 == 0) {\r\n \tjSum = jSum.add(bin.multiply(jPowN)) ;\r\n } else {\r\n \tjSum = jSum.subtract(bin.multiply(jPowN)) ;\r\n }\r\n\r\n bin = bin.multiply(valueOf(k-j).divide(valueOf(j+1)));\r\n }\r\n return jSum.divide(valueOf(k+1));\r\n \t}).reduce(ZERO, BigRational::add);\r\n }\r\n\r\n\t@Override\r\n\tpublic int intValue() {\r\n\t\treturn toBigDecimal().intValue();\r\n\t}\r\n\r\n\t@Override\r\n\tpublic long longValue() {\r\n\t\treturn toBigDecimal().longValue();\r\n\t}\r\n\r\n\t@Override\r\n\tpublic float floatValue() {\r\n\t\treturn toFloat();\r\n\t}\r\n\r\n\t@Override\r\n\tpublic double doubleValue() {\r\n\t\treturn toDouble();\r\n\t}\r\n}\r\n"
},
{
"path": "ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/DefaultBigDecimalMath.java",
"content": "package ch.obermuhlner.math.big;\n\nimport java.math.BigDecimal;\nimport java.math.MathContext;\nimport java.math.RoundingMode;\nimport java.util.*;\n\n/**\n * A wrapper around {@link BigDecimalMath} that passes a current {@link MathContext} to the\n * functions that need a {@link MathContext} argument.\n *\n *
The initial default {@link MathContext} is equivalent to {@link MathContext#DECIMAL128}\n * but this can be overridden by setting the following system properties:
\n *
\n *
ch.obermuhlner.math.big.default.precision to a positive integer precision (default=34)
\n *
ch.obermuhlner.math.big.default.rounding to a {@link RoundingMode} name (default=HALF_UP)
\n *
\n *\n *
It is also possible to programmatically set the default {@link MathContext} using {@link #setDefaultMathContext(MathContext)}.\n * It is recommended to set the desired precision in the {@link MathContext} very early in the startup of the application and to not change it afterwards.
\n *\n *
Important: Avoid the pitfall of setting the precision temporarily using {@link #setDefaultMathContext(MathContext)} for a calculation.\n * This can lead to race conditions and calculations with the wrong precision\n * if other threads in your application do the same thing.
\n *\n *
To set a temporary {@link MathContext} you have to choice to use either:\n *
\n *
DefaultBigDecimalMath.createLocalMathContext() in a try-with-resources statement
\n *
DefaultBigDecimalMath.withLocalMathContext() with a lambda function
\n *
\n *\n * Example code using DefaultBigDecimalMath.createLocalMathContext():\n *
The temporary {@link MathContext} are stored in {@link ThreadLocal} variables\n * and will therefore not conflict with each other when used in multi-threaded use case.
\n *\n *
Important: Due to the {@link ThreadLocal} variables the local {@link MathContext} will\n * not be available in other threads.\n * This includes streams using parallel(), thread pools and manually started threads.\n * If you need temporary {@link MathContext} for calculations then you must\n * set the local {@link MathContext} inside every separate thread.
\n */\npublic class DefaultBigDecimalMath {\n\n private static MathContext defaultMathContext = createDefaultMathContext();\n private static ThreadLocal> mathContextStack = new ThreadLocal<>();\n\n private static MathContext createDefaultMathContext () {\n int precision = getIntSystemProperty(\"ch.obermuhlner.math.big.default.precision\", MathContext.DECIMAL128.getPrecision());\n RoundingMode rounding = getRoundingModeSystemProperty(\"ch.obermuhlner.math.big.default.rounding\", MathContext.DECIMAL128.getRoundingMode());\n\n return new MathContext(precision, rounding);\n }\n\n private static void pushMathContext(MathContext mathContext) {\n Deque mathContexts = mathContextStack.get();\n if (mathContexts == null) {\n mathContexts = new ArrayDeque<>();\n mathContextStack.set(mathContexts);\n };\n mathContexts.addLast(mathContext);\n }\n\n private static MathContext popMathContext() {\n Deque mathContexts = mathContextStack.get();\n MathContext poppedMathContext = mathContexts.removeLast();\n if (mathContexts.isEmpty()) {\n mathContextStack.remove();\n }\n return poppedMathContext;\n }\n\n private static int getIntSystemProperty(String propertyKey, int defaultValue) {\n String propertyValue = System.getProperty(propertyKey, Integer.toString(defaultValue));\n try {\n return Integer.parseInt(propertyValue);\n } catch(NumberFormatException ex) {\n return propertyException(propertyKey,propertyValue,defaultValue);\n }\n }\n\n private static RoundingMode getRoundingModeSystemProperty(String propertyKey, RoundingMode defaultValue) {\n String propertyValue = System.getProperty(propertyKey, defaultValue.name());\n try {\n return RoundingMode.valueOf(propertyValue);\n } catch(IllegalArgumentException ex) {\n return propertyException(propertyKey,propertyValue,defaultValue);\n }\n }\n\n private static T propertyException(String propertyKey,String propertyValue,T defaultValue){\n System.err.println(\"Property '\" + propertyKey + \"' is not valid: \" + propertyValue + \" (using \" + defaultValue + \" instead)\");\n return defaultValue;\n }\n\n /**\n * Sets the default {@link MathContext} used if no other {@link MathContext} is defined using {@link #withLocalMathContext(MathContext, Runnable)}.\n *\n * @param defaultMathContext the default {@link MathContext}\n * @see #currentMathContext()\n * @see #withLocalMathContext(int, Runnable)\n * @see #withLocalMathContext(int, RoundingMode, Runnable)\n * @see #withLocalMathContext(MathContext, Runnable)\n */\n public static void setDefaultMathContext(MathContext defaultMathContext) {\n Objects.requireNonNull(defaultMathContext);\n DefaultBigDecimalMath.defaultMathContext = defaultMathContext;\n }\n\n /**\n * Returns the default {@link MathContext} used for all mathematical functions in this class.\n *\n * @return the default {@link MathContext}\n */\n public static MathContext getDefaultMathContext() {\n return defaultMathContext;\n }\n\n /**\n * Executes the given {@link Runnable} using the specified precision.\n *\n * @param precision the precision to use for calculations in the runnable\n * @param runnable the {@link Runnable} to execute\n */\n public static void withLocalMathContext(int precision, Runnable runnable) {\n withLocalMathContext(new MathContext(precision), runnable);\n }\n\n /**\n * Executes the given {@link Runnable} using the specified precision and {@link RoundingMode}.\n *\n * @param precision the precision to use for calculations in the runnable\n * @param roundingMode the {@link RoundingMode} to use for calculations in the runnable\n * @param runnable the {@link Runnable} to execute\n */\n public static void withLocalMathContext(int precision, RoundingMode roundingMode, Runnable runnable) {\n withLocalMathContext(new MathContext(precision, roundingMode), runnable);\n }\n\n /**\n * Executes the given {@link Runnable} using the specified {@link MathContext}.\n *\n * @param mathContext the {@link MathContext} to use for calculations in the runnable\n * @param runnable the {@link Runnable} to execute\n */\n public static void withLocalMathContext(MathContext mathContext, Runnable runnable) {\n try (LocalMathContext context = createLocalMathContext(mathContext)) {\n runnable.run();\n }\n }\n\n /**\n * Executes the given {@link Runnable} using the specified precision.\n *\n * @param precision the precision to use for calculations\n * @return the created {@link LocalMathContext} to be used in a try-with-resources statement\n */\n public static LocalMathContext createLocalMathContext(int precision) {\n return createLocalMathContext(new MathContext(precision));\n }\n\n /**\n * Executes the given {@link Runnable} using the specified precision and {@link RoundingMode}.\n *\n * @param precision the precision to use for calculations\n * @param roundingMode the {@link RoundingMode} to use for calculations in the runnable\n * @return the created {@link LocalMathContext} to be used in a try-with-resources statement\n */\n public static LocalMathContext createLocalMathContext(int precision, RoundingMode roundingMode) {\n return createLocalMathContext(new MathContext(precision, roundingMode));\n }\n\n /**\n * Executes the given {@link Runnable} using the specified {@link MathContext}.\n *\n * @param mathContext the {@link MathContext} to use for calculations\n * @return the created {@link LocalMathContext} to be used in a try-with-resources statement\n */\n public static LocalMathContext createLocalMathContext(MathContext mathContext) {\n return new LocalMathContext(mathContext);\n }\n\n /**\n * Returns the current {@link MathContext} used for all mathematical functions in this class.\n *\n *
The current {@link MathContext} is the last {@link MathContext} specified\n * using {@link #withLocalMathContext(MathContext, Runnable)}\n * or the default {@link MathContext} if none was specified.
\n *\n * @return the current {@link MathContext}\n * @see #currentMathContext()\n * @see #withLocalMathContext(int, Runnable)\n * @see #withLocalMathContext(int, RoundingMode, Runnable)\n * @see #withLocalMathContext(MathContext, Runnable)\n */\n public static MathContext currentMathContext() {\n Deque mathContexts = mathContextStack.get();\n if (mathContexts == null || mathContexts.isEmpty()) {\n return defaultMathContext;\n }\n\n return mathContexts.getLast();\n }\n \n /**\n * Rounds the specified {@link BigDecimal} to the precision of the current {@link MathContext}.\n *\n * @param value the {@link BigDecimal} to round\n * @return the rounded {@link BigDecimal} value\n * @see #currentMathContext()\n * @see BigDecimalMath#round(BigDecimal, MathContext)\n */\n public static BigDecimal round(BigDecimal value) {\n return BigDecimalMath.round(value, defaultMathContext);\n }\n\n /**\n * Rounds the specified {@link BigDecimal} to the precision of the current {@link MathContext} including trailing zeroes.\n *\n * @param value the {@link BigDecimal} to round\n * @return the rounded {@link BigDecimal} value including trailing zeroes\n * @see #currentMathContext()\n * @see BigDecimalMath#roundWithTrailingZeroes(BigDecimal, MathContext)\n */\n public static BigDecimal roundWithTrailingZeroes(BigDecimal value) {\n return BigDecimalMath.roundWithTrailingZeroes(value, currentMathContext());\n }\n\n /**\n * Returns the {@link BigDecimal} that is x + y using the current {@link MathContext}.\n *\n * @param x the x value\n * @param y the y value to add\n * @return the resulting {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimal#add(BigDecimal, MathContext)\n */\n public static BigDecimal add(BigDecimal x, BigDecimal y) {\n return x.add(y, currentMathContext());\n }\n\n /**\n * Returns the {@link BigDecimal} that is x - y using the current {@link MathContext}.\n *\n * @param x the x value\n * @param y the y value to subtract\n * @return the resulting {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimal#subtract(BigDecimal, MathContext)\n */\n public static BigDecimal subtract(BigDecimal x, BigDecimal y) {\n return x.subtract(y, currentMathContext());\n }\n\n /**\n * Returns the {@link BigDecimal} that is x * y using the current {@link MathContext}.\n *\n * @param x the x value\n * @param y the y value to multiply\n * @return the resulting {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimal#multiply(BigDecimal, MathContext)\n */\n public static BigDecimal multiply(BigDecimal x, BigDecimal y) {\n return x.multiply(y, currentMathContext());\n }\n\n /**\n * Returns the {@link BigDecimal} that is x / y using the current {@link MathContext}.\n *\n * @param x the x value\n * @param y the y value to divide\n * @return the resulting {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimal#divide(BigDecimal, MathContext)\n */\n public static BigDecimal divide(BigDecimal x, BigDecimal y) {\n return x.divide(y, currentMathContext());\n }\n\n /**\n * Returns the {@link BigDecimal} that is x % y using the current {@link MathContext}.\n *\n * @param x the x value\n * @param y the y value to divide\n * @return the resulting {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimal#remainder(BigDecimal, MathContext)\n */\n public static BigDecimal remainder(BigDecimal x, BigDecimal y) {\n return x.remainder(y, currentMathContext());\n }\n\n /**\n * Calculates the reciprocal of the specified {@link BigDecimal} using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal}\n * @return the reciprocal {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#reciprocal(BigDecimal, MathContext)\n */\n public static BigDecimal reciprocal(BigDecimal x) {\n return BigDecimalMath.reciprocal(x, currentMathContext());\n }\n\n /**\n * Calculates the factorial of the specified {@link BigDecimal} using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal}\n * @return the factorial {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#factorial(BigDecimal, MathContext)\n */\n public static BigDecimal factorial(BigDecimal x) {\n return BigDecimalMath.factorial(x, currentMathContext());\n }\n\n /**\n * Calculates the gamma function of the specified {@link BigDecimal} using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal}\n * @return the gamma {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#gamma(BigDecimal, MathContext)\n */\n public static BigDecimal gamma(BigDecimal x) {\n return BigDecimalMath.gamma(x, currentMathContext());\n }\n\n /**\n * Calculates the Bernoulli number for the specified index using the current {@link MathContext}.\n *\n * @param n the index of the Bernoulli number to be calculated (starting at 0)\n * @return the Bernoulli number for the specified index with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#bernoulli(int, MathContext)\n */\n public static BigDecimal bernoulli(int n) {\n return BigDecimalMath.bernoulli(n, currentMathContext());\n }\n\n /**\n * Calculates {@link BigDecimal} x to the power of {@link BigDecimal} y (xy) using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} value to take to the power\n * @param y the {@link BigDecimal} value to serve as exponent\n * @return the calculated x to the power of y with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#pow(BigDecimal, BigDecimal, MathContext)\n */\n public static BigDecimal pow(BigDecimal x, BigDecimal y) {\n return BigDecimalMath.pow(x, y, currentMathContext());\n }\n\n /**\n * Calculates {@link BigDecimal} x to the power of long y (xy) using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} value to take to the power\n * @param y the long value to serve as exponent\n * @return the calculated x to the power of y with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#pow(BigDecimal, long, MathContext)\n */\n public static BigDecimal pow(BigDecimal x, long y) {\n return BigDecimalMath.pow(x, y, currentMathContext());\n }\n\n /**\n * Calculates the square root of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} value to calculate the square root\n * @return the calculated square root of x with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#sqrt(BigDecimal, MathContext)\n */\n public static BigDecimal sqrt(BigDecimal x) {\n return BigDecimalMath.sqrt(x, currentMathContext());\n }\n\n /**\n * Calculates the n'th root of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} value to calculate the n'th root\n * @param n the {@link BigDecimal} defining the root\n *\n * @return the calculated n'th root of x with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#root(BigDecimal, BigDecimal, MathContext)\n */\n public static BigDecimal root(BigDecimal x, BigDecimal n) {\n return BigDecimalMath.root(x, n, currentMathContext());\n }\n\n /**\n * Calculates the natural logarithm of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the natural logarithm for\n * @return the calculated natural logarithm {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#log(BigDecimal, MathContext)\n */\n public static BigDecimal log(BigDecimal x) {\n return BigDecimalMath.log(x, currentMathContext());\n }\n\n /**\n * Calculates the logarithm of {@link BigDecimal} x to the base 2 using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the logarithm base 2 for\n * @return the calculated natural logarithm {@link BigDecimal} to the base 2 with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#log2(BigDecimal, MathContext)\n */\n public static BigDecimal log2(BigDecimal x) {\n return BigDecimalMath.log2(x, currentMathContext());\n }\n\n /**\n * Calculates the logarithm of {@link BigDecimal} x to the base 10 using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the logarithm base 10 for\n * @return the calculated natural logarithm {@link BigDecimal} to the base 10 with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#log10(BigDecimal, MathContext)\n */\n public static BigDecimal log10(BigDecimal x) {\n return BigDecimalMath.log10(x, currentMathContext());\n }\n\n /**\n * Returns the number pi using the current {@link MathContext}.\n *\n * @return the number pi with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#pi(MathContext)\n */\n public static BigDecimal pi() {\n return BigDecimalMath.pi(currentMathContext());\n }\n\n /**\n * Returns the number e using the current {@link MathContext}.\n *\n * @return the number e with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#e(MathContext)\n */\n public static BigDecimal e() {\n return BigDecimalMath.e(currentMathContext());\n }\n\n /**\n * Calculates the natural exponent of {@link BigDecimal} x (ex) using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the exponent for\n * @return the calculated exponent {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#exp(BigDecimal, MathContext)\n */\n public static BigDecimal exp(BigDecimal x) {\n return BigDecimalMath.exp(x, currentMathContext());\n }\n\n /**\n * Calculates the sine (sinus) of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the sine for\n * @return the calculated sine {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#sin(BigDecimal, MathContext)\n */\n public static BigDecimal sin(BigDecimal x) {\n return BigDecimalMath.sin(x, currentMathContext());\n }\n\n /**\n * Calculates the arc sine (inverted sine) of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the arc sine for\n * @return the calculated arc sine {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#asin(BigDecimal, MathContext)\n */\n public static BigDecimal asin(BigDecimal x) {\n return BigDecimalMath.asin(x, currentMathContext());\n }\n\n /**\n * Calculates the cosine (cosinus) of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the cosine for\n * @return the calculated cosine {@link BigDecimal} with the precision specified in the current {@link MathContext}\n */\n public static BigDecimal cos(BigDecimal x) {\n return BigDecimalMath.cos(x, currentMathContext());\n }\n\n /**\n * Calculates the arc cosine (inverted cosine) of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the arc cosine for\n * @return the calculated arc sine {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#acos(BigDecimal, MathContext)\n */\n public static BigDecimal acos(BigDecimal x) {\n return BigDecimalMath.acos(x, currentMathContext());\n }\n\n /**\n * Calculates the tangens of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the tangens for\n * @return the calculated tangens {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#tan(BigDecimal, MathContext)\n */\n public static BigDecimal tan(BigDecimal x) {\n return BigDecimalMath.tan(x, currentMathContext());\n }\n\n /**\n * Calculates the arc tangens (inverted tangens) of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the arc tangens for\n * @return the calculated arc tangens {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#atan(BigDecimal, MathContext)\n */\n public static BigDecimal atan(BigDecimal x) {\n return BigDecimalMath.atan(x, currentMathContext());\n }\n\n /**\n * Calculates the arc tangens (inverted tangens) of {@link BigDecimal} y / x in the range -pi to pi using the current {@link MathContext}.\n *\n * @param y the {@link BigDecimal}\n * @param x the {@link BigDecimal}\n * @return the calculated arc tangens {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see #atan2(BigDecimal, BigDecimal)\n */\n public static BigDecimal atan2(BigDecimal y, BigDecimal x) {\n return BigDecimalMath.atan2(y, x, currentMathContext());\n }\n\n /**\n * Calculates the cotangens of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the cotangens for\n * @return the calculated cotanges {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#cot(BigDecimal, MathContext)\n */\n public static BigDecimal cot(BigDecimal x) {\n return BigDecimalMath.cot(x, currentMathContext());\n }\n\n /**\n * Calculates the inverse cotangens (arc cotangens) of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the arc cotangens for\n * @return the calculated arc cotangens {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#acot(BigDecimal, MathContext)\n */\n public static BigDecimal acot(BigDecimal x) {\n return BigDecimalMath.acot(x, currentMathContext());\n }\n\n /**\n * Calculates the hyperbolic sine of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the hyperbolic sine for\n * @return the calculated hyperbolic sine {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#sinh(BigDecimal, MathContext)\n */\n public static BigDecimal sinh(BigDecimal x) {\n return BigDecimalMath.sinh(x, currentMathContext());\n }\n\n /**\n * Calculates the hyperbolic cosine of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the hyperbolic cosine for\n * @return the calculated hyperbolic cosine {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#cosh(BigDecimal, MathContext)\n */\n public static BigDecimal cosh(BigDecimal x) {\n return BigDecimalMath.cosh(x, currentMathContext());\n }\n\n /**\n * Calculates the hyperbolic tangens of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the hyperbolic tangens for\n * @return the calculated hyperbolic tangens {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#tanh(BigDecimal, MathContext)\n */\n public static BigDecimal tanh(BigDecimal x) {\n return BigDecimalMath.tanh(x, currentMathContext());\n }\n\n /**\n * Calculates the hyperbolic cotangens of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the hyperbolic cotangens for\n * @return the calculated hyperbolic cotangens {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#coth(BigDecimal, MathContext)\n */\n public static BigDecimal coth(BigDecimal x) {\n return BigDecimalMath.coth(x, currentMathContext());\n }\n\n /**\n * Calculates the arc hyperbolic sine (inverse hyperbolic sine) of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the arc hyperbolic sine for\n * @return the calculated arc hyperbolic sine {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#asinh(BigDecimal, MathContext)\n */\n public static BigDecimal asinh(BigDecimal x) {\n return BigDecimalMath.asinh(x, currentMathContext());\n }\n\n /**\n * Calculates the arc hyperbolic cosine (inverse hyperbolic cosine) of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the arc hyperbolic cosine for\n * @return the calculated arc hyperbolic cosine {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#acosh(BigDecimal, MathContext)\n */\n public static BigDecimal acosh(BigDecimal x) {\n return BigDecimalMath.acosh(x, currentMathContext());\n }\n\n /**\n * Calculates the arc hyperbolic tangens (inverse hyperbolic tangens) of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the arc hyperbolic tangens for\n * @return the calculated arc hyperbolic tangens {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#atanh(BigDecimal, MathContext)\n */\n public static BigDecimal atanh(BigDecimal x) {\n return BigDecimalMath.atanh(x, currentMathContext());\n }\n\n /**\n * Calculates the arc hyperbolic cotangens (inverse hyperbolic cotangens) of {@link BigDecimal} x using the current {@link MathContext}.\n *\n * @param x the {@link BigDecimal} to calculate the arc hyperbolic cotangens for\n * @return the calculated arc hyperbolic cotangens {@link BigDecimal} with the precision specified in the current {@link MathContext}\n * @see #currentMathContext()\n * @see BigDecimalMath#acoth(BigDecimal, MathContext)\n */\n public static BigDecimal acoth(BigDecimal x) {\n return BigDecimalMath.acoth(x, currentMathContext());\n }\n\n /**\n * The local context used to push and pop a {@link MathContext} on the stack.\n *\n *
The recommended way to use this class is to use the try-with-resources.
\n */\n public static class LocalMathContext implements AutoCloseable {\n public final MathContext mathContext;\n\n LocalMathContext(MathContext mathContext) {\n this.mathContext = mathContext;\n pushMathContext(mathContext);\n }\n\n @Override\n public void close() {\n popMathContext();\n }\n }\n}\n"
},
{
"path": "ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/internal/AsinCalculator.java",
"content": "package ch.obermuhlner.math.big.internal;\r\n\r\nimport java.math.BigDecimal;\r\nimport java.math.MathContext;\r\n\r\nimport ch.obermuhlner.math.big.BigRational;\r\n\r\n/**\r\n * Calculates arc sinus using the Maclaurin series.\r\n * \r\n *
No argument checking or optimizations are done.\r\n * This implementation is not intended to be called directly.
\r\n */\r\npublic class ExpCalculator extends SeriesCalculator {\r\n\r\n\tpublic static final ExpCalculator INSTANCE = new ExpCalculator();\r\n\t\r\n\tprivate int n = 0;\r\n\tprivate BigRational oneOverFactorialOfN = BigRational.ONE;\r\n\t\r\n\tprivate ExpCalculator() {\r\n\t\t// prevent instances\r\n\t}\r\n\r\n\t@Override\r\n\tprotected BigRational getCurrentFactor() {\r\n\t\treturn oneOverFactorialOfN;\r\n\t}\r\n\t\r\n\t@Override\r\n\tprotected void calculateNextFactor() {\r\n\t\tn++;\r\n\t\toneOverFactorialOfN = oneOverFactorialOfN.divide(n);\r\n\t}\r\n\r\n\t@Override\r\n\tprotected PowerIterator createPowerIterator(BigDecimal x, MathContext mathContext) {\r\n\t\treturn new PowerNIterator(x, mathContext);\r\n\t}\r\n}\r\n"
},
{
"path": "ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/internal/PowerIterator.java",
"content": "package ch.obermuhlner.math.big.internal;\r\n\r\nimport java.math.BigDecimal;\r\n\r\n/**\r\n * Iterator over the powers of a value x.\r\n * \r\n *
This API allows to efficiently calculate the various powers of x in a taylor series by storing intermediate results.
\r\n *
For example xn can be calculated using one multiplication by storing the previously calculated xn-1 and x.
\r\n * \r\n *
{@link #getCurrentPower()} will be called first to retrieve the initial value.
\r\n * \r\n * For later iterations {@link #calculateNextPower()} will be called before {@link #getCurrentPower()}.\r\n */\r\npublic interface PowerIterator {\r\n\t\r\n\t/**\r\n\t * Returns the current power.\r\n\t * \r\n\t * @return the current power.\r\n\t */\r\n\tBigDecimal getCurrentPower();\r\n\t\r\n\t/**\r\n\t * Calculates the next power.\r\n\t */\r\n\tvoid calculateNextPower();\r\n}"
},
{
"path": "ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/internal/PowerNIterator.java",
"content": "package ch.obermuhlner.math.big.internal;\r\n\r\nimport java.math.BigDecimal;\r\nimport java.math.MathContext;\r\n\r\n/**\r\n * {@link PowerIterator} to calculate xn.\r\n */\r\npublic class PowerNIterator implements PowerIterator {\r\n\r\n\tprivate final BigDecimal x;\r\n\r\n\tprivate final MathContext mathContext;\r\n\r\n\tprivate BigDecimal powerOfX;\r\n\r\n\tpublic PowerNIterator(BigDecimal x, MathContext mathContext) {\r\n\t\tthis.x = x;\r\n\t\tthis.mathContext = mathContext;\r\n\t\t\r\n\t\tpowerOfX = BigDecimal.ONE;\r\n\t}\r\n\t\r\n\t@Override\r\n\tpublic BigDecimal getCurrentPower() {\r\n\t\treturn powerOfX;\r\n\t}\r\n\r\n\t@Override\r\n\tpublic void calculateNextPower() {\r\n\t\tpowerOfX = powerOfX.multiply(x, mathContext);\r\n\t}\r\n}"
},
{
"path": "ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/internal/PowerTwoNIterator.java",
"content": "package ch.obermuhlner.math.big.internal;\r\n\r\nimport java.math.BigDecimal;\r\nimport java.math.MathContext;\r\n\r\n/**\r\n * {@link PowerIterator} to calculate x2*n.\r\n */\r\npublic class PowerTwoNIterator implements PowerIterator {\r\n\r\n\tprivate final MathContext mathContext;\r\n\r\n\tprivate final BigDecimal xPowerTwo;\r\n\r\n\tprivate BigDecimal powerOfX;\r\n\r\n\tpublic PowerTwoNIterator(BigDecimal x, MathContext mathContext) {\r\n\t\tthis.mathContext = mathContext;\r\n\t\t\r\n\t\txPowerTwo = x.multiply(x, mathContext);\r\n\t\tpowerOfX = BigDecimal.ONE;\r\n\t}\r\n\t\r\n\t@Override\r\n\tpublic BigDecimal getCurrentPower() {\r\n\t\treturn powerOfX;\r\n\t}\r\n\r\n\t@Override\r\n\tpublic void calculateNextPower() {\r\n\t\tpowerOfX = powerOfX.multiply(xPowerTwo, mathContext);\r\n\t}\r\n}"
},
{
"path": "ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/internal/PowerTwoNMinusOneIterator.java",
"content": "package ch.obermuhlner.math.big.internal;\n\nimport ch.obermuhlner.math.big.BigDecimalMath;\n\nimport java.math.BigDecimal;\nimport java.math.MathContext;\n\n/**\n * {@link PowerIterator} to calculate x2*n-1.\n */\npublic class PowerTwoNMinusOneIterator implements PowerIterator {\n\n\tprivate final MathContext mathContext;\n\n\tprivate final BigDecimal xPowerTwo;\n\n\tprivate BigDecimal powerOfX;\n\n\tpublic PowerTwoNMinusOneIterator(BigDecimal x, MathContext mathContext) {\n\t\tthis.mathContext = mathContext;\n\t\t\n\t\txPowerTwo = x.multiply(x, mathContext);\n\t\tpowerOfX = BigDecimalMath.reciprocal(x, mathContext);\n\t}\n\t\n\t@Override\n\tpublic BigDecimal getCurrentPower() {\n\t\treturn powerOfX;\n\t}\n\n\t@Override\n\tpublic void calculateNextPower() {\n\t\tpowerOfX = powerOfX.multiply(xPowerTwo, mathContext);\n\t}\n}"
},
{
"path": "ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/internal/PowerTwoNPlusOneIterator.java",
"content": "package ch.obermuhlner.math.big.internal;\r\n\r\nimport java.math.BigDecimal;\r\nimport java.math.MathContext;\r\n\r\n/**\r\n * {@link PowerIterator} to calculate x2*n+1.\r\n */\r\npublic class PowerTwoNPlusOneIterator implements PowerIterator {\r\n\r\n\tprivate final MathContext mathContext;\r\n\r\n\tprivate final BigDecimal xPowerTwo;\r\n\r\n\tprivate BigDecimal powerOfX;\r\n\r\n\tpublic PowerTwoNPlusOneIterator(BigDecimal x, MathContext mathContext) {\r\n\t\tthis.mathContext = mathContext;\r\n\t\t\r\n\t\txPowerTwo = x.multiply(x, mathContext);\r\n\t\tpowerOfX = x;\r\n\t}\r\n\t\r\n\t@Override\r\n\tpublic BigDecimal getCurrentPower() {\r\n\t\treturn powerOfX;\r\n\t}\r\n\r\n\t@Override\r\n\tpublic void calculateNextPower() {\r\n\t\tpowerOfX = powerOfX.multiply(xPowerTwo, mathContext);\r\n\t}\r\n}"
},
{
"path": "ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/internal/SeriesCalculator.java",
"content": "package ch.obermuhlner.math.big.internal;\n\nimport ch.obermuhlner.math.big.BigRational;\n\nimport java.math.BigDecimal;\nimport java.math.MathContext;\nimport java.util.ArrayList;\nimport java.util.List;\n\nimport static java.util.Objects.requireNonNull;\n\n/**\n * Utility class to calculate taylor series efficiently until the maximum error (as defined by the precision in the {@link MathContext} is reached.\n * \n *
Stores the factors of the taylor series terms so that future calculations will be faster.
\n */\npublic abstract class SeriesCalculator {\n\n\tprivate final boolean calculateInPairs;\n\n\tprivate final List factors = new ArrayList<>();\n\n\t/**\n\t * Constructs a {@link SeriesCalculator} that calculates single terms.\n\t */\n\tprotected SeriesCalculator() {\n\t\tthis(false);\n\t}\n\t\n\t/**\n\t * Constructs a {@link SeriesCalculator} with control over whether the sum terms are calculated in pairs.\n\t * \n\t *
Calculation of pairs is useful for taylor series where the terms alternate the sign.\n\t * In these cases it is more efficient to calculate two terms at once check then whether the acceptable error has been reached.
\n\t * \n\t * @param calculateInPairs true to calculate the terms in pairs, false to calculate single terms\n\t */\n\tprotected SeriesCalculator(boolean calculateInPairs) {\n\t\tthis.calculateInPairs = calculateInPairs;\n\t}\n\t\n\t/**\n\t * Calculates the series for the specified value x and the precision defined in the {@link MathContext}.\n\t *\n\t * @param x the value x\n\t * @param mathContext the {@link MathContext}\n\t * @return the calculated result\n\t */\n\tpublic BigDecimal calculate(BigDecimal x, MathContext mathContext) {\n\t\tBigDecimal acceptableError = BigDecimal.ONE.movePointLeft(mathContext.getPrecision() + 1);\n\n\t\tPowerIterator powerIterator = createPowerIterator(x, mathContext);\n\t\t\n\t\tBigDecimal sum = BigDecimal.ZERO;\n\t\tBigDecimal step;\n\t\tint i = 0;\n\t\tdo {\n\t\t\tBigRational factor;\n\t\t\tBigDecimal xToThePower;\n\n\t\t\tfactor = getFactor(i);\n\t\t\txToThePower = powerIterator.getCurrentPower();\n\t\t\tpowerIterator.calculateNextPower();\n\t\t\tstep = factor.getNumerator().multiply(xToThePower).divide(factor.getDenominator(), mathContext);\n\t\t\ti++;\n\n\t\t\tif (calculateInPairs) {\n\t\t\t\tfactor = getFactor(i);\n\t\t\t\txToThePower = powerIterator.getCurrentPower();\n\t\t\t\tpowerIterator.calculateNextPower();\n\t\t\t\tBigDecimal step2 = factor.getNumerator().multiply(xToThePower).divide(factor.getDenominator(), mathContext);\n\t\t\t\tstep = step.add(step2);\n\t\t\t\ti++;\n\t\t\t}\n\n\t\t\tsum = sum.add(step);\n\t\t\t//System.out.println(sum + \" \" + step);\n\t\t} while (step.abs().compareTo(acceptableError) > 0);\n\t\t\n\t\treturn sum.round(mathContext);\n\t}\n\t\n\t/**\n\t * Creates the {@link PowerIterator} used for this series.\n\t * \n\t * @param x the value x\n\t * @param mathContext the {@link MathContext}\n\t * @return the {@link PowerIterator}\n\t */\n\tprotected abstract PowerIterator createPowerIterator(BigDecimal x, MathContext mathContext);\n\n\t/**\n\t * Returns the factor of the term with specified index.\n\t *\n\t * All mutable state of this class (and all its subclasses) must be modified in this method.\n\t * This method is synchronized to allow thread-safe usage of this class.\n\t *\n\t * @param index the index (starting with 0)\n\t * @return the factor of the specified term\n\t */\n\tprotected synchronized BigRational getFactor(int index) {\n\t\twhile (factors.size() <= index) {\n\t\t\tBigRational factor = getCurrentFactor();\n\t\t\taddFactor(factor);\n\t\t\tcalculateNextFactor();\n\t\t}\n\t\treturn factors.get(index);\n\t}\n\n\tprivate void addFactor(BigRational factor){\n\t\tfactors.add(requireNonNull(factor, \"Factor cannot be null\"));\n\t}\n\n\t/**\n\t * Returns the factor of the highest term already calculated.\n\t *
When called for the first time will return the factor of the first term (index 0).
\n\t *
After this call the method {@link #calculateNextFactor()} will be called to prepare for the next term.
\n\t * \n\t * @return the factor of the highest term\n\t */\n\tprotected abstract BigRational getCurrentFactor();\n\t\n\t/**\n\t * Calculates the factor of the next term.\n\t */\n\tprotected abstract void calculateNextFactor();\n}\n"
},
{
"path": "ch.obermuhlner.math.big/src/main/java/ch/obermuhlner/math/big/internal/SinCalculator.java",
"content": "package ch.obermuhlner.math.big.internal;\r\n\r\nimport java.math.BigDecimal;\r\nimport java.math.MathContext;\r\n\r\nimport ch.obermuhlner.math.big.BigRational;\r\n\r\n/**\r\n * Calculates sinus using the Maclaurin series.\r\n * \r\n *
\r\nprivate static final BigDecimal TWO = valueOf(2);\r\n\r\npublic static BigDecimal logUsingNewtonFixPrecision(BigDecimal x, MathContext mathContext) {\r\n\tif (x.signum() <= 0) {\r\n\t\tthrow new ArithmeticException(\"Illegal log(x) for x <= 0: x = \" + x);\r\n\t}\r\n\r\n\tMathContext mc = new MathContext(mathContext.getPrecision() + 4, mathContext.getRoundingMode());\r\n\tBigDecimal acceptableError = BigDecimal.ONE.movePointLeft(mathContext.getPrecision() + 1);\r\n\t\r\n\tBigDecimal result = BigDecimal.valueOf(Math.log(x.doubleValue()));\r\n\tBigDecimal step;\r\n\t\r\n\tdo {\r\n\t\tBigDecimal expY = BigDecimalMath.exp(result, mc); // available on https://github.com/eobermuhlner/big-math\r\n\t\tstep = TWO.multiply(x.subtract(expY, mc), mc).divide(x.add(expY, mc), mc);\r\n\t\tresult = result.add(step);\r\n\t} while (step.abs().compareTo(acceptableError) > 0);\r\n\r\n\treturn result.round(mathContext);\r\n}\r\n
\r\n\r\nThe MathContext mc is created with a precision of 4 digits more than the output is expected to have.\r\nAll calculations are done with this MathContext and therefore with the full precision.\r\n\r\nThe result is correct but we can improve the performance significantly be adapting the precision for every iteration.\r\n\r\nThe initial approximation uses Math.log(x.doubleValue()) which has a precision of about 17 significant digits.\r\n\r\nWe can expect that the precision triples with every iteration so it does not make sense to calculate with a higher precision than necessary.\r\n\r\nHere the same implementation with a temporary MathContext that is recreated with a different precision every iteration.\r\n\r\n
\r\npublic static BigDecimal logUsingNewtonAdaptivePrecision(BigDecimal x, MathContext mathContext) {\r\n\tif (x.signum() <= 0) {\r\n\t\tthrow new ArithmeticException(\"Illegal log(x) for x <= 0: x = \" + x);\r\n\t}\r\n\r\n\tint maxPrecision = mathContext.getPrecision() + 4;\r\n\tBigDecimal acceptableError = BigDecimal.ONE.movePointLeft(mathContext.getPrecision() + 1);\r\n\t\r\n\tBigDecimal result = BigDecimal.valueOf(Math.log(x.doubleValue()));\r\n\tint adaptivePrecision = 17;\r\n\tBigDecimal step = null;\r\n\t\r\n\tdo {\r\n\t\tadaptivePrecision = adaptivePrecision * 3;\r\n\t\tif (adaptivePrecision > maxPrecision) {\r\n\t\t\tadaptivePrecision = maxPrecision;\r\n\t\t}\r\n\t\tMathContext mc = new MathContext(adaptivePrecision, mathContext.getRoundingMode());\r\n\t\t\r\n\t\tBigDecimal expY = BigDecimalMath.exp(result, mc); // available on https://github.com/eobermuhlner/big-math\r\n\t\tstep = TWO.multiply(x.subtract(expY, mc), mc).divide(x.add(expY, mc), mc);\r\n\t\tresult = result.add(step);\r\n\t} while (adaptivePrecision < maxPrecision || step.abs().compareTo(acceptableError) > 0);\r\n\r\n\treturn result.round(mathContext);\r\n}\r\n
\r\n\r\nThe performance comparison between the two implementations is impressive.\r\nThe following chart shows the time in nanoseconds it takes to calculate the log() of values of x in the range from 0 to 1 with a precision of 300 digits.\r\n\r\n[visualizer id=\"558\"]\r\n\r\nHere some more charts to show the performance improvements of the adaptive precision technique applied to different approximative implementations:\r\n[visualizer id=\"557\"]\r\n[visualizer id=\"553\"]\r\n\r\nThis method can only be applied to approximative methods that improve the result with every iteration and discard the previous result, such as Newton's Method.\r\n\r\nIt does obviously not work on methods that accumulate the results of each iteration to calculate the final result, such as Taylor series which add the terms.\r\n \r\n\r\n"
},
{
"path": "ch.obermuhlner.math.big.example/docu/wordpress/BigDecimalMath.txt",
"content": "[latex]\\require{AMSmath}[/latex]\r\nJava 8 is out and there are still no Math functions for BigDecimal.\r\n\r\nAfter playing around with some implementations to calculate Pi I decided to write some implementation of BigDecimalMath to fill this gap.\r\n\r\nThe result of this is available on github: big-math.\r\n\r\nThe goal was to provide the following functions:\r\n
\r\n\t
exp(x)
\r\n\t
log(x)
\r\n\t
pow(x, y)
\r\n\t
sqrt(x)
\r\n\t
root(n, x)
\r\n\t
sin(x), cos(x), tan(x), cot(x)
\r\n\t
asin(x), acos(x), atan(x), acot(x)
\r\n\t
sinh(x), cosh(x), tanh(x)
\r\n\t
asinh(x), acosh(x), atanh(x)
\r\n
\r\n\r\nThe calculations must be accurate to the desired precision (specified in the MathContext)\r\nand the performance should be acceptable and stable for a large range of input values.\r\n\r\n
Implementation Details
\r\n\r\n
Implementation exp(x)
\r\n\r\nTo implement exp() the classical Taylor series was used:\r\n[latex]\\displaystyle e^x = \\sum^{\\infty}_{n=0} \\frac{x^n}{n!} = 1 + x + \\frac{x^2}{2!} + \\frac{x^3}{3!} + \\cdots[/latex]\r\n\r\n
Implementation log()
\r\n\r\nNote that in Java the function name log() means the natural logarithm, which in mathematical notation is written [latex]\\ln{x}[/latex].\r\n\r\nThe implementation of log() is based on Newton's method.\r\nWe can use the double version Math.log() to give us a good initial value.\r\n\r\n[latex]\\displaystyle y_0 = \\operatorname{Math.log}(x),[/latex]\r\n[latex]\\displaystyle y_{i+1} = y_i + 2 \\frac{x - e^{y_i} }{ x + e^{y_i}},[/latex]\r\n[latex]\\displaystyle \\ln{x} = \\lim_{i \\to \\infty} y_i[/latex]\r\n \r\n\r\nSeveral optimizations in the implementation transform the argument of log(x) so that it will be nearer to the optimum of 1.0 to converge faster.\r\n[latex]\r\n\\begin{align}\r\n\\displaystyle \\ln{x} & = \\ln{\\left(a \\cdot 10^b\\right)} = \\ln{a} + \\ln{10} \\cdot b & \\qquad \\text{for } x \\leq 0.1 \\text{ or } x \\geq 10 \\\\\r\n\\displaystyle \\ln{x} & = \\ln{\\left( 2 x \\right)} - \\ln{2} & \\qquad \\text{for } x \\lt 0.115 \\\\\r\n\\displaystyle \\ln{x} & = \\ln{\\left( 3 x \\right)} - \\ln{3} & \\qquad \\text{for } x \\lt 0.14 \\\\\r\n\\displaystyle \\ln{x} & = \\ln{\\left( 4 x \\right)} - 2 \\ln{2} & \\qquad \\text{for } x \\lt 0.2 \\\\\r\n\\displaystyle \\ln{x} & = \\ln{\\left( 6 x \\right)} - \\ln{2} - \\ln{3} & \\qquad \\text{for } x \\lt 0.3 \\\\\r\n\\displaystyle \\ln{x} & = \\ln{\\left( 8 x \\right)} - 3 \\ln{2} & \\qquad \\text{for } x \\lt 0.42 \\\\\r\n\\displaystyle \\ln{x} & = \\ln{\\left( 9 x \\right)} - 3 \\ln{3} & \\qquad \\text{for } x \\lt 0.7 \\\\\r\n\\displaystyle \\ln{x} & = \\ln{\\left( \\frac{1}{2} x \\right)} + \\ln{2} & \\qquad \\text{for } x \\lt 2.5 \\\\\r\n\\displaystyle \\ln{x} & = \\ln{\\left( \\frac{1}{3} x \\right)} + \\ln{3} & \\qquad \\text{for } x \\lt 3.5 \\\\\r\n\\displaystyle \\ln{x} & = \\ln{\\left( \\frac{1}{4} x \\right)} + 2 \\ln{2} & \\qquad \\text{for } x \\lt 5.0 \\\\\r\n\\displaystyle \\ln{x} & = \\ln{\\left( \\frac{1}{6} x \\right)} + \\ln{2} + \\ln{3} & \\qquad \\text{for } x \\lt 7.0 \\\\\r\n\\displaystyle \\ln{x} & = \\ln{\\left( \\frac{1}{8} x \\right)} + 3 \\ln{2} & \\qquad \\text{for } x \\lt 8.5 \\\\\r\n\\displaystyle \\ln{x} & = \\ln{\\left( \\frac{1}{9} x \\right)} + 3 \\ln{3} & \\qquad \\text{for } x \\lt 10.0\r\n\\end{align}\r\n[/latex]\r\n\r\nThe additional logarithmic functions to different common bases are simple:\r\n[latex]\\displaystyle \\operatorname{log}_2{x} = \\frac{\\ln{x}}{\\ln{2}}[/latex]\r\n \r\n\r\n[latex]\\displaystyle \\operatorname{log}_{10}{x} = \\frac{\\ln{x}}{\\ln{10}}[/latex]\r\n \r\n\r\nSince the precalculated values for [latex]\\ln{2}, \\ln{3}, \\ln{10}[/latex] with a precision of up to 1100 digits already exist for the optimizations mentioned above, the log2() and log10() functions could reuse them and are therefore reasonably fast.\r\n\r\n
Implementation pow(x)
\r\n\r\nThe implementation of pow() with non-integer arguments is based on exp() and log():\r\n\r\n[latex]\\displaystyle x^y = e^{y \\ln x}[/latex]\r\n\r\nIf y is an integer argument then pow() is implemented with multiplications:\r\n\r\n[latex]\\displaystyle x^y = \\prod_{i \\to y} x[/latex]\r\n\r\nActually the implementation is further optimized to reduce the number of multiplications by squaring the argument whenever possible.\r\n\r\n
Implementation sqrt(x), root(n, x)
\r\n\r\nThe implementation of sqrt() and root() uses Newton's method to approximate the result until the necessary precision is reached.\r\nIn the case of sqrt() we can use the double version Math.sqrt() to give us a good initial value.\r\n\r\n[latex]\\displaystyle y_0 = \\operatorname{Math.sqrt}(x),[/latex]\r\n[latex]\\displaystyle y_{i+1} = \\frac{1}{2} \\left(y_i + \\frac{x}{y_i}\\right),[/latex]\r\n[latex]\\displaystyle \\sqrt{x} = \\lim_{i \\to \\infty} y_i[/latex]\r\n \r\n\r\nUnfortunately the root() function does not exist for double so we are forced to use a simpler initial value.\r\n\r\n[latex]\\displaystyle y_0 = \\frac{1}{n},[/latex]\r\n[latex]\\displaystyle y_{i+1} = \\frac{1}{n} \\left[{(n-1)y_i +\\frac{x}{y_i^{n-1}}}\\right],[/latex]\r\n[latex]\\displaystyle \\sqrt[n]{x} = \\lim_{i \\to \\infty} y_i[/latex]\r\n \r\n\r\n
Implementation sin(x), cos(x), tan(x), cot(x)
\r\n\r\nThe basic trigonometric functions where implemented using Taylor series or if this proved more efficient by their relationship with an already implemented functions:\r\n\r\n[latex]\\displaystyle \\sin x = \\sum^{\\infty}_{n=0} \\frac{(-1)^n}{(2n+1)!} x^{2n+1} = x - \\frac{x^3}{3!} + \\frac{x^5}{5!} - \\cdots[/latex]\r\n \r\n\r\n[latex]\\displaystyle \\cos x = \\sum^{\\infty}_{n=0} \\frac{(-1)^n}{(2n)!} x^{2n} = 1 - \\frac{x^2}{2!} + \\frac{x^4}{4!} - \\cdots[/latex]\r\n \r\n\r\n[latex]\\displaystyle \\tan x = \\frac{\\sin x}{\\cos x}[/latex]\r\n \r\n\r\n[latex]\\displaystyle \\cot x = \\frac{\\cos x}{\\sin x}[/latex]\r\n \r\n\r\n
Implementation asin(x), acos(x), atan(x), acot(x)
\r\n\r\nThe inverse trigonometric functions use a Taylor series for arcsin().\r\n\r\n[latex]\\displaystyle \\arcsin x = \\sum^{\\infty}_{n=0} \\frac{(2n)!}{4^n (n!)^2 (2n+1)} x^{2n+1}[/latex]\r\n \r\n\r\nThis series takes very long to converge, especially when the argument x gets close to 1.\r\nAs optimization the argument x is transformed to a more efficient range using the following relationship.\r\n\r\n[latex]\\displaystyle \\arcsin x = \\arccos \\sqrt{1-x^2} \\qquad \\text{for } x \\gt \\sqrt{\\frac{1}{2}} \\text{ (} \\approx 0.707107 \\text{)}[/latex]\r\n \r\n\r\nThe remaining functions are implemented by their relationship with arcsin().\r\n\r\n[latex]\\displaystyle \\arccos x = \\frac{\\pi}{2} - \\arcsin x[/latex]\r\n \r\n\r\n[latex]\\displaystyle \\arctan x = \\arcsin \\frac{x}{\\sqrt{1+x^2}}[/latex]\r\n \r\n\r\n[latex]\\displaystyle \\operatorname{arccot} x = \\frac{\\pi}{2} - \\arctan x[/latex]\r\n \r\n\r\n\r\n
Implementation sinh(x), cosh(x), tanh(x)
\r\n\r\nTaylor series are efficient for most of the implementations of hyperbolic functions. \r\n\r\n[latex]\\displaystyle \\sinh x= \\sum_{n=0}^\\infty \\frac{x^{2n+1}}{(2n+1)!} = x + \\frac{x^3}{3!} + \\frac{x^5}{5!} + \\frac{x^7}{7!} +\\cdots[/latex]\r\n \r\n\r\n[latex]\\displaystyle \\cosh x = \\sum_{n=0}^\\infty \\frac{x^{2n}}{(2n)!} = 1 + \\frac{x^2}{2!} + \\frac{x^4}{4!} + \\frac{x^6}{6!} + \\cdots[/latex]\r\n \r\n\r\nThe Taylor series for tanh() converges very slowly, so we use the relationship with sinh() and tanh() instead.\r\n[latex]\\displaystyle \\tanh x = \\frac{\\sinh x}{\\cosh x}[/latex]\r\n \r\n\r\n\r\n
Implementation asinh(x), acosh(x), atanh(x)
\r\n\r\nThe inverse hyperbolic functions can be expressed using natural logarithm.\r\n\r\n[latex]\\displaystyle \\operatorname{asinh} x = \\ln(x + \\sqrt{x^2 + 1} )[/latex]\r\n \r\n\r\n[latex]\\displaystyle \\operatorname{acosh} x = \\ln(x + \\sqrt{x^2-1} )[/latex]\r\n \r\n\r\n[latex]\\displaystyle \\operatorname{atanh} x = \\frac12\\ln\\left(\\frac{1+x}{1-x}\\right)[/latex]\r\n \r\n\r\n
Performance calculating different precisions
\r\nObviously it will take longer to calculate a function result with a higher precision than a lower precision.\r\n\r\nThe following charts show the time needed to calculate the functions with different precisions.\r\n\r\nThe arguments of the functions where:\r\n
\r\n\t
log(3.1)
\r\n\t
exp(3.1)
\r\n\t
pow(123.456, 3.1)
\r\n\t
sqrt(3.1)
\r\n\t
root(2, 3.1)
\r\n\t
root(3, 3.1)
\r\n\t
sin(3.1)
\r\n\t
cos(3.1)
\r\n
\r\n\r\n[visualizer id=\"479\"]\r\n[visualizer id=\"480\"]\r\nWhile the time to calculate the results grows worse than linear for higher precisions the speed is still reasonable for precisions of up to 1000 digits.\r\n\r\n
Performance calculating different values
\r\nThe following charts show the time needed to calculate the functions over a range of values with a precision of 300 digits.\r\n\r\n
\r\n\t
log(x)
\r\n\t
exp(x)
\r\n\t
pow(123.456, x)
\r\n\t
sqrt(x)
\r\n\t
root(2, x)
\r\n\t
root(3, x)
\r\n\t
sin(x)
\r\n\t
cos(x)
\r\n
\r\n\r\n\r\nThe functions have been separated in a fast group (exp, sqrt, root, sin, cos) and a slow group (exp, log, pow).\r\nFor comparison reasons the exp() function is contained in both groups.\r\n\r\n
Range 0 to 2
\r\n[visualizer id=\"484\"]\r\nThe performance of the functions is in a reasonable range and is stable, especially when getting close to 0 in which some functions might converge slowly.\r\nThe functions exp(), sin(), cos() need to be watched at the higher values of x to prove that the do not continue to grow.\r\n[visualizer id=\"477\"]\r\nShows nicely that log() is more efficient when x is close to 1.0.\r\nBy using divisions and multiplication with the prime numbers 2 and 3 the log() function was optimized to use this fact for values of x than can be brought closer to 1.0.\r\nThis gives the strange arches in the performance of log().\r\nThe pow() function performs fairly constant, except for the powers of integer values which are optimized specifically.\r\n\r\n
Range 0 to 10
\r\n[visualizer id=\"482\"]\r\nShows that sin(), cos() have been optimized with the period of 2*Pi (roughly 6.28) so that they do not continue to grow with higher values.\r\nThis optimization has some cost which needs to be watched at higher values.\r\n\r\n[visualizer id=\"492\"]\r\nexp() has become stable and does no longer grow.\r\nlog() is stable and shows the typical arches with optimas at 1.0, 2.0 (divided by 2), 3.0 (divided by 3), 4.0 (divided by 2*2), 6.0 (divided by 2*3), 8.0 (divided by 2*2*2) and 9.0 (divided by 3*3).\r\npow() continues stable.\r\n\r\n
Range -10 to 10
\r\n[visualizer id=\"481\"]\r\n[visualizer id=\"478\"]\r\nPositive and negative values are symmetric for all functions that are defined for the negative range.\r\n\r\n
Range 0 to 100
\r\n[visualizer id=\"483\"]\r\nAll functions are stable over this range.\r\n\r\n[visualizer id=\"493\"]\r\nAll functions are stable over this range.\r\nThe pow() function makes the chart somewhat hard to read because of the optimized version for integer powers.\r\nThe log() function shows here the effect of another optimization using the expoential form. The range from 10 to 100 is brought down to the range 1 to 10 and the same divisions are applied. This has the effect of showing the same arches again in the range from 10 to 100.\r\n"
},
{
"path": "ch.obermuhlner.math.big.example/src/main/java/ch/obermuhlner/math/big/example/BernoulliTable.java",
"content": "package ch.obermuhlner.math.big.example;\r\n\r\nimport ch.obermuhlner.math.big.BigRational;\r\n\r\npublic class BernoulliTable {\r\n\r\n\tpublic static void main(String[] args) {\r\n\t\tprintBernoulliTableSimple(500);\r\n\t\t//printBernoulliTableHtml(500);\r\n\t}\r\n\r\n\tprivate static void printBernoulliTableSimple(int n) {\r\n\t\tSystem.out.printf(\"%3s,%s\\n\", \"N\", \"Bernoulli\");\r\n\t\tfor (int i = 0; i < n; i++) {\r\n\t\t\tBigRational b = BigRational.bernoulli(i).reduce();\r\n\t\t\tSystem.out.printf(\"%3d,%s\\n\", i, b.toRationalString());\r\n\t\t}\r\n\t}\r\n\t\r\n\tprivate static void printBernoulliTableHtml(int n) {\r\n\t\tSystem.out.printf(\"
\\n\");\r\n\t\tSystem.out.printf(\"\\n\");\r\n\t\tfor (int i = 0; i < n; i++) {\r\n\t\t\tBigRational b = BigRational.bernoulli(i).reduce();\r\n\t\t\tSystem.out.printf(\"
\\n\");\r\n\t\t\r\n\t\tSystem.out.printf(\"\\n\");\r\n\t\tfor (int i = 0; i < n; i++) {\r\n\t\t\tBigRational b = BigRational.bernoulli(i).reduce();\r\n\t\t\tSystem.out.printf(\"
\n\t * The first step is to decide between the basic approach.\n\t * Here are the two basic formulas I found that converge reasonably fast:\n\t * Hyperbolic tangent area:\n\t * CODE logHyperbolic\n\t *
\n\t * The following graph shows the time in nanoseconds necessary to calculate the log(x) to a precision of 300 significant digits.\n\t * CHART hyperbolic, newton x=0.01 - 10\n\t *
\n\t * The hyperbolic tangent area approach wins hands down.\n\t *
\n\t * Both approaches have in common that they converge much faster when x is close to 1.0 and become increasingly slower the farther away we get from 1.0.\n\t * CHART hyperbolic x=0.01 - 10\n\t * CHART hyperbolic x=0.1 - 100\n\t *
\n\t * In order to optimize this calculation we must bring the argument x closer to 1.0 and correct this outside of the logarithm in the appropriate manner.\n\t * The Wikipedia article http://en.wikipedia.org/wiki/Natural_logarithm mentions the following trick:\n\t * We write the value x in the exponential form\n\t * x = a * 10b\n\t * then we can say that\n\t * log(x) = log(a) + log(10) * b\n\t * Since we can precalculate log(10) for reasonable precision this can be implemented very efficiently with BigDecimal.\n\t *
\n\t * The argument of the log() can now only be in the range from 0.1 to 10, which is already an improvement.\n\t * How can we further reduce the input range of log() and get even closer to the optimum value of 1.0?\n\t *
\n\t * For values > 1.0 we can try to divide by powers of 2.\n\t * For example the worst case values in the range from 6.0 to 10.0 can be divided by (2*2*2), which gives us a range from 0.75 to 1.25, another improvement.\n\t * This factor can be applied outside the log() function:\n\t * log(10.0) = log(10.0 / 8) + log(2)*3\n\t * To be efficient we must precalculate log(2).\n\t *
\n\t * The same logic applies to values > 1.0 but in this case we multiply with powers of 2.\n\t * log(0.1) = log(0.1 * 8) - log(2)*3\n\t *
\n\t * The powers of 2 come in a pretty good sequence in the value range between 1.0 and 10.0: (2, 4, 8).\n\t * Unfortunately this leaves a gaping whole around 6.0 so that the values in this area can not be efficiently optimized.\n\t * If we do the same trick by multiplying combinations of the prim factors 2 and 3 we get a nicer sequence that leaves less holes:\n\t * (2, 3, 2*2, 2*3, 2*2*2, 3*3) = (2, 3, 4, 6, 8, 9)\n\t * While this becomes a bit more complex to implement that just the powers of 2 it is still simple enough that we can hardcode all the combinations.\n\t *
\n\t * Another approach that does not need all the tricks with exponential form and combinations of 2 and 3.\n\t * REFERENCE https://github.com/miraclefoxx/bigdecimal-math/blob/master/src/main/java/io/github/miraclefoxx/math/BigDecimalMath.java\n\t * This needs another function root(n, x) which calculates the n'th root of the value x.\n\t * It follows the same recipe of bringing the argument of the log() function closer to 1 by writing it in this form:\n\t * log(x) = log(root(r, x)^r) = r * log(root(r, x))\n\t * By estimating r correctly we can bring the argument to log() reasonably close.\n\t *
\n\t * Looks very nice, the calculation becomes essentially independent of the distance to 1.0.\n\t *
\n\t * Lets compare the two approaches (assuming precalculated log(10), log(2), log(3)):\n\t * CHART logUsingRoot, logUsingTwoThree x=0.1 - 10\n\t *
\n\t * Nobody stops us from combining the two approaches, we calculate the final step\n\t * (after using exponential form and combinations of 2 and 3) calling logRoot().\n\t * This gives us:\n\t * CHART logUsingRoot, logUsingTwoThreeRoot x=0.1 - 10\n\t *
\n\t * If we cannot precalculate log(10), log(2) and log(3) (or the desired precision is outside the precalculated range)\n\t * then the root() approach becomes more efficient:\n\t * CHART logUsingRoot, logUsingTwoThreeNotPrecalculated x=0.1 - 10\n\t *
\n\t * This gives us the final solution:\n\t * If we are inside the precalculated precision we use logUsingTwoThreeRoot, otherwise logUsingRoot.\n\t *
public static boolean isDoubleValue(java.math.BigDecimal value)
\n
Returns whether the specified BigDecimal value can be represented as double.\n \n
If this returns true you can call BigDecimal.doubleValue()\n without fear of getting Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY as result.
\n \n
Example: BigDecimalMath.isDoubleValue(new BigDecimal(\"1E309\")) returns false,\n because new BigDecimal(\"1E309\").doubleValue() returns Infinity.
\n \n
Note: This method does not check for possible loss of precision.
\n \n
For example BigDecimalMath.isDoubleValue(new BigDecimal(\"1.23400000000000000000000000000000001\")) will return true,\n because new BigDecimal(\"1.23400000000000000000000000000000001\").doubleValue() returns a valid double value,\n although it loses precision and returns 1.234.
\n \n
BigDecimalMath.isDoubleValue(new BigDecimal(\"1E-325\")) will return true\n although this value is smaller than Double.MIN_VALUE (and therefore outside the range of values that can be represented as double)\n because new BigDecimal(\"1E-325\").doubleValue() returns 0 which is a legal value with loss of precision.
\n
\n
Parameters:
\n
value - the BigDecimal to check
\n
Returns:
\n
true if the value can be represented as double value
public class BigRational\nextends java.lang.Object\nimplements java.lang.Comparable<BigRational>
\n
A rational number represented as a quotient of two values.\n \n
Basic calculations with rational numbers (+ - * /) have no loss of precision.\n This allows to use BigRational as a replacement for BigDecimal if absolute accuracy is desired.
The values are internally stored as BigDecimal (for performance optimizations) but represented\n as BigInteger (for mathematical correctness)\n when accessed with getNumeratorBigInteger() and getDenominatorBigInteger().
\n \n
The following basic calculations have no loss of precision:
Any BigRational value can be converted into an arbitrary precision (number of significant digits)\n or scale (number of digits after the decimal point).
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".\n \n
The integer part is omitted if it is 0 (when this absolute rational number is smaller than 1).
\n
The fraction part is omitted it it is 0 (when this rational number is an integer).
\n
If this rational number is 0, then \"0\" is returned.
public static BigRational valueOf(int integer,\n int fractionNumerator,\n int fractionDenominator)
\n
Creates a rational number of the specified integer and fraction parts.\n \n
Useful to create numbers like 3 1/2 (= three and a half = 3.5) by calling\n BigRational.valueOf(3, 1, 2).
\n
To create a negative rational only the integer part argument is allowed to be negative:\n to create -3 1/2 (= minus three and a half = -3.5) call BigRational.valueOf(-3, 1, 2).
\n
\n
Parameters:
\n
integer - the integer part int value
\n
fractionNumerator - the fraction part numerator int value (negative not allowed)
\n
fractionDenominator - the fraction part denominator int value (0 or negative not allowed)
\n
Returns:
\n
the rational number
\n
Throws:
\n
java.lang.ArithmeticException - if the fraction part denominator is 0 (division by zero),\n or if the fraction part numerator or denominator is negative
Constructs a SeriesCalculator with control over whether the sum terms are calculated in pairs.\n \n
Calculation of pairs is useful for taylor series where the terms alternate the sign.\n In these cases it is more efficient to calculate two terms at once check then whether the acceptable error has been reached.
\n
\n
Parameters:
\n
calculateInPairs - true to calculate the terms in pairs, false to calculate single terms
public static java.util.stream.Stream<java.math.BigDecimal> range(long startInclusive,\n long endExclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endExclusive (exclusive) by an incremental step.\n \n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endExclusive - the exclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
public static java.util.stream.Stream<java.math.BigDecimal> rangeClosed(long startInclusive,\n long endInclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endInclusive (inclusive) by an incremental step.\n\n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endInclusive - the inclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
\n
\n
\n
\n
\n
Overview
\n
The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.
\n
\n
\n
Package
\n
Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:
\n
\n
Interfaces (italic)
\n
Classes
\n
Enums
\n
Exceptions
\n
Errors
\n
Annotation Types
\n
\n
\n
\n
Class/Interface
\n
Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
\n
\n
Class inheritance diagram
\n
Direct Subclasses
\n
All Known Subinterfaces
\n
All Known Implementing Classes
\n
Class/interface declaration
\n
Class/interface description
\n
\n
\n
Nested Class Summary
\n
Field Summary
\n
Constructor Summary
\n
Method Summary
\n
\n
\n
Field Detail
\n
Constructor Detail
\n
Method Detail
\n
\n
Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
\n
\n
\n
Annotation Type
\n
Each annotation type has its own separate page with the following sections:
\n
\n
Annotation Type declaration
\n
Annotation Type description
\n
Required Element Summary
\n
Optional Element Summary
\n
Element Detail
\n
\n
\n
\n
Enum
\n
Each enum has its own separate page with the following sections:
\n
\n
Enum declaration
\n
Enum description
\n
Enum Constant Summary
\n
Enum Constant Detail
\n
\n
\n
\n
Tree (Class Hierarchy)
\n
There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
\n
\n
When viewing the Overview page, clicking on \"Tree\" displays the hierarchy for all packages.
\n
When viewing a particular package, class or interface page, clicking \"Tree\" displays the hierarchy for only that package.
\n
\n
\n
\n
Deprecated API
\n
The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
\n
\n
\n
Index
\n
The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
\n
\n
\n
Prev/Next
\n
These links take you to the next or previous class, interface, package, or related page.
\n
\n
\n
Frames/No Frames
\n
These links show and hide the HTML frames. All pages are available with or without frames.
\n
\n
\n
All Classes
\n
The All Classes link shows all classes and interfaces except non-static nested types.
\n
\n
\n
Serialized Form
\n
Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking \"Serialized Form\" in the \"See also\" section of the class description.
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
public final class BigComplex\nextends java.lang.Object
\n
Represents a complex number consisting of a real and an imaginary BigDecimal part in the form a + bi.\n\n
It generally follows the design of BigDecimal with some convenience improvements like overloaded operator methods.
\n\n
The biggest difference to BigDecimal is that BigComplex.equals(Object) implements the mathematical equality\n and not the strict technical equality.\n This was a difficult decision because it means that BigComplex behaves slightly different than BigDecimal\n but considering that the strange equality of BigDecimal is a major source of bugs we\n decided it was worth the slight inconsistency.\n If you need the strict equality use strictEquals(Object)`.
\n\n
This class is immutable and therefore inherently thread safe.
Contrary to BigDecimal.equals(Object) this method implements mathematical equality\n (by calling BigDecimal.compareTo(BigDecimal) on the real and imaginary parts)\n instead of strict equality.
public static boolean isDoubleValue(java.math.BigDecimal value)
\n
Returns whether the specified BigDecimal value can be represented as double.\n \n
If this returns true you can call BigDecimal.doubleValue()\n without fear of getting Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY as result.
\n \n
Example: BigDecimalMath.isDoubleValue(new BigDecimal(\"1E309\")) returns false,\n because new BigDecimal(\"1E309\").doubleValue() returns Infinity.
\n \n
Note: This method does not check for possible loss of precision.
\n \n
For example BigDecimalMath.isDoubleValue(new BigDecimal(\"1.23400000000000000000000000000000001\")) will return true,\n because new BigDecimal(\"1.23400000000000000000000000000000001\").doubleValue() returns a valid double value,\n although it loses precision and returns 1.234.
\n \n
BigDecimalMath.isDoubleValue(new BigDecimal(\"1E-325\")) will return true\n although this value is smaller than Double.MIN_VALUE (and therefore outside the range of values that can be represented as double)\n because new BigDecimal(\"1E-325\").doubleValue() returns 0 which is a legal value with loss of precision.
\n
\n
Parameters:
\n
value - the BigDecimal to check
\n
Returns:
\n
true if the value can be represented as double value
public class BigRational\nextends java.lang.Object\nimplements java.lang.Comparable<BigRational>
\n
A rational number represented as a quotient of two values.\n \n
Basic calculations with rational numbers (+ - * /) have no loss of precision.\n This allows to use BigRational as a replacement for BigDecimal if absolute accuracy is desired.
The values are internally stored as BigDecimal (for performance optimizations) but represented\n as BigInteger (for mathematical correctness)\n when accessed with getNumeratorBigInteger() and getDenominatorBigInteger().
\n \n
The following basic calculations have no loss of precision:
Any BigRational value can be converted into an arbitrary precision (number of significant digits)\n or scale (number of digits after the decimal point).
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".\n \n
The integer part is omitted if it is 0 (when this absolute rational number is smaller than 1).
\n
The fraction part is omitted it it is 0 (when this rational number is an integer).
\n
If this rational number is 0, then \"0\" is returned.
public static BigRational valueOf(int integer,\n int fractionNumerator,\n int fractionDenominator)
\n
Creates a rational number of the specified integer and fraction parts.\n \n
Useful to create numbers like 3 1/2 (= three and a half = 3.5) by calling\n BigRational.valueOf(3, 1, 2).
\n
To create a negative rational only the integer part argument is allowed to be negative:\n to create -3 1/2 (= minus three and a half = -3.5) call BigRational.valueOf(-3, 1, 2).
\n
\n
Parameters:
\n
integer - the integer part int value
\n
fractionNumerator - the fraction part numerator int value (negative not allowed)
\n
fractionDenominator - the fraction part denominator int value (0 or negative not allowed)
\n
Returns:
\n
the rational number
\n
Throws:
\n
java.lang.ArithmeticException - if the fraction part denominator is 0 (division by zero),\n or if the fraction part numerator or denominator is negative
Constructs a SeriesCalculator with control over whether the sum terms are calculated in pairs.\n \n
Calculation of pairs is useful for taylor series where the terms alternate the sign.\n In these cases it is more efficient to calculate two terms at once check then whether the acceptable error has been reached.
\n
\n
Parameters:
\n
calculateInPairs - true to calculate the terms in pairs, false to calculate single terms
public static java.util.stream.Stream<java.math.BigDecimal> range(long startInclusive,\n long endExclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endExclusive (exclusive) by an incremental step.\n \n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endExclusive - the exclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
public static java.util.stream.Stream<java.math.BigDecimal> rangeClosed(long startInclusive,\n long endInclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endInclusive (inclusive) by an incremental step.\n\n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endInclusive - the inclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
\n
\n
\n
\n
\n
Overview
\n
The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.
\n
\n
\n
Package
\n
Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:
\n
\n
Interfaces (italic)
\n
Classes
\n
Enums
\n
Exceptions
\n
Errors
\n
Annotation Types
\n
\n
\n
\n
Class/Interface
\n
Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
\n
\n
Class inheritance diagram
\n
Direct Subclasses
\n
All Known Subinterfaces
\n
All Known Implementing Classes
\n
Class/interface declaration
\n
Class/interface description
\n
\n
\n
Nested Class Summary
\n
Field Summary
\n
Constructor Summary
\n
Method Summary
\n
\n
\n
Field Detail
\n
Constructor Detail
\n
Method Detail
\n
\n
Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
\n
\n
\n
Annotation Type
\n
Each annotation type has its own separate page with the following sections:
\n
\n
Annotation Type declaration
\n
Annotation Type description
\n
Required Element Summary
\n
Optional Element Summary
\n
Element Detail
\n
\n
\n
\n
Enum
\n
Each enum has its own separate page with the following sections:
\n
\n
Enum declaration
\n
Enum description
\n
Enum Constant Summary
\n
Enum Constant Detail
\n
\n
\n
\n
Tree (Class Hierarchy)
\n
There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
\n
\n
When viewing the Overview page, clicking on \"Tree\" displays the hierarchy for all packages.
\n
When viewing a particular package, class or interface page, clicking \"Tree\" displays the hierarchy for only that package.
\n
\n
\n
\n
Deprecated API
\n
The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
\n
\n
\n
Index
\n
The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
\n
\n
\n
Prev/Next
\n
These links take you to the next or previous class, interface, package, or related page.
\n
\n
\n
Frames/No Frames
\n
These links show and hide the HTML frames. All pages are available with or without frames.
\n
\n
\n
All Classes
\n
The All Classes link shows all classes and interfaces except non-static nested types.
\n
\n
\n
Serialized Form
\n
Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking \"Serialized Form\" in the \"See also\" section of the class description.
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
public final class BigComplex\nextends java.lang.Object
\n
Represents a complex number consisting of a real and an imaginary BigDecimal part in the form a + bi.\n\n
It generally follows the design of BigDecimal with some convenience improvements like overloaded operator methods.
\n\n
The biggest difference to BigDecimal is that BigComplex.equals(Object) implements the mathematical equality\n and not the strict technical equality.\n This was a difficult decision because it means that BigComplex behaves slightly different than BigDecimal\n but considering that the strange equality of BigDecimal is a major source of bugs we\n decided it was worth the slight inconsistency.\n If you need the strict equality use strictEquals(Object)`.
\n\n
This class is immutable and therefore inherently thread safe.
Contrary to BigDecimal.equals(Object) this method implements mathematical equality\n (by calling BigDecimal.compareTo(BigDecimal) on the real and imaginary parts)\n instead of strict equality.
public static boolean isDoubleValue(java.math.BigDecimal value)
\n
Returns whether the specified BigDecimal value can be represented as double.\n\n
If this returns true you can call BigDecimal.doubleValue()\n without fear of getting Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY as result.
\n\n
Example: BigDecimalMath.isDoubleValue(new BigDecimal(\"1E309\")) returns false,\n because new BigDecimal(\"1E309\").doubleValue() returns Infinity.
\n\n
Note: This method does not check for possible loss of precision.
\n\n
For example BigDecimalMath.isDoubleValue(new BigDecimal(\"1.23400000000000000000000000000000001\")) will return true,\n because new BigDecimal(\"1.23400000000000000000000000000000001\").doubleValue() returns a valid double value,\n although it loses precision and returns 1.234.
\n\n
BigDecimalMath.isDoubleValue(new BigDecimal(\"1E-325\")) will return true\n although this value is smaller than Double.MIN_VALUE (and therefore outside the range of values that can be represented as double)\n because new BigDecimal(\"1E-325\").doubleValue() returns 0 which is a legal value with loss of precision.
\n
\n
Parameters:
\n
value - the BigDecimal to check
\n
Returns:
\n
true if the value can be represented as double value
public static java.math.BigDecimal factorial(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the factorial of the specified BigDecimal.\n\n
This implementation uses\n Spouge's approximation\n to calculate the factorial for non-integer values.
\n\n
This involves calculating a series of constants that depend on the desired precision.\n Since this constant calculation is quite expensive (especially for higher precisions),\n the constants for a specific precision will be cached\n and subsequent calls to this method with the same precision will be much faster.
\n\n
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n and to avoid calling it with many different precisions.
public static java.math.BigDecimal gamma(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the gamma function of the specified BigDecimal.\n\n
This implementation uses factorial(BigDecimal, MathContext) internally,\n therefore the performance implications described there apply also for this method.\n\n
public class BigRational\nextends java.lang.Object\nimplements java.lang.Comparable<BigRational>
\n
A rational number represented as a quotient of two values.\n \n
Basic calculations with rational numbers (+ - * /) have no loss of precision.\n This allows to use BigRational as a replacement for BigDecimal if absolute accuracy is desired.
The values are internally stored as BigDecimal (for performance optimizations) but represented\n as BigInteger (for mathematical correctness)\n when accessed with getNumeratorBigInteger() and getDenominatorBigInteger().
\n \n
The following basic calculations have no loss of precision:
Any BigRational value can be converted into an arbitrary precision (number of significant digits)\n or scale (number of digits after the decimal point).
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".\n \n
The integer part is omitted if it is 0 (when this absolute rational number is smaller than 1).
\n
The fraction part is omitted it it is 0 (when this rational number is an integer).
\n
If this rational number is 0, then \"0\" is returned.
public static BigRational valueOf(int integer,\n int fractionNumerator,\n int fractionDenominator)
\n
Creates a rational number of the specified integer and fraction parts.\n \n
Useful to create numbers like 3 1/2 (= three and a half = 3.5) by calling\n BigRational.valueOf(3, 1, 2).
\n
To create a negative rational only the integer part argument is allowed to be negative:\n to create -3 1/2 (= minus three and a half = -3.5) call BigRational.valueOf(-3, 1, 2).
\n
\n
Parameters:
\n
integer - the integer part int value
\n
fractionNumerator - the fraction part numerator int value (negative not allowed)
\n
fractionDenominator - the fraction part denominator int value (0 or negative not allowed)
\n
Returns:
\n
the rational number
\n
Throws:
\n
java.lang.ArithmeticException - if the fraction part denominator is 0 (division by zero),\n or if the fraction part numerator or denominator is negative
Constructs a SeriesCalculator with control over whether the sum terms are calculated in pairs.\n \n
Calculation of pairs is useful for taylor series where the terms alternate the sign.\n In these cases it is more efficient to calculate two terms at once check then whether the acceptable error has been reached.
\n
\n
Parameters:
\n
calculateInPairs - true to calculate the terms in pairs, false to calculate single terms
public static java.util.stream.Stream<java.math.BigDecimal> range(long startInclusive,\n long endExclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endExclusive (exclusive) by an incremental step.\n \n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endExclusive - the exclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
public static java.util.stream.Stream<java.math.BigDecimal> rangeClosed(long startInclusive,\n long endInclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endInclusive (inclusive) by an incremental step.\n\n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endInclusive - the inclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
\n
\n
\n
\n
\n
Overview
\n
The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.
\n
\n
\n
Package
\n
Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:
\n
\n
Interfaces (italic)
\n
Classes
\n
Enums
\n
Exceptions
\n
Errors
\n
Annotation Types
\n
\n
\n
\n
Class/Interface
\n
Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
\n
\n
Class inheritance diagram
\n
Direct Subclasses
\n
All Known Subinterfaces
\n
All Known Implementing Classes
\n
Class/interface declaration
\n
Class/interface description
\n
\n
\n
Nested Class Summary
\n
Field Summary
\n
Constructor Summary
\n
Method Summary
\n
\n
\n
Field Detail
\n
Constructor Detail
\n
Method Detail
\n
\n
Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
\n
\n
\n
Annotation Type
\n
Each annotation type has its own separate page with the following sections:
\n
\n
Annotation Type declaration
\n
Annotation Type description
\n
Required Element Summary
\n
Optional Element Summary
\n
Element Detail
\n
\n
\n
\n
Enum
\n
Each enum has its own separate page with the following sections:
\n
\n
Enum declaration
\n
Enum description
\n
Enum Constant Summary
\n
Enum Constant Detail
\n
\n
\n
\n
Tree (Class Hierarchy)
\n
There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
\n
\n
When viewing the Overview page, clicking on \"Tree\" displays the hierarchy for all packages.
\n
When viewing a particular package, class or interface page, clicking \"Tree\" displays the hierarchy for only that package.
\n
\n
\n
\n
Deprecated API
\n
The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
\n
\n
\n
Index
\n
The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
\n
\n
\n
Prev/Next
\n
These links take you to the next or previous class, interface, package, or related page.
\n
\n
\n
Frames/No Frames
\n
These links show and hide the HTML frames. All pages are available with or without frames.
\n
\n
\n
All Classes
\n
The All Classes link shows all classes and interfaces except non-static nested types.
\n
\n
\n
Serialized Form
\n
Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking \"Serialized Form\" in the \"See also\" section of the class description.
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
public final class BigComplex\nextends java.lang.Object
\n
Represents a complex number consisting of a real and an imaginary BigDecimal part in the form a + bi.\n\n
It generally follows the design of BigDecimal with some convenience improvements like overloaded operator methods.
\n\n
The biggest difference to BigDecimal is that BigComplex.equals(Object) implements the mathematical equality\n and not the strict technical equality.\n This was a difficult decision because it means that BigComplex behaves slightly different than BigDecimal\n but considering that the strange equality of BigDecimal is a major source of bugs we\n decided it was worth the slight inconsistency.\n If you need the strict equality use strictEquals(Object)`.
\n\n
This class is immutable and therefore inherently thread safe.
Contrary to BigDecimal.equals(Object) this method implements mathematical equality\n (by calling BigDecimal.compareTo(BigDecimal) on the real and imaginary parts)\n instead of strict equality.
public static BigComplex factorial(BigComplex x,\n java.math.MathContext mathContext)
\n
Calculates the factorial of the specified BigComplex.\n\n
This implementation uses\n Spouge's approximation\n to calculate the factorial for non-integer values.
\n\n
This involves calculating a series of constants that depend on the desired precision.\n Since this constant calculation is quite expensive (especially for higher precisions),\n the constants for a specific precision will be cached\n and subsequent calls to this method with the same precision will be much faster.
\n\n
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n and to avoid calling it with many different precisions.
public static BigComplex gamma(BigComplex x,\n java.math.MathContext mathContext)
\n
Calculates the gamma function of the specified BigComplex.\n\n
This implementation uses factorial(BigComplex, MathContext) internally,\n therefore the performance implications described there apply also for this method.\n\n
public static java.math.BigDecimal toBigDecimal(java.lang.String string)
\n
Creates a BigDecimal from the specified String representation.\n\n
This method is equivalent to the String constructor BigDecimal.BigDecimal(String)\n but has been optimized for large strings (several thousand digits).
\n
\n
Parameters:
\n
string - the String representation
\n
Returns:
\n
the created BigDecimal
\n
Throws:
\n
java.lang.NumberFormatException - if string is not a valid representation of a BigDecimal
public static java.math.BigDecimal toBigDecimal(java.lang.String string,\n java.math.MathContext mathContext)
\n
Creates a BigDecimal from the specified String representation.\n\n
This method is equivalent to the String constructor BigDecimal.BigDecimal(String, MathContext)\n but has been optimized for large strings (several thousand digits).
\n
\n
Parameters:
\n
string - the string representation
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the created BigDecimal
\n
Throws:
\n
java.lang.NumberFormatException - if string is not a valid representation of a BigDecimal
\n
java.lang.ArithmeticException - if the result is inexact but the rounding mode is UNNECESSARY
public static boolean isDoubleValue(java.math.BigDecimal value)
\n
Returns whether the specified BigDecimal value can be represented as double.\n\n
If this returns true you can call BigDecimal.doubleValue()\n without fear of getting Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY as result.
\n\n
Example: BigDecimalMath.isDoubleValue(new BigDecimal(\"1E309\")) returns false,\n because new BigDecimal(\"1E309\").doubleValue() returns Infinity.
\n\n
Note: This method does not check for possible loss of precision.
\n\n
For example BigDecimalMath.isDoubleValue(new BigDecimal(\"1.23400000000000000000000000000000001\")) will return true,\n because new BigDecimal(\"1.23400000000000000000000000000000001\").doubleValue() returns a valid double value,\n although it loses precision and returns 1.234.
\n\n
BigDecimalMath.isDoubleValue(new BigDecimal(\"1E-325\")) will return true\n although this value is smaller than Double.MIN_VALUE (and therefore outside the range of values that can be represented as double)\n because new BigDecimal(\"1E-325\").doubleValue() returns 0 which is a legal value with loss of precision.
\n
\n
Parameters:
\n
value - the BigDecimal to check
\n
Returns:
\n
true if the value can be represented as double value
public static java.math.BigDecimal reciprocal(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the reciprocal of the specified BigDecimal.
\n
\n
Parameters:
\n
x - the BigDecimal
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the reciprocal BigDecimal
\n
Throws:
\n
java.lang.ArithmeticException - if x = 0
\n
java.lang.ArithmeticException - if the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
public static java.math.BigDecimal factorial(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the factorial of the specified BigDecimal.\n\n
This implementation uses\n Spouge's approximation\n to calculate the factorial for non-integer values.
\n\n
This involves calculating a series of constants that depend on the desired precision.\n Since this constant calculation is quite expensive (especially for higher precisions),\n the constants for a specific precision will be cached\n and subsequent calls to this method with the same precision will be much faster.
\n\n
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n and to avoid calling it with many different precisions.
public static java.math.BigDecimal gamma(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the gamma function of the specified BigDecimal.\n\n
This implementation uses factorial(BigDecimal, MathContext) internally,\n therefore the performance implications described there apply also for this method.\n\n
n - the index of the Bernoulli number to be calculated (starting at 0)
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the Bernoulli number for the specified index
\n
Throws:
\n
java.lang.ArithmeticException - if x < 0
\n
java.lang.ArithmeticException - if the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
the calculated x to the power of y with the precision specified in the mathContext
\n
Throws:
\n
java.lang.ArithmeticException - if y is negative and the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
\n
java.lang.ArithmeticException - if the rounding mode is\n UNNECESSARY and the\n BigDecimal operation would require rounding.
public class BigRational\nextends java.lang.Object\nimplements java.lang.Comparable<BigRational>
\n
A rational number represented as a quotient of two values.\n \n
Basic calculations with rational numbers (+ - * /) have no loss of precision.\n This allows to use BigRational as a replacement for BigDecimal if absolute accuracy is desired.
The values are internally stored as BigDecimal (for performance optimizations) but represented\n as BigInteger (for mathematical correctness)\n when accessed with getNumeratorBigInteger() and getDenominatorBigInteger().
\n \n
The following basic calculations have no loss of precision:
Any BigRational value can be converted into an arbitrary precision (number of significant digits)\n or scale (number of digits after the decimal point).
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".\n \n
The integer part is omitted if it is 0 (when this absolute rational number is smaller than 1).
\n
The fraction part is omitted it it is 0 (when this rational number is an integer).
\n
If this rational number is 0, then \"0\" is returned.
public static BigRational valueOf(int integer,\n int fractionNumerator,\n int fractionDenominator)
\n
Creates a rational number of the specified integer and fraction parts.\n \n
Useful to create numbers like 3 1/2 (= three and a half = 3.5) by calling\n BigRational.valueOf(3, 1, 2).
\n
To create a negative rational only the integer part argument is allowed to be negative:\n to create -3 1/2 (= minus three and a half = -3.5) call BigRational.valueOf(-3, 1, 2).
\n
\n
Parameters:
\n
integer - the integer part int value
\n
fractionNumerator - the fraction part numerator int value (negative not allowed)
\n
fractionDenominator - the fraction part denominator int value (0 or negative not allowed)
\n
Returns:
\n
the rational number
\n
Throws:
\n
java.lang.ArithmeticException - if the fraction part denominator is 0 (division by zero),\n or if the fraction part numerator or denominator is negative
public class DefaultBigDecimalMath\nextends java.lang.Object
\n
A wrapper around BigDecimalMath that passes always the same default MathContext to the\n functions that need a MathContext argument.\n\n
This class is designed for applications that will always need the same precision in all calculations.
\n\n
The initial default MathContext is equivalent to MathContext.DECIMAL128\n but this can be overridden by setting the following system properties:
\n
\n
ch.obermuhlner.math.big.default.precision to a positive integer precision (default=34)
\n
ch.obermuhlner.math.big.default.rounding to a RoundingMode name (default=HALF_UP)
\n
\n\n
It is also possible to set the default MathContext using setDefaultMathContext(MathContext).\n It is recommended to set the desired precision in the MathContext early in the startup of the application.
\n\n
Important: Avoid the pitfall of setting the precision temporarily for a calculation.\n This can lead to race conditions and calculations with the wrong precision\n if other threads in your application do the same thing.
Constructs a SeriesCalculator with control over whether the sum terms are calculated in pairs.\n \n
Calculation of pairs is useful for taylor series where the terms alternate the sign.\n In these cases it is more efficient to calculate two terms at once check then whether the acceptable error has been reached.
\n
\n
Parameters:
\n
calculateInPairs - true to calculate the terms in pairs, false to calculate single terms
public static java.util.stream.Stream<java.math.BigDecimal> range(long startInclusive,\n long endExclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endExclusive (exclusive) by an incremental step.\n \n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endExclusive - the exclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
public static java.util.stream.Stream<java.math.BigDecimal> rangeClosed(long startInclusive,\n long endInclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endInclusive (inclusive) by an incremental step.\n\n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endInclusive - the inclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
\n
\n
\n
\n
\n
Overview
\n
The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.
\n
\n
\n
Package
\n
Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:
\n
\n
Interfaces (italic)
\n
Classes
\n
Enums
\n
Exceptions
\n
Errors
\n
Annotation Types
\n
\n
\n
\n
Class/Interface
\n
Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
\n
\n
Class inheritance diagram
\n
Direct Subclasses
\n
All Known Subinterfaces
\n
All Known Implementing Classes
\n
Class/interface declaration
\n
Class/interface description
\n
\n
\n
Nested Class Summary
\n
Field Summary
\n
Constructor Summary
\n
Method Summary
\n
\n
\n
Field Detail
\n
Constructor Detail
\n
Method Detail
\n
\n
Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
\n
\n
\n
Annotation Type
\n
Each annotation type has its own separate page with the following sections:
\n
\n
Annotation Type declaration
\n
Annotation Type description
\n
Required Element Summary
\n
Optional Element Summary
\n
Element Detail
\n
\n
\n
\n
Enum
\n
Each enum has its own separate page with the following sections:
\n
\n
Enum declaration
\n
Enum description
\n
Enum Constant Summary
\n
Enum Constant Detail
\n
\n
\n
\n
Tree (Class Hierarchy)
\n
There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
\n
\n
When viewing the Overview page, clicking on \"Tree\" displays the hierarchy for all packages.
\n
When viewing a particular package, class or interface page, clicking \"Tree\" displays the hierarchy for only that package.
\n
\n
\n
\n
Deprecated API
\n
The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
\n
\n
\n
Index
\n
The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
\n
\n
\n
Prev/Next
\n
These links take you to the next or previous class, interface, package, or related page.
\n
\n
\n
Frames/No Frames
\n
These links show and hide the HTML frames. All pages are available with or without frames.
\n
\n
\n
All Classes
\n
The All Classes link shows all classes and interfaces except non-static nested types.
\n
\n
\n
Serialized Form
\n
Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking \"Serialized Form\" in the \"See also\" section of the class description.
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
public final class BigComplex\nextends java.lang.Object
\n
Represents a complex number consisting of a real and an imaginary BigDecimal part in the form a + bi.\n\n
It generally follows the design of BigDecimal with some convenience improvements like overloaded operator methods.
\n\n
The biggest difference to BigDecimal is that BigComplex.equals(Object) implements the mathematical equality\n and not the strict technical equality.\n This was a difficult decision because it means that BigComplex behaves slightly different than BigDecimal\n but considering that the strange equality of BigDecimal is a major source of bugs we\n decided it was worth the slight inconsistency.\n If you need the strict equality use strictEquals(Object)`.
\n\n
This class is immutable and therefore inherently thread safe.
Contrary to BigDecimal.equals(Object) this method implements mathematical equality\n (by calling BigDecimal.compareTo(BigDecimal) on the real and imaginary parts)\n instead of strict equality.
public static BigComplex factorial(BigComplex x,\n java.math.MathContext mathContext)
\n
Calculates the factorial of the specified BigComplex.\n\n
This implementation uses\n Spouge's approximation\n to calculate the factorial for non-integer values.
\n\n
This involves calculating a series of constants that depend on the desired precision.\n Since this constant calculation is quite expensive (especially for higher precisions),\n the constants for a specific precision will be cached\n and subsequent calls to this method with the same precision will be much faster.
\n\n
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n and to avoid calling it with many different precisions.
public static BigComplex gamma(BigComplex x,\n java.math.MathContext mathContext)
\n
Calculates the gamma function of the specified BigComplex.\n\n
This implementation uses factorial(BigComplex, MathContext) internally,\n therefore the performance implications described there apply also for this method.\n\n
public static java.math.BigDecimal toBigDecimal(java.lang.String string)
\n
Creates a BigDecimal from the specified String representation.\n\n
This method is equivalent to the String constructor BigDecimal.BigDecimal(String)\n but has been optimized for large strings (several thousand digits).
\n
\n
Parameters:
\n
string - the String representation
\n
Returns:
\n
the created BigDecimal
\n
Throws:
\n
java.lang.NumberFormatException - if string is not a valid representation of a BigDecimal
public static java.math.BigDecimal toBigDecimal(java.lang.String string,\n java.math.MathContext mathContext)
\n
Creates a BigDecimal from the specified String representation.\n\n
This method is equivalent to the String constructor BigDecimal.BigDecimal(String, MathContext)\n but has been optimized for large strings (several thousand digits).
\n
\n
Parameters:
\n
string - the string representation
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the created BigDecimal
\n
Throws:
\n
java.lang.NumberFormatException - if string is not a valid representation of a BigDecimal
\n
java.lang.ArithmeticException - if the result is inexact but the rounding mode is UNNECESSARY
public static boolean isDoubleValue(java.math.BigDecimal value)
\n
Returns whether the specified BigDecimal value can be represented as double.\n\n
If this returns true you can call BigDecimal.doubleValue()\n without fear of getting Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY as result.
\n\n
Example: BigDecimalMath.isDoubleValue(new BigDecimal(\"1E309\")) returns false,\n because new BigDecimal(\"1E309\").doubleValue() returns Infinity.
\n\n
Note: This method does not check for possible loss of precision.
\n\n
For example BigDecimalMath.isDoubleValue(new BigDecimal(\"1.23400000000000000000000000000000001\")) will return true,\n because new BigDecimal(\"1.23400000000000000000000000000000001\").doubleValue() returns a valid double value,\n although it loses precision and returns 1.234.
\n\n
BigDecimalMath.isDoubleValue(new BigDecimal(\"1E-325\")) will return true\n although this value is smaller than Double.MIN_VALUE (and therefore outside the range of values that can be represented as double)\n because new BigDecimal(\"1E-325\").doubleValue() returns 0 which is a legal value with loss of precision.
\n
\n
Parameters:
\n
value - the BigDecimal to check
\n
Returns:
\n
true if the value can be represented as double value
public static java.math.BigDecimal reciprocal(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the reciprocal of the specified BigDecimal.
\n
\n
Parameters:
\n
x - the BigDecimal
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the reciprocal BigDecimal
\n
Throws:
\n
java.lang.ArithmeticException - if x = 0
\n
java.lang.ArithmeticException - if the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
public static java.math.BigDecimal factorial(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the factorial of the specified BigDecimal.\n\n
This implementation uses\n Spouge's approximation\n to calculate the factorial for non-integer values.
\n\n
This involves calculating a series of constants that depend on the desired precision.\n Since this constant calculation is quite expensive (especially for higher precisions),\n the constants for a specific precision will be cached\n and subsequent calls to this method with the same precision will be much faster.
\n\n
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n and to avoid calling it with many different precisions.
public static java.math.BigDecimal gamma(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the gamma function of the specified BigDecimal.\n\n
This implementation uses factorial(BigDecimal, MathContext) internally,\n therefore the performance implications described there apply also for this method.\n\n
n - the index of the Bernoulli number to be calculated (starting at 0)
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the Bernoulli number for the specified index
\n
Throws:
\n
java.lang.ArithmeticException - if x < 0
\n
java.lang.ArithmeticException - if the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
the calculated x to the power of y with the precision specified in the mathContext
\n
Throws:
\n
java.lang.ArithmeticException - if y is negative and the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
\n
java.lang.ArithmeticException - if the rounding mode is\n UNNECESSARY and the\n BigDecimal operation would require rounding.
public class BigRational\nextends java.lang.Object\nimplements java.lang.Comparable<BigRational>
\n
A rational number represented as a quotient of two values.\n \n
Basic calculations with rational numbers (+ - * /) have no loss of precision.\n This allows to use BigRational as a replacement for BigDecimal if absolute accuracy is desired.
The values are internally stored as BigDecimal (for performance optimizations) but represented\n as BigInteger (for mathematical correctness)\n when accessed with getNumeratorBigInteger() and getDenominatorBigInteger().
\n \n
The following basic calculations have no loss of precision:
Any BigRational value can be converted into an arbitrary precision (number of significant digits)\n or scale (number of digits after the decimal point).
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".\n \n
The integer part is omitted if it is 0 (when this absolute rational number is smaller than 1).
\n
The fraction part is omitted it it is 0 (when this rational number is an integer).
\n
If this rational number is 0, then \"0\" is returned.
public static BigRational valueOf(int integer,\n int fractionNumerator,\n int fractionDenominator)
\n
Creates a rational number of the specified integer and fraction parts.\n \n
Useful to create numbers like 3 1/2 (= three and a half = 3.5) by calling\n BigRational.valueOf(3, 1, 2).
\n
To create a negative rational only the integer part argument is allowed to be negative:\n to create -3 1/2 (= minus three and a half = -3.5) call BigRational.valueOf(-3, 1, 2).
\n
\n
Parameters:
\n
integer - the integer part int value
\n
fractionNumerator - the fraction part numerator int value (negative not allowed)
\n
fractionDenominator - the fraction part denominator int value (0 or negative not allowed)
\n
Returns:
\n
the rational number
\n
Throws:
\n
java.lang.ArithmeticException - if the fraction part denominator is 0 (division by zero),\n or if the fraction part numerator or denominator is negative
public class DefaultBigDecimalMath\nextends java.lang.Object
\n
A wrapper around BigDecimalMath that passes always the same default MathContext to the\n functions that need a MathContext argument.\n\n
This class is designed for applications that will always need the same precision in all calculations.
\n\n
The initial default MathContext is equivalent to MathContext.DECIMAL128\n but this can be overridden by setting the following system properties:
\n
\n
ch.obermuhlner.math.big.default.precision to a positive integer precision (default=34)
\n
ch.obermuhlner.math.big.default.rounding to a RoundingMode name (default=HALF_UP)
\n
\n\n
It is also possible to set the default MathContext using setDefaultMathContext(MathContext).\n It is recommended to set the desired precision in the MathContext early in the startup of the application.
\n\n
Important: Avoid the pitfall of setting the precision temporarily for a calculation.\n This can lead to race conditions and calculations with the wrong precision\n if other threads in your application do the same thing.
Constructs a SeriesCalculator with control over whether the sum terms are calculated in pairs.\n \n
Calculation of pairs is useful for taylor series where the terms alternate the sign.\n In these cases it is more efficient to calculate two terms at once check then whether the acceptable error has been reached.
\n
\n
Parameters:
\n
calculateInPairs - true to calculate the terms in pairs, false to calculate single terms
public static java.util.stream.Stream<java.math.BigDecimal> range(long startInclusive,\n long endExclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endExclusive (exclusive) by an incremental step.\n \n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endExclusive - the exclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
public static java.util.stream.Stream<java.math.BigDecimal> rangeClosed(long startInclusive,\n long endInclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endInclusive (inclusive) by an incremental step.\n\n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endInclusive - the inclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
\n
\n
\n
\n
\n
Overview
\n
The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.
\n
\n
\n
Package
\n
Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:
\n
\n
Interfaces (italic)
\n
Classes
\n
Enums
\n
Exceptions
\n
Errors
\n
Annotation Types
\n
\n
\n
\n
Class/Interface
\n
Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
\n
\n
Class inheritance diagram
\n
Direct Subclasses
\n
All Known Subinterfaces
\n
All Known Implementing Classes
\n
Class/interface declaration
\n
Class/interface description
\n
\n
\n
Nested Class Summary
\n
Field Summary
\n
Constructor Summary
\n
Method Summary
\n
\n
\n
Field Detail
\n
Constructor Detail
\n
Method Detail
\n
\n
Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
\n
\n
\n
Annotation Type
\n
Each annotation type has its own separate page with the following sections:
\n
\n
Annotation Type declaration
\n
Annotation Type description
\n
Required Element Summary
\n
Optional Element Summary
\n
Element Detail
\n
\n
\n
\n
Enum
\n
Each enum has its own separate page with the following sections:
\n
\n
Enum declaration
\n
Enum description
\n
Enum Constant Summary
\n
Enum Constant Detail
\n
\n
\n
\n
Tree (Class Hierarchy)
\n
There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
\n
\n
When viewing the Overview page, clicking on \"Tree\" displays the hierarchy for all packages.
\n
When viewing a particular package, class or interface page, clicking \"Tree\" displays the hierarchy for only that package.
\n
\n
\n
\n
Deprecated API
\n
The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
\n
\n
\n
Index
\n
The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
\n
\n
\n
Prev/Next
\n
These links take you to the next or previous class, interface, package, or related page.
\n
\n
\n
Frames/No Frames
\n
These links show and hide the HTML frames. All pages are available with or without frames.
\n
\n
\n
All Classes
\n
The All Classes link shows all classes and interfaces except non-static nested types.
\n
\n
\n
Serialized Form
\n
Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking \"Serialized Form\" in the \"See also\" section of the class description.
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
public final class BigComplex\nextends java.lang.Object
\n
Represents a complex number consisting of a real and an imaginary BigDecimal part in the form a + bi.\n\n
It generally follows the design of BigDecimal with some convenience improvements like overloaded operator methods.
\n\n
The biggest difference to BigDecimal is that BigComplex.equals(Object) implements the mathematical equality\n and not the strict technical equality.\n This was a difficult decision because it means that BigComplex behaves slightly different than BigDecimal\n but considering that the strange equality of BigDecimal is a major source of bugs we\n decided it was worth the slight inconsistency.\n If you need the strict equality use strictEquals(Object)`.
\n\n
This class is immutable and therefore inherently thread safe.
Contrary to BigDecimal.equals(Object) this method implements mathematical equality\n (by calling BigDecimal.compareTo(BigDecimal) on the real and imaginary parts)\n instead of strict equality.
public static BigComplex factorial(BigComplex x,\n java.math.MathContext mathContext)
\n
Calculates the factorial of the specified BigComplex.\n\n
This implementation uses\n Spouge's approximation\n to calculate the factorial for non-integer values.
\n\n
This involves calculating a series of constants that depend on the desired precision.\n Since this constant calculation is quite expensive (especially for higher precisions),\n the constants for a specific precision will be cached\n and subsequent calls to this method with the same precision will be much faster.
\n\n
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n and to avoid calling it with many different precisions.
public static BigComplex gamma(BigComplex x,\n java.math.MathContext mathContext)
\n
Calculates the gamma function of the specified BigComplex.\n\n
This implementation uses factorial(BigComplex, MathContext) internally,\n therefore the performance implications described there apply also for this method.\n\n
public static java.math.BigDecimal toBigDecimal(java.lang.String string)
\n
Creates a BigDecimal from the specified String representation.\n\n
This method is equivalent to the String constructor BigDecimal.BigDecimal(String)\n but has been optimized for large strings (several thousand digits).
\n
\n
Parameters:
\n
string - the String representation
\n
Returns:
\n
the created BigDecimal
\n
Throws:
\n
java.lang.NumberFormatException - if string is not a valid representation of a BigDecimal
public static java.math.BigDecimal toBigDecimal(java.lang.String string,\n java.math.MathContext mathContext)
\n
Creates a BigDecimal from the specified String representation.\n\n
This method is equivalent to the String constructor BigDecimal.BigDecimal(String, MathContext)\n but has been optimized for large strings (several thousand digits).
\n
\n
Parameters:
\n
string - the string representation
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the created BigDecimal
\n
Throws:
\n
java.lang.NumberFormatException - if string is not a valid representation of a BigDecimal
\n
java.lang.ArithmeticException - if the result is inexact but the rounding mode is UNNECESSARY
public static boolean isDoubleValue(java.math.BigDecimal value)
\n
Returns whether the specified BigDecimal value can be represented as double.\n\n
If this returns true you can call BigDecimal.doubleValue()\n without fear of getting Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY as result.
\n\n
Example: BigDecimalMath.isDoubleValue(new BigDecimal(\"1E309\")) returns false,\n because new BigDecimal(\"1E309\").doubleValue() returns Infinity.
\n\n
Note: This method does not check for possible loss of precision.
\n\n
For example BigDecimalMath.isDoubleValue(new BigDecimal(\"1.23400000000000000000000000000000001\")) will return true,\n because new BigDecimal(\"1.23400000000000000000000000000000001\").doubleValue() returns a valid double value,\n although it loses precision and returns 1.234.
\n\n
BigDecimalMath.isDoubleValue(new BigDecimal(\"1E-325\")) will return true\n although this value is smaller than Double.MIN_VALUE (and therefore outside the range of values that can be represented as double)\n because new BigDecimal(\"1E-325\").doubleValue() returns 0 which is a legal value with loss of precision.
\n
\n
Parameters:
\n
value - the BigDecimal to check
\n
Returns:
\n
true if the value can be represented as double value
public static java.math.BigDecimal reciprocal(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the reciprocal of the specified BigDecimal.
\n
\n
Parameters:
\n
x - the BigDecimal
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the reciprocal BigDecimal
\n
Throws:
\n
java.lang.ArithmeticException - if x = 0
\n
java.lang.ArithmeticException - if the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
public static java.math.BigDecimal factorial(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the factorial of the specified BigDecimal.\n\n
This implementation uses\n Spouge's approximation\n to calculate the factorial for non-integer values.
\n\n
This involves calculating a series of constants that depend on the desired precision.\n Since this constant calculation is quite expensive (especially for higher precisions),\n the constants for a specific precision will be cached\n and subsequent calls to this method with the same precision will be much faster.
\n\n
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n and to avoid calling it with many different precisions.
public static java.math.BigDecimal gamma(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the gamma function of the specified BigDecimal.\n\n
This implementation uses factorial(BigDecimal, MathContext) internally,\n therefore the performance implications described there apply also for this method.\n\n
n - the index of the Bernoulli number to be calculated (starting at 0)
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the Bernoulli number for the specified index
\n
Throws:
\n
java.lang.ArithmeticException - if x < 0
\n
java.lang.ArithmeticException - if the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
the calculated x to the power of y with the precision specified in the mathContext
\n
Throws:
\n
java.lang.ArithmeticException - if y is negative and the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
\n
java.lang.ArithmeticException - if the rounding mode is\n UNNECESSARY and the\n BigDecimal operation would require rounding.
public class BigRational\nextends java.lang.Object\nimplements java.lang.Comparable<BigRational>
\n
A rational number represented as a quotient of two values.\n \n
Basic calculations with rational numbers (+ - * /) have no loss of precision.\n This allows to use BigRational as a replacement for BigDecimal if absolute accuracy is desired.
The values are internally stored as BigDecimal (for performance optimizations) but represented\n as BigInteger (for mathematical correctness)\n when accessed with getNumeratorBigInteger() and getDenominatorBigInteger().
\n \n
The following basic calculations have no loss of precision:
Any BigRational value can be converted into an arbitrary precision (number of significant digits)\n or scale (number of digits after the decimal point).
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".\n \n
The integer part is omitted if it is 0 (when this absolute rational number is smaller than 1).
\n
The fraction part is omitted it it is 0 (when this rational number is an integer).
\n
If this rational number is 0, then \"0\" is returned.
public static BigRational valueOf(int integer,\n int fractionNumerator,\n int fractionDenominator)
\n
Creates a rational number of the specified integer and fraction parts.\n \n
Useful to create numbers like 3 1/2 (= three and a half = 3.5) by calling\n BigRational.valueOf(3, 1, 2).
\n
To create a negative rational only the integer part argument is allowed to be negative:\n to create -3 1/2 (= minus three and a half = -3.5) call BigRational.valueOf(-3, 1, 2).
\n
\n
Parameters:
\n
integer - the integer part int value
\n
fractionNumerator - the fraction part numerator int value (negative not allowed)
\n
fractionDenominator - the fraction part denominator int value (0 or negative not allowed)
\n
Returns:
\n
the rational number
\n
Throws:
\n
java.lang.ArithmeticException - if the fraction part denominator is 0 (division by zero),\n or if the fraction part numerator or denominator is negative
public class DefaultBigDecimalMath\nextends java.lang.Object
\n
A wrapper around BigDecimalMath that passes always the same default MathContext to the\n functions that need a MathContext argument.\n\n
This class is designed for applications that will always need the same precision in all calculations.
\n\n
The initial default MathContext is equivalent to MathContext.DECIMAL128\n but this can be overridden by setting the following system properties:
\n
\n
ch.obermuhlner.math.big.default.precision to a positive integer precision (default=34)
\n
ch.obermuhlner.math.big.default.rounding to a RoundingMode name (default=HALF_UP)
\n
\n\n
It is also possible to set the default MathContext using setDefaultMathContext(MathContext).\n It is recommended to set the desired precision in the MathContext early in the startup of the application.
\n\n
Important: Avoid the pitfall of setting the precision temporarily for a calculation.\n This can lead to race conditions and calculations with the wrong precision\n if other threads in your application do the same thing.
Constructs a SeriesCalculator with control over whether the sum terms are calculated in pairs.\n \n
Calculation of pairs is useful for taylor series where the terms alternate the sign.\n In these cases it is more efficient to calculate two terms at once check then whether the acceptable error has been reached.
\n
\n
Parameters:
\n
calculateInPairs - true to calculate the terms in pairs, false to calculate single terms
Returns the factor of the term with specified index.\n\n All mutable state of this class (and all its subclasses) must be modified in this method.\n This method is synchronized to allow thread-safe usage of this class.
public static java.util.stream.Stream<java.math.BigDecimal> range(long startInclusive,\n long endExclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endExclusive (exclusive) by an incremental step.\n \n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endExclusive - the exclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
public static java.util.stream.Stream<java.math.BigDecimal> rangeClosed(long startInclusive,\n long endInclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endInclusive (inclusive) by an incremental step.\n\n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endInclusive - the inclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
\n
\n
\n
\n
\n
Overview
\n
The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.
\n
\n
\n
Package
\n
Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:
\n
\n
Interfaces (italic)
\n
Classes
\n
Enums
\n
Exceptions
\n
Errors
\n
Annotation Types
\n
\n
\n
\n
Class/Interface
\n
Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
\n
\n
Class inheritance diagram
\n
Direct Subclasses
\n
All Known Subinterfaces
\n
All Known Implementing Classes
\n
Class/interface declaration
\n
Class/interface description
\n
\n
\n
Nested Class Summary
\n
Field Summary
\n
Constructor Summary
\n
Method Summary
\n
\n
\n
Field Detail
\n
Constructor Detail
\n
Method Detail
\n
\n
Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
\n
\n
\n
Annotation Type
\n
Each annotation type has its own separate page with the following sections:
\n
\n
Annotation Type declaration
\n
Annotation Type description
\n
Required Element Summary
\n
Optional Element Summary
\n
Element Detail
\n
\n
\n
\n
Enum
\n
Each enum has its own separate page with the following sections:
\n
\n
Enum declaration
\n
Enum description
\n
Enum Constant Summary
\n
Enum Constant Detail
\n
\n
\n
\n
Tree (Class Hierarchy)
\n
There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
\n
\n
When viewing the Overview page, clicking on \"Tree\" displays the hierarchy for all packages.
\n
When viewing a particular package, class or interface page, clicking \"Tree\" displays the hierarchy for only that package.
\n
\n
\n
\n
Deprecated API
\n
The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
\n
\n
\n
Index
\n
The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
\n
\n
\n
Prev/Next
\n
These links take you to the next or previous class, interface, package, or related page.
\n
\n
\n
Frames/No Frames
\n
These links show and hide the HTML frames. All pages are available with or without frames.
\n
\n
\n
All Classes
\n
The All Classes link shows all classes and interfaces except non-static nested types.
\n
\n
\n
Serialized Form
\n
Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking \"Serialized Form\" in the \"See also\" section of the class description.
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
public final class BigComplex\nextends java.lang.Object
\n
Represents a complex number consisting of a real and an imaginary BigDecimal part in the form a + bi.\n\n
It generally follows the design of BigDecimal with some convenience improvements like overloaded operator methods.
\n\n
The biggest difference to BigDecimal is that BigComplex.equals(Object) implements the mathematical equality\n and not the strict technical equality.\n This was a difficult decision because it means that BigComplex behaves slightly different than BigDecimal\n but considering that the strange equality of BigDecimal is a major source of bugs we\n decided it was worth the slight inconsistency.\n If you need the strict equality use strictEquals(Object)`.
\n\n
This class is immutable and therefore inherently thread safe.
\n\n Contrary to BigDecimal.equals(Object) this method implements mathematical equality\n (by calling BigDecimal.compareTo(BigDecimal) on the real and imaginary parts)\n instead of strict equality.
Contrary to BigDecimal.equals(Object) this method implements mathematical equality\n (by calling BigDecimal.compareTo(BigDecimal) on the real and imaginary parts)\n instead of strict equality.
public static BigComplex factorial(BigComplex x,\n java.math.MathContext mathContext)
\n
Calculates the factorial of the specified BigComplex.\n\n
This implementation uses\n Spouge's approximation\n to calculate the factorial for non-integer values.
\n\n
This involves calculating a series of constants that depend on the desired precision.\n Since this constant calculation is quite expensive (especially for higher precisions),\n the constants for a specific precision will be cached\n and subsequent calls to this method with the same precision will be much faster.
\n\n
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n and to avoid calling it with many different precisions.
public static BigComplex gamma(BigComplex x,\n java.math.MathContext mathContext)
\n
Calculates the gamma function of the specified BigComplex.\n\n
This implementation uses factorial(BigComplex, MathContext) internally,\n therefore the performance implications described there apply also for this method.\n\n
public static java.math.BigDecimal toBigDecimal(java.lang.String string)
\n
Creates a BigDecimal from the specified String representation.\n\n
This method is equivalent to the String constructor BigDecimal.BigDecimal(String)\n but has been optimized for large strings (several thousand digits).
\n
\n
Parameters:
\n
string - the String representation
\n
Returns:
\n
the created BigDecimal
\n
Throws:
\n
java.lang.NumberFormatException - if string is not a valid representation of a BigDecimal
public static java.math.BigDecimal toBigDecimal(java.lang.String string,\n java.math.MathContext mathContext)
\n
Creates a BigDecimal from the specified String representation.\n\n
This method is equivalent to the String constructor BigDecimal.BigDecimal(String, MathContext)\n but has been optimized for large strings (several thousand digits).
\n
\n
Parameters:
\n
string - the string representation
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the created BigDecimal
\n
Throws:
\n
java.lang.NumberFormatException - if string is not a valid representation of a BigDecimal
\n
java.lang.ArithmeticException - if the result is inexact but the rounding mode is UNNECESSARY
public static boolean isDoubleValue(java.math.BigDecimal value)
\n
Returns whether the specified BigDecimal value can be represented as double.\n\n
If this returns true you can call BigDecimal.doubleValue()\n without fear of getting Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY as result.
\n\n
Example: BigDecimalMath.isDoubleValue(new BigDecimal(\"1E309\")) returns false,\n because new BigDecimal(\"1E309\").doubleValue() returns Infinity.
\n\n
Note: This method does not check for possible loss of precision.
\n\n
For example BigDecimalMath.isDoubleValue(new BigDecimal(\"1.23400000000000000000000000000000001\")) will return true,\n because new BigDecimal(\"1.23400000000000000000000000000000001\").doubleValue() returns a valid double value,\n although it loses precision and returns 1.234.
\n\n
BigDecimalMath.isDoubleValue(new BigDecimal(\"1E-325\")) will return true\n although this value is smaller than Double.MIN_VALUE (and therefore outside the range of values that can be represented as double)\n because new BigDecimal(\"1E-325\").doubleValue() returns 0 which is a legal value with loss of precision.
\n
\n
Parameters:
\n
value - the BigDecimal to check
\n
Returns:
\n
true if the value can be represented as double value
public static java.math.BigDecimal reciprocal(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the reciprocal of the specified BigDecimal.
\n
\n
Parameters:
\n
x - the BigDecimal
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the reciprocal BigDecimal
\n
Throws:
\n
java.lang.ArithmeticException - if x = 0
\n
java.lang.ArithmeticException - if the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
public static java.math.BigDecimal factorial(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the factorial of the specified BigDecimal.\n\n
This implementation uses\n Spouge's approximation\n to calculate the factorial for non-integer values.
\n\n
This involves calculating a series of constants that depend on the desired precision.\n Since this constant calculation is quite expensive (especially for higher precisions),\n the constants for a specific precision will be cached\n and subsequent calls to this method with the same precision will be much faster.
\n\n
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n and to avoid calling it with many different precisions.
public static java.math.BigDecimal gamma(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the gamma function of the specified BigDecimal.\n\n
This implementation uses factorial(BigDecimal, MathContext) internally,\n therefore the performance implications described there apply also for this method.\n\n
n - the index of the Bernoulli number to be calculated (starting at 0)
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the Bernoulli number for the specified index
\n
Throws:
\n
java.lang.ArithmeticException - if x < 0
\n
java.lang.ArithmeticException - if the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
the calculated x to the power of y with the precision specified in the mathContext
\n
Throws:
\n
java.lang.ArithmeticException - if y is negative and the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
\n
java.lang.ArithmeticException - if the rounding mode is\n UNNECESSARY and the\n BigDecimal operation would require rounding.
public class BigRational\nextends java.lang.Object\nimplements java.lang.Comparable<BigRational>
\n
A rational number represented as a quotient of two values.\n \n
Basic calculations with rational numbers (+ - * /) have no loss of precision.\n This allows to use BigRational as a replacement for BigDecimal if absolute accuracy is desired.
The values are internally stored as BigDecimal (for performance optimizations) but represented\n as BigInteger (for mathematical correctness)\n when accessed with getNumeratorBigInteger() and getDenominatorBigInteger().
\n \n
The following basic calculations have no loss of precision:
Any BigRational value can be converted into an arbitrary precision (number of significant digits)\n or scale (number of digits after the decimal point).
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".\n \n
The integer part is omitted if it is 0 (when this absolute rational number is smaller than 1).
\n
The fraction part is omitted it it is 0 (when this rational number is an integer).
\n
If this rational number is 0, then \"0\" is returned.
public static BigRational valueOf(int integer,\n int fractionNumerator,\n int fractionDenominator)
\n
Creates a rational number of the specified integer and fraction parts.\n \n
Useful to create numbers like 3 1/2 (= three and a half = 3.5) by calling\n BigRational.valueOf(3, 1, 2).
\n
To create a negative rational only the integer part argument is allowed to be negative:\n to create -3 1/2 (= minus three and a half = -3.5) call BigRational.valueOf(-3, 1, 2).
\n
\n
Parameters:
\n
integer - the integer part int value
\n
fractionNumerator - the fraction part numerator int value (negative not allowed)
\n
fractionDenominator - the fraction part denominator int value (0 or negative not allowed)
\n
Returns:
\n
the rational number
\n
Throws:
\n
java.lang.ArithmeticException - if the fraction part denominator is 0 (division by zero),\n or if the fraction part numerator or denominator is negative
public class DefaultBigDecimalMath\nextends java.lang.Object
\n
A wrapper around BigDecimalMath that passes a current MathContext to the\n functions that need a MathContext argument.\n\n
The initial default MathContext is equivalent to MathContext.DECIMAL128\n but this can be overridden by setting the following system properties:
\n
\n
ch.obermuhlner.math.big.default.precision to a positive integer precision (default=34)
\n
ch.obermuhlner.math.big.default.rounding to a RoundingMode name (default=HALF_UP)
\n
\n\n
It is also possible to programmatically set the default MathContext using setDefaultMathContext(MathContext).\n It is recommended to set the desired precision in the MathContext very early in the startup of the application and to not change it afterwards.
\n\n
Important: Avoid the pitfall of setting the precision temporarily using setDefaultMathContext(MathContext) for a calculation.\n This can lead to race conditions and calculations with the wrong precision\n if other threads in your application do the same thing.
\n\n
To set a temporary MathContext you have to choice to use either:\n
\n
DefaultBigDecimalMath.createLocalMathContext() in a try-with-resources statement
\n
DefaultBigDecimalMath.withLocalMathContext() with a lambda function
\n
\n\n Example code using DefaultBigDecimalMath.createLocalMathContext():\n
The temporary MathContext are stored in ThreadLocal variables\n and will therefore not conflict with each other when used in multi-threaded use case.
\n\n
Important: Due to the ThreadLocal variables the local MathContext will\n not be available in other threads.\n This includes streams using parallel(), thread pools and manually started threads.\n If you need temporary MathContext for calculations then you must\n set the local MathContext inside every separate thread.
Constructs a SeriesCalculator with control over whether the sum terms are calculated in pairs.\n \n
Calculation of pairs is useful for taylor series where the terms alternate the sign.\n In these cases it is more efficient to calculate two terms at once check then whether the acceptable error has been reached.
\n
\n
Parameters:
\n
calculateInPairs - true to calculate the terms in pairs, false to calculate single terms
Returns the factor of the term with specified index.\n\n All mutable state of this class (and all its subclasses) must be modified in this method.\n This method is synchronized to allow thread-safe usage of this class.
public static java.util.stream.Stream<java.math.BigDecimal> range(long startInclusive,\n long endExclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endExclusive (exclusive) by an incremental step.\n \n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endExclusive - the exclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
public static java.util.stream.Stream<java.math.BigDecimal> rangeClosed(long startInclusive,\n long endInclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endInclusive (inclusive) by an incremental step.\n\n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endInclusive - the inclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
\n
\n
\n
\n
\n
Overview
\n
The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.
\n
\n
\n
Package
\n
Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:
\n
\n
Interfaces (italic)
\n
Classes
\n
Enums
\n
Exceptions
\n
Errors
\n
Annotation Types
\n
\n
\n
\n
Class/Interface
\n
Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
\n
\n
Class inheritance diagram
\n
Direct Subclasses
\n
All Known Subinterfaces
\n
All Known Implementing Classes
\n
Class/interface declaration
\n
Class/interface description
\n
\n
\n
Nested Class Summary
\n
Field Summary
\n
Constructor Summary
\n
Method Summary
\n
\n
\n
Field Detail
\n
Constructor Detail
\n
Method Detail
\n
\n
Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
\n
\n
\n
Annotation Type
\n
Each annotation type has its own separate page with the following sections:
\n
\n
Annotation Type declaration
\n
Annotation Type description
\n
Required Element Summary
\n
Optional Element Summary
\n
Element Detail
\n
\n
\n
\n
Enum
\n
Each enum has its own separate page with the following sections:
\n
\n
Enum declaration
\n
Enum description
\n
Enum Constant Summary
\n
Enum Constant Detail
\n
\n
\n
\n
Tree (Class Hierarchy)
\n
There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
\n
\n
When viewing the Overview page, clicking on \"Tree\" displays the hierarchy for all packages.
\n
When viewing a particular package, class or interface page, clicking \"Tree\" displays the hierarchy for only that package.
\n
\n
\n
\n
Deprecated API
\n
The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
\n
\n
\n
Index
\n
The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
\n
\n
\n
Prev/Next
\n
These links take you to the next or previous class, interface, package, or related page.
\n
\n
\n
Frames/No Frames
\n
These links show and hide the HTML frames. All pages are available with or without frames.
\n
\n
\n
All Classes
\n
The All Classes link shows all classes and interfaces except non-static nested types.
\n
\n
\n
Serialized Form
\n
Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking \"Serialized Form\" in the \"See also\" section of the class description.
\n\n Contrary to BigDecimal.equals(Object) this method implements mathematical equality\n (by calling BigDecimal.compareTo(BigDecimal) on the real and imaginary parts)\n instead of strict equality.
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
public final class BigComplex\nextends java.lang.Object
\n
Represents a complex number consisting of a real and an imaginary BigDecimal part in the form a + bi.\n\n
It generally follows the design of BigDecimal with some convenience improvements like overloaded operator methods.
\n\n
The biggest difference to BigDecimal is that BigComplex.equals(Object) implements the mathematical equality\n and not the strict technical equality.\n This was a difficult decision because it means that BigComplex behaves slightly different than BigDecimal\n but considering that the strange equality of BigDecimal is a major source of bugs we\n decided it was worth the slight inconsistency.\n If you need the strict equality use strictEquals(Object)`.
\n\n
This class is immutable and therefore inherently thread safe.
Contrary to BigDecimal.equals(Object) this method implements mathematical equality\n (by calling BigDecimal.compareTo(BigDecimal) on the real and imaginary parts)\n instead of strict equality.
public static BigComplex factorial(BigComplex x,\n java.math.MathContext mathContext)
\n
Calculates the factorial of the specified BigComplex.\n\n
This implementation uses\n Spouge's approximation\n to calculate the factorial for non-integer values.
\n\n
This involves calculating a series of constants that depend on the desired precision.\n Since this constant calculation is quite expensive (especially for higher precisions),\n the constants for a specific precision will be cached\n and subsequent calls to this method with the same precision will be much faster.
\n\n
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n and to avoid calling it with many different precisions.
public static BigComplex gamma(BigComplex x,\n java.math.MathContext mathContext)
\n
Calculates the gamma function of the specified BigComplex.\n\n
This implementation uses factorial(BigComplex, MathContext) internally,\n therefore the performance implications described there apply also for this method.\n\n
Rounds the specified BigDecimal to the relative precision and if close to 0 the absolute precision of the specified MathContext including trailing zeroes.
public static java.math.BigDecimal toBigDecimal(java.lang.String string,\n java.math.MathContext mathContext)
\n
Creates a BigDecimal from the specified String representation.\n\n
This method is equivalent to the String constructor BigDecimal(String, MathContext)\n but has been optimized for large strings (several thousand digits).
\n
\n
Parameters:
\n
string - the string representation
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the created BigDecimal
\n
Throws:
\n
java.lang.NumberFormatException - if string is not a valid representation of a BigDecimal
\n
java.lang.ArithmeticException - if the result is inexact but the rounding mode is UNNECESSARY
public static boolean isDoubleValue(java.math.BigDecimal value)
\n
Returns whether the specified BigDecimal value can be represented as double.\n\n
If this returns true you can call BigDecimal.doubleValue()\n without fear of getting Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY as result.
\n\n
Example: BigDecimalMath.isDoubleValue(new BigDecimal(\"1E309\")) returns false,\n because new BigDecimal(\"1E309\").doubleValue() returns Infinity.
\n\n
Note: This method does not check for possible loss of precision.
\n\n
For example BigDecimalMath.isDoubleValue(new BigDecimal(\"1.23400000000000000000000000000000001\")) will return true,\n because new BigDecimal(\"1.23400000000000000000000000000000001\").doubleValue() returns a valid double value,\n although it loses precision and returns 1.234.
\n\n
BigDecimalMath.isDoubleValue(new BigDecimal(\"1E-325\")) will return true\n although this value is smaller than Double.MIN_VALUE (and therefore outside the range of values that can be represented as double)\n because new BigDecimal(\"1E-325\").doubleValue() returns 0 which is a legal value with loss of precision.
\n
\n
Parameters:
\n
value - the BigDecimal to check
\n
Returns:
\n
true if the value can be represented as double value
public static java.math.BigDecimal roundAbsolutePrecision(java.math.BigDecimal value,\n java.math.MathContext mathContext)
\n
Rounds the specified BigDecimal to the relative precision and if close to 0 the absolute precision of the specified MathContext.\n\n
This method returns BigDecimal.ZERO if the absolute value is smaller than the precision of the specified MathContext,\n otherwise it calls round(BigDecimal, MathContext).
\n
\n
Parameters:
\n
value - the BigDecimal to round
\n
mathContext - the MathContext used for the relative and absolute precision of the result
public static java.math.BigDecimal roundAbsolutePrecision(java.math.BigDecimal value,\n java.math.MathContext mathContext,\n int absolutePrecision)
\n
Rounds the specified BigDecimal to the relative precision of the specified MathContext and the specified absolute precision.\n\n
This method returns BigDecimal.ZERO if the absolute value is smaller than the specified absolute precision,\n otherwise it calls BigDecimal.round(MathContext).
\n
\n
Parameters:
\n
value - the BigDecimal to round
\n
mathContext - the MathContext relative precision used for the result
\n
absolutePrecision - the absolute precision (must be positive, 0 will be ignored)
\n
Returns:
\n
the rounded BigDecimal value
\n
Throws:
\n
java.lang.IllegalArgumentException - if the absolute precision is negative
public static java.math.BigDecimal roundAbsolutePrecisionWithTrailingZeroes(java.math.BigDecimal value,\n java.math.MathContext mathContext)
\n
Rounds the specified BigDecimal to the relative precision and if close to 0 the absolute precision of the specified MathContext including trailing zeroes.\n\n
This method is similar to BigDecimal.round(MathContext) but does not remove the trailing zeroes.
\n
\n
Parameters:
\n
value - the BigDecimal to round
\n
mathContext - the MathContext used for the relative precision of the result
\n
Returns:
\n
the rounded BigDecimal value including trailing zeroes
public static java.math.BigDecimal roundAbsolutePrecisionWithTrailingZeroes(java.math.BigDecimal value,\n java.math.MathContext mathContext,\n int absolutePrecision)
\n
Rounds the specified BigDecimal to the relative precision of the specified MathContext and the specified absolute precision including trailing zeroes.\n\n
public static java.math.BigDecimal reciprocal(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the reciprocal of the specified BigDecimal.
\n
\n
Parameters:
\n
x - the BigDecimal
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the reciprocal BigDecimal
\n
Throws:
\n
java.lang.ArithmeticException - if x = 0
\n
java.lang.ArithmeticException - if the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
public static java.math.BigDecimal factorial(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the factorial of the specified BigDecimal.\n\n
This implementation uses\n Spouge's approximation\n to calculate the factorial for non-integer values.
\n\n
This involves calculating a series of constants that depend on the desired precision.\n Since this constant calculation is quite expensive (especially for higher precisions),\n the constants for a specific precision will be cached\n and subsequent calls to this method with the same precision will be much faster.
\n\n
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n and to avoid calling it with many different precisions.
public static java.math.BigDecimal gamma(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the gamma function of the specified BigDecimal.\n\n
This implementation uses factorial(BigDecimal, MathContext) internally,\n therefore the performance implications described there apply also for this method.\n\n
n - the index of the Bernoulli number to be calculated (starting at 0)
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the Bernoulli number for the specified index
\n
Throws:
\n
java.lang.ArithmeticException - if x < 0
\n
java.lang.ArithmeticException - if the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
the calculated x to the power of y with the precision specified in the mathContext
\n
Throws:
\n
java.lang.ArithmeticException - if y is negative and the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
\n
java.lang.ArithmeticException - if the rounding mode is\n UNNECESSARY and the\n BigDecimal operation would require rounding.
public class BigRational\nextends java.lang.Number\nimplements java.lang.Comparable<BigRational>, java.io.Serializable
\n
A rational number represented as a quotient of two values.\n \n
Basic calculations with rational numbers (+ - * /) have no loss of precision.\n This allows to use BigRational as a replacement for BigDecimal if absolute accuracy is desired.
The values are internally stored as BigDecimal (for performance optimizations) but represented\n as BigInteger (for mathematical correctness)\n when accessed with getNumeratorBigInteger() and getDenominatorBigInteger().
\n \n
The following basic calculations have no loss of precision:
Any BigRational value can be converted into an arbitrary precision (number of significant digits)\n or scale (number of digits after the decimal point).
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".\n \n
The integer part is omitted if it is 0 (when this absolute rational number is smaller than 1).
\n
The fraction part is omitted it it is 0 (when this rational number is an integer).
\n
If this rational number is 0, then \"0\" is returned.
public static BigRational valueOf(int integer,\n int fractionNumerator,\n int fractionDenominator)
\n
Creates a rational number of the specified integer and fraction parts.\n \n
Useful to create numbers like 3 1/2 (= three and a half = 3.5) by calling\n BigRational.valueOf(3, 1, 2).
\n
To create a negative rational only the integer part argument is allowed to be negative:\n to create -3 1/2 (= minus three and a half = -3.5) call BigRational.valueOf(-3, 1, 2).
\n
\n
Parameters:
\n
integer - the integer part int value
\n
fractionNumerator - the fraction part numerator int value (negative not allowed)
\n
fractionDenominator - the fraction part denominator int value (0 or negative not allowed)
\n
Returns:
\n
the rational number
\n
Throws:
\n
java.lang.ArithmeticException - if the fraction part denominator is 0 (division by zero),\n or if the fraction part numerator or denominator is negative
public class DefaultBigDecimalMath\nextends java.lang.Object
\n
A wrapper around BigDecimalMath that passes a current MathContext to the\n functions that need a MathContext argument.\n\n
The initial default MathContext is equivalent to MathContext.DECIMAL128\n but this can be overridden by setting the following system properties:
\n
\n
ch.obermuhlner.math.big.default.precision to a positive integer precision (default=34)
\n
ch.obermuhlner.math.big.default.rounding to a RoundingMode name (default=HALF_UP)
\n
\n\n
It is also possible to programmatically set the default MathContext using setDefaultMathContext(MathContext).\n It is recommended to set the desired precision in the MathContext very early in the startup of the application and to not change it afterwards.
\n\n
Important: Avoid the pitfall of setting the precision temporarily using setDefaultMathContext(MathContext) for a calculation.\n This can lead to race conditions and calculations with the wrong precision\n if other threads in your application do the same thing.
\n\n
To set a temporary MathContext you have to choice to use either:\n
\n
DefaultBigDecimalMath.createLocalMathContext() in a try-with-resources statement
\n
DefaultBigDecimalMath.withLocalMathContext() with a lambda function
\n
\n\n Example code using DefaultBigDecimalMath.createLocalMathContext():\n
The temporary MathContext are stored in ThreadLocal variables\n and will therefore not conflict with each other when used in multi-threaded use case.
\n\n
Important: Due to the ThreadLocal variables the local MathContext will\n not be available in other threads.\n This includes streams using parallel(), thread pools and manually started threads.\n If you need temporary MathContext for calculations then you must\n set the local MathContext inside every separate thread.
public NewtonRaphsonSolver(java.util.function.BiFunction<java.math.BigDecimal,java.math.MathContext,java.math.BigDecimal> function,\n java.util.function.BiFunction<java.math.BigDecimal,java.math.MathContext,java.math.BigDecimal> functionFirstDerivative)
Constructs a SeriesCalculator with control over whether the sum terms are calculated in pairs.\n \n
Calculation of pairs is useful for taylor series where the terms alternate the sign.\n In these cases it is more efficient to calculate two terms at once check then whether the acceptable error has been reached.
\n
\n
Parameters:
\n
calculateInPairs - true to calculate the terms in pairs, false to calculate single terms
Returns the factor of the term with specified index.\n\n All mutable state of this class (and all its subclasses) must be modified in this method.\n This method is synchronized to allow thread-safe usage of this class.
public static java.util.stream.Stream<java.math.BigDecimal> range(long startInclusive,\n long endExclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endExclusive (exclusive) by an incremental step.\n \n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endExclusive - the exclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
public static java.util.stream.Stream<java.math.BigDecimal> rangeClosed(long startInclusive,\n long endInclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endInclusive (inclusive) by an incremental step.\n\n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endInclusive - the inclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
\n
\n
\n
\n
\n
Overview
\n
The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.
\n
\n
\n
Package
\n
Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:
\n
\n
Interfaces (italic)
\n
Classes
\n
Enums
\n
Exceptions
\n
Errors
\n
Annotation Types
\n
\n
\n
\n
Class/Interface
\n
Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
\n
\n
Class inheritance diagram
\n
Direct Subclasses
\n
All Known Subinterfaces
\n
All Known Implementing Classes
\n
Class/interface declaration
\n
Class/interface description
\n
\n
\n
Nested Class Summary
\n
Field Summary
\n
Constructor Summary
\n
Method Summary
\n
\n
\n
Field Detail
\n
Constructor Detail
\n
Method Detail
\n
\n
Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
\n
\n
\n
Annotation Type
\n
Each annotation type has its own separate page with the following sections:
\n
\n
Annotation Type declaration
\n
Annotation Type description
\n
Required Element Summary
\n
Optional Element Summary
\n
Element Detail
\n
\n
\n
\n
Enum
\n
Each enum has its own separate page with the following sections:
\n
\n
Enum declaration
\n
Enum description
\n
Enum Constant Summary
\n
Enum Constant Detail
\n
\n
\n
\n
Tree (Class Hierarchy)
\n
There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
\n
\n
When viewing the Overview page, clicking on \"Tree\" displays the hierarchy for all packages.
\n
When viewing a particular package, class or interface page, clicking \"Tree\" displays the hierarchy for only that package.
\n
\n
\n
\n
Deprecated API
\n
The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
\n
\n
\n
Index
\n
The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
\n
\n
\n
Prev/Next
\n
These links take you to the next or previous class, interface, package, or related page.
\n
\n
\n
Frames/No Frames
\n
These links show and hide the HTML frames. All pages are available with or without frames.
\n
\n
\n
All Classes
\n
The All Classes link shows all classes and interfaces except non-static nested types.
\n
\n
\n
Serialized Form
\n
Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking \"Serialized Form\" in the \"See also\" section of the class description.
Rounds the specified BigDecimal to the relative precision and if close to 0 the absolute precision of the specified MathContext including trailing zeroes.
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
public final class BigComplex\nextends java.lang.Object
\n
Represents a complex number consisting of a real and an imaginary BigDecimal part in the form a + bi.\n\n
It generally follows the design of BigDecimal with some convenience improvements like overloaded operator methods.
\n\n
The biggest difference to BigDecimal is that BigComplex.equals(Object) implements the mathematical equality\n and not the strict technical equality.\n This was a difficult decision because it means that BigComplex behaves slightly different than BigDecimal\n but considering that the strange equality of BigDecimal is a major source of bugs we\n decided it was worth the slight inconsistency.\n If you need the strict equality use strictEquals(Object)`.
\n\n
This class is immutable and therefore inherently thread safe.
Contrary to BigDecimal.equals(Object) this method implements mathematical equality\n (by calling BigDecimal.compareTo(BigDecimal) on the real and imaginary parts)\n instead of strict equality.
public static BigComplex factorial(BigComplex x,\n java.math.MathContext mathContext)
\n
Calculates the factorial of the specified BigComplex.\n\n
This implementation uses\n Spouge's approximation\n to calculate the factorial for non-integer values.
\n\n
This involves calculating a series of constants that depend on the desired precision.\n Since this constant calculation is quite expensive (especially for higher precisions),\n the constants for a specific precision will be cached\n and subsequent calls to this method with the same precision will be much faster.
\n\n
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n and to avoid calling it with many different precisions.
public static BigComplex gamma(BigComplex x,\n java.math.MathContext mathContext)
\n
Calculates the gamma function of the specified BigComplex.\n\n
This implementation uses factorial(BigComplex, MathContext) internally,\n therefore the performance implications described there apply also for this method.\n\n
public static java.math.BigDecimal toBigDecimal(java.lang.String string)
\n
Creates a BigDecimal from the specified String representation.\n\n
This method is equivalent to the String constructor BigDecimal.BigDecimal(String)\n but has been optimized for large strings (several thousand digits).
\n
\n
Parameters:
\n
string - the String representation
\n
Returns:
\n
the created BigDecimal
\n
Throws:
\n
java.lang.NumberFormatException - if string is not a valid representation of a BigDecimal
public static java.math.BigDecimal toBigDecimal(java.lang.String string,\n java.math.MathContext mathContext)
\n
Creates a BigDecimal from the specified String representation.\n\n
This method is equivalent to the String constructor BigDecimal.BigDecimal(String, MathContext)\n but has been optimized for large strings (several thousand digits).
\n
\n
Parameters:
\n
string - the string representation
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the created BigDecimal
\n
Throws:
\n
java.lang.NumberFormatException - if string is not a valid representation of a BigDecimal
\n
java.lang.ArithmeticException - if the result is inexact but the rounding mode is UNNECESSARY
public static boolean isDoubleValue(java.math.BigDecimal value)
\n
Returns whether the specified BigDecimal value can be represented as double.\n\n
If this returns true you can call BigDecimal.doubleValue()\n without fear of getting Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY as result.
\n\n
Example: BigDecimalMath.isDoubleValue(new BigDecimal(\"1E309\")) returns false,\n because new BigDecimal(\"1E309\").doubleValue() returns Infinity.
\n\n
Note: This method does not check for possible loss of precision.
\n\n
For example BigDecimalMath.isDoubleValue(new BigDecimal(\"1.23400000000000000000000000000000001\")) will return true,\n because new BigDecimal(\"1.23400000000000000000000000000000001\").doubleValue() returns a valid double value,\n although it loses precision and returns 1.234.
\n\n
BigDecimalMath.isDoubleValue(new BigDecimal(\"1E-325\")) will return true\n although this value is smaller than Double.MIN_VALUE (and therefore outside the range of values that can be represented as double)\n because new BigDecimal(\"1E-325\").doubleValue() returns 0 which is a legal value with loss of precision.
\n
\n
Parameters:
\n
value - the BigDecimal to check
\n
Returns:
\n
true if the value can be represented as double value
public static java.math.BigDecimal reciprocal(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the reciprocal of the specified BigDecimal.
\n
\n
Parameters:
\n
x - the BigDecimal
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the reciprocal BigDecimal
\n
Throws:
\n
java.lang.ArithmeticException - if x = 0
\n
java.lang.ArithmeticException - if the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
public static java.math.BigDecimal factorial(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the factorial of the specified BigDecimal.\n\n
This implementation uses\n Spouge's approximation\n to calculate the factorial for non-integer values.
\n\n
This involves calculating a series of constants that depend on the desired precision.\n Since this constant calculation is quite expensive (especially for higher precisions),\n the constants for a specific precision will be cached\n and subsequent calls to this method with the same precision will be much faster.
\n\n
It is therefore recommended to do one call to this method with the standard precision of your application during the startup phase\n and to avoid calling it with many different precisions.
public static java.math.BigDecimal gamma(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Calculates the gamma function of the specified BigDecimal.\n\n
This implementation uses factorial(BigDecimal, MathContext) internally,\n therefore the performance implications described there apply also for this method.\n\n
n - the index of the Bernoulli number to be calculated (starting at 0)
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
the Bernoulli number for the specified index
\n
Throws:
\n
java.lang.ArithmeticException - if x < 0
\n
java.lang.ArithmeticException - if the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
the calculated x to the power of y with the precision specified in the mathContext
\n
Throws:
\n
java.lang.ArithmeticException - if y is negative and the result is inexact but the\n rounding mode is UNNECESSARY or\n mc.precision == 0 and the quotient has a\n non-terminating decimal expansion.
\n
java.lang.ArithmeticException - if the rounding mode is\n UNNECESSARY and the\n BigDecimal operation would require rounding.
public static java.math.BigDecimal toDegrees(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
Converts an angle measured in radians to an approximately equivalent angle measured in degrees.\n The conversion from radians to degrees is generally inexact, it uses the number PI with the precision specified in the mathContext.
\n
\n
Parameters:
\n
x - An angle in radians.
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
The angle in degrees.
\n
Throws:
\n
java.lang.UnsupportedOperationException - if the MathContext has unlimited precision
public static java.math.BigDecimal toRadians(java.math.BigDecimal x,\n java.math.MathContext mathContext)
\n
/**\n Converts an angle measured in degrees to an approximately equivalent angle measured in radians.\n The conversion from degrees to radians is generally inexact, it uses the number PI with the precision specified in the mathContext.
\n
\n
Parameters:
\n
x - An angle in degrees.
\n
mathContext - the MathContext used for the result
\n
Returns:
\n
The angle in radians.
\n
Throws:
\n
java.lang.UnsupportedOperationException - if the MathContext has unlimited precision
public class BigRational\nextends java.lang.Number\nimplements java.lang.Comparable<BigRational>, java.io.Serializable
\n
A rational number represented as a quotient of two values.\n \n
Basic calculations with rational numbers (+ - * /) have no loss of precision.\n This allows to use BigRational as a replacement for BigDecimal if absolute accuracy is desired.
The values are internally stored as BigDecimal (for performance optimizations) but represented\n as BigInteger (for mathematical correctness)\n when accessed with getNumeratorBigInteger() and getDenominatorBigInteger().
\n \n
The following basic calculations have no loss of precision:
Any BigRational value can be converted into an arbitrary precision (number of significant digits)\n or scale (number of digits after the decimal point).
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".\n \n
The integer part is omitted if it is 0 (when this absolute rational number is smaller than 1).
\n
The fraction part is omitted it it is 0 (when this rational number is an integer).
\n
If this rational number is 0, then \"0\" is returned.
public static BigRational valueOf(int integer,\n int fractionNumerator,\n int fractionDenominator)
\n
Creates a rational number of the specified integer and fraction parts.\n \n
Useful to create numbers like 3 1/2 (= three and a half = 3.5) by calling\n BigRational.valueOf(3, 1, 2).
\n
To create a negative rational only the integer part argument is allowed to be negative:\n to create -3 1/2 (= minus three and a half = -3.5) call BigRational.valueOf(-3, 1, 2).
\n
\n
Parameters:
\n
integer - the integer part int value
\n
fractionNumerator - the fraction part numerator int value (negative not allowed)
\n
fractionDenominator - the fraction part denominator int value (0 or negative not allowed)
\n
Returns:
\n
the rational number
\n
Throws:
\n
java.lang.ArithmeticException - if the fraction part denominator is 0 (division by zero),\n or if the fraction part numerator or denominator is negative
public class DefaultBigDecimalMath\nextends java.lang.Object
\n
A wrapper around BigDecimalMath that passes a current MathContext to the\n functions that need a MathContext argument.\n\n
The initial default MathContext is equivalent to MathContext.DECIMAL128\n but this can be overridden by setting the following system properties:
\n
\n
ch.obermuhlner.math.big.default.precision to a positive integer precision (default=34)
\n
ch.obermuhlner.math.big.default.rounding to a RoundingMode name (default=HALF_UP)
\n
\n\n
It is also possible to programmatically set the default MathContext using setDefaultMathContext(MathContext).\n It is recommended to set the desired precision in the MathContext very early in the startup of the application and to not change it afterwards.
\n\n
Important: Avoid the pitfall of setting the precision temporarily using setDefaultMathContext(MathContext) for a calculation.\n This can lead to race conditions and calculations with the wrong precision\n if other threads in your application do the same thing.
\n\n
To set a temporary MathContext you have to choice to use either:\n
\n
DefaultBigDecimalMath.createLocalMathContext() in a try-with-resources statement
\n
DefaultBigDecimalMath.withLocalMathContext() with a lambda function
\n
\n\n Example code using DefaultBigDecimalMath.createLocalMathContext():\n
The temporary MathContext are stored in ThreadLocal variables\n and will therefore not conflict with each other when used in multi-threaded use case.
\n\n
Important: Due to the ThreadLocal variables the local MathContext will\n not be available in other threads.\n This includes streams using parallel(), thread pools and manually started threads.\n If you need temporary MathContext for calculations then you must\n set the local MathContext inside every separate thread.
Constructs a SeriesCalculator with control over whether the sum terms are calculated in pairs.\n \n
Calculation of pairs is useful for taylor series where the terms alternate the sign.\n In these cases it is more efficient to calculate two terms at once check then whether the acceptable error has been reached.
\n
\n
Parameters:
\n
calculateInPairs - true to calculate the terms in pairs, false to calculate single terms
Returns the factor of the term with specified index.\n\n All mutable state of this class (and all its subclasses) must be modified in this method.\n This method is synchronized to allow thread-safe usage of this class.
public static java.util.stream.Stream<java.math.BigDecimal> range(long startInclusive,\n long endExclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endExclusive (exclusive) by an incremental step.\n \n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endExclusive - the exclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
public static java.util.stream.Stream<java.math.BigDecimal> rangeClosed(long startInclusive,\n long endInclusive,\n long step,\n java.math.MathContext mathContext)
\n
Returns a sequential ordered Stream<BigDecimal> from startInclusive\n (inclusive) to endInclusive (inclusive) by an incremental step.\n\n
The long arguments are converted using BigDecimal.valueOf(long).
\n
\n
Parameters:
\n
startInclusive - the (inclusive) initial value
\n
endInclusive - the inclusive upper bound
\n
step - the step between elements
\n
mathContext - the MathContext used for all mathematical operations
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
\n
\n
\n
\n
\n
Overview
\n
The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.
\n
\n
\n
Package
\n
Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:
\n
\n
Interfaces (italic)
\n
Classes
\n
Enums
\n
Exceptions
\n
Errors
\n
Annotation Types
\n
\n
\n
\n
Class/Interface
\n
Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
\n
\n
Class inheritance diagram
\n
Direct Subclasses
\n
All Known Subinterfaces
\n
All Known Implementing Classes
\n
Class/interface declaration
\n
Class/interface description
\n
\n
\n
Nested Class Summary
\n
Field Summary
\n
Constructor Summary
\n
Method Summary
\n
\n
\n
Field Detail
\n
Constructor Detail
\n
Method Detail
\n
\n
Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
\n
\n
\n
Annotation Type
\n
Each annotation type has its own separate page with the following sections:
\n
\n
Annotation Type declaration
\n
Annotation Type description
\n
Required Element Summary
\n
Optional Element Summary
\n
Element Detail
\n
\n
\n
\n
Enum
\n
Each enum has its own separate page with the following sections:
\n
\n
Enum declaration
\n
Enum description
\n
Enum Constant Summary
\n
Enum Constant Detail
\n
\n
\n
\n
Tree (Class Hierarchy)
\n
There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
\n
\n
When viewing the Overview page, clicking on \"Tree\" displays the hierarchy for all packages.
\n
When viewing a particular package, class or interface page, clicking \"Tree\" displays the hierarchy for only that package.
\n
\n
\n
\n
Deprecated API
\n
The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
\n
\n
\n
Index
\n
The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
\n
\n
\n
Prev/Next
\n
These links take you to the next or previous class, interface, package, or related page.
\n
\n
\n
Frames/No Frames
\n
These links show and hide the HTML frames. All pages are available with or without frames.
\n
\n
\n
All Classes
\n
The All Classes link shows all classes and interfaces except non-static nested types.
\n
\n
\n
Serialized Form
\n
Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking \"Serialized Form\" in the \"See also\" section of the class description.
Returns the string representation of this rational number as integer and fraction parts in the form \"integerPart fractionNominator/fractionDenominator\".
![\"big-math\"](\"docs/images/big-math-splashscreen.png\")
\n![\"big-math\"](\"images/big-math-splashscreen.png\")
\n