pax_global_header 0000666 0000000 0000000 00000000064 15113064030 0014503 g ustar 00root root 0000000 0000000 52 comment=4047e2ecdf6bd7f9df13e4700703dd46437edc2e
apfloat-1.15.0/ 0000775 0000000 0000000 00000000000 15113064030 0013215 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/.github/ 0000775 0000000 0000000 00000000000 15113064030 0014555 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/.github/workflows/ 0000775 0000000 0000000 00000000000 15113064030 0016612 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/.github/workflows/maven.yml 0000664 0000000 0000000 00000002267 15113064030 0020452 0 ustar 00root root 0000000 0000000 # This workflow will build a Java project with Maven, and cache/restore any dependencies to improve the workflow execution time
# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-maven
# This workflow uses actions that are not certified by GitHub.
# They are provided by a third-party and are governed by
# separate terms of service, privacy policy, and support
# documentation.
name: Java CI with Maven
on:
push:
branches: [ "main" ]
pull_request:
branches: [ "main" ]
permissions:
contents: write
security-events: write
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up JDK 21
uses: actions/setup-java@v4
with:
java-version: '21'
distribution: 'corretto'
check-latest: true
cache: maven
- name: Build with Maven
run: mvn -B clean package -Dgpg.skip -Djarsigner.skip
# Optional: Uploads the full dependency graph to GitHub to improve the quality of Dependabot alerts this repository can receive
- name: Update dependency graph
uses: advanced-security/maven-dependency-submission-action@v4
apfloat-1.15.0/.gitignore 0000664 0000000 0000000 00000000213 15113064030 0015201 0 ustar 00root root 0000000 0000000 # Eclipse
.classpath
.metadata/
.project
.settings/
# Intellij
.idea/
*.iml
*.iws
# Mac
.DS_Store
# Maven
log/
target/
apfloat-1.15.0/LICENSE.txt 0000664 0000000 0000000 00000002101 15113064030 0015032 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) 2025 Mikko Tommila
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. apfloat-1.15.0/README.md 0000664 0000000 0000000 00000002151 15113064030 0014473 0 ustar 00root root 0000000 0000000 # Apfloat
Copyright © 2025 Mikko Tommila
This work is licensed under the terms of the MIT license. See the [MIT License](LICENSE.txt) for more details.
If you have any questions or need a different type of license, please [contact the author](mailto:Mikko.Tommila@apfloat.org).
## Building the Library
To build the library quickly, without running unit tests (takes about 20 minutes) and without signing with GPG run:
`mvn clean install -Dgpg.skip -Djarsigner.skip -DskipTests`
To build the signed applet files, you need to first generate a signing key, e.g. with:
`keytool -genkeypair -validity 21915 -dname "cn=Your Name, o=example.com" -storepass password -keypass password -alias mykey`
and then build without -Djarsigner.skip.
## Running the Sample Applications
To run the arbitrary precision calculator, run:
`mvn -pl :apfloat-calc exec:java -Dexec.mainClass=org.apfloat.calc.CalculatorGUI`
To run the pi calculator, run:
`mvn -pl :apfloat-samples exec:java -Dexec.mainClass=org.apfloat.samples.PiParallelGUI`
## Apfloat website
Go to the [apfloat for Java website](https://www.apfloat.org/apfloat_java/).
apfloat-1.15.0/apfloat-aparapi/ 0000775 0000000 0000000 00000000000 15113064030 0016256 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/pom.xml 0000664 0000000 0000000 00000005074 15113064030 0017601 0 ustar 00root root 0000000 0000000
4.0.0
org.apfloat
apfloat-parent
1.15.0
apfloat-aparapi
apfloat-aparapi
Fast number theoretic transform implementation using Aparapi
https://www.apfloat.org
org.apfloat
apfloat
com.aparapi
aparapi
junit
junit
test
org.apfloat
apfloat
test-jar
test
biz.aQute.bnd
bnd-maven-plugin
generate-osgi-manifest
bnd-process
org.apache.maven.plugins
maven-jar-plugin
${project.build.outputDirectory}/META-INF/MANIFEST.MF
org.apache.maven.plugins
maven-shade-plugin
shade
org.apfloat:apfloat-aparapi
${project.build.directory}/apfloat-aparapi.jar
apfloat-1.15.0/apfloat-aparapi/src/ 0000775 0000000 0000000 00000000000 15113064030 0017045 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/ 0000775 0000000 0000000 00000000000 15113064030 0017771 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/java/ 0000775 0000000 0000000 00000000000 15113064030 0020712 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/java/org/ 0000775 0000000 0000000 00000000000 15113064030 0021501 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/ 0000775 0000000 0000000 00000000000 15113064030 0023127 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/ 0000775 0000000 0000000 00000000000 15113064030 0024544 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/ColumnSixStepFNTStrategy.java 0000664 0000000 0000000 00000006404 15113064030 0032263 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2023 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.spi.ArrayAccess;
import org.apfloat.spi.MatrixStrategy;
import org.apfloat.spi.NTTStepStrategy;
import org.apfloat.internal.SixStepFNTStrategy;
/**
* Six-step NTT implementation that processes the data in the columns of the matrix.
*
* This transform only works together with an {@link NTTStepStrategy} implementation
* that processes the data in columns instead of rows and a {@link MatrixStrategy}
* implementation that can transpose the data.
*
* The data size should be sufficiently large to meet the parallelization needs of the GPU.
* The GPU global size i.e. the number of columns in the data matrix should be at least 1024.
*
* @since 1.8.3
* @version 1.8.3
* @author Mikko Tommila
*/
public class ColumnSixStepFNTStrategy
extends SixStepFNTStrategy
{
/**
* Basic constructor.
*
* @param stepStrategy A step strategy that can process data in columns.
* @param matrixStrategy A matrix strategy that can process the data.
*/
public ColumnSixStepFNTStrategy(NTTStepStrategy stepStrategy, MatrixStrategy matrixStrategy)
{
super.stepStrategy = stepStrategy;
super.matrixStrategy = matrixStrategy;
}
@Override
protected void transposeInitial(ArrayAccess arrayAccess, int n1, int n2, boolean isInverse)
{
// Omitted as we want to process the columns, not rows
}
@Override
protected void transposeMiddle(ArrayAccess arrayAccess, int n1, int n2, boolean isInverse)
{
// Matrix is in transposed form compared to the normal six-step algorithm, so swap n1 and n2
super.transposeMiddle(arrayAccess, n2, n1, isInverse);
}
@Override
protected void multiplyElements(ArrayAccess arrayAccess, int rows, int columns, long length, long totalTransformLength, boolean isInverse, int modulus)
{
// Matrix is in transposed form compared to the normal six-step algorithm, so swap rows and columns
super.multiplyElements(arrayAccess, columns, rows, length, totalTransformLength, isInverse, modulus);
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/ColumnTwoPassFNTStrategy.java 0000664 0000000 0000000 00000007106 15113064030 0032264 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2023 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.internal.TwoPassFNTStrategy;
import org.apfloat.spi.ArrayAccess;
import org.apfloat.spi.DataStorage;
import org.apfloat.spi.NTTStepStrategy;
/**
* Two-pass NTT implementation that processes the data in the columns of the matrix.
*
* This transform only works together with an {@link NTTStepStrategy} implementation
* that processes the data in columns instead of rows.
*
* Note that if the data size is too big compared to the maximum available memory then the
* data is read from disk in too thin slices and the level of parallelism may become too
* small for the GPU, ruining the performance. The GPU global size i.e. the number of columns
* read from the data matrix to memory at one time should be at least 1024.
*
* @since 1.8.3
* @version 1.8.3
* @author Mikko Tommila
*/
public class ColumnTwoPassFNTStrategy
extends TwoPassFNTStrategy
{
/**
* Basic constructor.
*
* @param stepStrategy A step strategy that can process data in columns.
*/
public ColumnTwoPassFNTStrategy(NTTStepStrategy stepStrategy)
{
// Note that there is no defaultStrategy here; if we get to the two-pass algorithm then we
// assume that the data size is always "big enough" for a sufficient level of parallelism on the GPU
super.stepStrategy = stepStrategy;
}
@Override
protected ArrayAccess getColumns(DataStorage dataStorage, int startColumn, int columns, int rows)
{
// Get columns un-transposed
return dataStorage.getArray(DataStorage.READ_WRITE, startColumn, columns, rows);
}
@Override
protected ArrayAccess getRows(DataStorage dataStorage, int startRow, int rows, int columns)
{
// Get rows transposed as we want to organize the data in columns
return dataStorage.subsequence(startRow * columns, rows * columns).getTransposedArray(DataStorage.READ_WRITE, 0, columns, rows);
}
@Override
protected void multiplyElements(ArrayAccess arrayAccess, int startRow, int startColumn, int rows, int columns, long length, long totalTransformLength, boolean isInverse, int modulus)
{
// Data is processed in transposed form compared to the normal two-pass algorithm, so swap rows and columns
super.multiplyElements(arrayAccess, startColumn, startRow, columns, rows, length, totalTransformLength, isInverse, modulus);
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/DecorableFactor3NTTStrategy.java 0000664 0000000 0000000 00000007774 15113064030 0032641 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.ApfloatRuntimeException;
import org.apfloat.internal.ApfloatInternalException;
import org.apfloat.internal.DecorableNTTStrategy;
import org.apfloat.internal.Factor3NTTStrategy;
import org.apfloat.spi.ArrayAccess;
import org.apfloat.spi.DataStorage;
import org.apfloat.spi.Factor3NTTStepStrategy;
import org.apfloat.spi.NTTStrategy;
/**
* Factor-3 NTT strategy that can be decorated.
*
* @since 1.15.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class DecorableFactor3NTTStrategy
extends Factor3NTTStrategy
implements DecorableNTTStrategy
{
/**
* Creates a new factor-3 transform strategy on top of an existing transform.
* The underlying transform needs to be capable of only doing transforms of
* length 2n.
*
* @param factor2Strategy The underlying transformation strategy, that can be capable of only doing radix-2 transforms.
*/
public DecorableFactor3NTTStrategy(NTTStrategy factor2Strategy)
{
super(factor2Strategy);
}
/**
* Creates a new factor-3 transform strategy on top of an existing factor-2 transform and a factor-3 step strategy.
*
* @param factor2Strategy The underlying transformation strategy, that can be capable of only doing radix-2 transforms.
* @param stepStrategy The factor-3 step strategy.
*/
public DecorableFactor3NTTStrategy(NTTStrategy factor2Strategy, Factor3NTTStepStrategy stepStrategy)
{
super(factor2Strategy, stepStrategy);
}
@Override
public void transform(DataStorage dataStorage, int modulus)
throws ApfloatRuntimeException
{
preTransform(dataStorage);
super.transform(dataStorage, modulus);
postTransform(dataStorage);
}
@Override
public void inverseTransform(DataStorage dataStorage, int modulus, long totalTransformLength)
throws ApfloatRuntimeException
{
preTransform(dataStorage);
super.inverseTransform(dataStorage, modulus, totalTransformLength);
postTransform(dataStorage);
}
private void preTransform(DataStorage dataStorage)
{
long length = dataStorage.getSize();
if (length > Integer.MAX_VALUE)
{
throw new ApfloatInternalException("Maximum array length exceeded: " + length);
}
ArrayAccess arrayAccess = dataStorage.getArray(DataStorage.READ_WRITE, 0, (int) length);
preTransform(arrayAccess);
}
private void postTransform(DataStorage dataStorage)
{
long length = dataStorage.getSize();
assert (length <= Integer.MAX_VALUE);
ArrayAccess arrayAccess = dataStorage.getArray(DataStorage.READ_WRITE, 0, (int) length);
postTransform(arrayAccess);
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/IntAparapiBuilderFactory.java 0000664 0000000 0000000 00000003715 15113064030 0032304 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.ApfloatContext;
import org.apfloat.spi.NTTBuilder;
import org.apfloat.internal.IntBuilderFactory;
/**
* Builder factory for aparapi transform implementations for the int element type.
*
* @since 1.8.3
* @version 1.15.0
* @author Mikko Tommila
*/
public class IntAparapiBuilderFactory
extends IntBuilderFactory
{
/**
* Default constructor.
*/
public IntAparapiBuilderFactory()
{
boolean rowOrientation = Boolean.parseBoolean(ApfloatContext.getContext().getProperty("rowOrientation"));
this.nttBuilder = new IntAparapiNTTBuilder(rowOrientation);
}
@Override
public NTTBuilder getNTTBuilder()
{
return this.nttBuilder;
}
private NTTBuilder nttBuilder;
}
IntAparapiColumnSixStepFNTStrategy.java 0000664 0000000 0000000 00000003250 15113064030 0034151 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
/**
* Six-step NTT implementation for the int element type using column orientation.
*
* @since 1.15.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class IntAparapiColumnSixStepFNTStrategy
extends ColumnSixStepFNTStrategy
implements IntAparapiNTTStrategy
{
/**
* Default constructor.
*/
public IntAparapiColumnSixStepFNTStrategy()
{
super(new IntAparapiNTTStepStrategy(false), new IntAparapiMatrixStrategy());
}
}
IntAparapiColumnTwoPassFNTStrategy.java 0000664 0000000 0000000 00000003210 15113064030 0034146 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
/**
* Two-pass NTT implementation for the int element type using column orientation.
*
* @since 1.15.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class IntAparapiColumnTwoPassFNTStrategy
extends ColumnTwoPassFNTStrategy
implements IntAparapiNTTStrategy
{
/**
* Default constructor.
*/
public IntAparapiColumnTwoPassFNTStrategy()
{
super(new IntAparapiNTTStepStrategy(false));
}
}
IntAparapiFactor3NTTStepStrategy.java 0000664 0000000 0000000 00000010354 15113064030 0033552 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2023 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.ApfloatRuntimeException;
import org.apfloat.spi.ArrayAccess;
import org.apfloat.spi.DataStorage;
import com.aparapi.Range;
import org.apfloat.internal.ApfloatInternalException;
import org.apfloat.internal.IntFactor3NTTStepStrategy;
import static org.apfloat.internal.IntModConstants.*;
/**
* Steps for the factor-3 NTT using the GPU, for the int element type.
*
* @since 1.8.3
* @version 1.8.3
* @author Mikko Tommila
*/
public class IntAparapiFactor3NTTStepStrategy
extends IntFactor3NTTStepStrategy
{
@Override
public void transformColumns(DataStorage dataStorage0, DataStorage dataStorage1, DataStorage dataStorage2, long startColumn, long columns, long power2length, long length, boolean isInverse, int modulus)
throws ApfloatRuntimeException
{
// Transform length is three times a power of two
assert (length == 3 * power2length);
// Check that the data storages use consecutive sections of the same memory array
if (!dataStorage0.isCached() || !dataStorage1.isCached() || !dataStorage2.isCached() ||
startColumn > Integer.MAX_VALUE || columns > Integer.MAX_VALUE)
{
throw new ApfloatInternalException("Data must be stored in memory");
}
ArrayAccess arrayAccess0 = dataStorage0.getArray(DataStorage.READ_WRITE, startColumn, (int) columns),
arrayAccess1 = dataStorage1.getArray(DataStorage.READ_WRITE, startColumn, (int) columns),
arrayAccess2 = dataStorage2.getArray(DataStorage.READ_WRITE, startColumn, (int) columns);
if (arrayAccess0.getIntData() != arrayAccess1.getIntData() || arrayAccess1.getIntData() != arrayAccess2.getIntData() ||
arrayAccess1.getOffset() != arrayAccess0.getOffset() + columns || arrayAccess2.getOffset() != arrayAccess1.getOffset() + columns)
{
throw new ApfloatInternalException("Data must be stored consecutively in memory");
}
setModulus(MODULUS[modulus]); // Modulus
int w = (isInverse ?
getInverseNthRoot(PRIMITIVE_ROOT[modulus], length) :
getForwardNthRoot(PRIMITIVE_ROOT[modulus], length)), // Forward/inverse n:th root
w3 = modPow(w, (int) power2length), // Forward/inverse 3rd root
ww = modMultiply(w, w),
w1 = negate(modDivide((int) 3, (int) 2)),
w2 = modAdd(w3, modDivide((int) 1, (int) 2));
IntKernel kernel = IntKernel.getInstance();
kernel.setOp(isInverse ? IntKernel.INVERSE_TRANSFORM_COLUMNS : IntKernel.TRANSFORM_COLUMNS);
kernel.setArrayAccess(arrayAccess0);
kernel.setStartColumn((int) startColumn);
kernel.setColumns((int) columns);
kernel.setW(w);
kernel.setWw(ww);
kernel.setW1(w1);
kernel.setW2(w2);
kernel.setModulus(MODULUS[modulus]);
Range range = RangeHelper.create((int) columns);
kernel.execute(range);
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/IntAparapiFactor3NTTStrategy.java 0000664 0000000 0000000 00000003744 15113064030 0033002 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.spi.NTTStrategy;
/**
* Factor-3 NTT implementation for the int element type.
*
* @since 1.8.3
* @version 1.15.0
* @author Mikko Tommila
*/
public class IntAparapiFactor3NTTStrategy
extends DecorableFactor3NTTStrategy
implements IntAparapiNTTStrategy
{
/**
* Creates a new factor-3 transform strategy on top of an existing transform.
* The underlying transform needs to be capable of only doing transforms of
* length 2n.
*
* @param factor2Strategy The underlying transformation strategy, that can be capable of only doing radix-2 transforms.
*/
public IntAparapiFactor3NTTStrategy(NTTStrategy factor2Strategy)
{
super(factor2Strategy, new IntAparapiFactor3NTTStepStrategy());
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/IntAparapiMatrixStrategy.java 0000664 0000000 0000000 00000015414 15113064030 0032354 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2023 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.ApfloatRuntimeException;
import org.apfloat.spi.ArrayAccess;
import org.apfloat.spi.MatrixStrategy;
import org.apfloat.internal.ApfloatInternalException;
import com.aparapi.Range;
/**
* Matrix transposition in the GPU for the int type.
*
* @since 1.8.3
* @version 1.8.3
* @author Mikko Tommila
*/
public class IntAparapiMatrixStrategy
implements MatrixStrategy
{
/**
* Default constructor.
*/
public IntAparapiMatrixStrategy()
{
}
@Override
public void transpose(ArrayAccess arrayAccess, int n1, int n2)
throws ApfloatRuntimeException
{
if (n1 != (n1 & -n1) ||
n2 != (n2 & -n2) ||
n1 <= 0 || n2 <= 0)
{
throw new ApfloatInternalException("Matrix size must be a power of two, not " + n1 + " x " + n2);
}
if (n1 == n2)
{
// Simply transpose
transposeSquare(arrayAccess, n1, n1);
}
else if (n2 == 2 * n1)
{
// First transpose two n1 x n1 blocks
transposeSquare(arrayAccess, n1, n2);
transposeSquare(arrayAccess.subsequence(n1, arrayAccess.getLength() - n1), n1, n2);
// Then permute the rows to correct order
permuteToHalfWidth(arrayAccess, n1, n2);
}
else if (n1 == 2 * n2)
{
// First permute the rows to correct order
permuteToDoubleWidth(arrayAccess, n1, n2);
// Then transpose two n2 x n2 blocks
transposeSquare(arrayAccess, n2, n1);
transposeSquare(arrayAccess.subsequence(n2, arrayAccess.getLength() - n2), n2, n1);
}
else
{
throw new ApfloatInternalException("Must be n1 = n2, n1 = 2*n2 or n2 = 2*n1; matrix is " + n1 + " x " + n2);
}
}
@Override
public void transposeSquare(ArrayAccess arrayAccess, int n1, int n2)
throws ApfloatRuntimeException
{
IntKernel kernel = IntKernel.getInstance();
kernel.setOp(IntKernel.TRANSPOSE);
kernel.setArrayAccess(arrayAccess);
kernel.setN2(n2);
Range range = RangeHelper.create2D(n1, n1);
kernel.execute(range);
}
@Override
public void permuteToHalfWidth(ArrayAccess arrayAccess, int n1, int n2)
throws ApfloatRuntimeException
{
if (n1 != (n1 & -n1) ||
n2 != (n2 & -n2) ||
n1 <= 0 || n2 <= 0)
{
throw new ApfloatInternalException("Matrix size must be a power of two, not " + n1 + " x " + n2);
}
// Permute the rows of matrix to correct order, to make the n1 x n2 matrix half as wide (2*n1 x n2/2)
if (n1 < 2)
{
return;
}
int twicen1 = 2 * n1;
boolean[] isRowDone = new boolean[twicen1];
int[] index = new int[twicen1 * 2]; // Overly big but twicen1 just isn't enough
int j = 1,
p = 0;
do
{
int m = j;
index[p++] = m;
isRowDone[m] = true;
m = (m < n1 ? 2 * m : 2 * (m - n1) + 1);
while (m != j)
{
isRowDone[m] = true;
index[p++] = m;
m = (m < n1 ? 2 * m : 2 * (m - n1) + 1);
}
index[p++] = 0;
while (isRowDone[j])
{
j++;
}
} while (j < twicen1 - 1);
IntKernel kernel = IntKernel.getInstance();
kernel.setOp(IntKernel.PERMUTE);
kernel.setArrayAccess(arrayAccess);
kernel.setN2(n2 / 2);
kernel.setIndex(index);
kernel.setIndexCount(p);
kernel.put(index);
Range range = RangeHelper.create(n2 / 2);
kernel.execute(range);
}
@Override
public void permuteToDoubleWidth(ArrayAccess arrayAccess, int n1, int n2)
throws ApfloatRuntimeException
{
if (n1 != (n1 & -n1) ||
n2 != (n2 & -n2) ||
n1 <= 0 || n2 <= 0)
{
throw new ApfloatInternalException("Matrix size must be a power of two, not " + n1 + " x " + n2);
}
if (n1 < 2)
{
throw new ApfloatInternalException("Matrix height must be at least 2.");
}
// Permute the rows of matrix to correct order, to make the n1 x n2 matrix twice as wide (n1/2 x 2*n2)
if (n1 < 4)
{
return;
}
int halfn1 = n1 / 2;
boolean[] isRowDone = new boolean[n1];
int[] index = new int[n1 * 2]; // Overly big but n1 just isn't enough
int j = 1,
p = 0;
do
{
int m = j;
index[p++] = m;
isRowDone[m] = true;
m = ((m & 1) != 0 ? m / 2 + halfn1 : m / 2);
while (m != j)
{
isRowDone[m] = true;
index[p++] = m;
m = ((m & 1) != 0 ? m / 2 + halfn1 : m / 2);
}
index[p++] = 0;
while (isRowDone[j])
{
j++;
}
} while (j < n1 - 1);
IntKernel kernel = IntKernel.getInstance();
kernel.setOp(IntKernel.PERMUTE);
kernel.setArrayAccess(arrayAccess);
kernel.setN2(n2);
kernel.setIndex(index);
kernel.setIndexCount(p);
kernel.put(index);
Range range = RangeHelper.create(n2);
kernel.execute(range);
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/IntAparapiNTTBuilder.java 0000664 0000000 0000000 00000006403 15113064030 0031337 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.spi.BuilderFactory;
import org.apfloat.spi.NTTStrategy;
import org.apfloat.ApfloatContext;
import org.apfloat.internal.IntNTTBuilder;
/**
* NTT Builder for aparapi transform implementations for the int element type.
*
* @since 1.8.3
* @version 1.15.0
* @author Mikko Tommila
*/
public class IntAparapiNTTBuilder
extends IntNTTBuilder
{
private static final int MIN_GPU_LENGTH = 1048576;
/**
* Basic constructor.
*
* @param rowOrientation If the data is using row orientation.
*/
public IntAparapiNTTBuilder(boolean rowOrientation)
{
this.rowOrientation = rowOrientation;
}
@Override
protected NTTStrategy createSixStepFNTStrategy(long size)
{
long length = size;
if (length < MIN_GPU_LENGTH)
{
return super.createSixStepFNTStrategy(size);
}
return this.rowOrientation ? new IntAparapiSixStepFNTStrategy() : new IntAparapiColumnSixStepFNTStrategy();
}
@Override
protected NTTStrategy createTwoPassFNTStrategy(long size)
{
long length = size;
if (length < MIN_GPU_LENGTH)
{
return super.createTwoPassFNTStrategy(size);
}
return (this.rowOrientation ? new IntAparapiTwoPassFNTStrategy() : new IntAparapiColumnTwoPassFNTStrategy());
}
@Override
protected NTTStrategy createFactor3NTTStrategy(long size, NTTStrategy nttStrategy)
{
if (nttStrategy instanceof IntAparapiNTTStrategy)
{
ApfloatContext ctx = ApfloatContext.getContext();
BuilderFactory builderFactory = ctx.getBuilderFactory();
long maxMemoryBlockSize = ctx.getMaxMemoryBlockSize() / builderFactory.getElementSize();
if (size <= maxMemoryBlockSize && size <= Integer.MAX_VALUE)
{
return new IntAparapiFactor3NTTStrategy(nttStrategy);
}
}
return super.createFactor3NTTStrategy(size, nttStrategy);
}
private boolean rowOrientation;
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/IntAparapiNTTStepStrategy.java 0000664 0000000 0000000 00000012524 15113064030 0032410 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.ApfloatRuntimeException;
import org.apfloat.spi.ArrayAccess;
import com.aparapi.Range;
import org.apfloat.internal.IntNTTStepStrategy;
import org.apfloat.internal.IntWTables;
import org.apfloat.internal.Scramble;
import static org.apfloat.internal.IntModConstants.*;
import org.apfloat.ApfloatContext;
/**
* NTT steps for the int element type aparapi transforms.
*
* @since 1.8.3
* @version 1.15.0
* @author Mikko Tommila
*/
public class IntAparapiNTTStepStrategy
extends IntNTTStepStrategy
{
/**
* Basic constructor.
*
* @param rowOrientation If the data is using row orientation.
*/
public IntAparapiNTTStepStrategy(boolean rowOrientation)
{
this.rowOrientation = rowOrientation;
}
@Override
public void multiplyElements(ArrayAccess arrayAccess, int startRow, int startColumn, int rows, int columns, long length, long totalTransformLength, boolean isInverse, int modulus)
throws ApfloatRuntimeException
{
setModulus(MODULUS[modulus]);
int w = (isInverse ?
getInverseNthRoot(PRIMITIVE_ROOT[modulus], length) :
getForwardNthRoot(PRIMITIVE_ROOT[modulus], length));
int scaleFactor = (isInverse ?
modDivide((int) 1, (int) totalTransformLength) :
(int) 1);
IntKernel kernel = IntKernel.getInstance();
kernel.setOp(IntKernel.MULTIPLY_ELEMENTS);
kernel.setArrayAccess(arrayAccess);
kernel.setStartRow(startRow);
kernel.setStartColumn(startColumn);
kernel.setRows(rows);
kernel.setColumns(columns);
kernel.setW(w);
kernel.setScaleFactor(scaleFactor);
kernel.setModulus(MODULUS[modulus]);
Range range = RangeHelper.create(columns);
kernel.execute(range);
}
/**
* Transform the rows or columns of the data matrix.
* If the data is oriented in rows, transforms physically the rows.
* If the data is oriented in columns, transforms physically columns.
*
* @param arrayAccess The memory array to split and transform.
* @param length Length of one transform.
* @param count Number of transforms to be done.
* @param isInverse true if an inverse transform is performed, false if a forward transform is performed.
* @param permute If permutation should be done.
* @param modulus Index of the modulus.
*/
@Override
public void transformRows(ArrayAccess arrayAccess, int length, int count, boolean isInverse, boolean permute, int modulus)
throws ApfloatRuntimeException
{
int[] wTable = (isInverse ?
IntWTables.getInverseWTable(modulus, length) :
IntWTables.getWTable(modulus, length));
int[] permutationTable = (permute ? Scramble.createScrambleTable(length) : null);
IntKernel kernel = IntKernel.getInstance();
kernel.setOp(this.rowOrientation ? (isInverse ? IntKernel.INVERSE_TRANSFORM_ROWS_ROWORIENTATION : IntKernel.TRANSFORM_ROWS_ROWORIENTATION) :
(isInverse ? IntKernel.INVERSE_TRANSFORM_ROWS_COLUMNORIENTATION : IntKernel.TRANSFORM_ROWS_COLUMNORIENTATION));
kernel.setLength(length);
kernel.setArrayAccess(arrayAccess);
kernel.setWTable(wTable);
kernel.setPermutationTable(permutationTable);
kernel.setModulus(MODULUS[modulus]);
kernel.put(wTable);
if (permutationTable != null)
{
kernel.put(permutationTable);
}
Range range;
if (this.rowOrientation)
{
int workGroupSize = Integer.parseInt(ApfloatContext.getContext().getProperty("workGroupSize", String.valueOf(RangeHelper.MAX_LOCAL_SIZE)));
int width = Math.min(length, workGroupSize);
range = Range.create2D(width, count, width, 1);
}
else
{
range = RangeHelper.create(count);
}
kernel.execute(range);
}
private boolean rowOrientation;
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/IntAparapiNTTStrategy.java 0000664 0000000 0000000 00000006524 15113064030 0031557 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import java.lang.ref.WeakReference;
import java.util.concurrent.atomic.AtomicInteger;
import org.apfloat.internal.NTTStrategyDecorator;
import org.apfloat.spi.ArrayAccess;
import org.apfloat.spi.NTTStrategy;
/**
* NTT strategy with decorator to set up the data for the GPU, for the int element type.
*
* @since 1.15.0
* @version 1.15.0
* @author Mikko Tommila
*/
public interface IntAparapiNTTStrategy
extends NTTStrategy, NTTStrategyDecorator
{
/**
* @hidden
*/
static final ThreadLocal LEVEL = ThreadLocal.withInitial(AtomicInteger::new);
/**
* @hidden
*/
static final ThreadLocal> DATA = ThreadLocal.withInitial(() -> new WeakReference<>(null));
@Override
default public void beforeTransform(ArrayAccess arrayAccess)
{
int[] data = arrayAccess.getIntData();
AtomicInteger currentLevel = LEVEL.get();
int[] currentData = DATA.get().get();
if (currentLevel.get() == 0 || data != currentData)
{
// If level is 0 then this is the outermost transform
IntKernel kernel = IntKernel.getInstance();
kernel.setExplicit(true);
kernel.put(data);
DATA.set(new WeakReference<>(data));
// If level is not 0 but we are not setting the same data, then something must have gone wrong previously, reset the level
currentLevel.set(0);
}
// If level is > 0 and we are just setting the same data again, then this is for a nested transform, increase nesting level and do nothing else
currentLevel.incrementAndGet();
}
@Override
default public void afterTransform(ArrayAccess arrayAccess)
{
AtomicInteger level = LEVEL.get();
// Decrement nesting level
int currentLevel = level.decrementAndGet();
// Only when we reach the outermost transform, get the data
if (currentLevel == 0)
{
IntKernel kernel = IntKernel.getInstance();
kernel.get(arrayAccess.getIntData());
kernel.cleanUpArrays();
}
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/IntAparapiSixStepFNTStrategy.java 0000664 0000000 0000000 00000003304 15113064030 0033052 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.internal.SixStepFNTStrategy;
/**
* Six-step NTT implementation for the int element type using row orientation.
*
* @since 1.8.3
* @version 1.15.0
* @author Mikko Tommila
*/
public class IntAparapiSixStepFNTStrategy
extends SixStepFNTStrategy
implements IntAparapiNTTStrategy
{
/**
* Default constructor.
*/
public IntAparapiSixStepFNTStrategy()
{
super(new IntAparapiNTTStepStrategy(true), new IntAparapiMatrixStrategy());
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/IntAparapiTwoPassFNTStrategy.java 0000664 0000000 0000000 00000003245 15113064030 0033057 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.internal.TwoPassFNTStrategy;
/**
* Two-pass NTT implementation for the int element type using row orientation.
*
* @since 1.15.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class IntAparapiTwoPassFNTStrategy
extends TwoPassFNTStrategy
implements IntAparapiNTTStrategy
{
/**
* Default constructor.
*/
public IntAparapiTwoPassFNTStrategy()
{
super(new IntAparapiNTTStepStrategy(true));
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/IntKernel.java 0000664 0000000 0000000 00000050647 15113064030 0027316 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import com.aparapi.Kernel;
import org.apfloat.ApfloatRuntimeException;
import org.apfloat.spi.ArrayAccess;
/**
* Kernel for the int element type. Contains everything needed for the NTT.
*
* There are two ways the data can be organized:
*
* - In columns: this is more efficient on older GPUs that don't have a cache
* - In rows: this is more efficient on newer GPUs that have large high-bandwidth caches
*
*
* When the data is organized in columns, the NTT algorithm makes O(log n) passes through
* the main memory of the GPU.
*
* When the data is organized in rows, and the GPU cache is sufficiently large, the algorithm
* makes a fixed number of passes through the main memory of the GPU (and O(log n) passes
* through the GPU cache.)
*
* Due to the extreme parallelization requirements (global size should be at lest 1024)
* this algorithm works efficiently only with 4 million decimal digit calculations or bigger.
* However with 4 million digits, it's only approximately as fast as the pure-Java
* version (depending on the GPU and CPU hardware). On the other hand, the algorithm
* mathematically only works up to about 226 million digits. So the useful range is only
* somewhere around 10-200 million digits.
*
* Some notes about the aparapi specific requirements for code that must be converted to OpenCL:
*
* assert() does not work- Can't check for null
* - Can't get array length
* - Arrays referenced by the kernel can't be null even if they are not accessed
* - Arrays referenced by the kernel can't be zero-length even if they are not accessed
* - Can't invoke methods in other classes e.g. enclosing class of an inner class
* - Early return statements do not work
* - Variables used inside loops must be initialized before the loop
* - Must compile the class with full debug information i.e. with
-g
*
*
* @since 1.8.3
* @version 1.15.0
* @author Mikko Tommila
*/
class IntKernel
extends Kernel
{
private IntKernel()
{
}
public static IntKernel getInstance()
{
return IntKernel.kernel.get();
}
private static ThreadLocal kernel = ThreadLocal.withInitial(IntKernel::new);
// Methods for calculating the column transforms in parallel
public static final int TRANSFORM_ROWS_COLUMNORIENTATION = 1;
public static final int INVERSE_TRANSFORM_ROWS_COLUMNORIENTATION = 2;
// Methods for calculating the row transforms in parallel
public static final int TRANSFORM_ROWS_ROWORIENTATION = 100001;
public static final int INVERSE_TRANSFORM_ROWS_ROWORIENTATION = 100002;
public void setLength(int length)
{
this.length = length; // Transform length
}
public void setArrayAccess(ArrayAccess arrayAccess)
throws ApfloatRuntimeException
{
this.data = arrayAccess.getIntData();
this.offset = arrayAccess.getOffset();
if (this.length != 0)
{
this.stride = arrayAccess.getLength() / this.length;
}
}
public void setWTable(int[] wTable)
{
this.wTable = wTable;
}
public void setPermutationTable(int[] permutationTable)
{
this.permutationTable = (permutationTable == null ? new int[1] : permutationTable); // Zero-length array or null won't work
this.permutationTableLength = (permutationTable == null ? 0 : permutationTable.length);
}
private void columnTableFNT()
{
int nn, istep = 0, mmax = 0, r = 0;
int[] data = this.data;
int offset = this.offset + getGlobalId();
int stride = this.stride;
nn = this.length;
if (nn >= 2)
{
r = 1;
mmax = nn >> 1;
while (mmax > 0)
{
istep = mmax << 1;
// Optimize first step when wr = 1
for (int i = offset; i < offset + nn * stride; i += istep * stride)
{
int j = i + mmax * stride;
int a = data[i];
int b = data[j];
data[i] = modAdd(a, b);
data[j] = modSubtract(a, b);
}
int t = r;
for (int m = 1; m < mmax; m++)
{
for (int i = offset + m * stride; i < offset + nn * stride; i += istep * stride)
{
int j = i + mmax * stride;
int a = data[i];
int b = data[j];
data[i] = modAdd(a, b);
data[j] = modMultiply(this.wTable[t], modSubtract(a, b));
}
t += r;
}
r <<= 1;
mmax >>= 1;
}
if (this.permutationTableLength > 0)
{
columnScramble(offset);
}
}
}
private void rowTableFNT()
{
int nn, offset, istepbits, mmax, mmaxbits, mmaxmask, r;
int[] data = this.data;
offset = this.offset + getGlobalId(1) * this.length;
nn = this.length;
if (nn >= 2)
{
r = 1;
mmax = nn >> 1;
mmaxbits = numberOfTrailingZeros(mmax);
while (mmax > 0)
{
istepbits = mmaxbits + 1;
mmaxmask = mmax - 1;
/*
int t = 0;
for (int m = 0; m < mmax; m++)
{
for (int i = offset + m; i < offset + nn; i += istep)
{
int j = i + mmax;
int a = data[i];
int b = data[j];
data[i] = modAdd(a, b);
data[j] = modMultiply(this.wTable[t], modSubtract(a, b));
}
t += r;
}
*/
for (int k = getGlobalId(0); k < nn / 2; k += getGlobalSize(0))
{
int m = k & mmaxmask;
int t = m * r;
int i = offset + m + ((k >> mmaxbits) << istepbits);
int j = i + mmax;
int a = data[i];
int b = data[j];
data[i] = modAdd(a, b);
data[j] = modMultiply(wTable[t], modSubtract(a, b));
}
r <<= 1;
mmax >>= 1;
mmaxbits--;
localBarrier(); // Use a local barrier to synchronize memory writes within the same work-group but don't force memory to be written from the GPU cache to the GPU global memory
}
if (this.permutationTableLength > 0)
{
rowScramble(offset);
}
}
}
// Copied from Integer.numberOfTrailingZeros()
private int numberOfTrailingZeros(int i)
{
i = ~i & (i - 1);
if (i <= 0)
{
return i & 32;
}
int n = 1;
if (i > 1 << 16) { n += 16; i >>>= 16; }
if (i > 1 << 8) { n += 8; i >>>= 8; }
if (i > 1 << 4) { n += 4; i >>>= 4; }
if (i > 1 << 2) { n += 2; i >>>= 2; }
return n + (i >>> 1);
}
private void inverseColumnTableFNT()
{
int nn, istep = 0, mmax = 0, r = 0;
int[] data = this.data;
int offset = this.offset + getGlobalId();
int stride = this.stride;
nn = this.length;
if (nn >= 2)
{
if (this.permutationTableLength > 0)
{
columnScramble(offset);
}
r = nn;
mmax = 1;
while (nn > mmax)
{
istep = mmax << 1;
r >>= 1;
// Optimize first step when w = 1
for (int i = offset; i < offset + nn * stride; i += istep * stride)
{
int j = i + mmax * stride;
int wTemp = data[j];
data[j] = modSubtract(data[i], wTemp);
data[i] = modAdd(data[i], wTemp);
}
int t = r;
for (int m = 1; m < mmax; m++)
{
for (int i = offset + m * stride; i < offset + nn * stride; i += istep * stride)
{
int j = i + mmax * stride;
int wTemp = modMultiply(this.wTable[t], data[j]);
data[j] = modSubtract(data[i], wTemp);
data[i] = modAdd(data[i], wTemp);
}
t += r;
}
mmax = istep;
}
}
}
private void inverseRowTableFNT()
{
int nn, offset, istepbits, mmax, mmaxbits, mmaxmask, r;
int[] data = this.data;
offset = this.offset + getGlobalId(1) * this.length;
nn = this.length;
if (nn >= 2)
{
if (permutationTableLength > 0)
{
rowScramble(offset);
}
r = nn;
mmax = 1;
mmaxbits = 0;
while (nn > mmax)
{
istepbits = mmaxbits + 1;
mmaxmask = mmax - 1;
r >>= 1;
/*
int t = 0;
for (int m = 0; m < mmax; m++)
{
for (int i = offset + m; i < offset + nn; i += istep)
{
int j = i + mmax;
int wTemp = modMultiply(this.wTable[t], data[j]);
data[j] = modSubtract(data[i], wTemp);
data[i] = modAdd(data[i], wTemp);
}
t += r;
}
*/
for (int k = getGlobalId(0); k < nn / 2; k += getGlobalSize(0))
{
int m = k & mmaxmask;
int t = m * r;
int i = offset + m + ((k >> mmaxbits) << istepbits);
int j = i + mmax;
int wTemp = modMultiply(wTable[t], data[j]);
data[j] = modSubtract(data[i], wTemp);
data[i] = modAdd(data[i], wTemp);
}
mmax <<= 1;
mmaxbits++;
localBarrier(); // Use a local barrier to synchronize memory writes within the same work-group but don't force memory to be written from the GPU cache to the GPU global memory
}
}
}
private void columnScramble(int offset)
{
for (int k = 0; k < this.permutationTableLength; k += 2)
{
int i = offset + this.permutationTable[k] * this.stride,
j = offset + this.permutationTable[k + 1] * this.stride;
int tmp = this.data[i];
this.data[i] = this.data[j];
this.data[j] = tmp;
}
}
private void rowScramble(int offset)
{
for (int k = 2 * getGlobalId(0); k < this.permutationTableLength; k += 2 * getGlobalSize(0))
{
int i = offset + this.permutationTable[k],
j = offset + this.permutationTable[k + 1];
int tmp = this.data[i];
this.data[i] = this.data[j];
this.data[j] = tmp;
}
localBarrier();
}
private int modMultiply(int a, int b)
{
long t = (long) a * (long) b;
//int r1 = a * b - (int) (this.inverseModulus * (double) a * (double) b) * this.modulus,
int r1 = (int) t - (int) ((t >>> 30) * this.inverseModulus >>> 33) * this.modulus,
r2 = r1 - this.modulus;
return (r2 < 0 ? r1 : r2);
}
private int modAdd(int a, int b)
{
int r1 = a + b,
r2 = r1 - this.modulus;
return (r2 < 0 ? r1 : r2);
}
private int modSubtract(int a, int b)
{
int r1 = a - b,
r2 = r1 + this.modulus;
return (r1 < 0 ? r2 : r1);
}
public void setModulus(int modulus)
{
//this.inverseModulus = 1.0 / (modulus + 0.5); // Round down
this.inverseModulus = (long) (9223372036854775808.0 / (double) modulus);
this.modulus = modulus;
}
public int getModulus()
{
return this.modulus;
}
private int stride;
private int length;
private int[] data;
private int offset;
private int[] wTable = { 0 };
private int[] permutationTable = { 0 };
private int permutationTableLength;
private int modulus;
//private double inverseModulus;
private long inverseModulus;
// Methods for transposing the matrix
public static final int TRANSPOSE = 3;
public static final int PERMUTE = 4;
public void setN2(int n2)
{
this.n2 = n2;
}
public void setIndex(int[] index)
{
this.index = index;
}
public void setIndexCount(int indexCount)
{
this.indexCount = indexCount;
}
private void transpose()
{
int i = getGlobalId(0),
j = getGlobalId(1);
if (i < j)
{
int position1 = this.offset + j * this.n2 + i,
position2 = this.offset + i * this.n2 + j;
int tmp = this.data[position1];
this.data[position1] = this.data[position2];
this.data[position2] = tmp;
}
}
private void permute()
{
int j = getGlobalId();
for (int i = 0; i < this.indexCount; i++)
{
int o = this.index[i];
int tmp = this.data[this.offset + this.n2 * o + j];
for (i++; this.index[i] != 0; i++)
{
int m = this.index[i];
this.data[this.offset + this.n2 * o + j] = this.data[this.offset + this.n2 * m + j];
o = m;
}
this.data[this.offset + this.n2 * o + j] = tmp;
}
}
private int n2;
private int[] index = { 0 };
private int indexCount;
// Methods for multiplying elements in the matrix
public static final int MULTIPLY_ELEMENTS = 5;
public void setStartRow(int startRow)
{
this.startRow = startRow;
}
public void setStartColumn(int startColumn)
{
this.startColumn = startColumn;
}
public void setRows(int rows)
{
this.rows = rows;
}
public void setColumns(int columns)
{
this.columns = columns;
}
public void setW(int w)
{
this.w = w;
}
public void setScaleFactor(int scaleFactor)
{
this.scaleFactor = scaleFactor;
}
private void multiplyElements()
{
int[] data = this.data;
int position = this.offset + getGlobalId();
int rowFactor = modPow(this.w, (int) this.startRow);
int columnFactor = modPow(this.w, (int) this.startColumn + getGlobalId());
int rowStartFactor = modMultiply(this.scaleFactor, modPow(rowFactor, (int) this.startColumn + getGlobalId()));
for (int i = 0; i < this.rows; i++)
{
data[position] = modMultiply(data[position], rowStartFactor);
position += this.columns;
rowStartFactor = modMultiply(rowStartFactor, columnFactor);
}
}
private int modPow(int a, int n)
{
if (n == 0)
{
return 1;
}
else if (n < 0)
{
n = getModulus() - 1 + n;
}
int exponent = (int) n;
while ((exponent & 1) == 0)
{
a = modMultiply(a, a);
exponent >>= 1;
}
int r = a;
for (exponent >>= 1; exponent > 0; exponent >>= 1)
{
a = modMultiply(a, a);
if ((exponent & 1) != 0)
{
r = modMultiply(r, a);
}
}
return r;
}
private int startRow;
private int startColumn;
private int rows;
private int columns;
private int w;
private int scaleFactor;
// Methods for factor-3 transform
public static final int TRANSFORM_COLUMNS = 6;
public static final int INVERSE_TRANSFORM_COLUMNS = 7;
public void setOp(int op)
{
this.op = op;
}
public void setWw(int ww)
{
this.ww = ww;
}
public void setW1(int w1)
{
this.w1 = w1;
}
public void setW2(int w2)
{
this.w2 = w2;
}
@Override
public void run()
{
if (this.op == TRANSFORM_ROWS_COLUMNORIENTATION)
{
columnTableFNT();
}
else if (this.op == INVERSE_TRANSFORM_ROWS_COLUMNORIENTATION)
{
inverseColumnTableFNT();
}
else if (this.op == TRANSFORM_ROWS_ROWORIENTATION)
{
rowTableFNT();
}
else if (this.op == INVERSE_TRANSFORM_ROWS_ROWORIENTATION)
{
inverseRowTableFNT();
}
else if (this.op == TRANSPOSE)
{
transpose();
}
else if (this.op == PERMUTE)
{
permute();
}
else if (this.op == MULTIPLY_ELEMENTS)
{
multiplyElements();
}
else if (this.op == TRANSFORM_COLUMNS || this.op == INVERSE_TRANSFORM_COLUMNS)
{
transformColumns();
}
}
private void transformColumns()
{
int i = getGlobalId();
int tmp1 = modPow(this.w, (int) this.startColumn + i),
tmp2 = modPow(this.ww, (int) this.startColumn + i);
// 3-point WFTA on the corresponding array elements
int x0 = this.data[this.offset + i],
x1 = this.data[this.offset + this.columns + i],
x2 = this.data[this.offset + 2 * this.columns + i],
t;
if (this.op == INVERSE_TRANSFORM_COLUMNS)
{
// Multiply before transform
x1 = modMultiply(x1, tmp1);
x2 = modMultiply(x2, tmp2);
}
// Transform column
t = modAdd(x1, x2);
x2 = modSubtract(x1, x2);
x0 = modAdd(x0, t);
t = modMultiply(t, this.w1);
x2 = modMultiply(x2, this.w2);
t = modAdd(t, x0);
x1 = modAdd(t, x2);
x2 = modSubtract(t, x2);
if (this.op == TRANSFORM_COLUMNS)
{
// Multiply after transform
x1 = modMultiply(x1, tmp1);
x2 = modMultiply(x2, tmp2);
}
this.data[this.offset + i] = x0;
this.data[this.offset + this.columns + i] = x1;
this.data[this.offset + 2 * this.columns + i] = x2;
}
private int op;
private int ww;
private int w1;
private int w2;
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/LongAparapiBuilderFactory.java 0000664 0000000 0000000 00000003723 15113064030 0032450 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.ApfloatContext;
import org.apfloat.spi.NTTBuilder;
import org.apfloat.internal.LongBuilderFactory;
/**
* Builder factory for aparapi transform implementations for the long element type.
*
* @since 1.8.3
* @version 1.15.0
* @author Mikko Tommila
*/
public class LongAparapiBuilderFactory
extends LongBuilderFactory
{
/**
* Default constructor.
*/
public LongAparapiBuilderFactory()
{
boolean rowOrientation = Boolean.parseBoolean(ApfloatContext.getContext().getProperty("rowOrientation"));
this.nttBuilder = new LongAparapiNTTBuilder(rowOrientation);
}
@Override
public NTTBuilder getNTTBuilder()
{
return this.nttBuilder;
}
private NTTBuilder nttBuilder;
}
LongAparapiColumnSixStepFNTStrategy.java 0000664 0000000 0000000 00000003256 15113064030 0034324 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
/**
* Six-step NTT implementation for the long element type using column orientation.
*
* @since 1.15.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class LongAparapiColumnSixStepFNTStrategy
extends ColumnSixStepFNTStrategy
implements LongAparapiNTTStrategy
{
/**
* Default constructor.
*/
public LongAparapiColumnSixStepFNTStrategy()
{
super(new LongAparapiNTTStepStrategy(false), new LongAparapiMatrixStrategy());
}
}
LongAparapiColumnTwoPassFNTStrategy.java 0000664 0000000 0000000 00000003215 15113064030 0034320 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
/**
* Two-pass NTT implementation for the long element type using column orientation.
*
* @since 1.15.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class LongAparapiColumnTwoPassFNTStrategy
extends ColumnTwoPassFNTStrategy
implements LongAparapiNTTStrategy
{
/**
* Default constructor.
*/
public LongAparapiColumnTwoPassFNTStrategy()
{
super(new LongAparapiNTTStepStrategy(false));
}
}
LongAparapiFactor3NTTStepStrategy.java 0000664 0000000 0000000 00000010405 15113064030 0033714 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2023 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.ApfloatRuntimeException;
import org.apfloat.spi.ArrayAccess;
import org.apfloat.spi.DataStorage;
import com.aparapi.Range;
import org.apfloat.internal.ApfloatInternalException;
import org.apfloat.internal.LongFactor3NTTStepStrategy;
import static org.apfloat.internal.LongModConstants.*;
/**
* Steps for the factor-3 NTT using the GPU, for the long element type.
*
* @since 1.8.3
* @version 1.8.3
* @author Mikko Tommila
*/
public class LongAparapiFactor3NTTStepStrategy
extends LongFactor3NTTStepStrategy
{
@Override
public void transformColumns(DataStorage dataStorage0, DataStorage dataStorage1, DataStorage dataStorage2, long startColumn, long columns, long power2length, long length, boolean isInverse, int modulus)
throws ApfloatRuntimeException
{
// Transform length is three times a power of two
assert (length == 3 * power2length);
// Check that the data storages use consecutive sections of the same memory array
if (!dataStorage0.isCached() || !dataStorage1.isCached() || !dataStorage2.isCached() ||
startColumn > Integer.MAX_VALUE || columns > Integer.MAX_VALUE)
{
throw new ApfloatInternalException("Data must be stored in memory");
}
ArrayAccess arrayAccess0 = dataStorage0.getArray(DataStorage.READ_WRITE, startColumn, (int) columns),
arrayAccess1 = dataStorage1.getArray(DataStorage.READ_WRITE, startColumn, (int) columns),
arrayAccess2 = dataStorage2.getArray(DataStorage.READ_WRITE, startColumn, (int) columns);
if (arrayAccess0.getLongData() != arrayAccess1.getLongData() || arrayAccess1.getLongData() != arrayAccess2.getLongData() ||
arrayAccess1.getOffset() != arrayAccess0.getOffset() + columns || arrayAccess2.getOffset() != arrayAccess1.getOffset() + columns)
{
throw new ApfloatInternalException("Data must be stored consecutively in memory");
}
setModulus(MODULUS[modulus]); // Modulus
long w = (isInverse ?
getInverseNthRoot(PRIMITIVE_ROOT[modulus], length) :
getForwardNthRoot(PRIMITIVE_ROOT[modulus], length)), // Forward/inverse n:th root
w3 = modPow(w, (long) power2length), // Forward/inverse 3rd root
ww = modMultiply(w, w),
w1 = negate(modDivide((long) 3, (long) 2)),
w2 = modAdd(w3, modDivide((long) 1, (long) 2));
LongKernel kernel = LongKernel.getInstance();
kernel.setOp(isInverse ? LongKernel.INVERSE_TRANSFORM_COLUMNS : LongKernel.TRANSFORM_COLUMNS);
kernel.setArrayAccess(arrayAccess0);
kernel.setStartColumn((int) startColumn);
kernel.setColumns((int) columns);
kernel.setW(w);
kernel.setWw(ww);
kernel.setW1(w1);
kernel.setW2(w2);
kernel.setModulus(MODULUS[modulus]);
Range range = RangeHelper.create((int) columns);
kernel.execute(range);
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/LongAparapiFactor3NTTStrategy.java 0000664 0000000 0000000 00000003751 15113064030 0033145 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.spi.NTTStrategy;
/**
* Factor-3 NTT implementation for the long element type.
*
* @since 1.8.3
* @version 1.15.0
* @author Mikko Tommila
*/
public class LongAparapiFactor3NTTStrategy
extends DecorableFactor3NTTStrategy
implements LongAparapiNTTStrategy
{
/**
* Creates a new factor-3 transform strategy on top of an existing transform.
* The underlying transform needs to be capable of only doing transforms of
* length 2n.
*
* @param factor2Strategy The underlying transformation strategy, that can be capable of only doing radix-2 transforms.
*/
public LongAparapiFactor3NTTStrategy(NTTStrategy factor2Strategy)
{
super(factor2Strategy, new LongAparapiFactor3NTTStepStrategy());
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/LongAparapiMatrixStrategy.java 0000664 0000000 0000000 00000015430 15113064030 0032517 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2023 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.ApfloatRuntimeException;
import org.apfloat.spi.ArrayAccess;
import org.apfloat.spi.MatrixStrategy;
import org.apfloat.internal.ApfloatInternalException;
import com.aparapi.Range;
/**
* Matrix transposition in the GPU for the long type.
*
* @since 1.8.3
* @version 1.8.3
* @author Mikko Tommila
*/
public class LongAparapiMatrixStrategy
implements MatrixStrategy
{
/**
* Default constructor.
*/
public LongAparapiMatrixStrategy()
{
}
@Override
public void transpose(ArrayAccess arrayAccess, int n1, int n2)
throws ApfloatRuntimeException
{
if (n1 != (n1 & -n1) ||
n2 != (n2 & -n2) ||
n1 <= 0 || n2 <= 0)
{
throw new ApfloatInternalException("Matrix size must be a power of two, not " + n1 + " x " + n2);
}
if (n1 == n2)
{
// Simply transpose
transposeSquare(arrayAccess, n1, n1);
}
else if (n2 == 2 * n1)
{
// First transpose two n1 x n1 blocks
transposeSquare(arrayAccess, n1, n2);
transposeSquare(arrayAccess.subsequence(n1, arrayAccess.getLength() - n1), n1, n2);
// Then permute the rows to correct order
permuteToHalfWidth(arrayAccess, n1, n2);
}
else if (n1 == 2 * n2)
{
// First permute the rows to correct order
permuteToDoubleWidth(arrayAccess, n1, n2);
// Then transpose two n2 x n2 blocks
transposeSquare(arrayAccess, n2, n1);
transposeSquare(arrayAccess.subsequence(n2, arrayAccess.getLength() - n2), n2, n1);
}
else
{
throw new ApfloatInternalException("Must be n1 = n2, n1 = 2*n2 or n2 = 2*n1; matrix is " + n1 + " x " + n2);
}
}
@Override
public void transposeSquare(ArrayAccess arrayAccess, int n1, int n2)
throws ApfloatRuntimeException
{
LongKernel kernel = LongKernel.getInstance();
kernel.setOp(LongKernel.TRANSPOSE);
kernel.setArrayAccess(arrayAccess);
kernel.setN2(n2);
Range range = RangeHelper.create2D(n1, n1);
kernel.execute(range);
}
@Override
public void permuteToHalfWidth(ArrayAccess arrayAccess, int n1, int n2)
throws ApfloatRuntimeException
{
if (n1 != (n1 & -n1) ||
n2 != (n2 & -n2) ||
n1 <= 0 || n2 <= 0)
{
throw new ApfloatInternalException("Matrix size must be a power of two, not " + n1 + " x " + n2);
}
// Permute the rows of matrix to correct order, to make the n1 x n2 matrix half as wide (2*n1 x n2/2)
if (n1 < 2)
{
return;
}
int twicen1 = 2 * n1;
boolean[] isRowDone = new boolean[twicen1];
int[] index = new int[twicen1 * 2]; // Overly big but twicen1 just isn't enough
int j = 1,
p = 0;
do
{
int m = j;
index[p++] = m;
isRowDone[m] = true;
m = (m < n1 ? 2 * m : 2 * (m - n1) + 1);
while (m != j)
{
isRowDone[m] = true;
index[p++] = m;
m = (m < n1 ? 2 * m : 2 * (m - n1) + 1);
}
index[p++] = 0;
while (isRowDone[j])
{
j++;
}
} while (j < twicen1 - 1);
LongKernel kernel = LongKernel.getInstance();
kernel.setOp(LongKernel.PERMUTE);
kernel.setArrayAccess(arrayAccess);
kernel.setN2(n2 / 2);
kernel.setIndex(index);
kernel.setIndexCount(p);
kernel.put(index);
Range range = RangeHelper.create(n2 / 2);
kernel.execute(range);
}
@Override
public void permuteToDoubleWidth(ArrayAccess arrayAccess, int n1, int n2)
throws ApfloatRuntimeException
{
if (n1 != (n1 & -n1) ||
n2 != (n2 & -n2) ||
n1 <= 0 || n2 <= 0)
{
throw new ApfloatInternalException("Matrix size must be a power of two, not " + n1 + " x " + n2);
}
if (n1 < 2)
{
throw new ApfloatInternalException("Matrix height must be at least 2.");
}
// Permute the rows of matrix to correct order, to make the n1 x n2 matrix twice as wide (n1/2 x 2*n2)
if (n1 < 4)
{
return;
}
int halfn1 = n1 / 2;
boolean[] isRowDone = new boolean[n1];
int[] index = new int[n1 * 2]; // Overly big but n1 just isn't enough
int j = 1,
p = 0;
do
{
int m = j;
index[p++] = m;
isRowDone[m] = true;
m = ((m & 1) != 0 ? m / 2 + halfn1 : m / 2);
while (m != j)
{
isRowDone[m] = true;
index[p++] = m;
m = ((m & 1) != 0 ? m / 2 + halfn1 : m / 2);
}
index[p++] = 0;
while (isRowDone[j])
{
j++;
}
} while (j < n1 - 1);
LongKernel kernel = LongKernel.getInstance();
kernel.setOp(LongKernel.PERMUTE);
kernel.setArrayAccess(arrayAccess);
kernel.setN2(n2);
kernel.setIndex(index);
kernel.setIndexCount(p);
kernel.put(index);
Range range = RangeHelper.create(n2);
kernel.execute(range);
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/LongAparapiNTTBuilder.java 0000664 0000000 0000000 00000006416 15113064030 0031510 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.spi.BuilderFactory;
import org.apfloat.spi.NTTStrategy;
import org.apfloat.ApfloatContext;
import org.apfloat.internal.LongNTTBuilder;
/**
* NTT Builder for aparapi transform implementations for the long element type.
*
* @since 1.8.3
* @version 1.15.0
* @author Mikko Tommila
*/
public class LongAparapiNTTBuilder
extends LongNTTBuilder
{
private static final int MIN_GPU_LENGTH = 1048576;
/**
* Basic constructor.
*
* @param rowOrientation If the data is using row orientation.
*/
public LongAparapiNTTBuilder(boolean rowOrientation)
{
this.rowOrientation = rowOrientation;
}
@Override
protected NTTStrategy createSixStepFNTStrategy(long size)
{
long length = size;
if (length < MIN_GPU_LENGTH)
{
return super.createSixStepFNTStrategy(size);
}
return this.rowOrientation ? new LongAparapiSixStepFNTStrategy() : new LongAparapiColumnSixStepFNTStrategy();
}
@Override
protected NTTStrategy createTwoPassFNTStrategy(long size)
{
long length = size;
if (length < MIN_GPU_LENGTH)
{
return super.createTwoPassFNTStrategy(size);
}
return (this.rowOrientation ? new LongAparapiTwoPassFNTStrategy() : new LongAparapiColumnTwoPassFNTStrategy());
}
@Override
protected NTTStrategy createFactor3NTTStrategy(long size, NTTStrategy nttStrategy)
{
if (nttStrategy instanceof LongAparapiNTTStrategy)
{
ApfloatContext ctx = ApfloatContext.getContext();
BuilderFactory builderFactory = ctx.getBuilderFactory();
long maxMemoryBlockSize = ctx.getMaxMemoryBlockSize() / builderFactory.getElementSize();
if (size <= maxMemoryBlockSize && size <= Integer.MAX_VALUE)
{
return new LongAparapiFactor3NTTStrategy(nttStrategy);
}
}
return super.createFactor3NTTStrategy(size, nttStrategy);
}
private boolean rowOrientation;
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/LongAparapiNTTStepStrategy.java 0000664 0000000 0000000 00000012562 15113064030 0032557 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.ApfloatRuntimeException;
import org.apfloat.spi.ArrayAccess;
import com.aparapi.Range;
import org.apfloat.internal.LongNTTStepStrategy;
import org.apfloat.internal.LongWTables;
import org.apfloat.internal.Scramble;
import static org.apfloat.internal.LongModConstants.*;
import org.apfloat.ApfloatContext;
/**
* NTT steps for the long element type aparapi transforms.
*
* @since 1.8.3
* @version 1.15.0
* @author Mikko Tommila
*/
public class LongAparapiNTTStepStrategy
extends LongNTTStepStrategy
{
/**
* Basic constructor.
*
* @param rowOrientation If the data is using row orientation.
*/
public LongAparapiNTTStepStrategy(boolean rowOrientation)
{
this.rowOrientation = rowOrientation;
}
@Override
public void multiplyElements(ArrayAccess arrayAccess, int startRow, int startColumn, int rows, int columns, long length, long totalTransformLength, boolean isInverse, int modulus)
throws ApfloatRuntimeException
{
setModulus(MODULUS[modulus]);
long w = (isInverse ?
getInverseNthRoot(PRIMITIVE_ROOT[modulus], length) :
getForwardNthRoot(PRIMITIVE_ROOT[modulus], length));
long scaleFactor = (isInverse ?
modDivide((long) 1, (long) totalTransformLength) :
(long) 1);
LongKernel kernel = LongKernel.getInstance();
kernel.setOp(LongKernel.MULTIPLY_ELEMENTS);
kernel.setArrayAccess(arrayAccess);
kernel.setStartRow(startRow);
kernel.setStartColumn(startColumn);
kernel.setRows(rows);
kernel.setColumns(columns);
kernel.setW(w);
kernel.setScaleFactor(scaleFactor);
kernel.setModulus(MODULUS[modulus]);
Range range = RangeHelper.create(columns);
kernel.execute(range);
}
/**
* Transform the rows or columns of the data matrix.
* If the data is oriented in rows, transforms physically the rows.
* If the data is oriented in columns, transforms physically columns.
*
* @param arrayAccess The memory array to split and transform.
* @param length Length of one transform.
* @param count Number of transforms to be done.
* @param isInverse true if an inverse transform is performed, false if a forward transform is performed.
* @param permute If permutation should be done.
* @param modulus Index of the modulus.
*/
@Override
public void transformRows(ArrayAccess arrayAccess, int length, int count, boolean isInverse, boolean permute, int modulus)
throws ApfloatRuntimeException
{
long[] wTable = (isInverse ?
LongWTables.getInverseWTable(modulus, length) :
LongWTables.getWTable(modulus, length));
int[] permutationTable = (permute ? Scramble.createScrambleTable(length) : null);
LongKernel kernel = LongKernel.getInstance();
kernel.setOp(this.rowOrientation ? (isInverse ? LongKernel.INVERSE_TRANSFORM_ROWS_ROWORIENTATION : LongKernel.TRANSFORM_ROWS_ROWORIENTATION) :
(isInverse ? LongKernel.INVERSE_TRANSFORM_ROWS_COLUMNORIENTATION : LongKernel.TRANSFORM_ROWS_COLUMNORIENTATION));
kernel.setLength(length);
kernel.setArrayAccess(arrayAccess);
kernel.setWTable(wTable);
kernel.setPermutationTable(permutationTable);
kernel.setModulus(MODULUS[modulus]);
kernel.put(wTable);
if (permutationTable != null)
{
kernel.put(permutationTable);
}
Range range;
if (this.rowOrientation)
{
int workGroupSize = Integer.parseInt(ApfloatContext.getContext().getProperty("workGroupSize", String.valueOf(RangeHelper.MAX_LOCAL_SIZE)));
int width = Math.min(length, workGroupSize);
range = Range.create2D(width, count, width, 1);
}
else
{
range = RangeHelper.create(count);
}
kernel.execute(range);
}
private boolean rowOrientation;
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/LongAparapiNTTStrategy.java 0000664 0000000 0000000 00000006537 15113064030 0031730 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import java.lang.ref.WeakReference;
import java.util.concurrent.atomic.AtomicInteger;
import org.apfloat.internal.NTTStrategyDecorator;
import org.apfloat.spi.ArrayAccess;
import org.apfloat.spi.NTTStrategy;
/**
* NTT strategy with decorator to set up the data for the GPU, for the long element type.
*
* @since 1.15.0
* @version 1.15.0
* @author Mikko Tommila
*/
public interface LongAparapiNTTStrategy
extends NTTStrategy, NTTStrategyDecorator
{
/**
* @hidden
*/
static final ThreadLocal LEVEL = ThreadLocal.withInitial(AtomicInteger::new);
/**
* @hidden
*/
static final ThreadLocal> DATA = ThreadLocal.withInitial(() -> new WeakReference<>(null));
@Override
default public void beforeTransform(ArrayAccess arrayAccess)
{
long[] data = arrayAccess.getLongData();
AtomicInteger currentLevel = LEVEL.get();
long[] currentData = DATA.get().get();
if (currentLevel.get() == 0 || data != currentData)
{
// If level is 0 then this is the outermost transform
LongKernel kernel = LongKernel.getInstance();
kernel.setExplicit(true);
kernel.put(data);
DATA.set(new WeakReference<>(data));
// If level is not 0 but we are not setting the same data, then something must have gone wrong previously, reset the level
currentLevel.set(0);
}
// If level is > 0 and we are just setting the same data again, then this is for a nested transform, increase nesting level and do nothing else
currentLevel.incrementAndGet();
}
@Override
default public void afterTransform(ArrayAccess arrayAccess)
{
AtomicInteger level = LEVEL.get();
// Decrement nesting level
int currentLevel = level.decrementAndGet();
// Only when we reach the outermost transform, get the data
if (currentLevel == 0)
{
LongKernel kernel = LongKernel.getInstance();
kernel.get(arrayAccess.getLongData());
kernel.cleanUpArrays();
}
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/LongAparapiSixStepFNTStrategy.java 0000664 0000000 0000000 00000003312 15113064030 0033216 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.internal.SixStepFNTStrategy;
/**
* Six-step NTT implementation for the long element type using row orientation.
*
* @since 1.8.3
* @version 1.15.0
* @author Mikko Tommila
*/
public class LongAparapiSixStepFNTStrategy
extends SixStepFNTStrategy
implements LongAparapiNTTStrategy
{
/**
* Default constructor.
*/
public LongAparapiSixStepFNTStrategy()
{
super(new LongAparapiNTTStepStrategy(true), new LongAparapiMatrixStrategy());
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/LongAparapiTwoPassFNTStrategy.java 0000664 0000000 0000000 00000003252 15113064030 0033222 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.internal.TwoPassFNTStrategy;
/**
* Two-pass NTT implementation for the long element type using row orientation.
*
* @since 1.15.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class LongAparapiTwoPassFNTStrategy
extends TwoPassFNTStrategy
implements LongAparapiNTTStrategy
{
/**
* Default constructor.
*/
public LongAparapiTwoPassFNTStrategy()
{
super(new LongAparapiNTTStepStrategy(true));
}
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/LongKernel.java 0000664 0000000 0000000 00000051074 15113064030 0027456 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import com.aparapi.Kernel;
import org.apfloat.ApfloatRuntimeException;
import org.apfloat.spi.ArrayAccess;
/**
* Kernel for the long element type. Contains everything needed for the NTT.
*
* There are two ways the data can be organized:
*
* - In columns: this is more efficient on older GPUs that don't have a cache
* - In rows: this is more efficient on newer GPUs that have large high-bandwidth caches
*
*
* When the data is organized in columns, the NTT algorithm makes O(log n) passes through
* the main memory of the GPU.
*
* When the data is organized in rows, and the GPU cache is sufficiently large, the algorithm
* makes a fixed number of passes through the main memory of the GPU (and O(log n) passes
* through the GPU cache.)
*
* Due to the extreme parallelization requirements (global size should be at least 1024)
* this algorithm works efficiently only with 8 million decimal digit calculations or bigger.
* However with 8 million digits, it's only approximately as fast as the pure-Java
* version (depending on the GPU and CPU hardware). Depending on the total amount of memory
* available for the GPU this algorithm will fail (or revert to the very slow software emulation)
* e.g. at one-billion-digit calculations if your GPU has 1 GB of memory. The maximum power-of-two
* size for a Java array is one billion (230) so if your GPU has more than 8 GB of
* memory then the algorithm can never fail (as any Java long[] will always fit to the GPU memory).
*
* Some notes about the aparapi specific requirements for code that must be converted to OpenCL:
*
* assert() does not work- Can't check for null
* - Can't get array length
* - Arrays referenced by the kernel can't be null even if they are not accessed
* - Arrays referenced by the kernel can't be zero-length even if they are not accessed
* - Can't invoke methods in other classes e.g. enclosing class of an inner class
* - Early return statements do not work
* - Variables used inside loops must be initialized before the loop
* - Must compile the class with full debug information i.e. with
-g
*
*
* @since 1.8.3
* @version 1.15.0
* @author Mikko Tommila
*/
class LongKernel
extends Kernel
{
private LongKernel()
{
}
public static LongKernel getInstance()
{
return LongKernel.kernel.get();
}
private static ThreadLocal kernel = ThreadLocal.withInitial(LongKernel::new);
// Methods for calculating the column transforms in parallel
public static final int TRANSFORM_ROWS_COLUMNORIENTATION = 1;
public static final int INVERSE_TRANSFORM_ROWS_COLUMNORIENTATION = 2;
// Methods for calculating the row transforms in parallel
public static final int TRANSFORM_ROWS_ROWORIENTATION = 100001;
public static final int INVERSE_TRANSFORM_ROWS_ROWORIENTATION = 100002;
public void setLength(int length)
{
this.length = length; // Transform length
}
public void setArrayAccess(ArrayAccess arrayAccess)
throws ApfloatRuntimeException
{
this.data = arrayAccess.getLongData();
this.offset = arrayAccess.getOffset();
if (this.length != 0)
{
this.stride = arrayAccess.getLength() / this.length;
}
}
public void setWTable(long[] wTable)
{
this.wTable = wTable;
}
public void setPermutationTable(int[] permutationTable)
{
this.permutationTable = (permutationTable == null ? new int[1] : permutationTable); // Zero-length array or null won't work
this.permutationTableLength = (permutationTable == null ? 0 : permutationTable.length);
}
private void columnTableFNT()
{
int nn, istep = 0, mmax = 0, r = 0;
long[] data = this.data;
int offset = this.offset + getGlobalId();
int stride = this.stride;
nn = this.length;
if (nn >= 2)
{
r = 1;
mmax = nn >> 1;
while (mmax > 0)
{
istep = mmax << 1;
// Optimize first step when wr = 1
for (int i = offset; i < offset + nn * stride; i += istep * stride)
{
int j = i + mmax * stride;
long a = data[i];
long b = data[j];
data[i] = modAdd(a, b);
data[j] = modSubtract(a, b);
}
int t = r;
for (int m = 1; m < mmax; m++)
{
for (int i = offset + m * stride; i < offset + nn * stride; i += istep * stride)
{
int j = i + mmax * stride;
long a = data[i];
long b = data[j];
data[i] = modAdd(a, b);
data[j] = modMultiply(this.wTable[t], modSubtract(a, b));
}
t += r;
}
r <<= 1;
mmax >>= 1;
}
if (this.permutationTableLength > 0)
{
columnScramble(offset);
}
}
}
private void rowTableFNT()
{
int nn, offset, istepbits, mmax, mmaxbits, mmaxmask, r;
long[] data = this.data;
offset = this.offset + getGlobalId(1) * this.length;
nn = this.length;
if (nn >= 2)
{
r = 1;
mmax = nn >> 1;
mmaxbits = numberOfTrailingZeros(mmax);
while (mmax > 0)
{
istepbits = mmaxbits + 1;
mmaxmask = mmax - 1;
/*
int t = 0;
for (int m = 0; m < mmax; m++)
{
for (int i = offset + m; i < offset + nn; i += istep)
{
int j = i + mmax;
long a = data[i];
long b = data[j];
data[i] = modAdd(a, b);
data[j] = modMultiply(this.wTable[t], modSubtract(a, b));
}
t += r;
}
*/
for (int k = getGlobalId(0); k < nn / 2; k += getGlobalSize(0))
{
int m = k & mmaxmask;
int t = m * r;
int i = offset + m + ((k >> mmaxbits) << istepbits);
int j = i + mmax;
long a = data[i];
long b = data[j];
data[i] = modAdd(a, b);
data[j] = modMultiply(wTable[t], modSubtract(a, b));
}
r <<= 1;
mmax >>= 1;
mmaxbits--;
localBarrier(); // Use a local barrier to synchronize memory writes within the same work-group but don't force memory to be written from the GPU cache to the GPU global memory
}
if (this.permutationTableLength > 0)
{
rowScramble(offset);
}
}
}
// Copied from Integer.numberOfTrailingZeros()
private int numberOfTrailingZeros(int i)
{
i = ~i & (i - 1);
if (i <= 0)
{
return i & 32;
}
int n = 1;
if (i > 1 << 16) { n += 16; i >>>= 16; }
if (i > 1 << 8) { n += 8; i >>>= 8; }
if (i > 1 << 4) { n += 4; i >>>= 4; }
if (i > 1 << 2) { n += 2; i >>>= 2; }
return n + (i >>> 1);
}
private void inverseColumnTableFNT()
{
int nn, istep = 0, mmax = 0, r = 0;
long[] data = this.data;
int offset = this.offset + getGlobalId();
int stride = this.stride;
nn = this.length;
if (nn >= 2)
{
if (this.permutationTableLength > 0)
{
columnScramble(offset);
}
r = nn;
mmax = 1;
while (nn > mmax)
{
istep = mmax << 1;
r >>= 1;
// Optimize first step when w = 1
for (int i = offset; i < offset + nn * stride; i += istep * stride)
{
int j = i + mmax * stride;
long wTemp = data[j];
data[j] = modSubtract(data[i], wTemp);
data[i] = modAdd(data[i], wTemp);
}
int t = r;
for (int m = 1; m < mmax; m++)
{
for (int i = offset + m * stride; i < offset + nn * stride; i += istep * stride)
{
int j = i + mmax * stride;
long wTemp = modMultiply(this.wTable[t], data[j]);
data[j] = modSubtract(data[i], wTemp);
data[i] = modAdd(data[i], wTemp);
}
t += r;
}
mmax = istep;
}
}
}
private void inverseRowTableFNT()
{
int nn, offset, istepbits, mmax, mmaxbits, mmaxmask, r;
long[] data = this.data;
offset = this.offset + getGlobalId(1) * this.length;
nn = this.length;
if (nn >= 2)
{
if (permutationTableLength > 0)
{
rowScramble(offset);
}
r = nn;
mmax = 1;
mmaxbits = 0;
while (nn > mmax)
{
istepbits = mmaxbits + 1;
mmaxmask = mmax - 1;
r >>= 1;
/*
int t = 0;
for (int m = 0; m < mmax; m++)
{
for (int i = offset + m; i < offset + nn; i += istep)
{
int j = i + mmax;
long wTemp = modMultiply(this.wTable[t], data[j]);
data[j] = modSubtract(data[i], wTemp);
data[i] = modAdd(data[i], wTemp);
}
t += r;
}
*/
for (int k = getGlobalId(0); k < nn / 2; k += getGlobalSize(0))
{
int m = k & mmaxmask;
int t = m * r;
int i = offset + m + ((k >> mmaxbits) << istepbits);
int j = i + mmax;
long wTemp = modMultiply(wTable[t], data[j]);
data[j] = modSubtract(data[i], wTemp);
data[i] = modAdd(data[i], wTemp);
}
mmax <<= 1;
mmaxbits++;
localBarrier(); // Use a local barrier to synchronize memory writes within the same work-group but don't force memory to be written from the GPU cache to the GPU global memory
}
}
}
private void columnScramble(int offset)
{
for (int k = 0; k < this.permutationTableLength; k += 2)
{
int i = offset + this.permutationTable[k] * this.stride,
j = offset + this.permutationTable[k + 1] * this.stride;
long tmp = this.data[i];
this.data[i] = this.data[j];
this.data[j] = tmp;
}
}
private void rowScramble(int offset)
{
for (int k = 2 * getGlobalId(0); k < this.permutationTableLength; k += 2 * getGlobalSize(0))
{
int i = offset + this.permutationTable[k],
j = offset + this.permutationTable[k + 1];
long tmp = this.data[i];
this.data[i] = this.data[j];
this.data[j] = tmp;
}
localBarrier();
}
private long modMultiply(long a, long b)
{
long r = a * b - this.modulus * (long) ((double) a * (double) b * this.inverseModulus);
r -= this.modulus * (int) ((double) r * this.inverseModulus);
r = (r >= this.modulus ? r - this.modulus : r);
r = (r < 0 ? r + this.modulus : r);
return r;
}
private long modAdd(long a, long b)
{
long r = a + b;
return (r >= this.modulus ? r - this.modulus : r);
}
private long modSubtract(long a, long b)
{
long r = a - b;
return (r < 0 ? r + this.modulus : r);
}
public void setModulus(long modulus)
{
this.inverseModulus = 1.0 / modulus;
this.modulus = modulus;
}
public long getModulus()
{
return this.modulus;
}
private int stride;
private int length;
private long[] data;
private int offset;
private long[] wTable = { 0 };
private int[] permutationTable = { 0 };
private int permutationTableLength;
private long modulus;
private double inverseModulus;
// Methods for transposing the matrix
public static final int TRANSPOSE = 3;
public static final int PERMUTE = 4;
public void setN2(int n2)
{
this.n2 = n2;
}
public void setIndex(int[] index)
{
this.index = index;
}
public void setIndexCount(int indexCount)
{
this.indexCount = indexCount;
}
private void transpose()
{
int i = getGlobalId(0),
j = getGlobalId(1);
if (i < j)
{
int position1 = this.offset + j * this.n2 + i,
position2 = this.offset + i * this.n2 + j;
long tmp = this.data[position1];
this.data[position1] = this.data[position2];
this.data[position2] = tmp;
}
}
private void permute()
{
int j = getGlobalId();
for (int i = 0; i < this.indexCount; i++)
{
int o = this.index[i];
long tmp = this.data[this.offset + this.n2 * o + j];
for (i++; this.index[i] != 0; i++)
{
int m = this.index[i];
this.data[this.offset + this.n2 * o + j] = this.data[this.offset + this.n2 * m + j];
o = m;
}
this.data[this.offset + this.n2 * o + j] = tmp;
}
}
private int n2;
private int[] index = { 0 };
private int indexCount;
// Methods for multiplying elements in the matrix
public static final int MULTIPLY_ELEMENTS = 5;
public void setStartRow(int startRow)
{
this.startRow = startRow;
}
public void setStartColumn(int startColumn)
{
this.startColumn = startColumn;
}
public void setRows(int rows)
{
this.rows = rows;
}
public void setColumns(int columns)
{
this.columns = columns;
}
public void setW(long w)
{
this.w = w;
}
public void setScaleFactor(long scaleFactor)
{
this.scaleFactor = scaleFactor;
}
private void multiplyElements()
{
long[] data = this.data;
int position = this.offset + getGlobalId();
long rowFactor = modPow(this.w, (long) this.startRow);
long columnFactor = modPow(this.w, (long) this.startColumn + getGlobalId());
long rowStartFactor = modMultiply(this.scaleFactor, modPow(rowFactor, (long) this.startColumn + getGlobalId()));
for (int i = 0; i < this.rows; i++)
{
data[position] = modMultiply(data[position], rowStartFactor);
position += this.columns;
rowStartFactor = modMultiply(rowStartFactor, columnFactor);
}
}
private long modPow(long a, long n)
{
if (n == 0)
{
return 1;
}
else if (n < 0)
{
n = getModulus() - 1 + n;
}
long exponent = (long) n;
while ((exponent & 1) == 0)
{
a = modMultiply(a, a);
exponent >>= 1;
}
long r = a;
for (exponent >>= 1; exponent > 0; exponent >>= 1)
{
a = modMultiply(a, a);
if ((exponent & 1) != 0)
{
r = modMultiply(r, a);
}
}
return r;
}
private int startRow;
private int startColumn;
private int rows;
private int columns;
private long w;
private long scaleFactor;
// Methods for factor-3 transform
public static final int TRANSFORM_COLUMNS = 6;
public static final int INVERSE_TRANSFORM_COLUMNS = 7;
public void setOp(int op)
{
this.op = op;
}
public void setWw(long ww)
{
this.ww = ww;
}
public void setW1(long w1)
{
this.w1 = w1;
}
public void setW2(long w2)
{
this.w2 = w2;
}
@Override
public void run()
{
if (this.op == TRANSFORM_ROWS_COLUMNORIENTATION)
{
columnTableFNT();
}
else if (this.op == INVERSE_TRANSFORM_ROWS_COLUMNORIENTATION)
{
inverseColumnTableFNT();
}
else if (this.op == TRANSFORM_ROWS_ROWORIENTATION)
{
rowTableFNT();
}
else if (this.op == INVERSE_TRANSFORM_ROWS_ROWORIENTATION)
{
inverseRowTableFNT();
}
else if (this.op == TRANSPOSE)
{
transpose();
}
else if (this.op == PERMUTE)
{
permute();
}
else if (this.op == MULTIPLY_ELEMENTS)
{
multiplyElements();
}
else if (this.op == TRANSFORM_COLUMNS || this.op == INVERSE_TRANSFORM_COLUMNS)
{
transformColumns();
}
}
private void transformColumns()
{
int i = getGlobalId();
long tmp1 = modPow(this.w, (long) this.startColumn + i),
tmp2 = modPow(this.ww, (long) this.startColumn + i);
// 3-point WFTA on the corresponding array elements
long x0 = this.data[this.offset + i],
x1 = this.data[this.offset + this.columns + i],
x2 = this.data[this.offset + 2 * this.columns + i],
t;
if (this.op == INVERSE_TRANSFORM_COLUMNS)
{
// Multiply before transform
x1 = modMultiply(x1, tmp1);
x2 = modMultiply(x2, tmp2);
}
// Transform column
t = modAdd(x1, x2);
x2 = modSubtract(x1, x2);
x0 = modAdd(x0, t);
t = modMultiply(t, this.w1);
x2 = modMultiply(x2, this.w2);
t = modAdd(t, x0);
x1 = modAdd(t, x2);
x2 = modSubtract(t, x2);
if (this.op == TRANSFORM_COLUMNS)
{
// Multiply after transform
x1 = modMultiply(x1, tmp1);
x2 = modMultiply(x2, tmp2);
}
this.data[this.offset + i] = x0;
this.data[this.offset + this.columns + i] = x1;
this.data[this.offset + 2 * this.columns + i] = x2;
}
private int op;
private long ww;
private long w1;
private long w2;
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/RangeHelper.java 0000664 0000000 0000000 00000005507 15113064030 0027612 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.spi.Util;
import com.aparapi.Range;
/**
* Range helper methods.
*
* @since 1.11.0
* @version 1.15.0
*
* @author Mikko Tommila
*/
class RangeHelper
{
// Note: it seems that this class is just a workaround to aparapi issue #171 where the local size is sometimes not set correctly
// See: https://github.com/Syncleus/aparapi/issues/171
private RangeHelper()
{
}
/**
* Creates a one-dimensional range with the maximum local size.
*
* @param size The size.
*
* @return The range.
*/
public static Range create(int size)
{
assert (size == (size & -size)); // Must be a power of two
int localSize = Math.min(size, MAX_LOCAL_SIZE);
return Range.create(size, localSize);
}
/**
* Creates a two-dimensional range with the maximum local sizes.
*
* @param width Size of the first dimension.
* @param height Size of the second dimension.
*
* @return The range.
*/
public static Range create2D(int width, int height)
{
assert (width == (width & -width)); // Must be a power of two
assert (height == (height & -height)); // Must be a power of two
int localWidth = Math.min(width, Util.sqrt4up(MAX_LOCAL_SIZE)),
localHeight = Math.min(height, MAX_LOCAL_SIZE / localWidth);
return Range.create2D(width, height, localWidth, localHeight);
}
/**
* Maximum OpenCL work-group size. Note that this is the local sizes in all dimensions multiplied together.
*/
public static final int MAX_LOCAL_SIZE = 256;
}
apfloat-1.15.0/apfloat-aparapi/src/main/java/org/apfloat/aparapi/package-info.java 0000664 0000000 0000000 00000003434 15113064030 0027737 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2023 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
Transforms for using a GPU via the aparapi library.
This package contains Number-Theoretic Transform implementations that can use
the GPU (Graphics Processing Unit) for executing the transforms. There is significant
overhead in invoking the GPU, e.g. in transferring the data between the main memory
and the GPU memory, so for small data sets there is usually no performance improvement,
and in many cases performance can be even significantly slower. However for very large
calculations, e.g. one billion digits, using the GPU can improve the performance noticeably,
depending on the hardware used.
*/
package org.apfloat.aparapi;
apfloat-1.15.0/apfloat-aparapi/src/main/resources/ 0000775 0000000 0000000 00000000000 15113064030 0022003 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/resources/META-INF/ 0000775 0000000 0000000 00000000000 15113064030 0023143 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/resources/META-INF/services/ 0000775 0000000 0000000 00000000000 15113064030 0024766 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/main/resources/META-INF/services/org.apfloat.spi.BuilderFactory 0000664 0000000 0000000 00000000135 15113064030 0032633 0 ustar 00root root 0000000 0000000 org.apfloat.aparapi.IntAparapiBuilderFactory
org.apfloat.aparapi.LongAparapiBuilderFactory
apfloat-1.15.0/apfloat-aparapi/src/test/ 0000775 0000000 0000000 00000000000 15113064030 0020024 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/test/java/ 0000775 0000000 0000000 00000000000 15113064030 0020745 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/test/java/org/ 0000775 0000000 0000000 00000000000 15113064030 0021534 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/test/java/org/apfloat/ 0000775 0000000 0000000 00000000000 15113064030 0023162 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/test/java/org/apfloat/aparapi/ 0000775 0000000 0000000 00000000000 15113064030 0024577 5 ustar 00root root 0000000 0000000 IntAparapiColumnSixStepFNTStrategyTest.java 0000664 0000000 0000000 00000005645 15113064030 0035056 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/test/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.*;
import org.apfloat.internal.*;
import junit.framework.TestSuite;
/**
* @version 1.15.0
* @author Mikko Tommila
*/
public class IntAparapiColumnSixStepFNTStrategyTest
extends IntAparapiSixStepFNTStrategyTest
{
public IntAparapiColumnSixStepFNTStrategyTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new IntAparapiColumnSixStepFNTStrategyTest("testForward"));
suite.addTest(new IntAparapiColumnSixStepFNTStrategyTest("testForwardBig"));
suite.addTest(new IntAparapiColumnSixStepFNTStrategyTest("testRoundTrip"));
suite.addTest(new IntAparapiColumnSixStepFNTStrategyTest("testRoundTripBig"));
return suite;
}
public static void testForward()
{
runTestForward(1024);
}
public static void testForwardBig()
{
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setMemoryThreshold(8192);
runTestForward(4096);
}
private static void runTestForward(int size)
{
runTestForward(new IntAparapiColumnSixStepFNTStrategy(), size);
}
public static void testRoundTrip()
{
runRoundTrip(1024);
}
public static void testRoundTripBig()
{
int size = (int) Math.min(1 << 21, IntModConstants.MAX_TRANSFORM_LENGTH & -IntModConstants.MAX_TRANSFORM_LENGTH);
runRoundTrip(size);
}
private static void runRoundTrip(int size)
{
runRoundTrip(new IntAparapiColumnSixStepFNTStrategy(), size);
}
}
IntAparapiColumnTwoPassFNTStrategyTest.java 0000664 0000000 0000000 00000005272 15113064030 0035053 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/test/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.*;
import org.apfloat.spi.*;
import org.apfloat.internal.*;
import junit.framework.TestSuite;
/**
* @version 1.15.0
* @author Mikko Tommila
*/
public class IntAparapiColumnTwoPassFNTStrategyTest
extends IntNTTStrategyTestCase
{
public IntAparapiColumnTwoPassFNTStrategyTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new IntAparapiColumnTwoPassFNTStrategyTest("testRoundTrip"));
suite.addTest(new IntAparapiColumnTwoPassFNTStrategyTest("testRoundTripBig"));
return suite;
}
public static void testRoundTrip()
{
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setMaxMemoryBlockSize(65536);
ctx.setMemoryThreshold(1024);
ctx.setBlockSize(256);
runRoundTrip(131072);
}
public static void testRoundTripBig()
{
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setMaxMemoryBlockSize(65536);
ctx.setMemoryThreshold(1024);
ctx.setBlockSize(256);
int size = (int) Math.min(1 << 21, Util.round2down(IntModConstants.MAX_TRANSFORM_LENGTH));
runRoundTrip(size);
}
private static void runRoundTrip(int size)
{
runRoundTrip(new IntAparapiColumnTwoPassFNTStrategy(), size);
}
}
IntAparapiFactor3NTTStrategyTest.java 0000664 0000000 0000000 00000014642 15113064030 0033615 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/test/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import java.util.Arrays;
import org.apfloat.*;
import org.apfloat.spi.*;
import org.apfloat.internal.*;
import junit.framework.TestSuite;
/**
* @version 1.15.0
* @author Mikko Tommila
*/
public class IntAparapiFactor3NTTStrategyTest
extends IntNTTStrategyTestCase
{
public IntAparapiFactor3NTTStrategyTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new IntAparapiFactor3NTTStrategyTest("testForward"));
suite.addTest(new IntAparapiFactor3NTTStrategyTest("testRoundTrip"));
suite.addTest(new IntAparapiFactor3NTTStrategyTest("testRoundTrip2"));
return suite;
}
public static void testForward()
{
runForward();
}
private static void runForward()
{
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setMemoryThreshold(Long.MAX_VALUE);
for (int modulus = 0; modulus < 3; modulus++)
{
int size = 3 * 2048;
DataStorage dataStorage = createDataStorage(size + 5).subsequence(5, size);
int[] data = getPlainArray(dataStorage),
expectedTransform = ntt(data, modulus);
Arrays.sort(expectedTransform);
NTTStrategy nttStrategy = new IntAparapiFactor3NTTStrategy(new IntAparapiColumnSixStepFNTStrategy());
nttStrategy.transform(dataStorage, modulus);
int[] actualTransform = getPlainArray(dataStorage);
Arrays.sort(actualTransform);
assertEquals("expected length", size, expectedTransform.length);
assertEquals("actual length", size, actualTransform.length);
for (int i = 0; i < size; i++)
{
assertEquals("MODULUS[" + modulus + "], [" + i + "]", (long) expectedTransform[i], (long) actualTransform[i]);
}
}
}
public static void testRoundTrip()
{
ApfloatContext ctx = ApfloatContext.getContext();
int numberOfProcessors = ctx.getNumberOfProcessors();
ctx.setNumberOfProcessors(1);
ctx.setMemoryThreshold(Long.MAX_VALUE);
runRoundTrip();
ctx.setNumberOfProcessors(numberOfProcessors);
}
private static void runRoundTrip()
{
int size = (int) Math.min(3 * 1048576, IntModConstants.MAX_TRANSFORM_LENGTH); // Will use six-step transform
DataStorage dataStorage = createDataStorage(size + 5).subsequence(5, size);
for (int modulus = 0; modulus < 3; modulus++)
{
Factor3NTTStrategy nttStrategy = new IntAparapiFactor3NTTStrategy(new IntAparapiColumnSixStepFNTStrategy());
nttStrategy.transform(dataStorage, modulus);
assertEquals("transformed size", size, dataStorage.getSize());
DataStorage.Iterator iterator = dataStorage.iterator(DataStorage.READ, 0, 1);
assertTrue("transformed [0]", 6 != (long) iterator.getInt());
iterator.close();
nttStrategy.inverseTransform(dataStorage, modulus, size);
assertEquals("inverse transformed size", size, dataStorage.getSize());
iterator = dataStorage.iterator(DataStorage.READ, 0, size);
for (int i = 0; i < size; i++)
{
assertEquals("MODULUS[" + modulus + "], round-tripped [" + i + "]", i + 6, (long) iterator.getInt());
iterator.next();
}
}
}
public static void testRoundTrip2()
{
ApfloatContext ctx = ApfloatContext.getContext();
int numberOfProcessors = ctx.getNumberOfProcessors();
ctx.setNumberOfProcessors(1);
ctx.setMemoryThreshold(Long.MAX_VALUE);
runRoundTrip2();
ctx.setNumberOfProcessors(numberOfProcessors);
}
private static void runRoundTrip2()
{
int size = 2048; // Will fall back to the power-of-two length transform
DataStorage dataStorage = createDataStorage(size + 5).subsequence(5, size);
for (int modulus = 0; modulus < 3; modulus++)
{
Factor3NTTStrategy nttStrategy = new IntAparapiFactor3NTTStrategy(new IntAparapiSixStepFNTStrategy());
nttStrategy.transform(dataStorage, modulus);
assertEquals("transformed size", size, dataStorage.getSize());
DataStorage.Iterator iterator = dataStorage.iterator(DataStorage.READ, 0, 1);
assertTrue("transformed [0]", 6 != (long) iterator.getInt());
iterator.close();
nttStrategy.inverseTransform(dataStorage, modulus, size);
assertEquals("inverse transformed size", size, dataStorage.getSize());
iterator = dataStorage.iterator(DataStorage.READ, 0, size);
for (int i = 0; i < size; i++)
{
assertEquals("MODULUS[" + modulus + "], round-tripped [" + i + "]", i + 6, (long) iterator.getInt());
iterator.next();
}
}
}
}
apfloat-1.15.0/apfloat-aparapi/src/test/java/org/apfloat/aparapi/IntAparapiMatrixStrategyTest.java 0000664 0000000 0000000 00000024645 15113064030 0033255 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2023 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.*;
import org.apfloat.spi.*;
import org.apfloat.internal.*;
import junit.framework.TestSuite;
/**
* @since 1.8.3
* @version 1.8.3
* @author Mikko Tommila
*/
public class IntAparapiMatrixStrategyTest
extends IntTestCase
{
public IntAparapiMatrixStrategyTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new IntAparapiMatrixStrategyTest("testTransposeSquare"));
suite.addTest(new IntAparapiMatrixStrategyTest("testTransposeSquarePart"));
suite.addTest(new IntAparapiMatrixStrategyTest("testTransposeWide"));
suite.addTest(new IntAparapiMatrixStrategyTest("testTransposeTall"));
suite.addTest(new IntAparapiMatrixStrategyTest("testPermuteToDoubleWidth"));
suite.addTest(new IntAparapiMatrixStrategyTest("testPermuteToHalfWidth"));
return suite;
}
private static ArrayAccess getArray(int count)
{
int[] data = new int[count + 5];
ArrayAccess arrayAccess = new IntMemoryArrayAccess(data, 5, count);
for (int i = 0; i < count; i++)
{
data[i + 5] = (int) (i + 1);
}
return arrayAccess;
}
public static void testTransposeSquare()
{
ArrayAccess arrayAccess = getArray(16);
new IntAparapiMatrixStrategy().transpose(arrayAccess, 4, 4);
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
assertEquals("16 elem [" + i + "][" + j + "]", 4 * j + i + 1, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + 4 * i + j]);
}
}
arrayAccess = getArray(18).subsequence(1, 16);
new IntAparapiMatrixStrategy().transpose(arrayAccess, 4, 4);
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
assertEquals("16 elem sub [" + i + "][" + j + "]", 4 * j + i + 2, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + 4 * i + j]);
}
}
ApfloatContext ctx = ApfloatContext.getContext();
int cacheBurstBlockSize = Util.round2down(ctx.getCacheBurst() / 4), // Cache burst in ints
cacheL1Size = Util.sqrt4down(ctx.getCacheL1Size() / 4), // To fit in processor L1 cache
cacheL2Size = Util.sqrt4down(ctx.getCacheL2Size() / 4), // To fit in processor L2 cache
bigSize = cacheL2Size * 2; // To not fit in processor L2 cache
arrayAccess = getArray(cacheBurstBlockSize * cacheBurstBlockSize);
new IntAparapiMatrixStrategy().transpose(arrayAccess, cacheBurstBlockSize, cacheBurstBlockSize);
for (int i = 0; i < cacheBurstBlockSize; i++)
{
for (int j = 0; j < cacheBurstBlockSize; j++)
{
assertEquals("cacheBurstBlockSize [" + i + "][" + j + "]", cacheBurstBlockSize * j + i + 1, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + cacheBurstBlockSize * i + j]);
}
}
arrayAccess = getArray(cacheL1Size * cacheL1Size);
new IntAparapiMatrixStrategy().transpose(arrayAccess, cacheL1Size, cacheL1Size);
for (int i = 0; i < cacheL1Size; i++)
{
for (int j = 0; j < cacheL1Size; j++)
{
assertEquals("cacheL1Size [" + i + "][" + j + "]", cacheL1Size * j + i + 1, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + cacheL1Size * i + j]);
}
}
arrayAccess = getArray(cacheL2Size * cacheL2Size);
new IntAparapiMatrixStrategy().transpose(arrayAccess, cacheL2Size, cacheL2Size);
for (int i = 0; i < cacheL2Size; i++)
{
for (int j = 0; j < cacheL2Size; j++)
{
assertEquals("cacheL2Size [" + i + "][" + j + "]", cacheL2Size * j + i + 1, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + cacheL2Size * i + j]);
}
}
arrayAccess = getArray(bigSize * bigSize);
new IntAparapiMatrixStrategy().transpose(arrayAccess, bigSize, bigSize);
for (int i = 0; i < bigSize; i++)
{
for (int j = 0; j < bigSize; j++)
{
assertEquals("bigSize [" + i + "][" + j + "]", bigSize * j + i + 1, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + bigSize * i + j]);
}
}
}
public static void testTransposeSquarePart()
{
ArrayAccess arrayAccess = getArray(32);
new IntAparapiMatrixStrategy().transposeSquare(arrayAccess, 4, 8);
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
assertEquals("1st transposed [" + i + "][" + j + "]", 8 * j + i + 1, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + 8 * i + j]);
}
for (int j = 4; j < 8; j++)
{
assertEquals("1st untransposed [" + i + "][" + j + "]", 8 * i + j + 1, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + 8 * i + j]);
}
}
arrayAccess = getArray(32);
new IntAparapiMatrixStrategy().transposeSquare(arrayAccess.subsequence(4, 28), 4, 8);
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
assertEquals("2nd untransposed [" + i + "][" + j + "]", 8 * i + j + 1, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + 8 * i + j]);
}
for (int j = 4; j < 8; j++)
{
assertEquals("2nd transposed [" + i + "][" + j + "]", 8 * (j - 4) + (i + 4) + 1, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + 8 * i + j]);
}
}
}
public static void testTransposeWide()
{
ApfloatContext ctx = ApfloatContext.getContext();
int cacheL2Size = Util.sqrt4down(ctx.getCacheL2Size() / 4), // To fit in processor L2 cache
bigSize = cacheL2Size * 2; // To not fit in processor L2 cache
ArrayAccess arrayAccess = getArray(2 * bigSize * bigSize + 5).subsequence(5, 2 * bigSize * bigSize);
new IntAparapiMatrixStrategy().transpose(arrayAccess, bigSize, 2 * bigSize);
for (int i = 0; i < 2 * bigSize; i++)
{
for (int j = 0; j < bigSize; j++)
{
assertEquals("transposed [" + i + "][" + j + "]", 2 * bigSize * j + i + 6, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + bigSize * i + j]);
}
}
}
public static void testTransposeTall()
{
ApfloatContext ctx = ApfloatContext.getContext();
int cacheL2Size = Util.sqrt4down(ctx.getCacheL2Size() / 4), // To fit in processor L2 cache
bigSize = cacheL2Size * 2; // To not fit in processor L2 cache
ArrayAccess arrayAccess = getArray(2 * bigSize * bigSize + 5).subsequence(5, 2 * bigSize * bigSize);
new IntAparapiMatrixStrategy().transpose(arrayAccess, 2 * bigSize, bigSize);
for (int i = 0; i < bigSize; i++)
{
for (int j = 0; j < 2 * bigSize; j++)
{
assertEquals("transposed [" + i + "][" + j + "]", bigSize * j + i + 6, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + 2 * bigSize * i + j]);
}
}
}
public static void testPermuteToDoubleWidth()
{
ArrayAccess arrayAccess = getArray(256);
new IntAparapiMatrixStrategy().permuteToDoubleWidth(arrayAccess, 8, 32);
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 32; j++)
{
assertEquals("permuted to double width [" + i + "][" + j + "]", 32 * i + j + 1, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + 64 * i + j]);
}
for (int j = 32; j < 64; j++)
{
assertEquals("permuted to double width [" + i + "][" + j + "]", 32 * i + j - 32 + 128 + 1, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + 64 * i + j]);
}
}
}
public static void testPermuteToHalfWidth()
{
ArrayAccess arrayAccess = getArray(256);
new IntAparapiMatrixStrategy().permuteToHalfWidth(arrayAccess, 4, 64);
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 32; j++)
{
assertEquals("permuted to half width [" + i + "][" + j + "]", 64 * i + j + 1, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + 32 * i + j]);
}
}
for (int i = 4; i < 8; i++)
{
for (int j = 0; j < 32; j++)
{
assertEquals("permuted to half width [" + i + "][" + j + "]", 64 * (i - 4) + j + 32 + 1, (long) arrayAccess.getIntData()[arrayAccess.getOffset() + 32 * i + j]);
}
}
}
}
IntAparapiSixStepFNTStrategyTest.java 0000664 0000000 0000000 00000007702 15113064030 0033674 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/test/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import java.util.Arrays;
import org.apfloat.*;
import org.apfloat.spi.*;
import org.apfloat.internal.*;
import junit.framework.TestSuite;
/**
* @version 1.15.0
* @author Mikko Tommila
*/
public class IntAparapiSixStepFNTStrategyTest
extends IntNTTStrategyTestCase
{
public IntAparapiSixStepFNTStrategyTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new IntAparapiSixStepFNTStrategyTest("testForward"));
suite.addTest(new IntAparapiSixStepFNTStrategyTest("testForwardBig"));
suite.addTest(new IntAparapiSixStepFNTStrategyTest("testRoundTrip"));
suite.addTest(new IntAparapiSixStepFNTStrategyTest("testRoundTripBig"));
return suite;
}
public static void testForward()
{
runTestForward(1024);
}
public static void testForwardBig()
{
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setMemoryThreshold(8192);
runTestForward(4096);
}
private static void runTestForward(int size)
{
runTestForward(new IntAparapiSixStepFNTStrategy(), size);
}
protected static void runTestForward(AbstractStepFNTStrategy nttStrategy, int size)
{
for (int modulus = 0; modulus < 3; modulus++)
{
DataStorage dataStorage = createDataStorage(size + 5).subsequence(5, size);
int[] data = getPlainArray(dataStorage),
expectedTransform = ntt(data, modulus);
IntScramble.scramble(expectedTransform, 0, Scramble.createScrambleTable(size));
Arrays.sort(expectedTransform);
nttStrategy.transform(dataStorage, modulus);
int[] actualTransform = getPlainArray(dataStorage);
Arrays.sort(actualTransform);
assertEquals("expected length", size, expectedTransform.length);
assertEquals("actual length", size, actualTransform.length);
for (int i = 0; i < size; i++)
{
assertEquals("MODULUS[" + modulus + "], [" + i + "]", (long) expectedTransform[i], (long) actualTransform[i]);
}
}
}
public static void testRoundTrip()
{
runRoundTrip(1024);
}
public static void testRoundTripBig()
{
int size = (int) Math.min(1 << 21, IntModConstants.MAX_TRANSFORM_LENGTH & -IntModConstants.MAX_TRANSFORM_LENGTH);
runRoundTrip(size);
}
private static void runRoundTrip(int size)
{
runRoundTrip(new IntAparapiSixStepFNTStrategy(), size);
}
}
IntAparapiTwoPassFNTStrategyTest.java 0000664 0000000 0000000 00000005234 15113064030 0033673 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/test/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.*;
import org.apfloat.spi.*;
import org.apfloat.internal.*;
import junit.framework.TestSuite;
/**
* @version 1.15.0
* @author Mikko Tommila
*/
public class IntAparapiTwoPassFNTStrategyTest
extends IntNTTStrategyTestCase
{
public IntAparapiTwoPassFNTStrategyTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new IntAparapiTwoPassFNTStrategyTest("testRoundTrip"));
suite.addTest(new IntAparapiTwoPassFNTStrategyTest("testRoundTripBig"));
return suite;
}
public static void testRoundTrip()
{
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setMaxMemoryBlockSize(65536);
ctx.setMemoryThreshold(1024);
ctx.setBlockSize(256);
runRoundTrip(131072);
}
public static void testRoundTripBig()
{
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setMaxMemoryBlockSize(65536);
ctx.setMemoryThreshold(1024);
ctx.setBlockSize(256);
int size = (int) Math.min(1 << 21, Util.round2down(IntModConstants.MAX_TRANSFORM_LENGTH));
runRoundTrip(size);
}
private static void runRoundTrip(int size)
{
runRoundTrip(new IntAparapiTwoPassFNTStrategy(), size);
}
}
LongAparapiColumnSixStepFNTStrategyTest.java 0000664 0000000 0000000 00000005660 15113064030 0035220 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/test/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.*;
import org.apfloat.internal.*;
import junit.framework.TestSuite;
/**
* @version 1.15.0
* @author Mikko Tommila
*/
public class LongAparapiColumnSixStepFNTStrategyTest
extends LongAparapiSixStepFNTStrategyTest
{
public LongAparapiColumnSixStepFNTStrategyTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new LongAparapiColumnSixStepFNTStrategyTest("testForward"));
suite.addTest(new LongAparapiColumnSixStepFNTStrategyTest("testForwardBig"));
suite.addTest(new LongAparapiColumnSixStepFNTStrategyTest("testRoundTrip"));
suite.addTest(new LongAparapiColumnSixStepFNTStrategyTest("testRoundTripBig"));
return suite;
}
public static void testForward()
{
runTestForward(1024);
}
public static void testForwardBig()
{
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setMemoryThreshold(8192);
runTestForward(4096);
}
private static void runTestForward(int size)
{
runTestForward(new LongAparapiColumnSixStepFNTStrategy(), size);
}
public static void testRoundTrip()
{
runRoundTrip(1024);
}
public static void testRoundTripBig()
{
int size = (int) Math.min(1 << 21, LongModConstants.MAX_TRANSFORM_LENGTH & -LongModConstants.MAX_TRANSFORM_LENGTH);
runRoundTrip(size);
}
private static void runRoundTrip(int size)
{
runRoundTrip(new LongAparapiColumnSixStepFNTStrategy(), size);
}
}
LongAparapiColumnTwoPassFNTStrategyTest.java 0000664 0000000 0000000 00000005301 15113064030 0035211 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/test/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.*;
import org.apfloat.spi.*;
import org.apfloat.internal.*;
import junit.framework.TestSuite;
/**
* @version 1.15.0
* @author Mikko Tommila
*/
public class LongAparapiColumnTwoPassFNTStrategyTest
extends LongNTTStrategyTestCase
{
public LongAparapiColumnTwoPassFNTStrategyTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new LongAparapiColumnTwoPassFNTStrategyTest("testRoundTrip"));
suite.addTest(new LongAparapiColumnTwoPassFNTStrategyTest("testRoundTripBig"));
return suite;
}
public static void testRoundTrip()
{
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setMaxMemoryBlockSize(65536);
ctx.setMemoryThreshold(1024);
ctx.setBlockSize(256);
runRoundTrip(131072);
}
public static void testRoundTripBig()
{
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setMaxMemoryBlockSize(65536);
ctx.setMemoryThreshold(1024);
ctx.setBlockSize(256);
int size = (int) Math.min(1 << 21, Util.round2down(LongModConstants.MAX_TRANSFORM_LENGTH));
runRoundTrip(size);
}
private static void runRoundTrip(int size)
{
runRoundTrip(new LongAparapiColumnTwoPassFNTStrategy(), size);
}
}
LongAparapiFactor3NTTStrategyTest.java 0000664 0000000 0000000 00000014665 15113064030 0033767 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/test/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import java.util.Arrays;
import org.apfloat.*;
import org.apfloat.spi.*;
import org.apfloat.internal.*;
import junit.framework.TestSuite;
/**
* @version 1.15.0
* @author Mikko Tommila
*/
public class LongAparapiFactor3NTTStrategyTest
extends LongNTTStrategyTestCase
{
public LongAparapiFactor3NTTStrategyTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new LongAparapiFactor3NTTStrategyTest("testForward"));
suite.addTest(new LongAparapiFactor3NTTStrategyTest("testRoundTrip"));
suite.addTest(new LongAparapiFactor3NTTStrategyTest("testRoundTrip2"));
return suite;
}
public static void testForward()
{
runForward();
}
private static void runForward()
{
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setMemoryThreshold(Long.MAX_VALUE);
for (int modulus = 0; modulus < 3; modulus++)
{
int size = 3 * 2048;
DataStorage dataStorage = createDataStorage(size + 5).subsequence(5, size);
long[] data = getPlainArray(dataStorage),
expectedTransform = ntt(data, modulus);
Arrays.sort(expectedTransform);
NTTStrategy nttStrategy = new LongAparapiFactor3NTTStrategy(new LongAparapiColumnSixStepFNTStrategy());
nttStrategy.transform(dataStorage, modulus);
long[] actualTransform = getPlainArray(dataStorage);
Arrays.sort(actualTransform);
assertEquals("expected length", size, expectedTransform.length);
assertEquals("actual length", size, actualTransform.length);
for (int i = 0; i < size; i++)
{
assertEquals("MODULUS[" + modulus + "], [" + i + "]", (long) expectedTransform[i], (long) actualTransform[i]);
}
}
}
public static void testRoundTrip()
{
ApfloatContext ctx = ApfloatContext.getContext();
int numberOfProcessors = ctx.getNumberOfProcessors();
ctx.setNumberOfProcessors(1);
ctx.setMemoryThreshold(Long.MAX_VALUE);
runRoundTrip();
ctx.setNumberOfProcessors(numberOfProcessors);
}
private static void runRoundTrip()
{
int size = (int) Math.min(3 * 1048576, LongModConstants.MAX_TRANSFORM_LENGTH); // Will use six-step transform
DataStorage dataStorage = createDataStorage(size + 5).subsequence(5, size);
for (int modulus = 0; modulus < 3; modulus++)
{
Factor3NTTStrategy nttStrategy = new LongAparapiFactor3NTTStrategy(new LongAparapiColumnSixStepFNTStrategy());
nttStrategy.transform(dataStorage, modulus);
assertEquals("transformed size", size, dataStorage.getSize());
DataStorage.Iterator iterator = dataStorage.iterator(DataStorage.READ, 0, 1);
assertTrue("transformed [0]", 6 != (long) iterator.getLong());
iterator.close();
nttStrategy.inverseTransform(dataStorage, modulus, size);
assertEquals("inverse transformed size", size, dataStorage.getSize());
iterator = dataStorage.iterator(DataStorage.READ, 0, size);
for (int i = 0; i < size; i++)
{
assertEquals("MODULUS[" + modulus + "], round-tripped [" + i + "]", i + 6, (long) iterator.getLong());
iterator.next();
}
}
}
public static void testRoundTrip2()
{
ApfloatContext ctx = ApfloatContext.getContext();
int numberOfProcessors = ctx.getNumberOfProcessors();
ctx.setNumberOfProcessors(1);
ctx.setMemoryThreshold(Long.MAX_VALUE);
runRoundTrip2();
ctx.setNumberOfProcessors(numberOfProcessors);
}
private static void runRoundTrip2()
{
int size = 2048; // Will fall back to the power-of-two length transform
DataStorage dataStorage = createDataStorage(size + 5).subsequence(5, size);
for (int modulus = 0; modulus < 3; modulus++)
{
Factor3NTTStrategy nttStrategy = new LongAparapiFactor3NTTStrategy(new LongAparapiSixStepFNTStrategy());
nttStrategy.transform(dataStorage, modulus);
assertEquals("transformed size", size, dataStorage.getSize());
DataStorage.Iterator iterator = dataStorage.iterator(DataStorage.READ, 0, 1);
assertTrue("transformed [0]", 6 != (long) iterator.getLong());
iterator.close();
nttStrategy.inverseTransform(dataStorage, modulus, size);
assertEquals("inverse transformed size", size, dataStorage.getSize());
iterator = dataStorage.iterator(DataStorage.READ, 0, size);
for (int i = 0; i < size; i++)
{
assertEquals("MODULUS[" + modulus + "], round-tripped [" + i + "]", i + 6, (long) iterator.getLong());
iterator.next();
}
}
}
}
apfloat-1.15.0/apfloat-aparapi/src/test/java/org/apfloat/aparapi/LongAparapiMatrixStrategyTest.java 0000664 0000000 0000000 00000024717 15113064030 0033422 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2023 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.*;
import org.apfloat.spi.*;
import org.apfloat.internal.*;
import junit.framework.TestSuite;
/**
* @since 1.8.3
* @version 1.8.3
* @author Mikko Tommila
*/
public class LongAparapiMatrixStrategyTest
extends LongTestCase
{
public LongAparapiMatrixStrategyTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new LongAparapiMatrixStrategyTest("testTransposeSquare"));
suite.addTest(new LongAparapiMatrixStrategyTest("testTransposeSquarePart"));
suite.addTest(new LongAparapiMatrixStrategyTest("testTransposeWide"));
suite.addTest(new LongAparapiMatrixStrategyTest("testTransposeTall"));
suite.addTest(new LongAparapiMatrixStrategyTest("testPermuteToDoubleWidth"));
suite.addTest(new LongAparapiMatrixStrategyTest("testPermuteToHalfWidth"));
return suite;
}
private static ArrayAccess getArray(int count)
{
long[] data = new long[count + 5];
ArrayAccess arrayAccess = new LongMemoryArrayAccess(data, 5, count);
for (int i = 0; i < count; i++)
{
data[i + 5] = (long) (i + 1);
}
return arrayAccess;
}
public static void testTransposeSquare()
{
ArrayAccess arrayAccess = getArray(16);
new LongAparapiMatrixStrategy().transpose(arrayAccess, 4, 4);
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
assertEquals("16 elem [" + i + "][" + j + "]", 4 * j + i + 1, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + 4 * i + j]);
}
}
arrayAccess = getArray(18).subsequence(1, 16);
new LongAparapiMatrixStrategy().transpose(arrayAccess, 4, 4);
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
assertEquals("16 elem sub [" + i + "][" + j + "]", 4 * j + i + 2, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + 4 * i + j]);
}
}
ApfloatContext ctx = ApfloatContext.getContext();
int cacheBurstBlockSize = Util.round2down(ctx.getCacheBurst() / 8), // Cache burst in longs
cacheL1Size = Util.sqrt4down(ctx.getCacheL1Size() / 8), // To fit in processor L1 cache
cacheL2Size = Util.sqrt4down(ctx.getCacheL2Size() / 8), // To fit in processor L2 cache
bigSize = cacheL2Size * 2; // To not fit in processor L2 cache
arrayAccess = getArray(cacheBurstBlockSize * cacheBurstBlockSize);
new LongAparapiMatrixStrategy().transpose(arrayAccess, cacheBurstBlockSize, cacheBurstBlockSize);
for (int i = 0; i < cacheBurstBlockSize; i++)
{
for (int j = 0; j < cacheBurstBlockSize; j++)
{
assertEquals("cacheBurstBlockSize [" + i + "][" + j + "]", cacheBurstBlockSize * j + i + 1, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + cacheBurstBlockSize * i + j]);
}
}
arrayAccess = getArray(cacheL1Size * cacheL1Size);
new LongAparapiMatrixStrategy().transpose(arrayAccess, cacheL1Size, cacheL1Size);
for (int i = 0; i < cacheL1Size; i++)
{
for (int j = 0; j < cacheL1Size; j++)
{
assertEquals("cacheL1Size [" + i + "][" + j + "]", cacheL1Size * j + i + 1, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + cacheL1Size * i + j]);
}
}
arrayAccess = getArray(cacheL2Size * cacheL2Size);
new LongAparapiMatrixStrategy().transpose(arrayAccess, cacheL2Size, cacheL2Size);
for (int i = 0; i < cacheL2Size; i++)
{
for (int j = 0; j < cacheL2Size; j++)
{
assertEquals("cacheL2Size [" + i + "][" + j + "]", cacheL2Size * j + i + 1, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + cacheL2Size * i + j]);
}
}
arrayAccess = getArray(bigSize * bigSize);
new LongAparapiMatrixStrategy().transpose(arrayAccess, bigSize, bigSize);
for (int i = 0; i < bigSize; i++)
{
for (int j = 0; j < bigSize; j++)
{
assertEquals("bigSize [" + i + "][" + j + "]", bigSize * j + i + 1, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + bigSize * i + j]);
}
}
}
public static void testTransposeSquarePart()
{
ArrayAccess arrayAccess = getArray(32);
new LongAparapiMatrixStrategy().transposeSquare(arrayAccess, 4, 8);
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
assertEquals("1st transposed [" + i + "][" + j + "]", 8 * j + i + 1, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + 8 * i + j]);
}
for (int j = 4; j < 8; j++)
{
assertEquals("1st untransposed [" + i + "][" + j + "]", 8 * i + j + 1, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + 8 * i + j]);
}
}
arrayAccess = getArray(32);
new LongAparapiMatrixStrategy().transposeSquare(arrayAccess.subsequence(4, 28), 4, 8);
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
assertEquals("2nd untransposed [" + i + "][" + j + "]", 8 * i + j + 1, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + 8 * i + j]);
}
for (int j = 4; j < 8; j++)
{
assertEquals("2nd transposed [" + i + "][" + j + "]", 8 * (j - 4) + (i + 4) + 1, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + 8 * i + j]);
}
}
}
public static void testTransposeWide()
{
ApfloatContext ctx = ApfloatContext.getContext();
int cacheL2Size = Util.sqrt4down(ctx.getCacheL2Size() / 8), // To fit in processor L2 cache
bigSize = cacheL2Size * 2; // To not fit in processor L2 cache
ArrayAccess arrayAccess = getArray(2 * bigSize * bigSize + 5).subsequence(5, 2 * bigSize * bigSize);
new LongAparapiMatrixStrategy().transpose(arrayAccess, bigSize, 2 * bigSize);
for (int i = 0; i < 2 * bigSize; i++)
{
for (int j = 0; j < bigSize; j++)
{
assertEquals("transposed [" + i + "][" + j + "]", 2 * bigSize * j + i + 6, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + bigSize * i + j]);
}
}
}
public static void testTransposeTall()
{
ApfloatContext ctx = ApfloatContext.getContext();
int cacheL2Size = Util.sqrt4down(ctx.getCacheL2Size() / 8), // To fit in processor L2 cache
bigSize = cacheL2Size * 2; // To not fit in processor L2 cache
ArrayAccess arrayAccess = getArray(2 * bigSize * bigSize + 5).subsequence(5, 2 * bigSize * bigSize);
new LongAparapiMatrixStrategy().transpose(arrayAccess, 2 * bigSize, bigSize);
for (int i = 0; i < bigSize; i++)
{
for (int j = 0; j < 2 * bigSize; j++)
{
assertEquals("transposed [" + i + "][" + j + "]", bigSize * j + i + 6, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + 2 * bigSize * i + j]);
}
}
}
public static void testPermuteToDoubleWidth()
{
ArrayAccess arrayAccess = getArray(256);
new LongAparapiMatrixStrategy().permuteToDoubleWidth(arrayAccess, 8, 32);
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 32; j++)
{
assertEquals("permuted to double width [" + i + "][" + j + "]", 32 * i + j + 1, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + 64 * i + j]);
}
for (int j = 32; j < 64; j++)
{
assertEquals("permuted to double width [" + i + "][" + j + "]", 32 * i + j - 32 + 128 + 1, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + 64 * i + j]);
}
}
}
public static void testPermuteToHalfWidth()
{
ArrayAccess arrayAccess = getArray(256);
new LongAparapiMatrixStrategy().permuteToHalfWidth(arrayAccess, 4, 64);
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 32; j++)
{
assertEquals("permuted to half width [" + i + "][" + j + "]", 64 * i + j + 1, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + 32 * i + j]);
}
}
for (int i = 4; i < 8; i++)
{
for (int j = 0; j < 32; j++)
{
assertEquals("permuted to half width [" + i + "][" + j + "]", 64 * (i - 4) + j + 32 + 1, (long) arrayAccess.getLongData()[arrayAccess.getOffset() + 32 * i + j]);
}
}
}
}
LongAparapiSixStepFNTStrategyTest.java 0000664 0000000 0000000 00000007720 15113064030 0034041 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/test/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import java.util.Arrays;
import org.apfloat.*;
import org.apfloat.spi.*;
import org.apfloat.internal.*;
import junit.framework.TestSuite;
/**
* @version 1.15.0
* @author Mikko Tommila
*/
public class LongAparapiSixStepFNTStrategyTest
extends LongNTTStrategyTestCase
{
public LongAparapiSixStepFNTStrategyTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new LongAparapiSixStepFNTStrategyTest("testForward"));
suite.addTest(new LongAparapiSixStepFNTStrategyTest("testForwardBig"));
suite.addTest(new LongAparapiSixStepFNTStrategyTest("testRoundTrip"));
suite.addTest(new LongAparapiSixStepFNTStrategyTest("testRoundTripBig"));
return suite;
}
public static void testForward()
{
runTestForward(1024);
}
public static void testForwardBig()
{
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setMemoryThreshold(8192);
runTestForward(4096);
}
private static void runTestForward(int size)
{
runTestForward(new LongAparapiSixStepFNTStrategy(), size);
}
protected static void runTestForward(AbstractStepFNTStrategy nttStrategy, int size)
{
for (int modulus = 0; modulus < 3; modulus++)
{
DataStorage dataStorage = createDataStorage(size + 5).subsequence(5, size);
long[] data = getPlainArray(dataStorage),
expectedTransform = ntt(data, modulus);
LongScramble.scramble(expectedTransform, 0, Scramble.createScrambleTable(size));
Arrays.sort(expectedTransform);
nttStrategy.transform(dataStorage, modulus);
long[] actualTransform = getPlainArray(dataStorage);
Arrays.sort(actualTransform);
assertEquals("expected length", size, expectedTransform.length);
assertEquals("actual length", size, actualTransform.length);
for (int i = 0; i < size; i++)
{
assertEquals("MODULUS[" + modulus + "], [" + i + "]", (long) expectedTransform[i], (long) actualTransform[i]);
}
}
}
public static void testRoundTrip()
{
runRoundTrip(1024);
}
public static void testRoundTripBig()
{
int size = (int) Math.min(1 << 21, LongModConstants.MAX_TRANSFORM_LENGTH & -LongModConstants.MAX_TRANSFORM_LENGTH);
runRoundTrip(size);
}
private static void runRoundTrip(int size)
{
runRoundTrip(new LongAparapiSixStepFNTStrategy(), size);
}
}
LongAparapiTwoPassFNTStrategyTest.java 0000664 0000000 0000000 00000005243 15113064030 0034040 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-aparapi/src/test/java/org/apfloat/aparapi /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.aparapi;
import org.apfloat.*;
import org.apfloat.spi.*;
import org.apfloat.internal.*;
import junit.framework.TestSuite;
/**
* @version 1.15.0
* @author Mikko Tommila
*/
public class LongAparapiTwoPassFNTStrategyTest
extends LongNTTStrategyTestCase
{
public LongAparapiTwoPassFNTStrategyTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new LongAparapiTwoPassFNTStrategyTest("testRoundTrip"));
suite.addTest(new LongAparapiTwoPassFNTStrategyTest("testRoundTripBig"));
return suite;
}
public static void testRoundTrip()
{
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setMaxMemoryBlockSize(65536);
ctx.setMemoryThreshold(1024);
ctx.setBlockSize(256);
runRoundTrip(131072);
}
public static void testRoundTripBig()
{
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setMaxMemoryBlockSize(65536);
ctx.setMemoryThreshold(1024);
ctx.setBlockSize(256);
int size = (int) Math.min(1 << 21, Util.round2down(LongModConstants.MAX_TRANSFORM_LENGTH));
runRoundTrip(size);
}
private static void runRoundTrip(int size)
{
runRoundTrip(new LongAparapiTwoPassFNTStrategy(), size);
}
}
apfloat-1.15.0/apfloat-applet/ 0000775 0000000 0000000 00000000000 15113064030 0016126 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-applet/pom.xml 0000664 0000000 0000000 00000003616 15113064030 0017451 0 ustar 00root root 0000000 0000000
4.0.0
org.apfloat
apfloat-parent
1.15.0
apfloat-applet
apfloat-applet
Configuration for apfloat to not use disk files for data storage
https://www.apfloat.org
org.apfloat
apfloat
junit
junit
test
org.apache.maven.plugins
maven-javadoc-plugin
org.apache.maven.plugins
maven-shade-plugin
shade
org.apfloat:apfloat-applet
${project.build.directory}/applet.jar
apfloat-1.15.0/apfloat-applet/src/ 0000775 0000000 0000000 00000000000 15113064030 0016715 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-applet/src/main/ 0000775 0000000 0000000 00000000000 15113064030 0017641 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-applet/src/main/java/ 0000775 0000000 0000000 00000000000 15113064030 0020562 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-applet/src/main/java/apfloat.java 0000664 0000000 0000000 00000007662 15113064030 0023066 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;
import java.util.ListResourceBundle;
import java.util.ServiceConfigurationError;
import org.apfloat.ApfloatContext;
import org.apfloat.spi.Util;
/**
* Default initial settings for the global {@link ApfloatContext}.
* These settings are intended for applets that are not allowed to create
* disk files.
*
* @version 1.15.0
* @author Mikko Tommila
*/
public class apfloat
extends ListResourceBundle
{
@Override
public Object[][] getContents()
{
return CONTENTS;
}
private static final Object[][] CONTENTS;
static
{
// Try to use up to 80% of total memory and all processors
long totalMemory = Runtime.getRuntime().maxMemory();
boolean disableJmx = Boolean.getBoolean("apfloat.disableJmx");
if (!disableJmx)
{
try
{
MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
MemoryUsage memoryUsage = memoryBean.getHeapMemoryUsage();
totalMemory = Math.max(memoryUsage.getCommitted(), memoryUsage.getMax());
}
catch (NoClassDefFoundError | ServiceConfigurationError | RuntimeException e)
{
// The ManagementFactory class might be unavailable
}
}
long maxMemoryBlockSize = Util.round23down(totalMemory / 5 * 4);
int numberOfProcessors = Runtime.getRuntime().availableProcessors();
long memoryThreshold = Long.MAX_VALUE;
int blockSize = Util.round2down((int) Math.min(Math.max(maxMemoryBlockSize >> 10, 65536), Integer.MAX_VALUE));
Object[][] contents =
{
{ ApfloatContext.BUILDER_FACTORY, "org.apfloat.internal.LongBuilderFactory" },
{ ApfloatContext.DEFAULT_RADIX, "10" },
{ ApfloatContext.MAX_MEMORY_BLOCK_SIZE, String.valueOf(maxMemoryBlockSize) },
{ ApfloatContext.CACHE_L1_SIZE, "8192" },
{ ApfloatContext.CACHE_L2_SIZE, "262144" },
{ ApfloatContext.CACHE_BURST, "32" },
{ ApfloatContext.MEMORY_THRESHOLD, String.valueOf(memoryThreshold) },
{ ApfloatContext.SHARED_MEMORY_TRESHOLD, String.valueOf(maxMemoryBlockSize / numberOfProcessors / 32) },
{ ApfloatContext.BLOCK_SIZE, String.valueOf(blockSize) },
{ ApfloatContext.NUMBER_OF_PROCESSORS, String.valueOf(numberOfProcessors) },
{ ApfloatContext.FILE_PATH, "" },
{ ApfloatContext.FILE_INITIAL_VALUE, "0" },
{ ApfloatContext.FILE_SUFFIX, ".ap" },
{ ApfloatContext.CLEANUP_AT_EXIT, "false" }
};
CONTENTS = contents;
}
}
apfloat-1.15.0/apfloat-calc/ 0000775 0000000 0000000 00000000000 15113064030 0015543 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-calc/pom.xml 0000664 0000000 0000000 00000006317 15113064030 0017067 0 ustar 00root root 0000000 0000000
4.0.0
org.apfloat
apfloat-parent
1.15.0
apfloat-calc
apfloat-calc
Interactive arbitrary precision calculator application
https://www.apfloat.org
org.apfloat
apfloat
junit
junit
test
org.codehaus.mojo
javacc-maven-plugin
javacc
javacc
src/main/java
biz.aQute.bnd
bnd-maven-plugin
generate-osgi-manifest
bnd-process
org.apache.maven.plugins
maven-jar-plugin
${project.build.outputDirectory}/META-INF/MANIFEST.MF
org.apache.maven.plugins
maven-shade-plugin
shade
org.apfloat:apfloat-calc
${project.build.directory}/calc.jar
apfloat.jar
apfloat-1.15.0/apfloat-calc/src/ 0000775 0000000 0000000 00000000000 15113064030 0016332 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-calc/src/main/ 0000775 0000000 0000000 00000000000 15113064030 0017256 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-calc/src/main/java/ 0000775 0000000 0000000 00000000000 15113064030 0020177 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-calc/src/main/java/org/ 0000775 0000000 0000000 00000000000 15113064030 0020766 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-calc/src/main/java/org/apfloat/ 0000775 0000000 0000000 00000000000 15113064030 0022414 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-calc/src/main/java/org/apfloat/calc/ 0000775 0000000 0000000 00000000000 15113064030 0023316 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-calc/src/main/java/org/apfloat/calc/AbstractCalculatorImpl.java 0000664 0000000 0000000 00000011403 15113064030 0030557 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2024 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.calc;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Basic calculator implementation.
* Provides a storage for variables, and maps
* the elementary operators to function calls.
*
* @version 1.14.0
* @author Mikko Tommila
*/
public abstract class AbstractCalculatorImpl
implements CalculatorImpl, Serializable
{
private static final long serialVersionUID = 1L;
/**
* Default constructor.
*/
protected AbstractCalculatorImpl()
{
this.variables = new HashMap<>();
this.pretty = false;
}
@Override
public Number negate(Number x)
throws ParseException
{
return function("negate", toList(x));
}
@Override
public Number add(Number x, Number y)
throws ParseException
{
return function("add", toList(x, y));
}
@Override
public Number subtract(Number x, Number y)
throws ParseException
{
return function("subtract", toList(x, y));
}
@Override
public Number multiply(Number x, Number y)
throws ParseException
{
return function("multiply", toList(x, y));
}
@Override
public Number divide(Number x, Number y)
throws ParseException
{
return function("divide", toList(x, y));
}
@Override
public Number mod(Number x, Number y)
throws ParseException
{
return function("mod", toList(x, y));
}
@Override
public Number pow(Number x, Number y)
throws ParseException
{
return function("pow", toList(x, y));
}
@Override
public Number factorial(Number x)
throws ParseException
{
return function("factorial", toList(x));
}
@Override
public Number doubleFactorial(Number x)
throws ParseException
{
return function("doubleFactorial", toList(x));
}
@Override
public Number getVariable(String name)
throws ParseException
{
Number variable = this.variables.get(name);
if (variable == null)
{
throw new ParseException("Invalid variable: " + name);
}
return variable;
}
@Override
public void setVariable(String name, Number value)
{
this.variables.put(name, value);
}
@Override
public void setFormat(boolean pretty)
{
this.pretty = pretty;
}
@Override
public void setInputPrecision(Long inputPrecision)
{
this.inputPrecision = inputPrecision;
}
/**
* Get the formatting option.
*
* @return If a fixed-point or a floating-point notation should be used.
*/
protected boolean getFormat()
{
return this.pretty;
}
/**
* Get the input precision.
*
* @return The input precision if a fixed precision is used or null for arbitrary precision.
*/
protected Long getInputPrecision()
{
return this.inputPrecision;
}
private static List toList(Number x)
{
List list = new ArrayList<>();
list.add(x);
return list;
}
private static List toList(Number x, Number y)
{
List list = new ArrayList<>();
list.add(x);
list.add(y);
return list;
}
private Map variables;
private boolean pretty;
private Long inputPrecision;
}
apfloat-1.15.0/apfloat-calc/src/main/java/org/apfloat/calc/ApfloatCalculatorImpl.java 0000664 0000000 0000000 00000125600 15113064030 0030407 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.calc;
import java.math.RoundingMode;
import java.util.function.BiFunction;
import org.apfloat.Apcomplex;
import org.apfloat.ApcomplexMath;
import org.apfloat.Apfloat;
import org.apfloat.ApfloatMath;
import org.apfloat.Apint;
import org.apfloat.ApintMath;
import org.apfloat.Aprational;
import org.apfloat.AprationalMath;
import org.apfloat.FixedPrecisionApcomplexHelper;
import org.apfloat.spi.Util;
/**
* Arbitrary precision calculator implementation.
*
* @version 1.15.0
* @author Mikko Tommila
*/
public class ApfloatCalculatorImpl
extends FunctionCalculatorImpl
{
private static final long serialVersionUID = 1L;
private class ApcomplexFunctions
implements Functions
{
@Override
public Number negate(Number x)
{
return ((Apcomplex) x).negate();
}
@Override
public Number add(Number x, Number y)
{
return ((Apcomplex) x).add((Apcomplex) y);
}
@Override
public Number subtract(Number x, Number y)
{
return ((Apcomplex) x).subtract((Apcomplex) y);
}
@Override
public Number multiply(Number x, Number y)
{
return ((Apcomplex) x).multiply((Apcomplex) y);
}
@Override
public Number divide(Number x, Number y)
{
return ((Apcomplex) x).divide((Apcomplex) y);
}
@Override
public Number mod(Number x, Number y)
{
throw new IllegalArgumentException("Modulus can only be used with scalar values");
}
@Override
public Number pow(Number x, Number y)
{
if (isLong(y))
{
if (((Apcomplex) y).precision() < ((Apcomplex) x).precision())
{
x = ((Apcomplex) x).precision(((Apcomplex) y).precision());
}
return pow(x, y.longValue());
}
else
{
return ApcomplexMath.pow((Apcomplex) x, (Apcomplex) y);
}
}
protected Number pow(Number x, long y)
{
return ApcomplexMath.pow((Apcomplex) x, y);
}
@Override
public Number arg(Number x)
{
return ApcomplexMath.arg((Apcomplex) x);
}
@Override
public Number conj(Number x)
{
return ((Apcomplex) x).conj();
}
@Override
public Number imag(Number x)
{
return ((Apcomplex) x).imag();
}
@Override
public Number real(Number x)
{
return ((Apcomplex) x).real();
}
@Override
public Number abs(Number x)
{
return ApcomplexMath.abs((Apcomplex) x);
}
@Override
public Number acos(Number x)
{
return fixedOrArbitraryPrecision(fixedPrecisionApcomplexHelper::acos, ApcomplexMath::acos, x);
}
@Override
public Number acosh(Number x)
{
return fixedOrArbitraryPrecision(fixedPrecisionApcomplexHelper::acosh, ApcomplexMath::acosh, x);
}
@Override
public Number airyAi(Number x)
{
return fixedOrArbitraryPrecision(fixedPrecisionApcomplexHelper::airyAi, ApcomplexMath::airyAi, x);
}
@Override
public Number airyAiPrime(Number x)
{
return fixedOrArbitraryPrecision(fixedPrecisionApcomplexHelper::airyAiPrime, ApcomplexMath::airyAiPrime, x);
}
@Override
public Number airyBi(Number x)
{
return fixedOrArbitraryPrecision(fixedPrecisionApcomplexHelper::airyBi, ApcomplexMath::airyBi, x);
}
@Override
public Number airyBiPrime(Number x)
{
return fixedOrArbitraryPrecision(fixedPrecisionApcomplexHelper::airyBiPrime, ApcomplexMath::airyBiPrime, x);
}
@Override
public Number angerJ(Number x, Number y)
{
return ApcomplexMath.angerJ((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number asin(Number x)
{
return ApcomplexMath.asin((Apcomplex) x);
}
@Override
public Number asinh(Number x)
{
return ApcomplexMath.asinh((Apcomplex) x);
}
@Override
public Number atan(Number x)
{
return ApcomplexMath.atan((Apcomplex) x);
}
@Override
public Number atanh(Number x)
{
return ApcomplexMath.atanh((Apcomplex) x);
}
@Override
public Number bernoulli(Number x)
{
if (!isLong(x))
{
throw new IllegalArgumentException("Bernoulli can only be used with a valid integer argument");
}
long n = x.longValue();
return AprationalMath.bernoulli(n);
}
@Override
public Number bernoulliB(Number x, Number y)
{
if (!isLong(x))
{
throw new IllegalArgumentException("Bernoulli B can only be used with a valid integer first argument");
}
long n = x.longValue();
return fixedOrArbitraryPrecision(fixedPrecisionApcomplexHelper::bernoulliB, ApcomplexMath::bernoulliB, n, (Apcomplex) y);
}
@Override
public Number besselI(Number x, Number y)
{
return ApcomplexMath.besselI((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number besselJ(Number x, Number y)
{
return ApcomplexMath.besselJ((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number besselK(Number x, Number y)
{
return ApcomplexMath.besselK((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number besselY(Number x, Number y)
{
return ApcomplexMath.besselY((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number beta(Number a, Number b)
{
return ApcomplexMath.beta((Apcomplex) a, (Apcomplex) b);
}
@Override
public Number beta(Number x, Number a, Number b)
{
return ApcomplexMath.beta((Apcomplex) x, (Apcomplex) a, (Apcomplex) b);
}
@Override
public Number beta(Number x1, Number x2, Number a, Number b)
{
return ApcomplexMath.beta((Apcomplex) x1, (Apcomplex) x2, (Apcomplex) a, (Apcomplex) b);
}
@Override
public Number binomial(Number x, Number y)
{
return ApcomplexMath.binomial((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number catalan(Number x)
{
if (!isLong(x))
{
throw new IllegalArgumentException("Catalan can only be used with a valid integer argument");
}
long n = x.longValue();
return ApfloatMath.catalan(n);
}
@Override
public Number cbrt(Number x)
{
return root(x, 3);
}
@Override
public Number ceil(Number x)
{
throw new IllegalArgumentException("Ceiling can only be used with scalar values");
}
@Override
public Number chebyshevT(Number x, Number y)
{
return ApcomplexMath.chebyshevT((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number chebyshevU(Number x, Number y)
{
return ApcomplexMath.chebyshevU((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number cos(Number x)
{
return ApcomplexMath.cos((Apcomplex) x);
}
@Override
public Number cosIntegral(Number x)
{
return ApcomplexMath.cosIntegral((Apcomplex) x);
}
@Override
public Number cosh(Number x)
{
return ApcomplexMath.cosh((Apcomplex) x);
}
@Override
public Number coshIntegral(Number x)
{
return ApcomplexMath.coshIntegral((Apcomplex) x);
}
@Override
public Number digamma(Number x)
{
return ApcomplexMath.digamma((Apcomplex) x);
}
@Override
public Number doubleFactorial(Number x)
{
if (!isLong(x))
{
throw new IllegalArgumentException("Double factorial can only be used with a valid integer argument");
}
long n = x.longValue();
return AprationalMath.doubleFactorial(n);
}
@Override
public Number e(Number x)
{
if (!isLong(x))
{
throw new IllegalArgumentException("E can only be used with a valid integer argument");
}
long n = x.longValue();
return ApfloatMath.e(n);
}
@Override
public Number ellipticE(Number x)
{
return fixedOrArbitraryPrecision(fixedPrecisionApcomplexHelper::ellipticE, ApcomplexMath::ellipticE, x);
}
@Override
public Number ellipticK(Number x)
{
return fixedOrArbitraryPrecision(fixedPrecisionApcomplexHelper::ellipticK, ApcomplexMath::ellipticK, x);
}
@Override
public Number erf(Number x)
{
return ApcomplexMath.erf((Apcomplex) x);
}
@Override
public Number erfc(Number x)
{
return ApcomplexMath.erfc((Apcomplex) x);
}
@Override
public Number erfi(Number x)
{
return ApcomplexMath.erfi((Apcomplex) x);
}
@Override
public Number euler(Number x)
{
if (!isLong(x))
{
throw new IllegalArgumentException("Euler can only be used with a valid integer argument");
}
long n = x.longValue();
return ApfloatMath.euler(n);
}
@Override
public Number eulerE(Number x, Number y)
{
if (!isLong(x))
{
throw new IllegalArgumentException("Euler E can only be used with a valid integer first argument");
}
long n = x.longValue();
return fixedOrArbitraryPrecision(fixedPrecisionApcomplexHelper::eulerE, ApcomplexMath::eulerE, n, (Apcomplex) y);
}
@Override
public Number exp(Number x)
{
return ApcomplexMath.exp((Apcomplex) x);
}
@Override
public Number expIntegralE(Number x, Number y)
{
return ApcomplexMath.expIntegralE((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number expIntegralEi(Number x)
{
return ApcomplexMath.expIntegralEi((Apcomplex) x);
}
@Override
public Number factorial(Number x)
{
if (!isLong(x))
{
throw new IllegalArgumentException("Factorial can only be used with a valid integer argument");
}
long n = x.longValue();
return ApintMath.factorial(n);
}
@Override
public Number fibonacci(Number x, Number y)
{
return ApcomplexMath.fibonacci((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number floor(Number x)
{
throw new IllegalArgumentException("Floor can only be used with scalar values");
}
@Override
public Number frac(Number x)
{
throw new IllegalArgumentException("Frac can only be used with scalar values");
}
@Override
public Number fresnelC(Number x)
{
return ApcomplexMath.fresnelC((Apcomplex) x);
}
@Override
public Number fresnelS(Number x)
{
return ApcomplexMath.fresnelS((Apcomplex) x);
}
@Override
public Number gegenbauerC(Number x, Number y)
{
return ApcomplexMath.gegenbauerC((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number gegenbauerC(Number x, Number y, Number z)
{
return ApcomplexMath.gegenbauerC((Apcomplex) x, (Apcomplex) y, (Apcomplex) z);
}
@Override
public Number glaisher(Number x)
{
if (!isLong(x))
{
throw new IllegalArgumentException("Glaisher can only be used with a valid integer argument");
}
long n = x.longValue();
return ApfloatMath.glaisher(n);
}
@Override
public Number gamma(Number x)
{
return ApcomplexMath.gamma((Apcomplex) x);
}
@Override
public Number gamma(Number x, Number y)
{
return ApcomplexMath.gamma((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number gamma(Number x, Number y, Number z)
{
return ApcomplexMath.gamma((Apcomplex) x, (Apcomplex) y, (Apcomplex) z);
}
@Override
public Number harmonicNumber(Number x)
{
return ApcomplexMath.harmonicNumber((Apcomplex) x);
}
@Override
public Number harmonicNumber(Number x, Number y)
{
return ApcomplexMath.harmonicNumber((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number hermiteH(Number x, Number y)
{
return ApcomplexMath.hermiteH((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number hypergeometric0F1(Number a, Number z)
{
return ApcomplexMath.hypergeometric0F1((Apcomplex) a, (Apcomplex) z);
}
@Override
public Number hypergeometric0F1Regularized(Number a, Number z)
{
return ApcomplexMath.hypergeometric0F1Regularized((Apcomplex) a, (Apcomplex) z);
}
@Override
public Number hypergeometric1F1(Number a, Number b, Number z)
{
return ApcomplexMath.hypergeometric1F1((Apcomplex) a, (Apcomplex) b, (Apcomplex) z);
}
@Override
public Number hypergeometric1F1Regularized(Number a, Number b, Number z)
{
return ApcomplexMath.hypergeometric1F1Regularized((Apcomplex) a, (Apcomplex) b, (Apcomplex) z);
}
@Override
public Number hypergeometric2F1(Number a, Number b, Number c, Number z)
{
return ApcomplexMath.hypergeometric2F1((Apcomplex) a, (Apcomplex) b, (Apcomplex) c, (Apcomplex) z);
}
@Override
public Number hypergeometric2F1Regularized(Number a, Number b, Number c, Number z)
{
return ApcomplexMath.hypergeometric2F1Regularized((Apcomplex) a, (Apcomplex) b, (Apcomplex) c, (Apcomplex) z);
}
@Override
public Number hypergeometricU(Number a, Number b, Number z)
{
return ApcomplexMath.hypergeometricU((Apcomplex) a, (Apcomplex) b, (Apcomplex) z);
}
@Override
public Number inverseErf(Number x)
{
throw new IllegalArgumentException("Inverse erf can only be used with scalar values");
}
@Override
public Number inverseErfc(Number x)
{
throw new IllegalArgumentException("Inverse erfc can only be used with scalar values");
}
@Override
public Number jacobiP(Number x, Number y, Number z, Number w)
{
return ApcomplexMath.jacobiP((Apcomplex) x, (Apcomplex) y, (Apcomplex) z, (Apcomplex) w);
}
@Override
public Number khinchin(Number x)
{
if (!isLong(x))
{
throw new IllegalArgumentException("Khinchin can only be used with a valid integer argument");
}
long n = x.longValue();
return ApfloatMath.khinchin(n);
}
@Override
public Number laguerreL(Number x, Number y)
{
return ApcomplexMath.laguerreL((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number laguerreL(Number x, Number y, Number z)
{
return ApcomplexMath.laguerreL((Apcomplex) x, (Apcomplex) y, (Apcomplex) z);
}
@Override
public Number legendreP(Number x, Number y)
{
return ApcomplexMath.legendreP((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number legendreP(Number x, Number y, Number z)
{
return ApcomplexMath.legendreP((Apcomplex) x, (Apcomplex) y, (Apcomplex) z);
}
@Override
public Number legendreQ(Number x, Number y)
{
return ApcomplexMath.legendreQ((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number legendreQ(Number x, Number y, Number z)
{
return ApcomplexMath.legendreQ((Apcomplex) x, (Apcomplex) y, (Apcomplex) z);
}
@Override
public Number log(Number x)
{
return ApcomplexMath.log((Apcomplex) x);
}
@Override
public Number log(Number x, Number y)
{
return ApcomplexMath.log((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number logGamma(Number x)
{
return ApcomplexMath.logGamma((Apcomplex) x);
}
@Override
public Number logIntegral(Number x)
{
return ApcomplexMath.logIntegral((Apcomplex) x);
}
@Override
public Number logisticSigmoid(Number x)
{
return ApcomplexMath.logisticSigmoid((Apcomplex) x);
}
@Override
public Number max(Number x, Number y)
{
throw new IllegalArgumentException("Max can only be used with scalar values");
}
@Override
public Number min(Number x, Number y)
{
throw new IllegalArgumentException("Min can only be used with scalar values");
}
@Override
public Number nextAfter(Number x, Number y)
{
throw new IllegalArgumentException("Next after can only be used with scalar values");
}
@Override
public Number nextDown(Number x)
{
throw new IllegalArgumentException("Next down can only be used with scalar values");
}
@Override
public Number nextUp(Number x)
{
throw new IllegalArgumentException("Next up can only be used with scalar values");
}
@Override
public Number pi(Number x)
{
if (!isLong(x))
{
throw new IllegalArgumentException("Pi can only be used with a valid integer argument");
}
long n = x.longValue();
return ApfloatMath.pi(n);
}
@Override
public Number pochhammer(Number x, Number y)
{
return ApcomplexMath.pochhammer((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number polygamma(Number x, Number y)
{
if (!isLong(x))
{
throw new IllegalArgumentException("Polygamma can only be used with a valid integer first argument");
}
long n = x.longValue();
return ApcomplexMath.polygamma(n, (Apcomplex) y);
}
@Override
public Number polylog(Number x, Number y)
{
return ApcomplexMath.polylog((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number random(Number x)
{
if (!isLong(x))
{
throw new IllegalArgumentException("Random can only be used with a valid integer argument");
}
long n = x.longValue();
return ApfloatMath.random(n);
}
@Override
public Number randomGaussian(Number x)
{
if (!isLong(x))
{
throw new IllegalArgumentException("Random Gaussian can only be used with a valid integer argument");
}
long n = x.longValue();
return ApfloatMath.randomGaussian(n);
}
@Override
public Number round(Number x, Number y)
{
return roundToPrecision(x, y);
}
@Override
public Number roundToPrecision(Number x, Number y)
{
throw new IllegalArgumentException("Rounding can only be used with scalar values");
}
@Override
public Number roundToInteger(Number x)
{
throw new IllegalArgumentException("Rounding can only be used with scalar values");
}
@Override
public Number roundToPlaces(Number x, Number y)
{
throw new IllegalArgumentException("Rounding can only be used with scalar values");
}
@Override
public Number roundToMultiple(Number x, Number y)
{
throw new IllegalArgumentException("Rounding can only be used with scalar values");
}
@Override
public Number sin(Number x)
{
return ApcomplexMath.sin((Apcomplex) x);
}
@Override
public Number sinc(Number x)
{
return ApcomplexMath.sinc((Apcomplex) x);
}
@Override
public Number sinIntegral(Number x)
{
return ApcomplexMath.sinIntegral((Apcomplex) x);
}
@Override
public Number sinh(Number x)
{
return ApcomplexMath.sinh((Apcomplex) x);
}
@Override
public Number sinhIntegral(Number x)
{
return ApcomplexMath.sinhIntegral((Apcomplex) x);
}
@Override
public Number sphericalHarmonicY(Number x, Number y, Number z, Number w)
{
return ApcomplexMath.sphericalHarmonicY((Apcomplex) x, (Apcomplex) y, (Apcomplex) z, (Apcomplex) w);
}
@Override
public Number sqrt(Number x)
{
return root(x, 2);
}
@Override
public Number struveH(Number x, Number y)
{
return ApcomplexMath.struveH((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number struveL(Number x, Number y)
{
return ApcomplexMath.struveL((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number tan(Number x)
{
return ApcomplexMath.tan((Apcomplex) x);
}
@Override
public Number tanh(Number x)
{
return ApcomplexMath.tanh((Apcomplex) x);
}
@Override
public Number truncate(Number x)
{
throw new IllegalArgumentException("Truncate can only be used with scalar values");
}
@Override
public Number toDegrees(Number x)
{
throw new IllegalArgumentException("ToDegrees can only be used with scalar values");
}
@Override
public Number toRadians(Number x)
{
throw new IllegalArgumentException("ToRadians can only be used with scalar values");
}
@Override
public Number ulp(Number x)
{
return ApcomplexMath.ulp((Apcomplex) x);
}
@Override
public Number weberE(Number x, Number y)
{
return ApcomplexMath.weberE((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number zeta(Number x)
{
return ApcomplexMath.zeta((Apcomplex) x);
}
@Override
public Number zeta(Number x, Number y)
{
return ApcomplexMath.zeta((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number agm(Number x, Number y)
{
return ApcomplexMath.agm((Apcomplex) x, (Apcomplex) y);
}
@Override
public Number w(Number x)
{
return ApcomplexMath.w((Apcomplex) x);
}
@Override
public Number w(Number x, Number y)
{
if (!isLong(y))
{
throw new IllegalArgumentException("Lambert W can only be used with a valid integer argument");
}
return ApcomplexMath.w((Apcomplex) x, y.longValue());
}
@Override
public Number atan2(Number x, Number y)
{
throw new IllegalArgumentException("Atan2 can only be used with scalar values");
}
@Override
public Number copySign(Number x, Number y)
{
throw new IllegalArgumentException("CopySign can only be used with scalar values");
}
@Override
public Number fmod(Number x, Number y)
{
throw new IllegalArgumentException("Fmod can only be used with scalar values");
}
@Override
public Number gcd(Number x, Number y)
{
throw new IllegalArgumentException("Greatest Common Ddivisor can only be used with integer values");
}
@Override
public Number hypot(Number x, Number y)
{
throw new IllegalArgumentException("Hypot can only be used with scalar values");
}
@Override
public Number inverseRoot(Number x, Number y)
{
if (!isLong(y))
{
throw new IllegalArgumentException("Inverse root can only be used with a valid integer argument");
}
return inverseRoot(x, y.longValue());
}
@Override
public Number inverseRoot(Number x, Number y, Number z)
{
if (!isLong(y) || !isLong(z))
{
throw new IllegalArgumentException("Inverse root can only be used with valid integer arguments");
}
return inverseRoot(x, y.longValue(), z.longValue());
}
protected Number inverseRoot(Number x, long y)
{
return ApcomplexMath.inverseRoot((Apcomplex) x, y);
}
protected Number inverseRoot(Number x, long y, long z)
{
return ApcomplexMath.inverseRoot((Apcomplex) x, y, z);
}
@Override
public Number lcm(Number x, Number y)
{
throw new IllegalArgumentException("Least Common Multiplier can only be used with integer values");
}
@Override
public Number root(Number x, Number y)
{
if (!isLong(y))
{
throw new IllegalArgumentException("Root can only be used with a valid integer argument");
}
return root(x, y.longValue());
}
@Override
public Number root(Number x, Number y, Number z)
{
if (!isLong(y) || !isLong(z))
{
throw new IllegalArgumentException("Root can only be used with valid integer arguments");
}
return root(x, y.longValue(), z.longValue());
}
protected Number root(Number x, long y)
{
return ApcomplexMath.root((Apcomplex) x, y);
}
protected Number root(Number x, long y, long z)
{
return ApcomplexMath.root((Apcomplex) x, y, z);
}
@Override
public Number scale(Number x, Number y)
{
if (!isLong(y))
{
throw new IllegalArgumentException("Scale can only be used with a valid integer argument");
}
return scale(x, y.longValue());
}
protected Number scale(Number x, long y)
{
return ApcomplexMath.scale((Apcomplex) x, y);
}
@Override
public Number precision(Number x, Number y)
{
if (!isLong(y))
{
throw new IllegalArgumentException("Precision can only be used with a valid integer argument");
}
return precision(x, y.longValue());
}
protected Number precision(Number x, long precision)
{
return ((Apcomplex) x).precision(precision);
}
protected boolean isLong(Number value)
{
return value instanceof Long || value != null && new Apint(value.longValue()).equals(value);
}
}
private class ApfloatFunctions
extends ApcomplexFunctions
{
@Override
public Number mod(Number x, Number y)
{
return ((Apfloat) x).mod((Apfloat) y);
}
@Override
public Number ceil(Number x)
{
return ((Apfloat) x).ceil();
}
@Override
public Number floor(Number x)
{
return ((Apfloat) x).floor();
}
@Override
public Number frac(Number x)
{
return ((Apfloat) x).frac();
}
@Override
public Number inverseErf(Number x)
{
return ApfloatMath.inverseErf((Apfloat) x);
}
@Override
public Number inverseErfc(Number x)
{
return ApfloatMath.inverseErfc((Apfloat) x);
}
@Override
public Number max(Number x, Number y)
{
return ApfloatMath.max((Apfloat) x, (Apfloat) y);
}
@Override
public Number min(Number x, Number y)
{
return ApfloatMath.min((Apfloat) x, (Apfloat) y);
}
@Override
public Number nextAfter(Number x, Number y)
{
return ApfloatMath.nextAfter((Apfloat) x, (Apfloat) y);
}
@Override
public Number nextDown(Number x)
{
return ApfloatMath.nextDown((Apfloat) x);
}
@Override
public Number nextUp(Number x)
{
return ApfloatMath.nextUp((Apfloat) x);
}
@Override
public Number truncate(Number x)
{
return ((Apfloat) x).truncate();
}
@Override
public Number toDegrees(Number x)
{
return ApfloatMath.toDegrees((Apfloat) x);
}
@Override
public Number toRadians(Number x)
{
return ApfloatMath.toRadians((Apfloat) x);
}
@Override
public Number atan2(Number x, Number y)
{
return ApfloatMath.atan2((Apfloat) x, (Apfloat) y);
}
@Override
public Number copySign(Number x, Number y)
{
return ApfloatMath.copySign((Apfloat) x, (Apfloat) y);
}
@Override
public Number fmod(Number x, Number y)
{
return ApfloatMath.fmod((Apfloat) x, (Apfloat) y);
}
@Override
public Number hypot(Number x, Number y)
{
return ApcomplexMath.abs(new Apcomplex((Apfloat) x, (Apfloat) y));
}
@Override
public Number roundToPrecision(Number x, Number y)
{
if (!isLong(y))
{
throw new IllegalArgumentException("Rounding can only be used with a valid integer argument");
}
return roundToPrecision(x, y.longValue());
}
protected Number roundToPrecision(Number x, long precision)
{
return ApfloatMath.roundToPrecision((Apfloat) x, precision, RoundingMode.HALF_UP);
}
@Override
public Number roundToInteger(Number x)
{
return ApfloatMath.roundToInteger((Apfloat) x, RoundingMode.HALF_UP);
}
@Override
public Number roundToPlaces(Number x, Number y)
{
if (!isLong(y))
{
throw new IllegalArgumentException("Rounding can only be used with a valid integer argument");
}
return roundToPlaces(x, y.longValue());
}
protected Number roundToPlaces(Number x, long precision)
{
return ApfloatMath.roundToPlaces((Apfloat) x, precision, RoundingMode.HALF_UP);
}
@Override
public Number roundToMultiple(Number x, Number y)
{
return ApfloatMath.roundToMultiple((Apfloat) x, (Apfloat) y, RoundingMode.HALF_UP);
}
}
private class AprationalFunctions
extends ApfloatFunctions
{
@Override
public Number add(Number x, Number y)
{
return ((Aprational) x).add((Aprational) y);
}
@Override
public Number subtract(Number x, Number y)
{
return ((Aprational) x).subtract((Aprational) y);
}
@Override
public Number multiply(Number x, Number y)
{
return ((Aprational) x).multiply((Aprational) y);
}
@Override
public Number divide(Number x, Number y)
{
return ((Aprational) x).divide((Aprational) y);
}
@Override
public Number mod(Number x, Number y)
{
return ((Aprational) x).mod((Aprational) y);
}
@Override
public Number pochhammer(Number x, Number y)
{
if (y instanceof Apint)
{
return AprationalMath.pochhammer((Aprational) x, (Apint) y);
}
return super.pochhammer(x, y);
}
@Override
protected Number pow(Number x, long y)
{
return AprationalMath.pow((Aprational) x, y);
}
@Override
public Number binomial(Number x, Number y)
{
return AprationalMath.binomial((Aprational) x, (Aprational) y);
}
@Override
public Number hypot(Number x, Number y)
{
return root(add(pow(x, 2), pow(y, 2)), 2);
}
@Override
protected Number root(Number x, long y)
{
return new Aprational(root(((Aprational) x).numerator(), y), root(((Aprational) x).denominator(), y));
}
private Apint root(Apint x, long y)
{
Apint[] root = ApintMath.root(x, y);
if (root[1].signum() != 0)
{
throw new IllegalArgumentException("Cannot calculate inexact root to infinite precision");
}
return root[0];
}
@Override
protected Number roundToPrecision(Number x, long precision)
{
return AprationalMath.roundToPrecision((Aprational) x, precision, RoundingMode.HALF_UP);
}
@Override
public Number roundToInteger(Number x)
{
return AprationalMath.roundToInteger((Aprational) x, RoundingMode.HALF_UP);
}
@Override
protected Number roundToPlaces(Number x, long places)
{
return AprationalMath.roundToPlaces((Aprational) x, places, RoundingMode.HALF_UP);
}
@Override
public Number roundToMultiple(Number x, Number y)
{
return AprationalMath.roundToMultiple((Aprational) x, (Aprational) y, RoundingMode.HALF_UP);
}
@Override
protected Number scale(Number x, long y)
{
return AprationalMath.scale((Aprational) x, y);
}
}
private class ApintFunctions
extends AprationalFunctions
{
@Override
public Number binomial(Number x, Number y)
{
if (isLong(x) && isLong(y))
{
return ApintMath.binomial(x.longValue(), y.longValue());
}
return ApintMath.binomial((Apint) x, (Apint) y);
}
@Override
public Number gcd(Number x, Number y)
{
return ApintMath.gcd((Apint) x, (Apint) y);
}
@Override
public Number harmonicNumber(Number x)
{
return AprationalMath.harmonicNumber((Apint) x);
}
@Override
public Number harmonicNumber(Number x, Number y)
{
return AprationalMath.harmonicNumber((Apint) x, (Apint) y);
}
@Override
public Number lcm(Number x, Number y)
{
return ApintMath.lcm((Apint) x, (Apint) y);
}
@Override
protected Number scale(Number x, long y)
{
return (y >= 0 ? ApintMath.scale((Apint) x, y) : super.scale(x, y));
}
}
/**
* Default constructor.
*/
public ApfloatCalculatorImpl()
{
}
@Override
public Number parseInteger(String value)
{
Apcomplex x;
if (value.equalsIgnoreCase("i"))
{
x = Apcomplex.I;
}
else if (value.endsWith("i") || value.endsWith("I"))
{
x = new Apint(value.substring(0, value.length() - 1)).multiply(Apcomplex.I);
}
else
{
x = new Apint(value);
}
if (getInputPrecision() != null)
{
x = x.precision(getInputPrecision());
}
return x;
}
@Override
public Number parseDecimal(String value)
{
Apcomplex x;
if (value.endsWith("i") || value.endsWith("I"))
{
x = new Apfloat(value.substring(0, value.length() - 1)).multiply(Apcomplex.I);
}
else
{
x = new Apfloat(value);
}
if (getInputPrecision() != null)
{
x = x.precision(getInputPrecision());
}
return x;
}
@Override
public String format(Number x)
{
String text;
boolean pretty = getFormat();
if (x instanceof Aprational)
{
text = x.toString();
}
else if (x instanceof Apfloat)
{
Apfloat a = (Apfloat) x;
a = ApfloatMath.roundToPrecision(a.precision(Util.ifFinite(a.precision(), a.precision() + 1)), a.precision(), RoundingMode.HALF_UP);
text = a.toString(pretty);
}
else
{
Apcomplex z = (Apcomplex) x;
String imag = (z.imag().equals(Apfloat.ONE) ? "" : (z.imag().negate().equals(Apfloat.ONE) ? "-" : format(z.imag())));
if (z.real().signum() == 0)
{
text = imag + "i";
}
else
{
text = format(z.real()) + (z.imag().signum() < 0 ? "" : "+") + imag + "i";
}
}
return text;
}
@Override
protected Functions getFunctions(Number x)
{
Functions functions;
if (x instanceof Apint)
{
functions = new ApintFunctions();
}
else if (x instanceof Aprational)
{
functions = new AprationalFunctions();
}
else if (x instanceof Apfloat)
{
functions = new ApfloatFunctions();
}
else
{
functions = new ApcomplexFunctions();
}
return functions;
}
@Override
protected Number promote(Number x)
{
if (!(x instanceof Apfloat) && ((Apcomplex) x).imag().signum() == 0)
{
// Complex to float
x = ((Apcomplex) x).real();
}
if (x instanceof Apfloat && !(x instanceof Aprational) && ((Apfloat) x).precision() == Apfloat.INFINITE && ((Apfloat) x).isInteger())
{
// Float to integer
x = ((Apfloat) x).truncate();
}
if (x instanceof Aprational && !(x instanceof Apint) && ((Aprational) x).denominator().equals(Apint.ONE))
{
// Rational to integer
x = ((Aprational) x).numerator();
}
return x;
}
@Override
public void setInputPrecision(Long inputPrecision)
{
super.setInputPrecision(inputPrecision);
this.fixedPrecisionApcomplexHelper = new FixedPrecisionApcomplexHelper(inputPrecision == null ? Apfloat.INFINITE : inputPrecision);
}
private Number fixedOrArbitraryPrecision(java.util.function.Function fixedPrecisionFunction, java.util.function.Function arbitraryPrecisionFunction, Number x)
{
Apcomplex z = (Apcomplex) x;
return (getInputPrecision() != null && z.isZero() ? fixedPrecisionFunction.apply(z) : arbitraryPrecisionFunction.apply(z));
}
private Number fixedOrArbitraryPrecision(BiFunction fixedPrecisionFunction, BiFunction arbitraryPrecisionFunction, T x, U y)
{
return (getInputPrecision() != null && y.isZero() ? fixedPrecisionFunction.apply(x, y) : arbitraryPrecisionFunction.apply(x, y));
}
private FixedPrecisionApcomplexHelper fixedPrecisionApcomplexHelper = new FixedPrecisionApcomplexHelper(Apfloat.INFINITE);
}
apfloat-1.15.0/apfloat-calc/src/main/java/org/apfloat/calc/Calculator.java 0000664 0000000 0000000 00000005511 15113064030 0026254 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2023 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.calc;
/**
* Command-line calculator.
*
* @version 1.11.0
* @author Mikko Tommila
*/
public class Calculator
{
private Calculator()
{
}
/**
* Command-line entry point.
*
* @param args Command-line parameters.
*
* @exception ParseException In case of invalid input
*/
public static void main(String args[])
throws ParseException
{
boolean pretty = false;
Long inputPrecision = null;
for (int i = 0; i < args.length; i++)
{
switch (args[i])
{
case "-p":
pretty = true;
break;
case "-i":
try
{
i++;
inputPrecision = Long.valueOf(args[i]);
break;
}
catch (NumberFormatException | ArrayIndexOutOfBoundsException e)
{
// Fall through to usage
}
default:
System.err.println("Usage: calculator [-p] [-i inputPrecision]");
System.exit(1);
}
}
CalculatorImpl calculatorImpl = new ApfloatCalculatorImpl();
calculatorImpl.setFormat(pretty);
calculatorImpl.setInputPrecision(inputPrecision);
CalculatorParser calculatorParser = new CalculatorParser(System.in, System.out, calculatorImpl);
while (calculatorParser.parseOneLine())
{
// Loop until input ends or exception is thrown
}
}
}
apfloat-1.15.0/apfloat-calc/src/main/java/org/apfloat/calc/CalculatorAWT.java 0000664 0000000 0000000 00000023556 15113064030 0026641 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2024 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.calc;
import java.awt.GridBagLayout;
import java.awt.GridBagConstraints;
import java.awt.Insets;
import java.awt.Panel;
import java.awt.Label;
import java.awt.Checkbox;
import java.awt.CheckboxGroup;
import java.awt.TextField;
import java.awt.TextArea;
import java.awt.Button;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.PrintWriter;
import java.util.List;
import java.util.ArrayList;
/**
* Graphical AWT elements for the calculator.
*
* @version 1.14.0
* @author Mikko Tommila
*/
public class CalculatorAWT
extends Panel
{
private static final long serialVersionUID = 1L;
/**
* Construct a panel with graphical elements.
*/
public CalculatorAWT()
{
this.calculatorImpl = new ApfloatCalculatorImpl();
this.history = new ArrayList<>();
this.historyPosition = 0;
initGUI();
this.out = new PrintWriter(new FlushStringWriter(this.outputArea), true);
}
// Initialize the container and add the graphical elements to it
private void initGUI()
{
setLayout(new GridBagLayout());
GridBagConstraints constraints = new GridBagConstraints();
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.insets = new Insets(5, 5, 5, 5);
constraints.weightx = 1;
constraints.weighty = 1;
// Initial focus will be on the first element, which is added here although it's located at the bottom
this.inputField = new TextField(null, 60);
constraints.gridy = 8;
add(this.inputField, constraints);
this.calculateButton = new Button("Calculate");
add(this.calculateButton, constraints);
this.abortButton = new Button("Abort");
this.abortButton.setEnabled(false);
constraints.gridwidth = GridBagConstraints.REMAINDER;
add(this.abortButton, constraints);
this.outputArea = new TextArea(null, 20, 60, TextArea.SCROLLBARS_VERTICAL_ONLY);
this.outputArea.setEditable(false);
constraints.gridy = 0;
constraints.gridwidth = 1;
constraints.gridheight = 8;
add(this.outputArea, constraints);
this.formatLabel = new Label("Format:");
constraints.gridwidth = GridBagConstraints.REMAINDER;
constraints.gridheight = 1;
add(this.formatLabel, constraints);
this.formats = new CheckboxGroup();
this.floating = new Checkbox("Floating", true, this.formats);
constraints.gridy = 1;
add(this.floating, constraints);
this.fixed = new Checkbox("Fixed", false, this.formats);
constraints.gridy = 2;
add(this.fixed, constraints);
this.inputTypeLabel = new Label("Input precision:");
constraints.gridy = 3;
add(this.inputTypeLabel, constraints);
this.inputPrecisionTypes = new CheckboxGroup();
this.inputPrecisionArbitrary = new Checkbox("Arbitrary", true, this.inputPrecisionTypes);
constraints.gridy = 4;
add(this.inputPrecisionArbitrary, constraints);
this.inputPrecisionFixed = new Checkbox("Fixed", false, this.inputPrecisionTypes);
constraints.gridy = 5;
add(this.inputPrecisionFixed, constraints);
this.inputPrecisionField = new TextField(null, 10);
constraints.gridy = 6;
add(this.inputPrecisionField, constraints);
this.clearButton = new Button("Clear");
constraints.gridy = 7;
constraints.weighty = 1000;
add(this.clearButton, constraints);
// Clear output area and command history
this.clearButton.addActionListener((actionEvent) ->
{
CalculatorAWT.this.outputArea.setText(null);
CalculatorAWT.this.history.clear();
CalculatorAWT.this.historyPosition = 0;
});
// Calculate current input button
this.calculateButton.addActionListener((actionEvent) -> processInput());
// Calculate current input by hitting enter in the input field
this.inputField.addActionListener((actionEvent) -> processInput());
// Abort button
this.abortButton.addActionListener((actionEvent) -> abortCalculation());
// Command history handler for up and down arrow keys
this.inputField.addKeyListener(new KeyAdapter()
{
@Override
public void keyPressed(KeyEvent keyEvent)
{
switch(keyEvent.getKeyCode())
{
case KeyEvent.VK_UP:
if (CalculatorAWT.this.historyPosition > 0)
{
CalculatorAWT.this.inputField.setText(CalculatorAWT.this.history.get(--CalculatorAWT.this.historyPosition));
CalculatorAWT.this.inputField.setCaretPosition(Integer.MAX_VALUE);
}
break;
case KeyEvent.VK_DOWN:
if (CalculatorAWT.this.historyPosition < CalculatorAWT.this.history.size() - 1)
{
CalculatorAWT.this.inputField.setText(CalculatorAWT.this.history.get(++CalculatorAWT.this.historyPosition));
CalculatorAWT.this.inputField.setCaretPosition(Integer.MAX_VALUE);
}
break;
default:
}
}
});
}
private void processInput()
{
this.calculateButton.setEnabled(false);
Long inputPrecision;
if (this.inputPrecisionArbitrary.getState())
{
inputPrecision = null;
}
else
{
try
{
inputPrecision = Long.parseLong(this.inputPrecisionField.getText());
}
catch (NumberFormatException nfe)
{
this.inputPrecisionField.requestFocus();
return;
}
}
String text = this.inputField.getText();
this.inputField.setText(null);
this.out.println(text);
// Parse the input line; the parser prints the output
this.calculatorImpl.setFormat(this.fixed.getState());
this.calculatorImpl.setInputPrecision(inputPrecision);
CalculatorParser calculatorParser = new CalculatorParser(new StringReader(text), this.out, this.calculatorImpl);
this.calculatorThread = new Thread(() ->
{
try
{
calculatorParser.parseOneLine();
}
catch (Exception e)
{
this.out.println(e.getMessage());
}
finally
{
this.abortButton.setEnabled(false);
this.calculateButton.setEnabled(true);
}
});
this.calculatorThread.start();
this.abortButton.setEnabled(true);
// Show the bottom part of the output area
this.outputArea.requestFocus();
this.outputArea.setCaretPosition(Integer.MAX_VALUE);
this.inputField.requestFocus();
// Add last command to history and reset history position
this.history.add(text);
this.historyPosition = this.history.size();
}
private void abortCalculation()
{
this.calculatorThread.interrupt();
}
// Prints output to a text area
private static class FlushStringWriter
extends StringWriter
{
public FlushStringWriter(TextArea dst)
{
this.dst = dst;
}
@Override
public void flush()
{
super.flush();
StringBuffer buffer = getBuffer();
String text = buffer.toString();
this.dst.append(text);
buffer.setLength(0);
}
private TextArea dst;
}
private CalculatorImpl calculatorImpl;
private List history;
private int historyPosition;
private TextArea outputArea;
private Label formatLabel;
private CheckboxGroup formats;
private Checkbox floating;
private Checkbox fixed;
private Label inputTypeLabel;
private CheckboxGroup inputPrecisionTypes;
private Checkbox inputPrecisionArbitrary;
private Checkbox inputPrecisionFixed;
private TextField inputPrecisionField;
private Button clearButton;
private TextField inputField;
private Button calculateButton;
private Button abortButton;
private PrintWriter out;
private Thread calculatorThread;
}
apfloat-1.15.0/apfloat-calc/src/main/java/org/apfloat/calc/CalculatorApplet.java 0000664 0000000 0000000 00000006535 15113064030 0027431 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2023 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.calc;
import java.applet.Applet;
import java.io.File;
import java.security.AccessControlException;
import org.apfloat.ApfloatContext;
import org.apfloat.spi.FilenameGenerator;
/**
* Calculator applet.
*
* @version 1.9.1
* @author Mikko Tommila
*/
public class CalculatorApplet
extends Applet
{
private static final long serialVersionUID = 1L;
/**
* Default constructor.
*/
public CalculatorApplet()
{
}
/**
* Initialize this applet.
*/
@Override
public void init()
{
add(new CalculatorAWT());
// Recreate the executor service in case the old thread group was destroyed by reloading the applet
ApfloatContext ctx = ApfloatContext.getContext();
ctx.setExecutorService(ApfloatContext.getDefaultExecutorService());
try
{
// The applet may not be able to write files to the current directory, but probably can write to the temp directory
String path = System.getProperty("java.io.tmpdir");
if (path != null && !path.endsWith(File.separator))
{
path = path + File.separator;
}
FilenameGenerator filenameGenerator = new FilenameGenerator(path, null, null);
ctx.setFilenameGenerator(filenameGenerator);
}
catch (AccessControlException ace)
{
// Ignore - reading the system property may not be allowed in unsigned applets
}
}
/**
* Called when this applet is destroyed.
*/
@Override
public void destroy()
{
removeAll();
}
/**
* Get information about this applet.
*
* @return Information about this applet.
*/
@Override
public String getAppletInfo()
{
String lineSeparator = System.lineSeparator();
return "Calculator applet" + lineSeparator +
"Written by Mikko Tommila 2011 - 2023" + lineSeparator +
"Java version: " + System.getProperty("java.version") + lineSeparator +
"Java Virtual Machine: " + System.getProperty("java.vm.name");
}
}
apfloat-1.15.0/apfloat-calc/src/main/java/org/apfloat/calc/CalculatorGUI.java 0000664 0000000 0000000 00000004510 15113064030 0026617 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2023 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.calc;
import java.awt.Frame;
import java.awt.BorderLayout;
import java.awt.Label;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
/**
* AWT client application for the calculator.
*
* @version 1.9.0
* @author Mikko Tommila
*/
public class CalculatorGUI
extends Frame
{
private static final long serialVersionUID = 1L;
/**
* Default constructor.
*/
protected CalculatorGUI()
{
super("Calculator");
setSize(720, 540);
addWindowListener(new WindowAdapter()
{
@Override
public void windowClosing(WindowEvent windowEvent)
{
setVisible(false);
dispose();
System.exit(0);
}
});
setLayout(new BorderLayout());
add(new CalculatorAWT(), BorderLayout.NORTH);
add(new Label(), BorderLayout.SOUTH);
setVisible(true);
}
/**
* Command-line entry point.
*
* @param args Command-line parameters.
*/
public static void main(String[] args)
{
new CalculatorGUI();
}
}
apfloat-1.15.0/apfloat-calc/src/main/java/org/apfloat/calc/CalculatorImpl.java 0000664 0000000 0000000 00000014317 15113064030 0027102 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2024 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.calc;
import java.util.List;
/**
* Calculator implementation interface.
* The calculator parser uses this interface to perform the actual calculations.
*
* @version 1.14.0
* @author Mikko Tommila
*/
public interface CalculatorImpl
{
/**
* Negative value.
*
* @param x The argument.
*
* @return -x
*
* @exception ParseException In case of invalid argument.
*/
public Number negate(Number x)
throws ParseException;
/**
* Addition.
*
* @param x First argument.
* @param y Second argument.
*
* @return x + y
*
* @exception ParseException In case of invalid arguments.
*/
public Number add(Number x, Number y)
throws ParseException;
/**
* Subtraction.
*
* @param x First argument.
* @param y Second argument.
*
* @return x - y
*
* @exception ParseException In case of invalid arguments.
*/
public Number subtract(Number x, Number y)
throws ParseException;
/**
* Multiplication.
*
* @param x First argument.
* @param y Second argument.
*
* @return x * y
*
* @exception ParseException In case of invalid arguments.
*/
public Number multiply(Number x, Number y)
throws ParseException;
/**
* Division.
*
* @param x First argument.
* @param y Second argument.
*
* @return x / y
*
* @exception ParseException In case of invalid arguments.
*/
public Number divide(Number x, Number y)
throws ParseException;
/**
* Remainder.
*
* @param x First argument.
* @param y Second argument.
*
* @return x % y
*
* @exception ParseException In case of invalid arguments.
*/
public Number mod(Number x, Number y)
throws ParseException;
/**
* Power.
*
* @param x First argument.
* @param y Second argument.
*
* @return xy
*
* @exception ParseException In case of invalid arguments.
*/
public Number pow(Number x, Number y)
throws ParseException;
/**
* Factorial.
*
* @param x The argument.
*
* @return x!
*
* @exception ParseException In case of invalid arguments.
*/
public Number factorial(Number x)
throws ParseException;
/**
* Double factorial.
*
* @param x The argument.
*
* @return x!!
*
* @exception ParseException In case of invalid arguments.
*/
public Number doubleFactorial(Number x)
throws ParseException;
/**
* Arbitrary function.
*
* @param name Name of the function.
* @param arguments Function arguments.
*
* @return Function value.
*
* @exception ParseException In case of invalid arguments.
*/
public Number function(String name, List arguments)
throws ParseException;
/**
* Parse a string to an integer number.
*
* @param value The string to parse.
*
* @return The number.
*
* @exception ParseException In case of invalid number.
*/
public Number parseInteger(String value)
throws ParseException;
/**
* Parse a string to a floating-point number.
*
* @param value The string to parse.
*
* @return The number.
*
* @exception ParseException In case of invalid number.
*/
public Number parseDecimal(String value)
throws ParseException;
/**
* Get a variable.
*
* @param name Name of the variable.
*
* @return Value of the variable, or null if the variable is not defined.
*
* @exception ParseException In case of invalid argument.
*/
public Number getVariable(String name)
throws ParseException;
/**
* Set a variable.
*
* @param name Name of the variable.
* @param value Value of the variable.
*
* @exception ParseException In case of invalid arguments.
*/
public void setVariable(String name, Number value)
throws ParseException;
/**
* Set the formatting option.
*
* @param pretty If a fixed-point or a floating-point notation should be used.
*/
public void setFormat(boolean pretty);
/**
* Set a fixed input precision.
*
* @param inputPrecision The precision if a fixed precision is used or null for arbitrary precision.
*/
public void setInputPrecision(Long inputPrecision);
/**
* Convert a number to a String. The current formatting option is used.
*
* @param x The number.
*
* @return The String.
*/
public String format(Number x);
}
apfloat-1.15.0/apfloat-calc/src/main/java/org/apfloat/calc/CalculatorParser.jj 0000664 0000000 0000000 00000015343 15113064030 0027117 0 ustar 00root root 0000000 0000000 options
{
LOOKAHEAD = 2;
STATIC = false;
UNICODE_INPUT = true;
ERROR_REPORTING = false;
}
PARSER_BEGIN(CalculatorParser)
package org.apfloat.calc;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.Writer;
import java.util.List;
import java.util.ArrayList;
public class CalculatorParser
{
public CalculatorParser(InputStream in, OutputStream out, CalculatorImpl calculatorImpl)
{
this(in);
this.out = new PrintWriter(new OutputStreamWriter(out), true);
this.calculatorImpl = calculatorImpl;
}
public CalculatorParser(Reader in, Writer out, CalculatorImpl calculatorImpl)
{
this(in);
this.out = new PrintWriter(out, true);
this.calculatorImpl = calculatorImpl;
}
public CalculatorParser(Reader in, PrintWriter out, CalculatorImpl calculatorImpl)
{
this(in);
this.out = out;
this.calculatorImpl = calculatorImpl;
}
private PrintWriter out;
private CalculatorImpl calculatorImpl;
}
PARSER_END(CalculatorParser)
SKIP:
{
" "
| "\t"
}
TOKEN:
{
< INTEGER: (()+ ()? | ()) >
| < DECIMAL: (()+ ("." ()*)? | "." ()+) (["e","E"] (["+","-"])? ()+)? ()? >
| < DIGIT: ["0"-"9"] >
| < IMAGINARY: ["i","I"] >
| < IDENTIFIER: () ( | )* >
| < LETTER: ["$","A"-"Z","_","a"-"z","\u00c0"-"\u00d6","\u00d8"-"\u00f6","\u00f8"-"\u00ff","\u0100"-"\u1fff","\u3040"-"\u318f","\u3300"-"\u337f","\u3400"-"\u3d2d","\u4e00"-"\u9fff","\uf900"-"\ufaff"] >
| < DELIMITER: (";")+ >
| < EOL: ("\n" | "\r\n" | "\r") >
}
boolean parseOneLine():
{
Number a;
}
{
(
a = expression() { this.out.println(this.calculatorImpl.format(a)); }
)?
(
a = expression() { this.out.println(this.calculatorImpl.format(a)); }
)*
(
)?
(
{ return true; }
| { return false; }
)
}
Number expression():
{
Number a;
}
{
(
a = assignmentExpression()
| a = additiveExpression()
)
{ return a; }
}
Number assignmentExpression():
{
String v;
Number a;
}
{
v = variable()
(
"=" a = additiveExpression() { this.calculatorImpl.setVariable(v, a); }
| "+=" a = additiveExpression() { this.calculatorImpl.setVariable(v, this.calculatorImpl.add(this.calculatorImpl.getVariable(v), a)); }
| "-=" a = additiveExpression() { this.calculatorImpl.setVariable(v, this.calculatorImpl.subtract(this.calculatorImpl.getVariable(v), a)); }
| "*=" a = additiveExpression() { this.calculatorImpl.setVariable(v, this.calculatorImpl.multiply(this.calculatorImpl.getVariable(v), a)); }
| "/=" a = additiveExpression() { this.calculatorImpl.setVariable(v, this.calculatorImpl.divide(this.calculatorImpl.getVariable(v), a)); }
| "%=" a = additiveExpression() { this.calculatorImpl.setVariable(v, this.calculatorImpl.mod(this.calculatorImpl.getVariable(v), a)); }
| "^=" a = additiveExpression() { this.calculatorImpl.setVariable(v, this.calculatorImpl.pow(this.calculatorImpl.getVariable(v), a)); }
)
{ return this.calculatorImpl.getVariable(v); }
}
Number additiveExpression():
{
Number a;
Number b;
}
{
a = multiplicativeExpression()
(
"+" b = multiplicativeExpression() { a = this.calculatorImpl.add(a, b); }
| "-" b = multiplicativeExpression() { a = this.calculatorImpl.subtract(a, b); }
)*
{ return a; }
}
Number multiplicativeExpression():
{
Number a;
Number b;
}
{
a = unaryExpression()
(
"*" b = unaryExpression() { a = this.calculatorImpl.multiply(a, b); }
| "/" b = unaryExpression() { a = this.calculatorImpl.divide(a, b); }
| "%" b = unaryExpression() { a = this.calculatorImpl.mod(a, b); }
)*
{ return a; }
}
Number unaryExpression():
{
Number a;
}
{
"-" a = unaryExpression() { return this.calculatorImpl.negate(a); }
| "+" a = unaryExpression() { return a; }
| a = powerExpression() { return a; }
}
Number powerExpression():
{
Number a;
Number b;
}
{
a = factorialExpression()
(
"^" b = unaryExpression() { a = this.calculatorImpl.pow(a, b); }
)?
{ return a; }
}
Number factorialExpression():
{
Number a;
}
{
a = element()
(
"!!" { a = this.calculatorImpl.doubleFactorial(a); }
| "!" { a = this.calculatorImpl.factorial(a); }
)*
{ return a; }
}
Number element():
{
String v;
Number a;
}
{
a = constant() { return a; }
| a = function() { return a; }
| v = variable() { return this.calculatorImpl.getVariable(v); }
| "(" a = expression() ")" { return a; }
}
String variable():
{
String v;
}
{
v = identifier() { return v; }
}
Number function():
{
String v;
List l;
Number a;
}
{
v = identifier()
"(" l = argumentList() ")" { return this.calculatorImpl.function(v, l); }
}
List argumentList():
{
List list = new ArrayList();
Number a;
}
{
(
a = expression() { list.add(a); }
(
"," a = expression() { list.add(a); }
)*
)?
{ return list; }
}
String identifier():
{
Token t;
}
{
t = { return t.toString(); }
}
Number constant():
{
Token t;
}
{
t = { return this.calculatorImpl.parseInteger(t.toString()); }
| t = { return this.calculatorImpl.parseDecimal(t.toString()); }
}
TOKEN:
{
< INVALID_CHAR: ~[] >
}
apfloat-1.15.0/apfloat-calc/src/main/java/org/apfloat/calc/FunctionCalculatorImpl.java 0000664 0000000 0000000 00000101040 15113064030 0030576 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.calc;
import java.io.Serializable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Calculator implementation with function support.
* Provides a mapping mechanism for functions.
*
* @version 1.15.0
* @author Mikko Tommila
*/
public abstract class FunctionCalculatorImpl
extends AbstractCalculatorImpl
{
private static final long serialVersionUID = 1L;
/**
* Arbitrary function.
*/
@FunctionalInterface
protected static interface Function
extends Serializable
{
/**
* Call the function.
*
* @param arguments The function's arguments.
*
* @return The function's value.
*
* @exception ParseException In case the arguments are invalid.
*/
public Number call(List arguments)
throws ParseException;
}
/**
* Function taking a fixed number of arguments.
*/
protected class FixedFunction
implements Function
{
private static final long serialVersionUID = 1L;
/**
* Validate the number of arguments.
*
* @param arguments The function's arguments.
*
* @exception ParseException In case of incorrect number of arguments.
*/
protected void validate(List arguments)
throws ParseException
{
if (this.minArguments == this.maxArguments && arguments.size() != this.minArguments)
{
throw new ParseException("Function " + this.name + " takes " + this.minArguments + " argument" + (this.minArguments == 1 ? "" : "s") + ", not " + arguments.size());
}
if (arguments.size() < this.minArguments || arguments.size() > this.maxArguments)
{
throw new ParseException("Function " + this.name + " takes " + this.minArguments + " to " + this.maxArguments + " arguments, not " + arguments.size());
}
}
@Override
public final Number call(List arguments)
throws ParseException
{
validate(arguments);
return promote(handler.call(getFunctions(arguments), arguments));
}
private String name;
private int minArguments;
private int maxArguments;
private FixedFunctionHandler handler;
}
/**
* Handler for FixedFunction.
*/
@FunctionalInterface
protected static interface FixedFunctionHandler
extends Serializable
{
/**
* Call the function.
*
* @param functions The function implementations.
* @param arguments The function's argument(s).
*
* @return The function's value.
*/
public Number call(Functions functions, List arguments);
}
/**
* Function implementations.
*/
protected static interface Functions
{
public Number negate(Number x);
public Number add(Number x, Number y);
public Number subtract(Number x, Number y);
public Number multiply(Number x, Number y);
public Number divide(Number x, Number y);
public Number mod(Number x, Number y);
public Number pow(Number x, Number y);
public Number arg(Number x);
public Number conj(Number x);
public Number imag(Number x);
public Number real(Number x);
public Number abs(Number x);
public Number acos(Number x);
public Number acosh(Number x);
public Number airyAi(Number x);
public Number airyAiPrime(Number x);
public Number airyBi(Number x);
public Number airyBiPrime(Number x);
public Number angerJ(Number x, Number y);
public Number asin(Number x);
public Number asinh(Number x);
public Number atan(Number x);
public Number atanh(Number x);
public Number bernoulli(Number x);
public Number bernoulliB(Number x, Number y);
public Number besselI(Number x, Number y);
public Number besselJ(Number x, Number y);
public Number besselK(Number x, Number y);
public Number besselY(Number x, Number y);
public Number beta(Number a, Number b);
public Number beta(Number x, Number a, Number b);
public Number beta(Number x1, Number x2, Number a, Number b);
public Number binomial(Number x, Number y);
public Number catalan(Number x);
public Number cbrt(Number x);
public Number ceil(Number x);
public Number chebyshevT(Number x, Number y);
public Number chebyshevU(Number x, Number y);
public Number cos(Number x);
public Number cosIntegral(Number x);
public Number cosh(Number x);
public Number coshIntegral(Number x);
public Number digamma(Number x);
public Number doubleFactorial(Number x);
public Number e(Number x);
public Number ellipticE(Number x);
public Number ellipticK(Number x);
public Number erf(Number x);
public Number erfc(Number x);
public Number erfi(Number x);
public Number euler(Number x);
public Number eulerE(Number x, Number y);
public Number exp(Number x);
public Number expIntegralE(Number x, Number y);
public Number expIntegralEi(Number x);
public Number factorial(Number x);
public Number fibonacci(Number x, Number y);
public Number floor(Number x);
public Number frac(Number x);
public Number fresnelC(Number x);
public Number fresnelS(Number x);
public Number gamma(Number x);
public Number gamma(Number x, Number y);
public Number gamma(Number x, Number y, Number z);
public Number gegenbauerC(Number x, Number y);
public Number gegenbauerC(Number x, Number y, Number z);
public Number harmonicNumber(Number x);
public Number harmonicNumber(Number x, Number y);
public Number hermiteH(Number x, Number y);
public Number hypergeometric0F1(Number a, Number z);
public Number hypergeometric0F1Regularized(Number a, Number z);
public Number hypergeometric1F1(Number a, Number b, Number z);
public Number hypergeometric1F1Regularized(Number a, Number b, Number z);
public Number hypergeometric2F1(Number a, Number b, Number c, Number z);
public Number hypergeometric2F1Regularized(Number a, Number b, Number c, Number z);
public Number hypergeometricU(Number a, Number b, Number z);
public Number inverseErf(Number x);
public Number inverseErfc(Number x);
public Number jacobiP(Number x, Number y, Number z, Number w);
public Number glaisher(Number x);
public Number khinchin(Number x);
public Number laguerreL(Number x, Number y);
public Number laguerreL(Number x, Number y, Number z);
public Number legendreP(Number x, Number y);
public Number legendreP(Number x, Number y, Number z);
public Number legendreQ(Number x, Number y);
public Number legendreQ(Number x, Number y, Number z);
public Number log(Number x);
public Number log(Number x, Number y);
public Number logGamma(Number x);
public Number logIntegral(Number x);
public Number logisticSigmoid(Number x);
public Number max(Number x, Number y);
public Number min(Number x, Number y);
public Number nextAfter(Number x, Number y);
public Number nextDown(Number x);
public Number nextUp(Number x);
public Number pi(Number x);
public Number pochhammer(Number x, Number y);
public Number polygamma(Number x, Number y);
public Number polylog(Number x, Number y);
public Number random(Number x);
public Number randomGaussian(Number x);
@Deprecated
public Number round(Number x, Number y);
public Number roundToPrecision(Number x, Number y);
public Number roundToInteger(Number x);
public Number roundToPlaces(Number x, Number y);
public Number roundToMultiple(Number x, Number y);
public Number sin(Number x);
public Number sinc(Number x);
public Number sinIntegral(Number x);
public Number sinh(Number x);
public Number sinhIntegral(Number x);
public Number sphericalHarmonicY(Number x, Number y, Number z, Number w);
public Number sqrt(Number x);
public Number struveH(Number x, Number y);
public Number struveL(Number x, Number y);
public Number tan(Number x);
public Number tanh(Number x);
public Number truncate(Number x);
public Number toDegrees(Number x);
public Number toRadians(Number x);
public Number ulp(Number x);
public Number weberE(Number x, Number y);
public Number zeta(Number x);
public Number zeta(Number x, Number y);
public Number agm(Number x, Number y);
public Number w(Number x);
public Number w(Number x, Number y);
public Number atan2(Number x, Number y);
public Number copySign(Number x, Number y);
public Number fmod(Number x, Number y);
public Number gcd(Number x, Number y);
public Number hypot(Number x, Number y);
public Number inverseRoot(Number x, Number y);
public Number inverseRoot(Number x, Number y, Number z);
public Number lcm(Number x, Number y);
public Number root(Number x, Number y);
public Number root(Number x, Number y, Number z);
public Number scale(Number x, Number y);
public Number precision(Number x, Number y);
}
/**
* Default constructor.
*/
protected FunctionCalculatorImpl()
{
this.functions = new HashMap<>();
setFunction("negate", fixedFunction("negate", 1, (functions, arguments) -> functions.negate(arguments.get(0))));
setFunction("add", fixedFunction("add", 2, (functions, arguments) -> functions.add(arguments.get(0), arguments.get(1))));
setFunction("subtract", fixedFunction("subtract", 2, (functions, arguments) -> functions.subtract(arguments.get(0), arguments.get(1))));
setFunction("multiply", fixedFunction("multiply", 2, (functions, arguments) -> functions.multiply(arguments.get(0), arguments.get(1))));
setFunction("divide", fixedFunction("divide", 2, (functions, arguments) -> functions.divide(arguments.get(0), arguments.get(1))));
setFunction("mod", fixedFunction("mod", 2, (functions, arguments) -> functions.mod(arguments.get(0), arguments.get(1))));
setFunction("pow", fixedFunction("pow", 2, (functions, arguments) -> functions.pow(arguments.get(0), arguments.get(1))));
setFunction("abs", fixedFunction("abs", 1, (functions, arguments) -> functions.abs(arguments.get(0))));
setFunction("acos", fixedFunction("acos", 1, (functions, arguments) -> functions.acos(arguments.get(0))));
setFunction("acosh", fixedFunction("acosh", 1, (functions, arguments) -> functions.acosh(arguments.get(0))));
setFunction("airyAi", fixedFunction("airyAi", 1, (functions, arguments) -> functions.airyAi(arguments.get(0))));
setFunction("airyAiPrime", fixedFunction("airyAiPrime", 1, (functions, arguments) -> functions.airyAiPrime(arguments.get(0))));
setFunction("airyBi", fixedFunction("airyBi", 1, (functions, arguments) -> functions.airyBi(arguments.get(0))));
setFunction("airyBiPrime", fixedFunction("airyBiPrime", 1, (functions, arguments) -> functions.airyBiPrime(arguments.get(0))));
setFunction("angerJ", fixedFunction("angerJ", 2, (functions, arguments) -> functions.angerJ(arguments.get(0), arguments.get(1))));
setFunction("asin", fixedFunction("asin", 1, (functions, arguments) -> functions.asin(arguments.get(0))));
setFunction("asinh", fixedFunction("asinh", 1, (functions, arguments) -> functions.asinh(arguments.get(0))));
setFunction("atan", fixedFunction("atan", 1, (functions, arguments) -> functions.atan(arguments.get(0))));
setFunction("atanh", fixedFunction("atanh", 1, (functions, arguments) -> functions.atanh(arguments.get(0))));
setFunction("bernoulli", fixedFunction("bernoulli", 1, (functions, arguments) -> functions.bernoulli(arguments.get(0))));
setFunction("bernoulliB", fixedFunction("bernoulliB", 2, (functions, arguments) -> functions.bernoulliB(arguments.get(0), arguments.get(1))));
setFunction("besselI", fixedFunction("besselI", 2, (functions, arguments) -> functions.besselI(arguments.get(0), arguments.get(1))));
setFunction("besselJ", fixedFunction("besselJ", 2, (functions, arguments) -> functions.besselJ(arguments.get(0), arguments.get(1))));
setFunction("besselK", fixedFunction("besselK", 2, (functions, arguments) -> functions.besselK(arguments.get(0), arguments.get(1))));
setFunction("besselY", fixedFunction("besselY", 2, (functions, arguments) -> functions.besselY(arguments.get(0), arguments.get(1))));
setFunction("beta", fixedFunction("beta", 2, 4, (functions, arguments) -> (arguments.size() == 2 ? functions.beta(arguments.get(0), arguments.get(1)) : arguments.size() == 3 ? functions.beta(arguments.get(0), arguments.get(1), arguments.get(2)): functions.beta(arguments.get(0), arguments.get(1), arguments.get(2), arguments.get(3)))));
setFunction("binomial", fixedFunction("binomial", 2, (functions, arguments) -> functions.binomial(arguments.get(0), arguments.get(1))));
setFunction("catalan", fixedFunction("catalan", 0, 1, (functions, arguments) -> functions.catalan(argumentOrInputPrecision(arguments))));
setFunction("cbrt", fixedFunction("cbrt", 1, (functions, arguments) -> functions.cbrt(arguments.get(0))));
setFunction("ceil", fixedFunction("ceil", 1, (functions, arguments) -> functions.ceil(arguments.get(0))));
setFunction("chebyshevT", fixedFunction("chebyshevT", 2, (functions, arguments) -> functions.chebyshevT(arguments.get(0), arguments.get(1))));
setFunction("chebyshevU", fixedFunction("chebyshevU", 2, (functions, arguments) -> functions.chebyshevU(arguments.get(0), arguments.get(1))));
setFunction("cos", fixedFunction("cos", 1, (functions, arguments) -> functions.cos(arguments.get(0))));
setFunction("cosIntegral", fixedFunction("cosIntegral", 1, (functions, arguments) -> functions.cosIntegral(arguments.get(0))));
setFunction("cosh", fixedFunction("cosh", 1, (functions, arguments) -> functions.cosh(arguments.get(0))));
setFunction("coshIntegral", fixedFunction("coshIntegral", 1, (functions, arguments) -> functions.coshIntegral(arguments.get(0))));
setFunction("digamma", fixedFunction("digamma", 1, (functions, arguments) -> functions.digamma(arguments.get(0))));
setFunction("doubleFactorial", fixedFunction("doubleFactorial", 1, (functions, arguments) -> functions.doubleFactorial(arguments.get(0))));
setFunction("e", fixedFunction("e", 0, 1, (functions, arguments) -> functions.e(argumentOrInputPrecision(arguments))));
setFunction("ellipticE", fixedFunction("ellipticE", 1, (functions, arguments) -> functions.ellipticE(arguments.get(0))));
setFunction("ellipticK", fixedFunction("ellipticK", 1, (functions, arguments) -> functions.ellipticK(arguments.get(0))));
setFunction("erf", fixedFunction("erf", 1, (functions, arguments) -> functions.erf(arguments.get(0))));
setFunction("erfc", fixedFunction("erfc", 1, (functions, arguments) -> functions.erfc(arguments.get(0))));
setFunction("erfi", fixedFunction("erfi", 1, (functions, arguments) -> functions.erfi(arguments.get(0))));
setFunction("euler", fixedFunction("euler", 0, 1, (functions, arguments) -> functions.euler(argumentOrInputPrecision(arguments))));
setFunction("eulerE", fixedFunction("eulerE", 2, (functions, arguments) -> functions.eulerE(arguments.get(0), arguments.get(1))));
setFunction("exp", fixedFunction("exp", 1, (functions, arguments) -> functions.exp(arguments.get(0))));
setFunction("expIntegralE", fixedFunction("expIntegralE", 2, (functions, arguments) -> functions.expIntegralE(arguments.get(0), arguments.get(1))));
setFunction("expIntegralEi", fixedFunction("expIntegralEi", 1, (functions, arguments) -> functions.expIntegralEi(arguments.get(0))));
setFunction("factorial", fixedFunction("factorial", 1, (functions, arguments) -> functions.factorial(arguments.get(0))));
setFunction("fibonacci", fixedFunction("fibonacci", 2, (functions, arguments) -> functions.fibonacci(arguments.get(0), arguments.get(1))));
setFunction("floor", fixedFunction("floor", 1, (functions, arguments) -> functions.floor(arguments.get(0))));
setFunction("frac", fixedFunction("frac", 1, (functions, arguments) -> functions.frac(arguments.get(0))));
setFunction("fresnelC", fixedFunction("fresnelC", 1, (functions, arguments) -> functions.fresnelC(arguments.get(0))));
setFunction("fresnelS", fixedFunction("fresnelS", 1, (functions, arguments) -> functions.fresnelS(arguments.get(0))));
setFunction("gamma", fixedFunction("gamma", 1, 3, (functions, arguments) -> (arguments.size() == 1 ? functions.gamma(arguments.get(0)) : arguments.size() == 2 ? functions.gamma(arguments.get(0), arguments.get(1)): functions.gamma(arguments.get(0), arguments.get(1), arguments.get(2)))));
setFunction("gegenbauerC", fixedFunction("gegenbauerC", 2, 3, (functions, arguments) -> (arguments.size() == 2 ? functions.gegenbauerC(arguments.get(0), arguments.get(1)) : functions.gegenbauerC(arguments.get(0), arguments.get(1), arguments.get(2)))));
setFunction("glaisher", fixedFunction("glaisher", 0, 1, (functions, arguments) -> functions.glaisher(argumentOrInputPrecision(arguments))));
setFunction("harmonicNumber", fixedFunction("harmonicNumber", 1, 2, (functions, arguments) -> (arguments.size() == 1 ? functions.harmonicNumber(arguments.get(0)) : functions.harmonicNumber(arguments.get(0), arguments.get(1)))));
setFunction("hermiteH", fixedFunction("hermiteH", 2, (functions, arguments) -> functions.hermiteH(arguments.get(0), arguments.get(1))));
setFunction("hypergeometric0F1", fixedFunction("hypergeometric0F1", 2, (functions, arguments) -> functions.hypergeometric0F1(arguments.get(0), arguments.get(1))));
setFunction("hypergeometric0F1Regularized", fixedFunction("hypergeometric0F1Regularized", 2, (functions, arguments) -> functions.hypergeometric0F1Regularized(arguments.get(0), arguments.get(1))));
setFunction("hypergeometric1F1", fixedFunction("hypergeometric1F1", 3, (functions, arguments) -> functions.hypergeometric1F1(arguments.get(0), arguments.get(1), arguments.get(2))));
setFunction("hypergeometric1F1Regularized", fixedFunction("hypergeometric1F1Regularized", 3, (functions, arguments) -> functions.hypergeometric1F1Regularized(arguments.get(0), arguments.get(1), arguments.get(2))));
setFunction("hypergeometric2F1", fixedFunction("hypergeometric2F1", 4, (functions, arguments) -> functions.hypergeometric2F1(arguments.get(0), arguments.get(1), arguments.get(2), arguments.get(3))));
setFunction("hypergeometric2F1Regularized", fixedFunction("hypergeometric2F1Regularized", 4, (functions, arguments) -> functions.hypergeometric2F1Regularized(arguments.get(0), arguments.get(1), arguments.get(2), arguments.get(3))));
setFunction("hypergeometricU", fixedFunction("hypergeometricU", 3, (functions, arguments) -> functions.hypergeometricU(arguments.get(0), arguments.get(1), arguments.get(2))));
setFunction("inverseErf", fixedFunction("inverseErf", 1, (functions, arguments) -> functions.inverseErf(arguments.get(0))));
setFunction("inverseErfc", fixedFunction("inverseErfc", 1, (functions, arguments) -> functions.inverseErfc(arguments.get(0))));
setFunction("jacobiP", fixedFunction("jacobiP", 4, (functions, arguments) -> functions.jacobiP(arguments.get(0), arguments.get(1), arguments.get(2), arguments.get(3))));
setFunction("khinchin", fixedFunction("khinchin", 0, 1, (functions, arguments) -> functions.khinchin(argumentOrInputPrecision(arguments))));
setFunction("laguerreL", fixedFunction("laguerreL", 2, 3, (functions, arguments) -> (arguments.size() == 2 ? functions.laguerreL(arguments.get(0), arguments.get(1)) : functions.laguerreL(arguments.get(0), arguments.get(1), arguments.get(2)))));
setFunction("legendreP", fixedFunction("legendreP", 2, 3, (functions, arguments) -> (arguments.size() == 2 ? functions.legendreP(arguments.get(0), arguments.get(1)) : functions.legendreP(arguments.get(0), arguments.get(1), arguments.get(2)))));
setFunction("legendreQ", fixedFunction("legendreQ", 2, 3, (functions, arguments) -> (arguments.size() == 2 ? functions.legendreQ(arguments.get(0), arguments.get(1)) : functions.legendreQ(arguments.get(0), arguments.get(1), arguments.get(2)))));
setFunction("log", fixedFunction("log", 1, 2, (functions, arguments) -> (arguments.size() == 1 ? functions.log(arguments.get(0)) : functions.log(arguments.get(0), arguments.get(1)))));
setFunction("logGamma", fixedFunction("logGamma", 1, (functions, arguments) -> functions.logGamma(arguments.get(0))));
setFunction("logIntegral", fixedFunction("logIntegral", 1, (functions, arguments) -> functions.logIntegral(arguments.get(0))));
setFunction("logisticSigmoid", fixedFunction("logisticSigmoid", 1, (functions, arguments) -> functions.logisticSigmoid(arguments.get(0))));
setFunction("max", fixedFunction("max", 2, (functions, arguments) -> functions.max(arguments.get(0), arguments.get(1))));
setFunction("min", fixedFunction("min", 2, (functions, arguments) -> functions.min(arguments.get(0), arguments.get(1))));
setFunction("nextAfter", fixedFunction("nextAfter", 2, (functions, arguments) -> functions.nextAfter(arguments.get(0), arguments.get(1))));
setFunction("nextDown", fixedFunction("nextDown", 1, (functions, arguments) -> functions.nextDown(arguments.get(0))));
setFunction("nextUp", fixedFunction("nextUp", 1, (functions, arguments) -> functions.nextUp(arguments.get(0))));
setFunction("pi", fixedFunction("pi", 0, 1, (functions, arguments) -> functions.pi(argumentOrInputPrecision(arguments))));
setFunction("pochhammer", fixedFunction("pochhammer", 2, (functions, arguments) -> functions.pochhammer(arguments.get(0), arguments.get(1))));
setFunction("polygamma", fixedFunction("polygamma", 2, (functions, arguments) -> functions.polygamma(arguments.get(0), arguments.get(1))));
setFunction("polylog", fixedFunction("polylog", 2, (functions, arguments) -> functions.polylog(arguments.get(0), arguments.get(1))));
setFunction("random", fixedFunction("random", 0, 1, (functions, arguments) -> functions.random(argumentOrInputPrecision(arguments))));
setFunction("randomGaussian", fixedFunction("randomGaussian", 0, 1, (functions, arguments) -> functions.randomGaussian(argumentOrInputPrecision(arguments))));
setFunction("round", fixedFunction("round", 2, (functions, arguments) -> functions.round(arguments.get(0), arguments.get(1))));
setFunction("roundToPrecision", fixedFunction("roundToPrecision", 2, (functions, arguments) -> functions.roundToPrecision(arguments.get(0), arguments.get(1))));
setFunction("roundToInteger", fixedFunction("roundToInteger", 1, (functions, arguments) -> functions.roundToInteger(arguments.get(0))));
setFunction("roundToPlaces", fixedFunction("roundToPlaces", 2, (functions, arguments) -> functions.roundToPlaces(arguments.get(0), arguments.get(1))));
setFunction("roundToMultiple", fixedFunction("roundToMultiple", 2, (functions, arguments) -> functions.roundToMultiple(arguments.get(0), arguments.get(1))));
setFunction("sin", fixedFunction("sin", 1, (functions, arguments) -> functions.sin(arguments.get(0))));
setFunction("sinc", fixedFunction("sinc", 1, (functions, arguments) -> functions.sinc(arguments.get(0))));
setFunction("sinIntegral", fixedFunction("sinIntegral", 1, (functions, arguments) -> functions.sinIntegral(arguments.get(0))));
setFunction("sinh", fixedFunction("sinh", 1, (functions, arguments) -> functions.sinh(arguments.get(0))));
setFunction("sinhIntegral", fixedFunction("sinhIntegral", 1, (functions, arguments) -> functions.sinhIntegral(arguments.get(0))));
setFunction("sphericalHarmonicY", fixedFunction("sphericalHarmonicY", 4, (functions, arguments) -> functions.sphericalHarmonicY(arguments.get(0), arguments.get(1), arguments.get(2), arguments.get(3))));
setFunction("sqrt", fixedFunction("sqrt", 1, (functions, arguments) -> functions.sqrt(arguments.get(0))));
setFunction("struveH", fixedFunction("struveH", 2, (functions, arguments) -> functions.struveH(arguments.get(0), arguments.get(1))));
setFunction("struveL", fixedFunction("struveL", 2, (functions, arguments) -> functions.struveL(arguments.get(0), arguments.get(1))));
setFunction("tan", fixedFunction("tan", 1, (functions, arguments) -> functions.tan(arguments.get(0))));
setFunction("tanh", fixedFunction("tanh", 1, (functions, arguments) -> functions.tanh(arguments.get(0))));
setFunction("truncate", fixedFunction("truncate", 1, (functions, arguments) -> functions.truncate(arguments.get(0))));
setFunction("toDegrees", fixedFunction("toDegrees", 1, (functions, arguments) -> functions.toDegrees(arguments.get(0))));
setFunction("toRadians", fixedFunction("toRadians", 1, (functions, arguments) -> functions.toRadians(arguments.get(0))));
setFunction("ulp", fixedFunction("ulp", 1, (functions, arguments) -> functions.ulp(arguments.get(0))));
setFunction("weberE", fixedFunction("weberE", 2, (functions, arguments) -> functions.weberE(arguments.get(0), arguments.get(1))));
setFunction("zeta", fixedFunction("zeta", 1, 2, (functions, arguments) -> (arguments.size() == 1 ? functions.zeta(arguments.get(0)) : functions.zeta(arguments.get(0), arguments.get(1)))));
setFunction("arg", fixedFunction("arg", 1, (functions, arguments) -> functions.arg(arguments.get(0))));
setFunction("conj", fixedFunction("conj", 1, (functions, arguments) -> functions.conj(arguments.get(0))));
setFunction("imag", fixedFunction("imag", 1, (functions, arguments) -> functions.imag(arguments.get(0))));
setFunction("real", fixedFunction("real", 1, (functions, arguments) -> functions.real(arguments.get(0))));
setFunction("agm", fixedFunction("agm", 2, (functions, arguments) -> functions.agm(arguments.get(0), arguments.get(1))));
setFunction("w", fixedFunction("w", 1, 2, (functions, arguments) -> (arguments.size() == 1 ? functions.w(arguments.get(0)) : functions.w(arguments.get(0), arguments.get(1)))));
setFunction("atan2", fixedFunction("atan2", 2, (functions, arguments) -> functions.atan2(arguments.get(0), arguments.get(1))));
setFunction("copySign", fixedFunction("copySign", 2, (functions, arguments) -> functions.copySign(arguments.get(0), arguments.get(1))));
setFunction("fmod", fixedFunction("fmod", 2, (functions, arguments) -> functions.fmod(arguments.get(0), arguments.get(1))));
setFunction("gcd", fixedFunction("gcd", 2, (functions, arguments) -> functions.gcd(arguments.get(0), arguments.get(1))));
setFunction("hypot", fixedFunction("hypot", 2, (functions, arguments) -> functions.hypot(arguments.get(0), arguments.get(1))));
setFunction("inverseRoot", fixedFunction("inverseRoot", 2, 3, (functions, arguments) -> (arguments.size() == 2 ? functions.inverseRoot(arguments.get(0), arguments.get(1)) : functions.inverseRoot(arguments.get(0), arguments.get(1), arguments.get(2)))));
setFunction("lcm", fixedFunction("lcm", 2, (functions, arguments) -> functions.lcm(arguments.get(0), arguments.get(1))));
setFunction("root", fixedFunction("root", 2, 3, (functions, arguments) -> (arguments.size() == 2 ? functions.root(arguments.get(0), arguments.get(1)) : functions.root(arguments.get(0), arguments.get(1), arguments.get(2)))));
setFunction("scale", fixedFunction("scale", 2, (functions, arguments) -> functions.scale(arguments.get(0), arguments.get(1))));
setFunction("n", fixedFunction("precision", 2, (functions, arguments) -> functions.precision(arguments.get(0), arguments.get(1))));
}
@Override
public Number function(String name, List arguments)
throws ParseException
{
Function function = functions.get(name);
if (function == null)
{
throw new ParseException("Invalid function: " + name);
}
return function.call(arguments);
}
private Functions getFunctions(List arguments)
{
Functions functions = (arguments.isEmpty() ? getFunctions((Number) null) : null);
for (Number argument : arguments)
{
Functions functions2 = getFunctions(argument);
functions = (functions != null && functions.getClass().isAssignableFrom(functions2.getClass()) ? functions : functions2);
}
return functions;
}
private Number argumentOrInputPrecision(List arguments)
{
return arguments.size() == 0 ? getInputPrecision() : arguments.get(0);
}
/**
* Factory method.
*
* @param name The function's name.
* @param arguments The number of arguments that the function takes.
* @param handler The handler of the function.
*
* @return The function.
*/
protected FixedFunction fixedFunction(String name, int arguments, FixedFunctionHandler handler)
{
return fixedFunction(name, arguments, arguments, handler);
}
/**
* Factory method.
*
* @param name The function's name.
* @param minArguments The minimum number of arguments that the function takes.
* @param maxArguments The maximum number of arguments that the function takes.
* @param handler The handler of the function.
*
* @return The function.
*/
protected FixedFunction fixedFunction(String name, int minArguments, int maxArguments, FixedFunctionHandler handler)
{
FixedFunction fixedFunction = new FixedFunction();
fixedFunction.name = name;
fixedFunction.minArguments = minArguments;
fixedFunction.maxArguments = maxArguments;
fixedFunction.handler = handler;
return fixedFunction;
}
/**
* Define a function.
*
* @param name The function name.
* @param function The function.
*/
protected void setFunction(String name, Function function)
{
this.functions.put(name, function);
}
/**
* Get the function implementations.
*
* @param x The number to use as the function argument.
*
* @return The function implementations.
*/
protected abstract Functions getFunctions(Number x);
/**
* Promote a number to a more specific class.
*
* @param x The argument.
*
* @return The argument, possibly converted to a more specific subclass.
*/
protected abstract Number promote(Number x);
private Map functions;
}
apfloat-1.15.0/apfloat-calc/src/main/java/org/apfloat/calc/package-info.java 0000664 0000000 0000000 00000002355 15113064030 0026512 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2023 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
Arbitrary precision calculator interactive application.
*/
package org.apfloat.calc;
apfloat-1.15.0/apfloat-calc/src/test/ 0000775 0000000 0000000 00000000000 15113064030 0017311 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-calc/src/test/java/ 0000775 0000000 0000000 00000000000 15113064030 0020232 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-calc/src/test/java/org/ 0000775 0000000 0000000 00000000000 15113064030 0021021 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-calc/src/test/java/org/apfloat/ 0000775 0000000 0000000 00000000000 15113064030 0022447 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-calc/src/test/java/org/apfloat/calc/ 0000775 0000000 0000000 00000000000 15113064030 0023351 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-calc/src/test/java/org/apfloat/calc/CalculatorTest.java 0000664 0000000 0000000 00000123743 15113064030 0027157 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.calc;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.PrintStream;
import org.apfloat.ApfloatArithmeticException;
import org.apfloat.ApfloatRuntimeException;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* @version 1.15.0
* @author Mikko Tommila
*/
public class CalculatorTest
extends TestCase
{
public CalculatorTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new CalculatorTest("testOperators"));
suite.addTest(new CalculatorTest("testFunctions"));
suite.addTest(new CalculatorTest("testArguments"));
return suite;
}
private static void assertCalculation(String expected, String input, String... args)
throws ParseException
{
String actual = runCalculation(input, args);
assertEquals(input, expected + NEWLINE, actual);
}
private static void assertCalculationMatch(String expectedPattern, String input, String... args)
throws ParseException
{
String actual = runCalculation(input, args);
if (!actual.matches('(' + expectedPattern + ')' + NEWLINE))
{
assertEquals(input, expectedPattern + NEWLINE, actual);
}
}
private static String runCalculation(String input, String... args)
throws ParseException
{
InputStream oldIn = System.in;
PrintStream oldOut = System.out;
String actual;
try
{
InputStream in = new ByteArrayInputStream(input.getBytes());
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
PrintStream out = new PrintStream(buffer, true);
System.setIn(in);
System.setOut(out);
Calculator.main(args);
actual = new String(buffer.toByteArray());
}
finally
{
System.setIn(oldIn);
System.setOut(oldOut);
}
return actual;
}
private static void assertCalculationFailure(String input, String... args)
{
try
{
runCalculation(input, args);
fail(input + " accepted");
}
catch (ParseException pe)
{
// OK: syntax error
}
catch (ApfloatArithmeticException aae)
{
// OK: result is not a number
}
catch (IllegalArgumentException iae)
{
// OK: invalid parameter
}
catch (ApfloatRuntimeException are)
{
// OK: attempt invalid calculation
}
}
public static void testOperators()
throws ParseException
{
assertCalculation("163", "1+2*3^4");
assertCalculation("77", "99-22");
assertCalculation("7.7e1", "99.1-22.1");
assertCalculation("i", "2i-i");
assertCalculation("5" + NEWLINE + "11", "x = 5; x + 6");
assertCalculation("5" + NEWLINE + "11" + NEWLINE + "11", "x = 5; x += 6; x");
assertCalculation("5" + NEWLINE + "-1" + NEWLINE + "-1", "x = 5; x -= 6; x");
assertCalculation("5" + NEWLINE + "30" + NEWLINE + "30", "x = 5; x *= 6; x");
assertCalculation("30" + NEWLINE + "5" + NEWLINE + "5", "x = 30; x /= 6; x");
assertCalculation("31" + NEWLINE + "1" + NEWLINE + "1", "x = 31; x %= 6; x");
assertCalculation("5" + NEWLINE + "125" + NEWLINE + "125", "x = 5; x ^= 3; x");
assertCalculation("2", "5 % 3");
assertCalculation("2.1", "5.1 % 3");
assertCalculation("2", "5 + -3");
assertCalculation("7/6", "1/2 + 2/3");
assertCalculation("5e-1", "1./2");
assertCalculation("5e-1", ".5");
assertCalculation("5e-1", ".5e0");
assertCalculation("5e-1", "5e-1");
assertCalculation("5e-1", "5.e-1");
assertCalculation("5e1", "5e1");
assertCalculation("6.67", "20.0/3.00");
assertCalculation("-1", "I*I");
assertCalculation("3+2i", "2I+3");
assertCalculation("3-2i", "i*-2+3");
assertCalculation("35", "((5))*(3+4)");
assertCalculation("7", "+++++++++++++7");
assertCalculation("8", "--8");
assertCalculation("-9", "-----9");
assertCalculation("1", " ;;; \t 1 ;;;;;;;;; ");
assertCalculation("1.41421", "2.0000^0.50000");
assertCalculation("8.8080652584e646456992", "2^2147483647.0");
assertCalculation("-1", "i^2");
assertCalculation("1", "1^2i");
assertCalculation("2417851639229258349412352", "2^3^4");
assertCalculation("120", "5!");
assertCalculation("15", "5!!");
assertCalculation("64", "2^3!");
assertCalculation("8", "2^3!!");
assertCalculation("1307674368000", "5!!!");
assertCalculation("2027025", "5!!!!");
assertCalculation("-24", "-4!");
assertCalculation("1/16777216", "2^-4!");
assertCalculation("-1/16777216", "-2^-4!");
assertCalculation("8", "2^3!!!!");
assertCalculation("-1/8", "-2^-3!!!!");
assertCalculation("4", "2!^2!");
assertCalculation("4", "2!!^2!!");
assertCalculationFailure("6%i");
assertCalculationFailure("5e");
assertCalculationFailure("2^^2");
assertCalculationFailure("2a2");
assertCalculationFailure("x=");
assertCalculationFailure("x+=");
assertCalculationFailure("x-=");
assertCalculationFailure("x*=");
assertCalculationFailure("x/=");
assertCalculationFailure("x%=");
assertCalculationFailure("x^=");
assertCalculationFailure("*5");
assertCalculationFailure("/");
assertCalculationFailure("6%");
assertCalculationFailure("2-");
assertCalculationFailure("bogus^5");
assertCalculationFailure("!");
assertCalculationFailure("bogus!");
assertCalculationFailure("bogus!!");
assertCalculationFailure("5!=");
assertCalculationFailure("5!=4");
}
public static void testFunctions()
throws ParseException
{
assertCalculation("3", "abs(-3)");
assertCalculation("3", "abs(-3i)");
assertCalculation("5", "abs(3.00 + 4.00I)");
assertCalculation("3.03703e-1", "airyAi(0.200000)");
assertCalculation("-2.52405e-1", "airyAiPrime(0.200000)");
assertCalculation("7.05464e-1", "airyBi(0.200000)");
assertCalculation("4.61789e-1", "airyBiPrime(0.200000)");
assertCalculation("9.5235e-1", "angerJ(0.200000,0.700000)");
assertCalculation("7/6", "bernoulli(14)");
assertCalculation("3.3124e4", "bernoulliB(4,14.0000)");
assertCalculation("1.72763", "besselI(0.700000,1.90000)");
assertCalculation("5.84978e-1", "besselJ(0.700000,1.90000)");
assertCalculation("2.06052", "besselK(0.700000,0.300000)");
assertCalculation("-1.6523", "besselY(0.700000,0.300000)");
assertCalculation("3.55114", "beta(0.200000,4.00000)");
assertCalculation("3.00545", "beta(0.100000,0.200000,4.00000)");
assertCalculation("-1.02994", "beta(0.100000,2.90000,0.200000,4.00000)");
assertCalculation("1.5057e2", "binomial(9.20000,4.60000)");
assertCalculation("2.3282", "binomial(4,3.5000)");
assertCalculation("6.5625", "binomial(4.5000,3)");
assertCalculation("45", "binomial(10,2)");
assertCalculation("366166666666666666665821666666666666666667100000000000000000000", "binomial(1300000000000000000000,3)");
assertCalculation("0", "binomial(3,1300000000000000000000)");
assertCalculation("1", "binomial(1300000000000000000000,1300000000000000000000)");
assertCalculation("1040/81", "binomial(16/3,7/3)");
assertCalculation("-455/81", "binomial(-7/3,-16/3)");
assertCalculation("-1", "binomial(-1,1)");
assertCalculation("0", "binomial(1,-1)");
assertCalculation("0", "binomial(3.5,4.5)");
assertCalculation("-3.109-1.604i", "binomial(3.000+4.000i,5.000+6.000i)");
assertCalculation("9.1596559e-1", "catalan(8)");
assertCalculation("2", "cbrt(8)");
assertCalculation("2/3", "cbrt(8/27)");
assertCalculation("7.07e-1+7.07e-1i", "cbrt(-0.707+0.707i)");
assertCalculation("1.2599", "cbrt(2.0000)");
assertCalculation("2", "ceil(1.1)");
assertCalculation("2", "ceil(3/2)");
assertCalculation("1.41288", "chebyshevT(0.70000,1.9000)");
assertCalculation("2.58673", "chebyshevU(0.700000,1.90000)");
assertCalculation("-2", "copySign(2, -3)");
assertCalculation("-1.04221", "cosIntegral(0.200000)");
assertCalculation("-1.02221", "coshIntegral(0.200000)");
assertCalculation("1.7061", "digamma(6.0000)");
assertCalculation("34459425", "doubleFactorial(17)");
assertCalculation("1", "doubleFactorial(-1)");
assertCalculation("-1", "doubleFactorial(-3)");
assertCalculation("1/3", "doubleFactorial(-5)");
assertCalculation("1.48904", "ellipticE(0.200000)");
assertCalculation("1.65962", "ellipticK(0.200000)");
assertCalculation("2.22703e-1", "erf(0.200000)");
assertCalculation("7.77297e-1", "erfc(0.200000)");
assertCalculation("2.41591", "erfi(1.20000)");
assertCalculation("1.2141", "eulerE(4, 1.90000)");
assertCalculation("1.1722", "expIntegralE(0.70000,0.30000)");
assertCalculation("2.44209", "expIntegralEi(1.20000)");
assertCalculation("5040", "factorial(7)");
assertCalculation("7.3936", "fibonacci(5.00000, 1.20000)");
assertCalculation("2", "floor(2.9)");
assertCalculation("2", "floor(29/10)");
assertCalculation("9e-1", "frac(2.9)");
assertCalculation("9/10", "frac(29/10)");
assertCalculation("7.15438e-1", "fresnelC(1.20000)");
assertCalculation("6.23401e-1", "fresnelS(1.20000)");
assertCalculation("6", "gamma(4)");
assertCalculation("5.8861", "gamma(4.0000, 1.0000)");
assertCalculation("5.0928", "gamma(4.0000, 0, 6.0000)");
assertCalculation("4.74294943677064514689542753377e1-3.27488916473624576880974867017e1i", "gamma(100.000000000000000000000000000+374.000000000000000000000000000i)");
assertCalculation("-5.25676", "gegenbauerC(-1.10000,2.50000)");
assertCalculation("-2.60129", "gegenbauerC(-1.10000,-1.30000,2.50000)");
assertCalculation("1.282427", "glaisher(7)");
assertCalculation("1.12151", "harmonicNumber(1.20000)");
assertCalculation("1.104113", "harmonicNumber(1.200000,1.300000)");
assertCalculation("42142223/12252240", "harmonicNumber(17)");
assertCalculation("6301272372663207205033976933/6076911214672415134617600000", "harmonicNumber(13,5)");
assertCalculation("3.04424", "hermiteH(1.20000,1.30000)");
assertCalculation("1.453+1.237i", "hypergeometric0F1(3.456+2.890i,0.1234+4.678i)");
assertCalculation("2.6328", "hypergeometric0F1Regularized(-3.00000,2.50000)");
assertCalculation("-7.477+3.738i", "hypergeometric1F1(3.456+2.890i,3.456+2.890i,2.1234+2.678i)");
assertCalculation("1.2856", "hypergeometric1F1Regularized(0.200000,-3,1.50000)");
assertCalculation("-1.477-2.073i", "hypergeometric2F1(9.456+4.890i,3.456+2.890i,1.256+1.390i,0.11234+0.1678i)");
assertCalculation("4.8317", "hypergeometric2F1Regularized(0.100000,0.200000,-3,0.800000)");
assertCalculation("4.99704", "hypergeometricU(1.20000,2,0.200000)");
assertCalculation("2", "fmod(5, 3)");
assertCalculation("5", "hypot(3, 4)");
assertCalculation("5e-1", "hypot(0.3, 0.4)");
assertCalculation("1.16309", "inverseErf(0.900000)");
assertCalculation("1.0179", "inverseErfc(0.150000)");
assertCalculation("5e-1", "inverseRoot(2.0, 1)");
assertCalculation("5e-1", "inverseRoot(4.0, 2)");
assertCalculation("7.07e-1-7.07e-1i", "inverseRoot(-0.707+0.707i, 3)");
assertCalculation("-5e-1", "inverseRoot(4.0, 2, 1)");
assertCalculation("6.28477", "jacobiP(1.20000,1.70000,0.900000,1.90000)");
assertCalculation("2.685452", "khinchin(7)");
assertCalculation("-1.01693", "laguerreL(1.20000,1.90000)");
assertCalculation("1.38308", "laguerreL(1.20000,1.70000,1.30000)");
assertCalculation("2.26206", "legendreP(1.20000,1.90000)");
assertCalculation("-3.36749", "legendreP(1.20000,1.70000,0.900000)");
assertCalculation("1.07204", "legendreQ(1.70000,-0.900000)");
assertCalculation("4.1358", "legendreQ(1.20000,1.70000,0.900000)");
assertCalculation("-4.371-3.651i", "logGamma(-1.234+2.345i)");
assertCalculation("1.04516", "logIntegral(2.0000)");
assertCalculation("8.80797e-1", "logisticSigmoid(2.00000)");
assertCalculation("1.23", "n(1.23456, 3)");
assertCalculation("1.04748", "pochhammer(1.20000,0.700000)");
assertCalculation("280/81", "pochhammer(1/3,4)");
assertCalculation("-3.2018", "polygamma(2,0.900000)");
assertCalculation("1.79112-2.61823i", "polylog(1.20000,1.30000)");
assertCalculation("2", "root(8, 3)");
assertCalculation("2/3", "root(16/81, 4)");
assertCalculation("7.07e-1+7.07e-1i", "root(-0.707+0.707i, 3)");
assertCalculation("1.2599", "root(2.0000, 3)");
assertCalculation("-4", "root(16.0, 2, 1)");
assertCalculation("3", "round(2.9, 1)");
assertCalculation("3", "round(29/10, 1)");
assertCalculation("3", "round(2.5, 1)");
assertCalculation("4", "round(3.5, 1)");
assertCalculation("-3", "round(-2.5, 1)");
assertCalculation("-4", "round(-3.5, 1)");
assertCalculation("3", "roundToPrecision(2.9, 1)");
assertCalculation("3", "roundToPrecision(29/10, 1)");
assertCalculation("3", "roundToPrecision(2.5, 1)");
assertCalculation("4", "roundToPrecision(3.5, 1)");
assertCalculation("-3", "roundToPrecision(-2.5, 1)");
assertCalculation("-4", "roundToPrecision(-3.5, 1)");
assertCalculation("3", "roundToInteger(2.9)");
assertCalculation("3", "roundToInteger(29/10)");
assertCalculation("3", "roundToInteger(2.5)");
assertCalculation("-3", "roundToInteger(-2.5)");
assertCalculation("-4", "roundToInteger(-3.5)");
assertCalculation("2.9", "roundToPlaces(2.94, 1)");
assertCalculation("3e-1", "roundToPlaces(29/100, 1)");
assertCalculation("30", "roundToPlaces(25, -1)");
assertCalculation("4", "roundToPlaces(3.5, 0)");
assertCalculation("-2.35", "roundToPlaces(-2.345, 2)");
assertCalculation("-3.36", "roundToPlaces(-3.355, 2)");
assertCalculation("2.4", "roundToMultiple(2.9, 1.2)");
assertCalculation("20/7", "roundToMultiple(29/10, 1/7)");
assertCalculation("3", "roundToMultiple(2.5, 1.0)");
assertCalculation("4", "roundToMultiple(3.5, 1.0)");
assertCalculation("-2.5", "roundToMultiple(-2.5, 1.25)");
assertCalculation("-3", "roundToMultiple(-3., 0.3)");
assertCalculation("20000000000", "scale(2, 10)");
assertCalculation("1/5", "scale(2, -1)");
assertCalculation("2.1e10", "scale(2.1, 10)");
assertCalculation("2.5e10+1.5e10i", "scale(2.5+1.5i, 10)");
assertCalculation("200000/3", "scale(2/3, 5)");
assertCalculation("4.54649e-1", "sinc(2.00000)");
assertCalculation("1.60541", "sinIntegral(2.00000)");
assertCalculation("2.50157", "sinhIntegral(2.00000)");
assertCalculation("4.33712e-1-1.30178e-1i", "sphericalHarmonicY(1.20000,1.50000,0.900000,1.90000)");
assertCalculation("3", "sqrt(9)");
assertCalculation("2/3", "sqrt(4/9)");
assertCalculation("7.07+7.07i", "sqrt(100.i)");
assertCalculation("1.4142", "sqrt(2.0000)");
assertCalculation("1.45336", "struveH(1.80000,4.70000)");
assertCalculation("1.40023", "struveL(1.80000,2.70000)");
assertCalculation("2", "truncate(2.5)");
assertCalculation("2", "truncate(5/2)");
assertCalculation("1.79e2", "toDegrees(3.14)");
assertCalculation("1.57", "toRadians(90.0)");
assertCalculation("2.16872e-1", "weberE(1.700000,0.7000000)");
assertCalculation("1.645", "zeta(2.000)");
assertCalculation("1.181e-1", "zeta(3.000,-1.500)");
assertCalculation("3.14", "acos(-1.00)");
assertCalculation("1.01", "acosh(1.55)");
assertCalculation("1.57", "asin(1.00)");
assertCalculation("0", "asinh(0)");
assertCalculation("7.85e-1", "atan(1.00)");
assertCalculation("0", "atanh(0)");
assertCalculation("1.57", "atan2(1.00, 0)");
assertCalculation("1", "cos(0)");
assertCalculation("1.54", "cosh(1.00)");
assertCalculation("8.414709848e-1", "sin(1.000000000)");
assertCalculation("1.18", "sinh(1.00)");
assertCalculation("1.56", "tan(1.00)");
assertCalculation("9.64e-1", "tanh(2.00)");
assertCalculation("2.7182818284590452353602874713526624977572470937", "e(47)");
assertCalculation("5.772e-1", "euler(4)");
assertCalculation("2.718", "exp(1.000)");
assertCalculation("1.79+3.14i", "log(-6.00)");
assertCalculation("1.58", "log(3.00, 2.00)");
assertCalculation("1.585", "log(3.000, 2)");
assertCalculation("1.585", "log(3, 2.0000)");
assertCalculation("1.2", "max(1.1, 1.2)");
assertCalculation("1/3", "max(1/3, 1/4)");
assertCalculation("2", "max(1, 2)");
assertCalculation("1.1", "min(1.1, 1.2)");
assertCalculation("1/4", "min(1/3, 1/4)");
assertCalculation("1", "min(1, 2)");
assertCalculation("2", "nextAfter(1., 2)");
assertCalculation("2", "nextUp(1.)");
assertCalculation("1", "nextDown(2.)");
assertCalculation("2/3", "nextDown(2/3)");
assertCalculation("1", "ulp(2.)");
assertCalculation("0", "ulp(2/3)");
assertCalculation("0", "ulp(1+i)");
assertCalculation("1e-1", "ulp(-10.00-2.0i)");
assertCalculation("1.57", "arg(1.00i)");
assertCalculation("2-i", "conj(2+i)");
assertCalculation("1", "imag(2+i)");
assertCalculation("2", "real(2+i)");
assertCalculation("2.47468", "agm(2.000000, 3.000000)");
assertCalculation("5.672e-1", "w(1.000)");
assertCalculation("-3.181e-1+1.3372i", "w(-1.0000)");
assertCalculation("-1.34285+5.24725i", "w(1.00000+i, 1)");
assertCalculation("3", "gcd(15, 12)");
assertCalculation("60", "lcm(15, 12)");
assertCalculation("3.14159", "pi(6)");
assertCalculationMatch("0|[1-9]e-1", "random(1)");
assertCalculationMatch("0|-?([1-5]|[1-9]e-1)", "randomGaussian(1)");
assertCalculation("5", "add(2, 3)");
assertCalculation("-1", "subtract(2, 3)");
assertCalculation("6", "multiply(2, 3)");
assertCalculation("2/3", "divide(2, 3)");
assertCalculation("-2", "negate(2)");
assertCalculation("2", "mod(5, 3)");
assertCalculation("8", "pow(2, 3)");
assertCalculationFailure("airyAi()");
assertCalculationFailure("airyAi(0,0)");
assertCalculationFailure("airyAiPrime()");
assertCalculationFailure("airyAiPrime(0,0)");
assertCalculationFailure("airyBi()");
assertCalculationFailure("airyBi(0,0)");
assertCalculationFailure("airyBiPrime()");
assertCalculationFailure("airyBiPrime(0,0)");
assertCalculationFailure("angerJ()");
assertCalculationFailure("angerJ(1.0)");
assertCalculationFailure("angerJ(1.0,1.0,1.0)");
assertCalculationFailure("bernoulli(-1)");
assertCalculationFailure("bernoulli(i)");
assertCalculationFailure("bernoulli()");
assertCalculationFailure("bernoulli(1,1)");
assertCalculationFailure("bernoulliB(1)");
assertCalculationFailure("bernoulliB(1,1.0,1.0)");
assertCalculationFailure("bernoulliB(-1,1.0)");
assertCalculationFailure("bernoulliB(i,1.0)");
assertCalculationFailure("bernoulliB(2/3,1.0)");
assertCalculationFailure("besselI(1.0)");
assertCalculationFailure("besselI(1.0,1.0,1.0)");
assertCalculationFailure("besselJ(1.0)");
assertCalculationFailure("besselJ(1.0,1.0,1.0)");
assertCalculationFailure("besselK(1.0)");
assertCalculationFailure("besselK(1.0,1.0,1.0)");
assertCalculationFailure("besselY(1.0)");
assertCalculationFailure("besselY(1.0,1.0,1.0)");
assertCalculationFailure("beta(1.0)");
assertCalculationFailure("beta(1.0,1.0,1.0,1.0,1.0)");
assertCalculationFailure("binomial(-3,5i)");
assertCalculationFailure("binomial(-3i,5)");
assertCalculationFailure("binomial(-3i,5i)");
assertCalculationFailure("binomial(-3,3.5)");
assertCalculationFailure("binomial(4/3,3/2)");
assertCalculationFailure("binomial()");
assertCalculationFailure("binomial(2)");
assertCalculationFailure("binomial(2,2,2)");
assertCalculationFailure("catalan()");
assertCalculationFailure("catalan(5, 5)");
assertCalculationFailure("catalan(0)");
assertCalculationFailure("catalan(-1)");
assertCalculationFailure("catalan(0.5)");
assertCalculationFailure("catalan(i)");
assertCalculationFailure("cbrt(2)");
assertCalculationFailure("cbrt()");
assertCalculationFailure("cbrt(8, 2)");
assertCalculationFailure("ceil(i)");
assertCalculationFailure("ceil()");
assertCalculationFailure("ceil(2, 2)");
assertCalculationFailure("chebyshevT(1.0)");
assertCalculationFailure("chebyshevT(1.0,1.0,1.0)");
assertCalculationFailure("chebyshevU(1.0)");
assertCalculationFailure("chebyshevU(1.0,1.0,1.0)");
assertCalculationFailure("copySign(2i, -3)");
assertCalculationFailure("copySign(2)");
assertCalculationFailure("copySign(2, 2, 2)");
assertCalculationFailure("cosIntegral()");
assertCalculationFailure("cosIntegral(1.0,1.0)");
assertCalculationFailure("coshIntegral()");
assertCalculationFailure("coshIntegral(1.0,1.0)");
assertCalculationFailure("digamma(0)");
assertCalculationFailure("digamma()");
assertCalculationFailure("digamma(2,2)");
assertCalculationFailure("doubleFactorial(0.5)");
assertCalculationFailure("doubleFactorial(-2)");
assertCalculationFailure("doubleFactorial(2i)");
assertCalculationFailure("doubleFactorial(2/3)");
assertCalculationFailure("doubleFactorial()");
assertCalculationFailure("doubleFactorial(2, 2)");
assertCalculationFailure("ellipticE()");
assertCalculationFailure("ellipticE(0.5,0.5)");
assertCalculationFailure("ellipticK()");
assertCalculationFailure("ellipticK(0.5,0.5)");
assertCalculationFailure("erf()");
assertCalculationFailure("erf(0.5,0.5)");
assertCalculationFailure("erfc()");
assertCalculationFailure("erfc(0.5,0.5)");
assertCalculationFailure("erfi()");
assertCalculationFailure("erfi(0.5,0.5)");
assertCalculationFailure("eulerE(1)");
assertCalculationFailure("eulerE(1,1.0,1.0");
assertCalculationFailure("eulerE(-1,1.0)");
assertCalculationFailure("eulerE(i,1.0)");
assertCalculationFailure("eulerE(2/3,1.0)");
assertCalculationFailure("expIntegralE(0.5)");
assertCalculationFailure("expIntegralE(0.5,0.5,0.5)");
assertCalculationFailure("expIntegralEi()");
assertCalculationFailure("expIntegralEi(0.5,0.5)");
assertCalculationFailure("factorial(0.5)");
assertCalculationFailure("factorial(2i)");
assertCalculationFailure("factorial(2/3)");
assertCalculationFailure("factorial()");
assertCalculationFailure("factorial(2, 2)");
assertCalculationFailure("fibonacci(1.0)");
assertCalculationFailure("fibonacci(1.0,1.0,1.0)");
assertCalculationFailure("floor(i)");
assertCalculationFailure("floor()");
assertCalculationFailure("floor(2, 2)");
assertCalculationFailure("frac(i)");
assertCalculationFailure("frac()");
assertCalculationFailure("frac(2, 2)");
assertCalculationFailure("fresnelC()");
assertCalculationFailure("fresnelC(1.0,1.0)");
assertCalculationFailure("fresnelS()");
assertCalculationFailure("fresnelS(1.0,1.0)");
assertCalculationFailure("gamma(0)");
assertCalculationFailure("gamma()");
assertCalculationFailure("gamma(2, 2, 2, 2)");
assertCalculationFailure("gegenbauerC(1.0)");
assertCalculationFailure("gegenbauerC(1.0,1.0,1.0,1.0)");
assertCalculationFailure("glaisher()");
assertCalculationFailure("glaisher(5, 5)");
assertCalculationFailure("glaisher(0)");
assertCalculationFailure("glaisher(-1)");
assertCalculationFailure("glaisher(0.5)");
assertCalculationFailure("glaisher(i)");
assertCalculationFailure("harmonicNumber()");
assertCalculationFailure("harmonicNumber(-1)");
assertCalculationFailure("harmonicNumber(-1,1)");
assertCalculationFailure("harmonicNumber(1.0,1.0,1.0)");
assertCalculationFailure("hermiteH(1.0)");
assertCalculationFailure("hermiteH(1.0,1.0,1.0)");
assertCalculationFailure("hypergeometric0F1(0)");
assertCalculationFailure("hypergeometric0F1(0,0)");
assertCalculationFailure("hypergeometric0F1(0,0,0)");
assertCalculationFailure("hypergeometric0F1Regularized(0)");
assertCalculationFailure("hypergeometric0F1Regularized(0,0,0)");
assertCalculationFailure("hypergeometric1F1(0,0)");
assertCalculationFailure("hypergeometric1F1(1,0,0)");
assertCalculationFailure("hypergeometric1F1(0,0,0,0)");
assertCalculationFailure("hypergeometric1F1Regularized(0,0)");
assertCalculationFailure("hypergeometric1F1Regularized(0,0,0,0)");
assertCalculationFailure("hypergeometric2F1(0,0,0)");
assertCalculationFailure("hypergeometric2F1(1,2,0,0)");
assertCalculationFailure("hypergeometric2F1(0,0,0,0,0)");
assertCalculationFailure("hypergeometric2F1Regularized(0,0,0)");
assertCalculationFailure("hypergeometric2F1Regularized(0,0,0,0,0)");
assertCalculationFailure("hypergeometricU(0,0)");
assertCalculationFailure("hypergeometricU(0,0,0,0)");
assertCalculationFailure("fmod(2, i)");
assertCalculationFailure("fmod(2)");
assertCalculationFailure("fmod(2, 2, 2)");
assertCalculationFailure("hypot(2, i)");
assertCalculationFailure("hypot(2)");
assertCalculationFailure("hypot(2, 2, 2)");
assertCalculationFailure("inverseErf()");
assertCalculationFailure("inverseErf(-1.0)");
assertCalculationFailure("inverseErf(1.0)");
assertCalculationFailure("inverseErf(2.0)");
assertCalculationFailure("inverseErf(0.5i)");
assertCalculationFailure("inverseErf(0.5,0.5)");
assertCalculationFailure("inverseErfc()");
assertCalculationFailure("inverseErfc(0)");
assertCalculationFailure("inverseErfc(2.0)");
assertCalculationFailure("inverseErfc(3.0)");
assertCalculationFailure("inverseErfc(0.5i)");
assertCalculationFailure("inverseErfc(0.5,0.5)");
assertCalculationFailure("inverseRoot(2.0, i)");
assertCalculationFailure("inverseRoot(2.0, 1/2)");
assertCalculationFailure("inverseRoot(2, 2)");
assertCalculationFailure("inverseRoot(2)");
assertCalculationFailure("inverseRoot(2.0, 1, i)");
assertCalculationFailure("inverseRoot(2.0, i, 1)");
assertCalculationFailure("inverseRoot(2.0, i, i)");
assertCalculationFailure("inverseRoot(2.0, 2, 2, 2)");
assertCalculationFailure("jacobiP(1.0,1.0,1.0)");
assertCalculationFailure("jacobiP(1.0,1.0,1.0,1.0,1.0)");
assertCalculationFailure("khinchin()");
assertCalculationFailure("khinchin(5, 5)");
assertCalculationFailure("khinchin(0)");
assertCalculationFailure("khinchin(-1)");
assertCalculationFailure("khinchin(0.5)");
assertCalculationFailure("khinchin(i)");
assertCalculationFailure("laguerreL(1.0)");
assertCalculationFailure("laguerreL(1.0,1.0,1.0,1.0)");
assertCalculationFailure("legendreP(1.0)");
assertCalculationFailure("legendreP(1.0,1.0,1.0,1.0)");
assertCalculationFailure("legendreQ(1.0)");
assertCalculationFailure("legendreQ(1.0,1.0,1.0,1.0)");
assertCalculationFailure("logGamma(0)");
assertCalculationFailure("logGamma(-1)");
assertCalculationFailure("logGamma()");
assertCalculationFailure("logGamma(2,2)");
assertCalculationFailure("logIntegral()");
assertCalculationFailure("logIntegral(1.0,1.0)");
assertCalculationFailure("logisticSigmoid()");
assertCalculationFailure("logisticSigmoid(2.0,2.0)");
assertCalculationFailure("n(1.23456, i)");
assertCalculationFailure("n(1.23456, 0.5)");
assertCalculationFailure("n(1.23456)");
assertCalculationFailure("n(1.23456, 2, 2)");
assertCalculationFailure("pochhammer(1.0)");
assertCalculationFailure("pochhammer(1.0,1.0,1.0)");
assertCalculationFailure("pochhammer(1/3,1/4)");
assertCalculationFailure("polygamma(1)");
assertCalculationFailure("polygamma(-1,1.0)");
assertCalculationFailure("polygamma(1,1.0,1.0)");
assertCalculationFailure("polylog(0.5)");
assertCalculationFailure("polylog(0.5,0.5,0.5)");
assertCalculationFailure("root(2, 2)");
assertCalculationFailure("root(2)");
assertCalculationFailure("root(2, i)");
assertCalculationFailure("root(2, 1, i)");
assertCalculationFailure("root(2, i, 1)");
assertCalculationFailure("root(2, i, i)");
assertCalculationFailure("root(4.0, 2, 2, 2)");
assertCalculationFailure("round(2)");
assertCalculationFailure("round(2, 0)");
assertCalculationFailure("round(2, 0.5)");
assertCalculationFailure("round(2, i)");
assertCalculationFailure("round(i, 2)");
assertCalculationFailure("round(2, 2, 2)");
assertCalculationFailure("roundToPrecision(2)");
assertCalculationFailure("roundToPrecision(2, 0)");
assertCalculationFailure("roundToPrecision(2, 0.5)");
assertCalculationFailure("roundToPrecision(2, i)");
assertCalculationFailure("roundToPrecision(i, 2)");
assertCalculationFailure("roundToPrecision(2, 2, 2)");
assertCalculationFailure("roundToInteger()");
assertCalculationFailure("roundToInteger(i)");
assertCalculationFailure("roundToInteger(2, 0)");
assertCalculationFailure("roundToPlaces(2)");
assertCalculationFailure("roundToPlaces(2, 0.5)");
assertCalculationFailure("roundToPlaces(2, i)");
assertCalculationFailure("roundToPlaces(i, 2)");
assertCalculationFailure("roundToPlaces(2, 2, 2)");
assertCalculationFailure("roundToMultiple(2)");
assertCalculationFailure("roundToMultiple(2, 0)");
assertCalculationFailure("roundToMultiple(2, i)");
assertCalculationFailure("roundToMultiple(i, 2)");
assertCalculationFailure("roundToMultiple(2, 2, 2)");
assertCalculationFailure("scale(1.23456, i)");
assertCalculationFailure("scale(1.23456, 0.5)");
assertCalculationFailure("scale(1.23456)");
assertCalculationFailure("scale(1.23456, 2, 2)");
assertCalculationFailure("sinc()");
assertCalculationFailure("sinc(1.0,1.0)");
assertCalculationFailure("sinIntegral()");
assertCalculationFailure("sinIntegral(1.0,1.0)");
assertCalculationFailure("sinhIntegral()");
assertCalculationFailure("sinhIntegral(1.0,1.0)");
assertCalculationFailure("sphericalHarmonicY(1.0,1.0,1.0)");
assertCalculationFailure("sphericalHarmonicY(1.0,1.0,1.0,1.0,1.0)");
assertCalculationFailure("sqrt(2)");
assertCalculationFailure("sqrt()");
assertCalculationFailure("sqrt(4, 2)");
assertCalculationFailure("struveH()");
assertCalculationFailure("struveH(1.0)");
assertCalculationFailure("struveH(-1.0,0)");
assertCalculationFailure("struveH(1.0,1.0,1.0)");
assertCalculationFailure("struveL()");
assertCalculationFailure("struveL(1.0)");
assertCalculationFailure("struveL(-1.0,0)");
assertCalculationFailure("struveL(1.0,1.0,1.0)");
assertCalculationFailure("truncate(i)");
assertCalculationFailure("truncate()");
assertCalculationFailure("truncate(2, 2)");
assertCalculationFailure("toDegrees(2)");
assertCalculationFailure("toDegrees(i)");
assertCalculationFailure("toDegrees()");
assertCalculationFailure("toDegrees(2, 2)");
assertCalculationFailure("toRadians(2)");
assertCalculationFailure("toRadians(i)");
assertCalculationFailure("toRadians()");
assertCalculationFailure("toRadians(2, 2)");
assertCalculationFailure("weberE()");
assertCalculationFailure("weberE(1.0)");
assertCalculationFailure("weberE(1.0,1.0,1.0)");
assertCalculationFailure("zeta(1)");
assertCalculationFailure("zeta(2,0)");
assertCalculationFailure("zeta(2,-1)");
assertCalculationFailure("zeta()");
assertCalculationFailure("zeta(2,3,4)");
assertCalculationFailure("acos()");
assertCalculationFailure("acos(1, 1)");
assertCalculationFailure("acosh()");
assertCalculationFailure("acosh(1, 1)");
assertCalculationFailure("asin()");
assertCalculationFailure("asin(1, 1)");
assertCalculationFailure("asinh()");
assertCalculationFailure("asinh(1, 1)");
assertCalculationFailure("atan()");
assertCalculationFailure("atan(1, 1)");
assertCalculationFailure("atanh()");
assertCalculationFailure("atanh(1, 1)");
assertCalculationFailure("atan2(1)");
assertCalculationFailure("atan2(i, i)");
assertCalculationFailure("atan2(1, 1, 1)");
assertCalculationFailure("cos()");
assertCalculationFailure("cos(1, 1)");
assertCalculationFailure("cosh()");
assertCalculationFailure("cosh(1, 1)");
assertCalculationFailure("sin()");
assertCalculationFailure("sin(1, 1)");
assertCalculationFailure("sinh()");
assertCalculationFailure("sinh(1, 1)");
assertCalculationFailure("tan()");
assertCalculationFailure("tan(1, 1)");
assertCalculationFailure("tanh()");
assertCalculationFailure("tanh(1, 1)");
assertCalculationFailure("e()");
assertCalculationFailure("e(0)");
assertCalculationFailure("e(-1)");
assertCalculationFailure("e(0.5)");
assertCalculationFailure("e(i)");
assertCalculationFailure("e(1, 1)");
assertCalculationFailure("euler()");
assertCalculationFailure("euler(0)");
assertCalculationFailure("euler(-1)");
assertCalculationFailure("euler(0.5)");
assertCalculationFailure("euler(i)");
assertCalculationFailure("euler(1, 1)");
assertCalculationFailure("exp()");
assertCalculationFailure("exp(1, 1)");
assertCalculationFailure("log()");
assertCalculationFailure("log(1, 1, 1)");
assertCalculationFailure("max()");
assertCalculationFailure("max(1)");
assertCalculationFailure("max(1, 1, 1)");
assertCalculationFailure("max(i, i)");
assertCalculationFailure("min()");
assertCalculationFailure("min(1)");
assertCalculationFailure("min(1, 1, 1)");
assertCalculationFailure("min(i, i)");
assertCalculationFailure("nextAfter(1)");
assertCalculationFailure("nextAfter(1, 2, 3)");
assertCalculationFailure("nextAfter(1, i)");
assertCalculationFailure("nextUp()");
assertCalculationFailure("nextUp(1, 1)");
assertCalculationFailure("nextUp(i)");
assertCalculationFailure("nextDown()");
assertCalculationFailure("nextDown(2, 2)");
assertCalculationFailure("nextDown(i)");
assertCalculationFailure("ulp()");
assertCalculationFailure("ulp(2, 2)");
assertCalculationFailure("arg()");
assertCalculationFailure("arg(1, 1)");
assertCalculationFailure("conj()");
assertCalculationFailure("conj(1, 1)");
assertCalculationFailure("imag()");
assertCalculationFailure("imag(1, 1)");
assertCalculationFailure("real()");
assertCalculationFailure("real(1, 1)");
assertCalculationFailure("agm(1)");
assertCalculationFailure("agm(1, 1, 1)");
assertCalculationFailure("w(1, 1, 1)");
assertCalculationFailure("w(1, i)");
assertCalculationFailure("w(1, 1.5)");
assertCalculationFailure("w(1, 2/3)");
assertCalculationFailure("gcd(2, i)");
assertCalculationFailure("gcd(2, 2/3)");
assertCalculationFailure("gcd(1)");
assertCalculationFailure("gcd(1, 1, 1)");
assertCalculationFailure("lcm(2, i)");
assertCalculationFailure("lcm(2, 2/3)");
assertCalculationFailure("lcm(1)");
assertCalculationFailure("lcm(1, 1, 1)");
assertCalculationFailure("pi(i)");
assertCalculationFailure("pi(0.5)");
assertCalculationFailure("pi()");
assertCalculationFailure("pi(1, 1)");
assertCalculationFailure("random(i)");
assertCalculationFailure("random(0.5)");
assertCalculationFailure("random()");
assertCalculationFailure("random(1, 1)");
assertCalculationFailure("randomGaussian(i)");
assertCalculationFailure("randomGaussian(0.5)");
assertCalculationFailure("randomGaussian()");
assertCalculationFailure("randomGaussian(1, 1)");
assertCalculationFailure("add(2)");
assertCalculationFailure("add(2, 2, 2)");
assertCalculationFailure("subtract(2)");
assertCalculationFailure("subtract(2, 2, 2)");
assertCalculationFailure("multiply(2)");
assertCalculationFailure("multiply(2, 2, 2)");
assertCalculationFailure("divide(2)");
assertCalculationFailure("divide(2, 2, 2)");
assertCalculationFailure("negate()");
assertCalculationFailure("negate(2, 2)");
assertCalculationFailure("mod(2, i)");
assertCalculationFailure("mod(2)");
assertCalculationFailure("mod(2, 2, 2)");
assertCalculationFailure("pow(2)");
assertCalculationFailure("pow(2, 2, 2)");
assertCalculationFailure("bogusfunc(5)");
}
public static void testArguments()
throws ParseException
{
assertCalculation("1.4142", "sqrt(2.)", "-i", "5");
assertCalculation("0.5", "1/2", "-p", "-i", "1");
assertCalculation("0.5", "1.0/2.0", "-p");
assertCalculation("0.915966", "catalan()", "-p", "-i", "6");
assertCalculation("2.71828", "e()", "-i", "6");
assertCalculation("0.577216", "euler()", "-p", "-i", "6");
assertCalculation("1.28243", "glaisher()", "-i", "6");
assertCalculation("2.68545", "khinchin()", "-p", "-i", "6");
assertCalculation("3.14159", "pi()", "-i", "6");
assertCalculationMatch("0|[1-9]e-1", "random()", "-i", "1");
assertCalculationMatch("0|-?([1-5]|[1-9]e-1)", "randomGaussian()", "-i", "1");
assertCalculation("1.5708", "acos(0)", "-p", "-i", "6");
assertCalculation("1.5708i", "acosh(0)", "-p", "-i", "6");
assertCalculation("0.355028", "airyAi(0)", "-p", "-i", "6");
assertCalculation("-0.258819", "airyAiPrime(0)", "-p", "-i", "6");
assertCalculation("0.614927", "airyBi(0)", "-p", "-i", "6");
assertCalculation("0.448288", "airyBiPrime(0)", "-p", "-i", "6");
assertCalculation("-7.09216", "bernoulliB(16, 0)", "-i", "6");
assertCalculation("1.5708", "ellipticE(0)", "-p", "-i", "6");
assertCalculation("1.5708", "ellipticK(0)", "-p", "-i", "6");
assertCalculation("58098.1", "eulerE(15, 0)", "-p", "-i", "6");
}
private static final String NEWLINE = System.lineSeparator();
}
apfloat-1.15.0/apfloat-jscience/ 0000775 0000000 0000000 00000000000 15113064030 0016424 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-jscience/pom.xml 0000664 0000000 0000000 00000005042 15113064030 0017742 0 ustar 00root root 0000000 0000000
4.0.0
org.apfloat
apfloat-parent
1.15.0
apfloat-jscience
apfloat-jscience
JScience wrapper for apfloat
https://www.apfloat.org
org.apfloat
apfloat
org.jscience
jscience
junit
junit
test
org.apfloat
apfloat
test-jar
test
biz.aQute.bnd
bnd-maven-plugin
generate-osgi-manifest
bnd-process
org.apache.maven.plugins
maven-jar-plugin
${project.build.outputDirectory}/META-INF/MANIFEST.MF
org.apache.maven.plugins
maven-shade-plugin
shade
org.apfloat:apfloat-jscience
${project.build.directory}/apfloat-jscience.jar
apfloat-1.15.0/apfloat-jscience/src/ 0000775 0000000 0000000 00000000000 15113064030 0017213 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-jscience/src/main/ 0000775 0000000 0000000 00000000000 15113064030 0020137 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-jscience/src/main/java/ 0000775 0000000 0000000 00000000000 15113064030 0021060 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-jscience/src/main/java/org/ 0000775 0000000 0000000 00000000000 15113064030 0021647 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-jscience/src/main/java/org/apfloat/ 0000775 0000000 0000000 00000000000 15113064030 0023275 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-jscience/src/main/java/org/apfloat/jscience/ 0000775 0000000 0000000 00000000000 15113064030 0025060 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-jscience/src/main/java/org/apfloat/jscience/AbstractField.java 0000664 0000000 0000000 00000016276 15113064030 0030446 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import javolution.text.Text;
import javolution.xml.XMLFormat.InputElement;
import javolution.xml.XMLFormat.OutputElement;
import javolution.xml.stream.XMLStreamException;
import org.apfloat.Apcomplex;
import org.apfloat.ApcomplexMath;
import org.apfloat.Apfloat;
import org.apfloat.ApfloatContext;
import org.apfloat.ApfloatMath;
import org.apfloat.Apint;
import org.jscience.mathematics.number.Number;
import org.jscience.mathematics.structure.Field;
/**
* This class represents an arbitrary precision field object.
*
* @param The type of the field.
* @param The type of the underlying value.
*
* @since 1.8.0
* @version 1.15.0
* @author Mikko Tommila
*/
public abstract class AbstractField, V extends Apcomplex>
extends Number
implements Field
{
/**
* Constructs a new field object with the specified value.
*
* @param value The value.
*/
protected AbstractField(V value)
{
if (value == null)
{
throw new NullPointerException("Value can't be null");
}
this.value = value;
}
/**
* Returns the sum of this object with the one specified.
*
* @param that The addend.
*
* @return this + that
*/
@Override
public abstract T plus(T that);
/**
* Returns the additive inverse of this object.
*
* @return -this
*/
@Override
public abstract T opposite();
/**
* Returns the product of this object with the one specified.
*
* @param that The multiplicand.
*
* @return this * that
*/
@Override
public abstract T times(T that);
/**
* Returns the multiplicative inverse of this object.
*
* @return 1 / this
*
* @exception ArithmeticException If the divisor is zero.
*/
@Override
public abstract T inverse()
throws ArithmeticException;
/**
* Returns a copy of this object.
*
* @return A copy of this object.
*/
@Override
public abstract T copy();
/**
* Compares the absolute value of this number
* with the absolute value of the number specified.
*
* @param that The number to be compared with.
*
* @return |this| > |that|
*/
@Override
public boolean isLargerThan(T that)
{
return ApcomplexMath.norm(value()).compareTo(ApcomplexMath.norm(that.value())) > 0;
}
/**
* Returns the value of this number as the underlying type.
*
* @return The value.
*/
public V value()
{
return this.value;
}
/**
* Returns the value of this number as a double.
*
* @return The value.
*/
@Override
public double doubleValue()
{
return value().doubleValue();
}
/**
* Returns the value of this number as a long.
*
* @return The value.
*/
@Override
public long longValue()
{
return value().longValue();
}
/**
* Returns the text representation of this number.
*
* @return The string representation of this number as a Text.
*/
@Override
public Text toText()
{
return Text.valueOf(value().toString());
}
/**
* Compares this number to another number.
*
* @param that The number to be compared with.
*
* @return -1, 0, or 1 depending on the ordering.
*/
@Override
public int compareTo(T that)
{
int result = value().real().compareTo(that.value().real());
if (result == 0)
{
result = value().imag().compareTo(that.value().imag());
}
return result;
}
/**
* Returns the hash code for this number.
*
* @return The hash code value.
*/
@Override
public int hashCode()
{
return value().hashCode();
}
/**
* Compares for equality.
*
* @return If the objects are equal.
*/
@Override
public boolean equals(Object obj)
{
if (obj instanceof AbstractField)
{
AbstractField that = (AbstractField) obj;
return value().equals(that.value());
}
return false;
}
static Apfloat parse(String prefix, InputElement xml)
throws XMLStreamException
{
String mantissa = xml.getAttribute(prefix + "mantissa", "0");
long exponent = Long.parseLong(xml.getAttribute(prefix + "exponent", "0")),
precision = Long.parseLong(xml.getAttribute(prefix + "precision", String.valueOf(mantissa.length())));
int radix = Integer.parseInt(xml.getAttribute(prefix + "radix", String.valueOf(ApfloatContext.getContext().getDefaultRadix())));
return ApfloatMath.scale(new Apint(mantissa, radix).precision(precision), exponent);
}
static void format(Apfloat value, String prefix, OutputElement xml)
throws XMLStreamException
{
format(value, prefix, xml, value.precision());
}
static void format(Apfloat value, String prefix, OutputElement xml, Long precision)
throws XMLStreamException
{
Apint mantissa = ApfloatMath.scale(value, Math.subtractExact(value.size(), value.scale())).truncate();
long exponent = (value.signum() == 0 ? 0 : Math.subtractExact(value.scale(), value.size()));
xml.setAttribute(prefix + "mantissa", mantissa.toString());
xml.setAttribute(prefix + "exponent", exponent);
if (precision != null)
{
xml.setAttribute(prefix + "precision", precision.longValue());
}
xml.setAttribute(prefix + "radix", value.radix());
}
private static final long serialVersionUID = -7725271295007354895L;
private V value;
}
apfloat-1.15.0/apfloat-jscience/src/main/java/org/apfloat/jscience/ApcomplexField.java 0000664 0000000 0000000 00000007430 15113064030 0030623 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import javolution.xml.XMLFormat;
import javolution.xml.stream.XMLStreamException;
import org.apfloat.Apcomplex;
import org.apfloat.ApcomplexMath;
/**
* This class represents an arbitrary precision complex number.
*
* The precision of each calculation is determined separately, which means
* that loss of precision can easily accumulate in complicated calculations
* (e.g. matrix inversion). If this should be avoided, and a fixed precision is
* required, then it may be better to use {@link FixedPrecisionApcomplexField}
* instead.
*
* @since 1.8.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class ApcomplexField
extends AbstractField
{
/**
* Holds the default XML representation for arbitrary precision complex fields.
*/
static final XMLFormat XML = new XMLFormat(ApcomplexField.class)
{
@Override
public ApcomplexField newInstance(Class cls, InputElement xml)
throws XMLStreamException
{
return new ApcomplexField(new Apcomplex(parse("real-", xml), parse("imag-", xml)));
}
@Override
public void write(ApcomplexField field, OutputElement xml)
throws XMLStreamException
{
format(field.value().real(), "real-", xml);
format(field.value().imag(), "imag-", xml);
}
@Override
public void read(InputElement xml, ApcomplexField complex)
{
// Immutable, deserialization occurs at creation, see newInstance()
}
};
/**
* Constructs a new complex field object with the specified value.
*
* @param value The value.
*/
public ApcomplexField(Apcomplex value)
{
super(value);
}
@Override
public ApcomplexField plus(ApcomplexField that)
{
return new ApcomplexField(value().add(that.value()));
}
@Override
public ApcomplexField opposite()
{
return new ApcomplexField(value().negate());
}
@Override
public ApcomplexField times(ApcomplexField that)
{
return new ApcomplexField(value().multiply(that.value()));
}
@Override
public ApcomplexField inverse()
throws ArithmeticException
{
return new ApcomplexField(ApcomplexMath.inverseRoot(value(), 1));
}
@Override
public ApcomplexField copy()
{
return new ApcomplexField(value());
}
private static final long serialVersionUID = -6242843580910131563L;
}
apfloat-1.15.0/apfloat-jscience/src/main/java/org/apfloat/jscience/ApfloatField.java 0000664 0000000 0000000 00000007251 15113064030 0030262 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import javolution.xml.XMLFormat;
import javolution.xml.stream.XMLStreamException;
import org.apfloat.Apfloat;
import org.apfloat.ApfloatMath;
/**
* This class represents an arbitrary precision floating-point number.
*
* The precision of each calculation is determined separately, which means
* that loss of precision can easily accumulate in complicated calculations
* (e.g. matrix inversion). If this should be avoided, and a fixed precision is
* required, then it may be better to use {@link FixedPrecisionApfloatField}
* instead.
*
* @since 1.8.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class ApfloatField
extends AbstractField
{
/**
* Holds the default XML representation for arbitrary precision floating-point fields.
*/
static final XMLFormat XML = new XMLFormat(ApfloatField.class)
{
@Override
public ApfloatField newInstance(Class cls, InputElement xml)
throws XMLStreamException
{
return new ApfloatField(parse("", xml));
}
@Override
public void write(ApfloatField field, OutputElement xml)
throws XMLStreamException
{
format(field.value(), "", xml);
}
@Override
public void read(InputElement xml, ApfloatField field)
throws XMLStreamException
{
// Immutable, deserialization occurs at creation, see newInstance()
}
};
/**
* Constructs a new floating-point field object with the specified value.
*
* @param value The value.
*/
public ApfloatField(Apfloat value)
{
super(value);
}
@Override
public ApfloatField plus(ApfloatField that)
{
return new ApfloatField(value().add(that.value()));
}
@Override
public ApfloatField opposite()
{
return new ApfloatField(value().negate());
}
@Override
public ApfloatField times(ApfloatField that)
{
return new ApfloatField(value().multiply(that.value()));
}
@Override
public ApfloatField inverse()
throws ArithmeticException
{
return new ApfloatField(ApfloatMath.inverseRoot(value(), 1));
}
@Override
public ApfloatField copy()
{
return new ApfloatField(value());
}
private static final long serialVersionUID = -901594332306254700L;
}
apfloat-1.15.0/apfloat-jscience/src/main/java/org/apfloat/jscience/AprationalField.java 0000664 0000000 0000000 00000007673 15113064030 0030776 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import javolution.xml.XMLFormat;
import javolution.xml.stream.XMLStreamException;
import org.apfloat.Aprational;
import org.apfloat.ApfloatArithmeticException;
/**
* This class represents an arbitrary precision rational number.
*
* @since 1.8.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class AprationalField
extends AbstractField
{
/**
* Holds the default XML representation for arbitrary precision rational fields.
*/
static final XMLFormat XML = new XMLFormat(AprationalField.class)
{
@Override
public AprationalField newInstance(Class cls, InputElement xml)
throws XMLStreamException
{
return new AprationalField(new Aprational(parse("numerator-", xml).truncate(), parse("denominator-", xml).truncate()));
}
@Override
public void write(AprationalField field, OutputElement xml)
throws XMLStreamException
{
format(field.value().numerator(), "numerator-", xml, null);
format(field.value().denominator(), "denominator-", xml, null);
}
@Override
public void read(InputElement xml, AprationalField field)
throws XMLStreamException
{
// Immutable, deserialization occurs at creation, see newInstance()
}
};
/**
* Constructs a new rational field object with the specified value.
*
* @param value The value.
*/
public AprationalField(Aprational value)
{
super(value);
}
@Override
public AprationalField plus(AprationalField that)
{
return new AprationalField(value().add(that.value()));
}
@Override
public AprationalField opposite()
{
return new AprationalField(value().negate());
}
@Override
public AprationalField times(AprationalField that)
{
return new AprationalField(value().multiply(that.value()));
}
@Override
public AprationalField inverse()
throws ArithmeticException
{
if (value().signum() == 0)
{
throw new ApfloatArithmeticException("Division by zero", "divide.byZero");
}
return new AprationalField(new Aprational(value().denominator(), value().numerator()));
}
@Override
public AprationalField copy()
{
return new AprationalField(value());
}
@Override
public boolean isLargerThan(AprationalField that)
{
return value().multiply(value()).compareTo(that.value().multiply(that.value())) > 0;
}
private static final long serialVersionUID = -4642791345140583865L;
}
apfloat-1.15.0/apfloat-jscience/src/main/java/org/apfloat/jscience/EllipticCurveGroup.java 0000664 0000000 0000000 00000037243 15113064030 0031523 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import javolution.context.LocalContext;
import javolution.lang.Realtime;
import javolution.text.Text;
import javolution.xml.XMLFormat;
import javolution.xml.XMLSerializable;
import javolution.xml.stream.XMLStreamException;
import org.apfloat.Apint;
import org.apfloat.ApintMath;
import org.jscience.mathematics.structure.GroupAdditive;
import java.io.Serializable;
import java.util.Objects;
import static org.apfloat.jscience.AbstractField.format;
import static org.apfloat.jscience.AbstractField.parse;
/**
* This class represents a point on an elliptic curve defined over the integers modulo a modulus.
* All arithmetic is done in Weierstrass form.
*
* This class sets the modulus using {@link ModuloApintField#setModulus(Apint)}.
*
* @since 1.15.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class EllipticCurveGroup
implements GroupAdditive, Realtime, XMLSerializable, Serializable
{
/**
* Holds the default XML representation for elliptic curve points.
*/
static final XMLFormat XML = new XMLFormat(EllipticCurveGroup.class)
{
@Override
public EllipticCurveGroup newInstance(Class cls, InputElement xml)
throws XMLStreamException
{
return new EllipticCurveGroup(parse("x-", xml).truncate(), parse("y-", xml).truncate());
}
@Override
public void write(EllipticCurveGroup group, OutputElement xml)
throws XMLStreamException
{
format(group.x.value(), "x-", xml, null);
format(group.y.value(), "y-", xml, null);
}
@Override
public void read(InputElement xml, EllipticCurveGroup group)
throws XMLStreamException
{
// Immutable, deserialization occurs at creation, see newInstance()
}
};
/**
* The "point at infinity".
*/
public static final EllipticCurveGroup O = new EllipticCurveGroup((ModuloApintField) null, (ModuloApintField) null);
/**
* Constructs a new point on the elliptic curve. Uses Weierstrass coordinates.
*
* @param x The x-coordinate.
* @param y The y-coordinate.
*/
public EllipticCurveGroup(Apint x, Apint y)
{
this(new ModuloApintField(x), new ModuloApintField(y));
}
private EllipticCurveGroup(ModuloApintField x, ModuloApintField y)
{
this.x = x;
this.y = y;
}
/**
* Construct a point from Montgomery curve coordinates.
* The Montgomery curve parameters must be first set with {@link #setMontgomeryParameters(Apint, Apint, Apint)}.
*
* @param x The Montgomery curve x-coordinate.
* @param y The Montgomery curve y-coordinate.
*
* @return The point in Weierstrass coordinates.
*/
public static EllipticCurveGroup fromMontgomeryPoint(Apint x, Apint y)
{
return fromMontgomeryPoint(new ModuloApintField(x), new ModuloApintField(y));
}
private static EllipticCurveGroup fromMontgomeryPoint(ModuloApintField x, ModuloApintField y)
{
ModuloApintField A = montgomeryA.get(),
B = montgomeryB.get();
if (A == null || B == null)
{
throw new IllegalStateException("Curve parameters have not been set");
}
int radix = x.value().radix();
ModuloApintField inverseB = B.inverse(),
inverseThree = new ModuloApintField(new Apint(3, radix)).inverse();
return new EllipticCurveGroup(x.times(inverseB).plus(A.times(inverseB).times(inverseThree)), y.times(inverseB));
}
/**
* Construct a point from twisted Edwards curve coordinates.
* The Edwards curve parameters must be first set with {@link #setEdwardsParameters(Apint, Apint, Apint)}.
*
* @param x The Edwards curve x-coordinate.
* @param y The Edwards curve y-coordinate.
*
* @return The point in Weierstrass coordinates.
*/
public static EllipticCurveGroup fromEdwardsPoint(Apint x, Apint y)
{
return fromEdwardsPoint(new ModuloApintField(x), new ModuloApintField(y));
}
private static EllipticCurveGroup fromEdwardsPoint(ModuloApintField x, ModuloApintField y)
{
int radix = x.value().radix();
ModuloApintField one = new ModuloApintField(new Apint(1, radix)),
y1 = one.plus(y).times(one.minus(y).inverse());
return fromMontgomeryPoint(y1, y1.times(x.inverse()));
}
/**
* Set the curve parameters in Weierstrass form.
* The elliptic curve specified in the Weierstrass form is
* y2 = x3 + a x + b
*
* For example, Curve25519 can be set with
* setWeierstrassParameters(new Apint(486662), new Apint(1), ApintMath.pow(new Apint(2), 255).subtract(new Apint(19)))
*
* @param a The curve parameter a.
* @param b The curve parameter b.
* @param p The modulus.
*/
public static void setWeierstrassParameters(Apint a, Apint b, Apint p)
{
ModuloApintField.setModulus(p);
int radix = a.radix();
ModuloApintField α = new ModuloApintField(a),
β = new ModuloApintField(b),
four = new ModuloApintField(new Apint(4, radix)),
twentyseven = new ModuloApintField(new Apint(3, radix));
if (four.times(α).times(α).times(α).plus(twentyseven.times(β).times(β)).value().signum() == 0)
{
throw new IllegalArgumentException("Curve is not valid");
}
weierstrassA.set(α);
weierstrassB.set(β);
montgomeryA.set(null);
montgomeryB.set(null);
}
/**
* Set the curve parameters in Montgomery form.
* The elliptic curve specified in the Montgomery form is
* B y2 = x3 + A x2 + x
*
* For example, Curve25519 can be set with
* setMontgomeryParameters(new Apint(1), new Apint(486662), ApintMath.pow(new Apint(2), 255).subtract(new Apint(19)))
*
* @param b The curve parameter B.
* @param a The curve parameter A.
* @param p The modulus.
*/
public static void setMontgomeryParameters(Apint b, Apint a, Apint p)
{
int radix = p.radix();
ModuloApintField.setModulus(p);
ModuloApintField A = new ModuloApintField(a),
B = new ModuloApintField(b),
two = new ModuloApintField(new Apint(2, radix)),
three = new ModuloApintField(new Apint(3, radix)),
nine = new ModuloApintField(new Apint(9, radix)),
twentyseven = new ModuloApintField(new Apint(27, radix));
setWeierstrassParameters(three.minus(A.times(A)).times(three.times(B).times(B).inverse()).value(),
two.times(A).times(A).minus(nine).times(A).times(twentyseven.times(B).times(B).times(B).inverse()).value(),
p);
montgomeryA.set(A);
montgomeryB.set(B);
}
/**
* Set the curve parameters in twisted Edwards form.
* The elliptic curve specified in the twisted Edwards form is
* a x2 + y2 = 1 + d x2 y2
*
* For example, Curve448 can be set with
* setEdwardsParameters(new Apint(1), new Apint(-39081), ApintMath.pow(new Apint(2), 448).subtract(ApintMath.pow(new Apint(2), 224).subtract(new Apint(1))))
*
* @param a The curve parameter a.
* @param d The curve parameter d.
* @param p The modulus.
*/
public static void setEdwardsParameters(Apint a, Apint d, Apint p)
{
int radix = p.radix();
ModuloApintField.setModulus(p);
ModuloApintField x = new ModuloApintField(a.subtract(d)).inverse(),
ad = new ModuloApintField(a.add(d)),
two = new ModuloApintField(new Apint(2, radix)),
four = new ModuloApintField(new Apint(4, radix));
setMontgomeryParameters(four.times(x).value(),
two.times(ad).times(x).value(),
p);
}
/**
* Returns the curve parameter a in Weierstrass form.
*
* @return The curve parameter a.
*
* @see #setWeierstrassParameters(Apint, Apint, Apint)
*/
public static Apint getA()
{
return weierstrassA.get().value();
}
/**
* Returns the curve parameter b in Weierstrass form.
*
* @return The curve parameter b.
*
* @see #setWeierstrassParameters(Apint, Apint, Apint)
*/
public static Apint getB()
{
return weierstrassB.get().value();
}
/**
* Returns the j-invariant of the curve.
*
* @return The j-invariant of the curve.
*/
public static Apint getJInvariant()
{
ModuloApintField a = weierstrassA.get(),
b = weierstrassB.get();
int radix = a.value().radix();
ModuloApintField foura3 = new ModuloApintField(new Apint(4, radix)).times(a).times(a).times(a),
twentyseven = new ModuloApintField(new Apint(27, radix)),
twelve3 = new ModuloApintField(new Apint(1728, radix));
return twelve3.times(foura3).times(foura3.plus(twentyseven.times(b).times(b)).inverse()).value();
}
/**
* Returns the x-coordinate of this point.
*
* @return The x-coordinate.
*/
public Apint getX()
{
return this.x.value();
}
/**
* Returns the y-coordinate of this point.
*
* @return The y-coordinate.
*/
public Apint getY()
{
return this.y.value();
}
@Override
public EllipticCurveGroup plus(EllipticCurveGroup that)
{
if (this.equals(O))
{
return that;
}
if (that.equals(O))
{
return this;
}
ModuloApintField a = weierstrassA.get(),
b = weierstrassB.get(),
x,
y;
if (a == null || b == null)
{
throw new IllegalStateException("Curve parameters have not been set");
}
if (!this.x.equals(that.x))
{
// P != Q
ModuloApintField λ = that.y.minus(this.y).times(that.x.minus(this.x).inverse());
x = λ.times(λ).minus(this.x).minus(that.x);
y = λ.times(this.x.minus(x)).minus(this.y);
}
else if (this.y.equals(that.y))
{
// P == Q
int radix = this.y.value().radix();
ModuloApintField two = new ModuloApintField(new Apint(2, radix)),
three = new ModuloApintField(new Apint(3, radix)),
λ = three.times(this.x).times(this.x).plus(a).times(two.times(this.y).inverse());
x = λ.times(λ).minus(two.times(this.x));
y = λ.times(this.x.minus(x)).minus(this.y);
}
else
{
// P == -Q
assert (this.x.equals(that.x) && this.y.equals(that.y.opposite()));
// Result is O, the "point at infinity"
return O;
}
assert (y.times(y).equals(x.times(x).plus(a).times(x).plus(b)));
return new EllipticCurveGroup(x, y);
}
/**
* Returns this elliptic curve point multiplied by a scalar.
*
* @param that The multiplier.
*
* @return The resulting elliptic curve point.
*/
public EllipticCurveGroup times(Apint that)
{
if (this.equals(O))
{
return this;
}
if (that.signum() < 0)
{
return opposite().times(that.negate());
}
Apint two = new Apint(2, that.radix());
EllipticCurveGroup a = this,
result = O;
while (that.signum() != 0)
{
Apint[] qr = ApintMath.div(that, two);
if (qr[1].signum() != 0)
{
result = result.plus(a);
}
if (qr[0].signum() != 0)
{
a = a.plus(a);
}
that = qr[0];
}
return result;
}
@Override
public EllipticCurveGroup opposite()
{
if (this.equals(O))
{
return this;
}
return new EllipticCurveGroup(this.x, this.y.opposite());
}
@Override
public EllipticCurveGroup copy()
{
if (this.equals(O))
{
return new EllipticCurveGroup((ModuloApintField) null, (ModuloApintField) null);
}
return new EllipticCurveGroup(this.x.value(), this.y.value());
}
@Override
public Text toText()
{
if (this.equals(O))
{
return Text.valueOf("(∞, ∞)");
}
return Text.valueOf("(" + this.x + ", " + this.y + ')');
}
@Override
public String toString() {
return toText().toString();
}
@Override
public int hashCode()
{
return Objects.hashCode(this.x) + 3 * Objects.hashCode(this.y);
}
@Override
public boolean equals(Object obj)
{
if (obj instanceof EllipticCurveGroup)
{
EllipticCurveGroup that = (EllipticCurveGroup) obj;
return Objects.equals(this.x, that.x) && Objects.equals(this.y, that.y);
}
return false;
}
private static final long serialVersionUID = 4239380063596030297L;
private final ModuloApintField x,
y;
private static final LocalContext.Reference weierstrassA = new LocalContext.Reference<>(),
weierstrassB = new LocalContext.Reference<>(),
montgomeryA = new LocalContext.Reference<>(),
montgomeryB = new LocalContext.Reference<>();
}
apfloat-1.15.0/apfloat-jscience/src/main/java/org/apfloat/jscience/FixedPrecisionApcomplexField.java0000664 0000000 0000000 00000011333 15113064030 0033454 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import javolution.xml.XMLFormat;
import javolution.xml.stream.XMLStreamException;
import org.apfloat.Apcomplex;
import org.apfloat.FixedPrecisionApcomplexHelper;
/**
* This class represents a fixed-precision complex number. The precision
* is reset after each computation using the provided FixedPrecisionApcomplexHelper.
* This can help avoid accumulating round-off errors and loss of precision
* in complicated computations such as matrix inversion.
*
* @since 1.8.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class FixedPrecisionApcomplexField
extends AbstractField
{
/**
* Holds the default XML representation for fixed-precision complex fields.
*/
static final XMLFormat XML = new XMLFormat(FixedPrecisionApcomplexField.class)
{
@Override
public FixedPrecisionApcomplexField newInstance(Class cls, InputElement xml)
throws XMLStreamException
{
return new FixedPrecisionApcomplexField(new Apcomplex(parse("real-", xml), parse("imag-", xml)), new FixedPrecisionApcomplexHelper(xml.getAttribute("precision", 0L)));
}
@Override
public void write(FixedPrecisionApcomplexField field, OutputElement xml)
throws XMLStreamException
{
format(field.value().real(), "real-", xml);
format(field.value().imag(), "imag-", xml);
xml.setAttribute("precision", field.helper().precision());
}
@Override
public void read(InputElement xml, FixedPrecisionApcomplexField complex)
{
// Immutable, deserialization occurs at creation, see newInstance()
}
};
/**
* Constructs a new complex field object with the specified value and precision helper.
*
* @param value The value.
* @param helper The precision helper.
*/
public FixedPrecisionApcomplexField(Apcomplex value, FixedPrecisionApcomplexHelper helper)
{
super(value);
if (helper == null)
{
throw new NullPointerException("Helper can't be null");
}
this.helper = helper;
}
@Override
public FixedPrecisionApcomplexField plus(FixedPrecisionApcomplexField that)
{
return new FixedPrecisionApcomplexField(helper().add(value(), that.value()), helper());
}
@Override
public FixedPrecisionApcomplexField opposite()
{
return new FixedPrecisionApcomplexField(helper().negate(value()), helper());
}
@Override
public FixedPrecisionApcomplexField times(FixedPrecisionApcomplexField that)
{
return new FixedPrecisionApcomplexField(helper().multiply(value(), that.value()), helper());
}
@Override
public FixedPrecisionApcomplexField inverse()
throws ArithmeticException
{
return new FixedPrecisionApcomplexField(helper().inverseRoot(value(), 1), helper());
}
@Override
public FixedPrecisionApcomplexField copy()
{
return new FixedPrecisionApcomplexField(value(), helper());
}
/**
* Return the precision helper.
*
* @return The precision helper.
*/
public FixedPrecisionApcomplexHelper helper()
{
return this.helper;
}
private static final long serialVersionUID = -2069599698604093434L;
private FixedPrecisionApcomplexHelper helper;
}
apfloat-1.15.0/apfloat-jscience/src/main/java/org/apfloat/jscience/FixedPrecisionApfloatField.java 0000664 0000000 0000000 00000011000 15113064030 0033101 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import javolution.xml.XMLFormat;
import javolution.xml.stream.XMLStreamException;
import org.apfloat.Apfloat;
import org.apfloat.FixedPrecisionApfloatHelper;
/**
* This class represents a fixed-precision floating-point number. The precision
* is reset after each computation using the provided FixedPrecisionApfloatHelper.
* This can help avoid accumulating round-off errors and loss of precision
* in complicated computations such as matrix inversion.
*
* @since 1.8.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class FixedPrecisionApfloatField
extends AbstractField
{
/**
* Holds the default XML representation for fixed-precision floating-point fields.
*/
static final XMLFormat XML = new XMLFormat(FixedPrecisionApfloatField.class)
{
@Override
public FixedPrecisionApfloatField newInstance(Class cls, InputElement xml)
throws XMLStreamException
{
return new FixedPrecisionApfloatField(parse("", xml), new FixedPrecisionApfloatHelper(xml.getAttribute("precision", 0L)));
}
@Override
public void write(FixedPrecisionApfloatField field, OutputElement xml)
throws XMLStreamException
{
format(field.value(), "", xml,field.helper().precision());
}
@Override
public void read(InputElement xml, FixedPrecisionApfloatField complex)
{
// Immutable, deserialization occurs at creation, see newInstance()
}
};
/**
* Constructs a new floating-point field object with the specified value.
*
* @param value The value.
* @param helper The precision helper.
*/
public FixedPrecisionApfloatField(Apfloat value, FixedPrecisionApfloatHelper helper)
{
super(value);
if (helper == null)
{
throw new NullPointerException("Helper can't be null");
}
this.helper = helper;
}
@Override
public FixedPrecisionApfloatField plus(FixedPrecisionApfloatField that)
{
return new FixedPrecisionApfloatField(helper().add(value(), that.value()), helper());
}
@Override
public FixedPrecisionApfloatField opposite()
{
return new FixedPrecisionApfloatField(helper().negate(value()), helper());
}
@Override
public FixedPrecisionApfloatField times(FixedPrecisionApfloatField that)
{
return new FixedPrecisionApfloatField(helper().multiply(value(), that.value()), helper());
}
@Override
public FixedPrecisionApfloatField inverse()
throws ArithmeticException
{
return new FixedPrecisionApfloatField(helper().inverseRoot(value(), 1), helper());
}
@Override
public FixedPrecisionApfloatField copy()
{
return new FixedPrecisionApfloatField(value(), helper());
}
/**
* Return the precision helper.
*
* @return The precision helper.
*/
public FixedPrecisionApfloatHelper helper()
{
return this.helper;
}
private static final long serialVersionUID = -8969242537753892317L;
private FixedPrecisionApfloatHelper helper;
}
apfloat-1.15.0/apfloat-jscience/src/main/java/org/apfloat/jscience/ModuloApintField.java 0000664 0000000 0000000 00000014225 15113064030 0031126 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import javolution.context.LocalContext;
import javolution.xml.XMLFormat;
import javolution.xml.stream.XMLStreamException;
import org.apfloat.Apint;
import org.apfloat.ApintMath;
import org.apfloat.ApfloatArithmeticException;
import org.jscience.mathematics.structure.Ring;
/**
* This class represents an arbitrary precision modulo integer.
* The modulus must be set with {@link #setModulus(Apint)}; otherwise
* the modulo reduction is not done.
*
* For the modulo integers to actually for a field, the modulus must
* be prime. Otherwise it's just a {@link Ring} and the {@link #inverse()}
* method may fail.
*
* @since 1.8.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class ModuloApintField
extends AbstractField
{
/**
* Holds the default XML representation for arbitrary precision modulo integer fields.
*/
static final XMLFormat XML = new XMLFormat(ModuloApintField.class)
{
@Override
public ModuloApintField newInstance(Class cls, InputElement xml)
throws XMLStreamException
{
return new ModuloApintField(parse("", xml).truncate());
}
@Override
public void write(ModuloApintField field, OutputElement xml)
throws XMLStreamException
{
format(field.value(), "", xml, null);
}
@Override
public void read(InputElement xml, ModuloApintField field)
throws XMLStreamException
{
// Immutable, deserialization occurs at creation, see newInstance()
}
};
/**
* Constructs a new integer field object with the specified value.
*
* @param value The value.
*/
public ModuloApintField(Apint value)
{
super(reduce(value));
}
/**
* Returns the modulus or null if modulo reduction is not done.
* The modulus can be set in a thread-specific way using
* {@link javolution.context.LocalContext}.
*
* @return The local modulus or null if modulo reduction is not done.
*
* @see #setModulus
*/
public static Apint getModulus()
{
return MODULUS.get();
}
/**
* Sets the modulus.
* The modulus can be set in a thread-specific way using
* {@link javolution.context.LocalContext}.
*
* @param modulus The modulus or null if modulo reduction is not done.
*
* @throws IllegalArgumentException If modulus is not positive.
*/
public static void setModulus(Apint modulus)
{
if (modulus != null && modulus.signum() <= 0)
{
throw new IllegalArgumentException("Modulus has to be greater than zero");
}
MODULUS.set(modulus);
}
/**
* Reduce the value with the current modulus.
*
* @param value The value.
*
* @return The value mod the current modulus.
*/
public static Apint reduce(Apint value)
{
Apint modulus = MODULUS.get();
if (modulus != null)
{
value = value.mod(modulus);
if (value.signum() < 0) // The modulus is always positive, so reduce values to positive
{
value = value.add(modulus);
}
}
return value;
}
@Override
public ModuloApintField plus(ModuloApintField that)
{
return new ModuloApintField(value().add(that.value()));
}
@Override
public ModuloApintField opposite()
{
return new ModuloApintField(value().negate());
}
@Override
public ModuloApintField times(ModuloApintField that)
{
return new ModuloApintField(value().multiply(that.value()));
}
@Override
public ModuloApintField inverse()
throws ArithmeticException
{
Apint modulus = MODULUS.get();
if (modulus == null)
{
throw new ApfloatArithmeticException("Modulus is not set");
}
return new ModuloApintField(ApintMath.modPow(value(), new Apint(-1), modulus));
}
/**
* Modular power.
*
* @param exp The exponent
*
* @return thisexp
*
* @since 1.15.0
*/
public ModuloApintField pow(Apint exp)
{
Apint modulus = MODULUS.get();
if (modulus == null)
{
throw new ApfloatArithmeticException("Modulus is not set");
}
return new ModuloApintField(ApintMath.modPow(value(), exp, modulus));
}
@Override
public ModuloApintField copy()
{
return new ModuloApintField(value());
}
private static final long serialVersionUID = 5308452222350777004L;
private static final LocalContext.Reference MODULUS = new LocalContext.Reference<>();
}
apfloat-1.15.0/apfloat-jscience/src/main/java/org/apfloat/jscience/ModuloPolynomialField.java 0000664 0000000 0000000 00000041174 15113064030 0032201 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import org.apfloat.ApfloatArithmeticException;
import org.jscience.mathematics.function.Constant;
import org.jscience.mathematics.function.Polynomial;
import org.jscience.mathematics.function.Term;
import org.jscience.mathematics.function.Variable;
import org.jscience.mathematics.structure.Field;
import org.jscience.mathematics.structure.Ring;
import javolution.context.LocalContext;
import javolution.lang.Realtime;
import javolution.text.Text;
/**
* This class represents a polynomial modulo a modulus.
* The modulus must be set with {@link #setModulus(Polynomial)}; otherwise
* the modulo reduction is not done.
*
* For the polynomials to actually form a field, the modulus must be irreducible
* over the coefficient field. Otherwise it's just a {@link Ring} and the
* multiplicative {@link #inverse()} method may fail.
*
* @param The type of the polynomial coefficients.
*
* @since 1.15.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class ModuloPolynomialField>
implements Field>, Serializable, Realtime
{
private static class FiniteFieldPolynomial>
{
public FiniteFieldPolynomial(Polynomial polynomial)
{
this.polynomial = normalize(polynomial);
}
public FiniteFieldPolynomial plus(FiniteFieldPolynomial that)
{
return new FiniteFieldPolynomial<>(this.polynomial.plus(that.polynomial));
}
public FiniteFieldPolynomial minus(FiniteFieldPolynomial that)
{
return new FiniteFieldPolynomial<>(this.polynomial.minus(that.polynomial));
}
public FiniteFieldPolynomial opposite()
{
return new FiniteFieldPolynomial<>(this.polynomial.opposite());
}
public FiniteFieldPolynomial times(R that)
{
return new FiniteFieldPolynomial<>(this.polynomial.times(that));
}
public FiniteFieldPolynomial times(FiniteFieldPolynomial that)
{
// JScience does not handle correctly polynomial multiplication when the coefficients are defined over a finite field
Map resultTermMap = new HashMap<>();
R zero = null;
for (Term t1 : this.polynomial.getTerms())
{
R c1 = this.polynomial.getCoefficient(t1);
for (Term t2 : that.polynomial.getTerms())
{
R c2 = that.polynomial.getCoefficient(t2);
Term t = t1.times(t2);
R c = c1.times(c2);
R prev = resultTermMap.get(t);
R coef = (prev != null) ? prev.plus(c) : c;
if (isZero(coef))
{
zero = coef;
resultTermMap.remove(t); // This line is missing in JScience
}
else
{
resultTermMap.put(t, coef);
}
}
}
Polynomial result = resultTermMap.entrySet().stream().map(e -> Polynomial.valueOf(e.getValue(), e.getKey())).reduce(Polynomial::plus).orElse(Constant.valueOf(zero));
return new FiniteFieldPolynomial<>(result);
}
public Set getTerms()
{
return this.polynomial.getTerms();
}
public R getCoefficient(Term term)
{
return this.polynomial.getCoefficient(term);
}
public Polynomial value()
{
return this.polynomial;
}
@Override
public boolean equals(Object obj)
{
if (obj instanceof FiniteFieldPolynomial)
{
FiniteFieldPolynomial that = (FiniteFieldPolynomial) obj;
return this.polynomial.equals(that.polynomial);
}
return false;
}
@Override
public int hashCode()
{
return this.polynomial.hashCode() * 3;
}
private static > Polynomial normalize(Polynomial polynomial)
{
// This is necessary only because JScience has some bugs with a nonzero polynomial containing a zero constant term
for (Term term : polynomial.getTerms())
{
R coefficient = polynomial.getCoefficient(term);
if (term.size() == 0 && isZero(coefficient))
{
return polynomial.plus(coefficient);
}
}
return polynomial;
}
private Polynomial polynomial;
}
/**
* Create a new modulo polynomial.
*
* @param polynomial The polynomial. Will be reduced by the modulus, if any.
*/
public ModuloPolynomialField(Polynomial polynomial)
{
this(new FiniteFieldPolynomial<>(polynomial));
}
private ModuloPolynomialField(FiniteFieldPolynomial polynomial)
{
this.polynomial = reduce(polynomial);
}
/**
* Returns the modulus or null if modulo reduction is not done.
* The modulus can be set in a thread-specific way using
* {@link javolution.context.LocalContext}.
*
* @param The type of the polynomial coefficients.
*
* @return The local modulus or null if modulo reduction is not done.
*
* @see #setModulus
*/
public static > Polynomial getModulus()
{
@SuppressWarnings("unchecked")
FiniteFieldPolynomial modulus = (FiniteFieldPolynomial) getModulusInternal();
return modulus == null ? null : modulus.value();
}
private static > FiniteFieldPolynomial getModulusInternal()
{
@SuppressWarnings("unchecked")
FiniteFieldPolynomial modulus = (FiniteFieldPolynomial) MODULUS.get();
return modulus;
}
/**
* Sets the modulus.
* The modulus can be set in a thread-specific way using
* {@link javolution.context.LocalContext}.
*
* @param The type of the polynomial coefficients.
* @param modulus The modulus or null if modulo reduction is not done.
*/
public static > void setModulus(Polynomial modulus)
{
setModulus(modulus == null ? null : new FiniteFieldPolynomial<>(modulus));
}
private static > void setModulus(FiniteFieldPolynomial modulus)
{
if (modulus != null)
{
List terms = new ArrayList<>(modulus.getTerms());
if (getDegree(terms) == 0)
{
throw new IllegalArgumentException("Polynomial must have degree > 0");
}
terms.sort(null);
Term leadingTerm = terms.get(0);
R leadingCoefficient = modulus.getCoefficient(leadingTerm);
if (terms.size() == 1)
{
if (isZero(leadingCoefficient))
{
throw new IllegalArgumentException("Polynomial must be nonzero");
}
}
// Scale leading term of modulus to 1
R inverseLeadingCoefficient = leadingCoefficient.inverse();
FiniteFieldPolynomial scaledModulus = modulus.times(inverseLeadingCoefficient);
SCALED_MODULUS.set(scaledModulus);
ZERO.set(new FiniteFieldPolynomial<>(Constant.valueOf(leadingCoefficient.plus(leadingCoefficient.opposite()))));
ONE.set(new FiniteFieldPolynomial<>(Constant.valueOf(leadingCoefficient.times(inverseLeadingCoefficient))));
}
MODULUS.set(modulus);
}
/**
* Reduce the polynomial with the current modulus.
*
* @param The type of the polynomial coefficients.
* @param polynomial The polynomial.
*
* @return The polynomial mod the current modulus.
*/
public static > Polynomial reduce(Polynomial polynomial)
{
return reduce(new FiniteFieldPolynomial<>(polynomial)).value();
}
private static > FiniteFieldPolynomial reduce(FiniteFieldPolynomial polynomial)
{
FiniteFieldPolynomial modulus = getModulusInternal();
if (modulus != null)
{
polynomial = div(polynomial, modulus)[1];
}
return polynomial;
}
private static > FiniteFieldPolynomial[] div(FiniteFieldPolynomial dividend, FiniteFieldPolynomial divisor)
{
FiniteFieldPolynomial quotient = zero(),
remainder = dividend;
List divisorTerms = new ArrayList<>(divisor.getTerms());
int divisorOrder = getDegree(divisorTerms),
dividendOrder;
divisorTerms.sort(null);
Term divisorLeadingTerm = divisorTerms.get(0);
R divisorLeadingCoefficientInverse = divisor.getCoefficient(divisorLeadingTerm).inverse();
do
{
List terms = new ArrayList<>(remainder.getTerms());
dividendOrder = getDegree(terms);
if (dividendOrder >= divisorOrder)
{
terms.sort(null);
Term leadingTerm = terms.get(0);
Variable variable = (leadingTerm.size() == 0 ? null : leadingTerm.getVariable(0));
R coefficient = remainder.getCoefficient(leadingTerm).times(divisorLeadingCoefficientInverse);
FiniteFieldPolynomial quotientTerm = new FiniteFieldPolynomial<>(variable == null ? Constant.valueOf(coefficient) : Polynomial.valueOf(coefficient, Term.valueOf(variable, dividendOrder - divisorOrder)));
quotient = quotient.plus(quotientTerm);
remainder = remainder.minus(divisor.times(quotientTerm));
}
} while (dividendOrder > divisorOrder);
assert divisor.times(quotient).plus(remainder).equals(dividend) : divisor + " * " + quotient + " + " + remainder + " != " + dividend;
@SuppressWarnings("unchecked")
FiniteFieldPolynomial[] qr = (FiniteFieldPolynomial[]) new FiniteFieldPolynomial[] { quotient, remainder };
return qr;
}
private static int getDegree(Collection terms)
{
// Polynomial.getVariables() is very inefficient
if (terms.stream().mapToInt(Term::size).anyMatch(i -> i > 1) ||
terms.stream().filter(t -> t.size() > 0).map(t -> t.getVariable(0)).distinct().count() > 1)
{
throw new IllegalArgumentException("Polynomial must use a single variable");
}
return terms.stream().filter(t -> t.size() > 0).mapToInt(t -> t.getPower(0)).max().orElse(0);
}
@Override
public ModuloPolynomialField plus(ModuloPolynomialField that)
{
return new ModuloPolynomialField<>(this.polynomial.plus(that.polynomial));
}
/**
* Returns the difference of two polynomials.
*
* @param that The polynomial being subtracted.
*
* @return this - that
*/
public ModuloPolynomialField minus(ModuloPolynomialField that)
{
return new ModuloPolynomialField<>(this.polynomial.minus(that.polynomial));
}
@Override
public ModuloPolynomialField opposite()
{
return new ModuloPolynomialField<>(this.polynomial.opposite());
}
@Override
public ModuloPolynomialField times(ModuloPolynomialField that)
{
return new ModuloPolynomialField<>(this.polynomial.times(that.polynomial));
}
@Override
public ModuloPolynomialField inverse()
{
// Extended Euclidean algorithm
FiniteFieldPolynomial a = this.polynomial,
zero = zero(),
one = one(),
x = zero,
oldX = one,
b = getModulusInternal();
if (b == null)
{
throw new ApfloatArithmeticException("Modulus is not set");
}
while (!b.equals(zero))
{
FiniteFieldPolynomial[] qr = div(a, b);
FiniteFieldPolynomial q = qr[0];
a = b;
b = qr[1];
FiniteFieldPolynomial tmp = x;
x = oldX.minus(q.times(x));
oldX = tmp;
}
List terms = new ArrayList<>(a.getTerms());
if (getDegree(terms) != 0)
{
// GCD is not a unit
throw new ApfloatArithmeticException("Modular inverse does not exist", "modInverse.notExists");
}
// Normalize by scaling with the inverse of the GCD
oldX = oldX.times(a.getCoefficient(terms.get(0)).inverse());
return new ModuloPolynomialField<>(oldX);
}
/**
* Returns the underlying polynomial.
*
* @return The polynomial.
*/
public Polynomial value()
{
return this.polynomial.value();
}
@Override
public Object copy()
{
return new ModuloPolynomialField<>(this.polynomial.value().copy());
}
@Override
public Text toText()
{
return this.polynomial.value().toText();
}
@Override
public String toString() {
return toText().toString();
}
@Override
public int hashCode()
{
return Objects.hashCode(this.polynomial);
}
@Override
public boolean equals(Object obj)
{
if (obj instanceof ModuloPolynomialField)
{
ModuloPolynomialField that = (ModuloPolynomialField) obj;
return Objects.equals(this.polynomial, that.polynomial);
}
return false;
}
private static > boolean isZero(R coefficient)
{
return coefficient.equals(coefficient.opposite());
}
private static > FiniteFieldPolynomial zero()
{
@SuppressWarnings("unchecked")
FiniteFieldPolynomial zero = (FiniteFieldPolynomial) ZERO.get();
return zero;
}
private static > FiniteFieldPolynomial one()
{
@SuppressWarnings("unchecked")
FiniteFieldPolynomial one = (FiniteFieldPolynomial) ONE.get();
return one;
}
private static final long serialVersionUID = -7690334128073794662L;
private static final LocalContext.Reference>> MODULUS = new LocalContext.Reference<>(),
SCALED_MODULUS = new LocalContext.Reference<>(),
ZERO = new LocalContext.Reference<>(),
ONE = new LocalContext.Reference<>();
private FiniteFieldPolynomial polynomial;
}
apfloat-1.15.0/apfloat-jscience/src/main/java/org/apfloat/jscience/package-info.java 0000664 0000000 0000000 00000002640 15113064030 0030251 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2023 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
JScience wrapper for apfloat.
This package contains classes that allow using the apfloat library
classes with the JScience library. For example, it's possible
to perform arbitrary-precision matrix or polynomial operations.
*/
package org.apfloat.jscience;
apfloat-1.15.0/apfloat-jscience/src/test/ 0000775 0000000 0000000 00000000000 15113064030 0020172 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-jscience/src/test/java/ 0000775 0000000 0000000 00000000000 15113064030 0021113 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-jscience/src/test/java/org/ 0000775 0000000 0000000 00000000000 15113064030 0021702 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-jscience/src/test/java/org/apfloat/ 0000775 0000000 0000000 00000000000 15113064030 0023330 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-jscience/src/test/java/org/apfloat/jscience/ 0000775 0000000 0000000 00000000000 15113064030 0025113 5 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-jscience/src/test/java/org/apfloat/jscience/ApcomplexFieldTest.java 0000664 0000000 0000000 00000015125 15113064030 0031516 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.HashSet;
import org.apfloat.*;
import org.jscience.mathematics.function.*;
import org.jscience.mathematics.vector.*;
import javolution.text.*;
import javolution.xml.*;
import javolution.xml.stream.*;
import junit.framework.TestSuite;
/**
* @since 1.8.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class ApcomplexFieldTest
extends ApfloatTestCase
{
public ApcomplexFieldTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new ApcomplexFieldTest("testBasic"));
suite.addTest(new ApcomplexFieldTest("testXmlSerialization"));
suite.addTest(new ApcomplexFieldTest("testMatrixInverse"));
suite.addTest(new ApcomplexFieldTest("testRationalFunction"));
return suite;
}
public static void testBasic()
{
ApcomplexField a = valueOf("(0,100)");
ApcomplexField b = valueOf("(0,200)");
ApcomplexField c = valueOf("(0,200)");
ApcomplexField zero = valueOf("0");
assertEquals("100 + 200", valueOf("(0,300)"), a.plus(b));
assertEquals("-100", valueOf("(0,-100)"), a.opposite());
assertEquals("100 - 200", valueOf("(0,-100)"), a.minus(b));
assertEquals("100 * 200", valueOf("-20000"), a.times(b));
assertEquals("1 / 100", valueOf("(0,-0.01)"), a.inverse());
assertEquals("copy", a, a.copy());
assertEquals("doubleValue", 0.0, a.doubleValue());
assertEquals("longValue", 0L, a.longValue());
assertEquals("String", "(0, 1e2)", a.toString());
assertEquals("Text", new Text("(0, 1e2)"), a.toText());
assertTrue("isLargerThan", b.isLargerThan(a));
assertEquals("compareTo", -1, a.compareTo(b));
HashSet set = new HashSet<>();
set.add(b);
set.add(c);
assertEquals("hashCode", 1, set.size());
try
{
zero.inverse();
fail("Zero divisor accepted");
}
catch (ApfloatArithmeticException aae)
{
// OK, modulus is not set
}
try
{
new ApcomplexField(null);
fail("null accepted");
}
catch (NullPointerException npe)
{
// OK, illegal
}
}
public static void testXmlSerialization()
throws XMLStreamException
{
ApcomplexField field = new ApcomplexField(new Apcomplex("(1.23,-45.6789)"));
StringWriter out = new StringWriter();
XMLObjectWriter xmlWriter = XMLObjectWriter.newInstance(out);
xmlWriter.write(field);
xmlWriter.close();
String xml = out.toString();
assertEquals("XML", "", xml);
StringReader in = new StringReader(xml);
XMLObjectReader xmlReader = XMLObjectReader.newInstance(in);
field = xmlReader.read();
assertEquals("Value", new Apcomplex("(1.23,-45.6789)"), field.value());
assertEquals("Real precision", 3, field.value().real().precision());
assertEquals("Imag precision", 6, field.value().imag().precision());
}
public static void testMatrixInverse()
{
ApcomplexField[][] elements = { { valueOf("1"), valueOf("(0,2)"), valueOf("3") },
{ valueOf("4"), valueOf("5"), valueOf("(0,6)") },
{ valueOf("(0,7)"), valueOf("8"), valueOf("9") } };
Matrix m = DenseMatrix.valueOf(elements);
Vector vectorization = m.minus(m.inverse().inverse()).vectorization();
Apfloat sum = Apfloat.ZERO;
for (int i = 0; i < vectorization.getDimension(); i++)
{
sum = sum.add(ApcomplexMath.abs(vectorization.get(i).value()));
}
assertEquals("Double inverse error", Apfloat.ZERO, sum, new Apfloat(5e-27));
}
public static void testRationalFunction()
{
Variable.Local x = new Variable.Local("x");
Polynomial dividend = Polynomial.valueOf(valueOf("(1,2)"), Term.valueOf(x, 2)).plus(Polynomial.valueOf(valueOf("(3,4)"), x));
Polynomial divisor = Polynomial.valueOf(valueOf("(5,6)"), x).plus(valueOf("(7,8)"));
RationalFunction function = RationalFunction.valueOf(dividend, divisor);
assertEquals("Function value", new Apcomplex("(0.570962479608482871125611745514,0.983686786296900489396411092985)"), function.evaluate(valueOf("(2,3)")).value(), new Apfloat("5e-30"));
assertEquals("Function plus inverse, value", new Apcomplex("(1.01232439638023570845221956392,0.22328325540156631537371248012)"), function.plus(function.inverse()).evaluate(valueOf("(2,3)")).value(), new Apfloat("5e-29"));
}
private static ApcomplexField valueOf(String value)
{
return new ApcomplexField(new Apcomplex(value).precision(30));
}
}
apfloat-1.15.0/apfloat-jscience/src/test/java/org/apfloat/jscience/ApfloatFieldTest.java 0000664 0000000 0000000 00000014345 15113064030 0031157 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.HashSet;
import org.apfloat.*;
import org.jscience.mathematics.function.*;
import org.jscience.mathematics.vector.*;
import javolution.text.*;
import javolution.xml.*;
import javolution.xml.stream.*;
import junit.framework.TestSuite;
/**
* @since 1.8.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class ApfloatFieldTest
extends ApfloatTestCase
{
public ApfloatFieldTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new ApfloatFieldTest("testBasic"));
suite.addTest(new ApfloatFieldTest("testXmlSerialization"));
suite.addTest(new ApfloatFieldTest("testMatrixInverse"));
suite.addTest(new ApfloatFieldTest("testRationalFunction"));
return suite;
}
public static void testBasic()
{
ApfloatField a = valueOf("100");
ApfloatField b = valueOf("200");
ApfloatField c = valueOf("200");
ApfloatField zero = valueOf("0");
assertEquals("100 + 200", valueOf("300"), a.plus(b));
assertEquals("-100", valueOf("-100"), a.opposite());
assertEquals("100 - 200", valueOf("-100"), a.minus(b));
assertEquals("100 * 200", valueOf("20000"), a.times(b));
assertEquals("1 / 100", valueOf("0.01"), a.inverse());
assertEquals("copy", a, a.copy());
assertEquals("doubleValue", 100.0, a.doubleValue(), 0.00000000000005);
assertEquals("longValue", 100L, a.longValue());
assertEquals("String", "1e2", a.toString());
assertEquals("Text", new Text("1e2"), a.toText());
assertTrue("isLargerThan", b.isLargerThan(a));
assertEquals("compareTo", -1, a.compareTo(b));
HashSet set = new HashSet<>();
set.add(b);
set.add(c);
assertEquals("hashCode", 1, set.size());
try
{
zero.inverse();
fail("Zero divisor accepted");
}
catch (ApfloatArithmeticException aae)
{
// OK, modulus is not set
}
try
{
new ApfloatField(null);
fail("null accepted");
}
catch (NullPointerException npe)
{
// OK, illegal
}
}
public static void testXmlSerialization()
throws XMLStreamException
{
ApfloatField field = new ApfloatField(new Apfloat("1.234", 5, 11));
StringWriter out = new StringWriter();
XMLObjectWriter xmlWriter = XMLObjectWriter.newInstance(out);
xmlWriter.write(field);
xmlWriter.close();
String xml = out.toString();
assertEquals("XML", "", xml);
StringReader in = new StringReader(xml);
XMLObjectReader xmlReader = XMLObjectReader.newInstance(in);
field = xmlReader.read();
assertEquals("Value", new Apfloat("1.234", 5, 11), field.value());
assertEquals("Precision", 5, field.value().precision());
assertEquals("Radix", 11, field.value().radix());
}
public static void testMatrixInverse()
{
ApfloatField[][] elements = { { valueOf("1"), valueOf("2"), valueOf("3") },
{ valueOf("4"), valueOf("5"), valueOf("6") },
{ valueOf("7"), valueOf("8"), valueOf("10") } };
Matrix m = DenseMatrix.valueOf(elements);
Vector vectorization = m.minus(m.inverse().inverse()).vectorization();
Apfloat sum = Apfloat.ZERO;
for (int i = 0; i < vectorization.getDimension(); i++)
{
sum = sum.add(ApfloatMath.abs(vectorization.get(i).value()));
}
assertEquals("Double inverse error", Apfloat.ZERO, sum, new Apfloat(5e-25));
}
public static void testRationalFunction()
{
Variable.Local x = new Variable.Local("x");
Polynomial dividend = Polynomial.valueOf(valueOf("2"), Term.valueOf(x, 2)).plus(Polynomial.valueOf(valueOf("3"), x));
Polynomial divisor = Polynomial.valueOf(valueOf("5"), x).plus(valueOf("6"));
RationalFunction function = RationalFunction.valueOf(dividend, divisor);
assertEquals("Function value", new Apfloat("0.875"), function.evaluate(valueOf("2")).value(), new Apfloat("5e-30"));
assertEquals("Function plus inverse, value", new Apfloat("2.017857142857142857142857142857"), function.plus(function.inverse()).evaluate(valueOf("2")).value(), new Apfloat("5e-29"));
}
private static ApfloatField valueOf(String value)
{
return new ApfloatField(new Apfloat(value, 30));
}
}
apfloat-1.15.0/apfloat-jscience/src/test/java/org/apfloat/jscience/AprationalFieldTest.java 0000664 0000000 0000000 00000016647 15113064030 0031672 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.HashSet;
import org.apfloat.*;
import org.jscience.mathematics.function.*;
import org.jscience.mathematics.vector.*;
import javolution.text.*;
import javolution.xml.*;
import javolution.xml.stream.*;
import junit.framework.TestSuite;
/**
* @since 1.8.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class AprationalFieldTest
extends ApfloatTestCase
{
public AprationalFieldTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new AprationalFieldTest("testBasic"));
suite.addTest(new AprationalFieldTest("testXmlSerialization"));
suite.addTest(new AprationalFieldTest("testMatrixInverse"));
suite.addTest(new AprationalFieldTest("testRationalFunction"));
return suite;
}
public static void testBasic()
{
AprationalField a = valueOf("100");
AprationalField b = valueOf("200");
AprationalField c = valueOf("200");
AprationalField zero = valueOf("0");
assertEquals("100 + 200", valueOf("300"), a.plus(b));
assertEquals("-100", valueOf("-100"), a.opposite());
assertEquals("100 - 200", valueOf("-100"), a.minus(b));
assertEquals("100 * 200", valueOf("20000"), a.times(b));
assertEquals("1 / 100", valueOf("1/100"), a.inverse());
assertEquals("copy", a, a.copy());
assertEquals("doubleValue", 100.0, a.doubleValue(), 0.00000000000005);
assertEquals("longValue", 100L, a.longValue());
assertEquals("String", "100", a.toString());
assertEquals("Text", new Text("100"), a.toText());
assertTrue("isLargerThan", b.isLargerThan(a));
assertEquals("compareTo", -1, a.compareTo(b));
HashSet set = new HashSet<>();
set.add(b);
set.add(c);
assertEquals("hashCode", 1, set.size());
a = valueOf("2/7");
b = valueOf("1/6");
c = valueOf("1/6");
assertEquals("2/7 + 1/6", valueOf("19/42"), a.plus(b));
assertEquals("-2/7", valueOf("-2/7"), a.opposite());
assertEquals("2/7 - 1/6", valueOf("5/42"), a.minus(b));
assertEquals("2/7 * 1/6", valueOf("1/21"), a.times(b));
assertEquals("1 / 2/7", valueOf("7/2"), a.inverse());
assertEquals("copy", a, a.copy());
assertEquals("doubleValue", 0.28571428571428571, a.doubleValue(), 0.0000000000000005);
assertEquals("longValue", 0L, a.longValue());
assertEquals("String", "2/7", a.toString());
assertEquals("Text", new Text("2/7"), a.toText());
assertTrue("isLargerThan", a.isLargerThan(b));
assertEquals("compareTo", 1, a.compareTo(b));
set = new HashSet<>();
set.add(b);
set.add(c);
assertEquals("hashCode", 1, set.size());
try
{
zero.inverse();
fail("Zero divisor accepted");
}
catch (ApfloatArithmeticException aae)
{
// OK, modulus is not set
}
try
{
new AprationalField(null);
fail("null accepted");
}
catch (NullPointerException npe)
{
// OK, illegal
}
}
public static void testXmlSerialization()
throws XMLStreamException
{
AprationalField field = new AprationalField(new Aprational("2/10", 13));
StringWriter out = new StringWriter();
XMLObjectWriter xmlWriter = XMLObjectWriter.newInstance(out);
xmlWriter.write(field);
xmlWriter.close();
String xml = out.toString();
assertEquals("XML", "", xml);
StringReader in = new StringReader(xml);
XMLObjectReader xmlReader = XMLObjectReader.newInstance(in);
field = xmlReader.read();
assertEquals("Value", new Aprational("2/10", 13), field.value());
assertEquals("Radix", 13, field.value().radix());
}
public static void testMatrixInverse()
{
AprationalField[][] elements = { { valueOf("1"), valueOf("1/2"), valueOf("1/3"), valueOf("1/4"), valueOf("1/5") },
{ valueOf("1/2"), valueOf("1/3"), valueOf("1/4"), valueOf("1/5"), valueOf("1/6") },
{ valueOf("1/3"), valueOf("1/4"), valueOf("1/5"), valueOf("1/6"), valueOf("1/7") },
{ valueOf("1/4"), valueOf("1/5"), valueOf("1/6"), valueOf("1/7"), valueOf("1/8") },
{ valueOf("1/5"), valueOf("1/6"), valueOf("1/7"), valueOf("1/8"), valueOf("1/9") } };
Matrix m = DenseMatrix.valueOf(elements);
Vector vectorization = m.minus(m.inverse().inverse()).vectorization();
for (int i = 0; i < vectorization.getDimension(); i++)
{
assertEquals("Element " + i, 0, vectorization.get(i).value().signum());
}
}
public static void testRationalFunction()
{
Variable.Local x = new Variable.Local("x");
Polynomial dividend = Polynomial.valueOf(valueOf("1/2"), Term.valueOf(x, 2)).plus(Polynomial.valueOf(valueOf("2/3"), x));
Polynomial divisor = Polynomial.valueOf(valueOf("3/4"), x).plus(valueOf("5/6"));
RationalFunction function = RationalFunction.valueOf(dividend, divisor);
assertEquals("Function value", valueOf("10/7"), function.evaluate(valueOf("2")));
assertEquals("Function plus inverse, value", valueOf("149/70"), function.plus(function.inverse()).evaluate(valueOf("2")));
}
private static AprationalField valueOf(String value)
{
return new AprationalField(new Aprational(value));
}
}
apfloat-1.15.0/apfloat-jscience/src/test/java/org/apfloat/jscience/EllipticCurveGroupTest.java 0000664 0000000 0000000 00000041224 15113064030 0032410 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.HashSet;
import org.apfloat.*;
import javolution.text.*;
import javolution.xml.*;
import javolution.xml.stream.*;
import junit.framework.TestSuite;
/**
* @since 1.15.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class EllipticCurveGroupTest
extends ApfloatTestCase
{
public EllipticCurveGroupTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new EllipticCurveGroupTest("testBasic"));
suite.addTest(new EllipticCurveGroupTest("testOpposite"));
suite.addTest(new EllipticCurveGroupTest("testPlus"));
suite.addTest(new EllipticCurveGroupTest("testTimes"));
suite.addTest(new EllipticCurveGroupTest("testFromMontgomeryPoint"));
suite.addTest(new EllipticCurveGroupTest("testFromEdwardsPoint"));
suite.addTest(new EllipticCurveGroupTest("testSetWeierstrassParameters"));
suite.addTest(new EllipticCurveGroupTest("testSetMontgomeryParameters"));
suite.addTest(new EllipticCurveGroupTest("testSetEdwardsParameters"));
suite.addTest(new EllipticCurveGroupTest("testJInvariant"));
suite.addTest(new EllipticCurveGroupTest("testWeierstrassAliceBob"));
suite.addTest(new EllipticCurveGroupTest("testMontgomeryAliceBob"));
suite.addTest(new EllipticCurveGroupTest("testEdwardsAliceBob"));
suite.addTest(new EllipticCurveGroupTest("testXmlSerialization"));
return suite;
}
public static void testBasic()
{
EllipticCurveGroup.setWeierstrassParameters(new Apint(3), new Apint(4), new Apint(19));
EllipticCurveGroup p = valueOf(5, 12);
EllipticCurveGroup q = valueOf(7, 8);
EllipticCurveGroup r = valueOf(7, 8);
EllipticCurveGroup zero = EllipticCurveGroup.O;
assertFalse("opposite", p.equals(p.opposite()));
assertFalse("object", p.equals(new Object()));
assertEquals("copy", p, p.copy());
assertEquals("copy zero", zero, zero.copy());
assertEquals("String", "(5, 12)", p.toString());
assertEquals("String zero", "(∞, ∞)", zero.toString());
assertEquals("Text", new Text("(5, 12)"), p.toText());
HashSet set = new HashSet<>();
set.add(q);
set.add(r);
assertEquals("hashCode", 1, set.size());
set.add(zero);
assertEquals("hashCode zero", 2, set.size());
try
{
new EllipticCurveGroup(null, null);
fail("null accepted");
}
catch (NullPointerException npe)
{
// OK, illegal
}
}
public static void testOpposite()
{
EllipticCurveGroup.setWeierstrassParameters(new Apint(3), new Apint(4), new Apint(19));
EllipticCurveGroup p = valueOf(5, 12);
EllipticCurveGroup zero = EllipticCurveGroup.O;
assertEquals("-(5, 12)", valueOf(5, 7), p.opposite());
assertEquals("-O", zero, zero.opposite());
}
public static void testPlus()
{
EllipticCurveGroup.setWeierstrassParameters(new Apint(3), new Apint(4), new Apint(19));
EllipticCurveGroup p = valueOf(5, 12);
EllipticCurveGroup q = valueOf(7, 8);
EllipticCurveGroup zero = EllipticCurveGroup.O;
assertEquals("(5, 12) + O", valueOf(5, 12), p.plus(zero));
assertEquals("O + (5, 12)", valueOf(5, 12), zero.plus(p));
assertEquals("(5, 12) + (7, 8)", valueOf(11, 0), p.plus(q));
assertEquals("(5, 12) + (5, 12)", valueOf(16, 14), p.plus(p));
assertEquals("(5, 12) - (5, 12)", zero, p.plus(p.opposite()));
EllipticCurveGroup.setWeierstrassParameters(new Apint(3, 3), new Apint(4, 3), new Apint(19, 3));
assertEquals("(5, 12) + (7, 8) radix 2", new EllipticCurveGroup(new Apint(11, 3), new Apint(0, 3)), new EllipticCurveGroup(new Apint(5, 3), new Apint(12, 3)).plus(new EllipticCurveGroup(new Apint(7, 3), new Apint(8, 3))));
assertEquals("(5, 12) + (5, 12) radix 2", new EllipticCurveGroup(new Apint(16, 3), new Apint(14, 3)), new EllipticCurveGroup(new Apint(5, 3), new Apint(12, 3)).plus(new EllipticCurveGroup(new Apint(5, 3), new Apint(12, 3))));
}
public static void testTimes()
{
EllipticCurveGroup.setWeierstrassParameters(new Apint(3), new Apint(4), new Apint(19));
EllipticCurveGroup p = valueOf(5, 12);
EllipticCurveGroup zero = EllipticCurveGroup.O;
assertEquals("O * 5", zero, zero.times(new Apint(5)));
assertEquals("(5, 12) * 0", zero, p.times(new Apint(0)));
assertEquals("(5, 12) * 1", valueOf(5, 12), p.times(new Apint(1)));
assertEquals("(5, 12) * -1", valueOf(5, 7), p.times(new Apint(-1)));
assertEquals("(5, 12) * 4", valueOf(15, 2), p.times(new Apint(4)));
assertEquals("(5, 12) * -4", valueOf(15, 17), p.times(new Apint(-4)));
assertEquals("(5, 12) * 5", valueOf(0, 2), p.times(new Apint(5)));
EllipticCurveGroup.setWeierstrassParameters(new Apint(3, 3), new Apint(4, 3), new Apint(19, 3));
assertEquals("(5, 12) * 5 radix 2", new EllipticCurveGroup(new Apint(0, 3), new Apint(2, 3)), new EllipticCurveGroup(new Apint(5, 3), new Apint(12, 3)).times(new Apint(5, 3)));
}
public static void testFromMontgomeryPoint()
{
EllipticCurveGroup.setMontgomeryParameters(new Apint(4, 5), new Apint(3, 5), new Apint(19, 5));
EllipticCurveGroup e = EllipticCurveGroup.fromMontgomeryPoint(new Apint(3, 5), new Apint(5, 5));
assertEquals("x radix 5", new Apint(1, 5), e.getX());
assertEquals("y radix 5", new Apint(6, 5), e.getY());
try
{
EllipticCurveGroup.setWeierstrassParameters(new Apint(3), new Apint(4), new Apint(19));
EllipticCurveGroup.fromMontgomeryPoint(new Apint(3), new Apint(5));
fail("Unset parameters accepted");
}
catch (IllegalStateException ise)
{
// OK, invalid
}
}
public static void testFromEdwardsPoint()
{
EllipticCurveGroup.setEdwardsParameters(new Apint(3, 5), new Apint(4, 5), new Apint(19, 5));
EllipticCurveGroup e = EllipticCurveGroup.fromEdwardsPoint(new Apint(1, 5), new Apint(8, 5));
assertEquals("x radix 5", new Apint(18, 5), e.getX());
assertEquals("y radix 5", new Apint(1, 5), e.getY());
try
{
EllipticCurveGroup.setWeierstrassParameters(new Apint(3), new Apint(4), new Apint(19));
EllipticCurveGroup.fromEdwardsPoint(Apint.ONE, new Apint(8));
fail("Unset parameters accepted");
}
catch (IllegalStateException ise)
{
// OK, invalid
}
}
public static void testSetWeierstrassParameters()
{
EllipticCurveGroup.setWeierstrassParameters(new Apint(486662), new Apint(1), ApintMath.pow(new Apint(2), 255).subtract(new Apint(19)));
assertEquals("a", new Apint("486662"), EllipticCurveGroup.getA());
assertEquals("b", new Apint("1"), EllipticCurveGroup.getB());
try
{
EllipticCurveGroup.setWeierstrassParameters(new Apint(5), new Apint(6), new Apint(19));
fail("Invalid parameters accepted");
}
catch (IllegalArgumentException iae)
{
// OK, invalid
}
}
public static void testSetMontgomeryParameters()
{
EllipticCurveGroup.setMontgomeryParameters(new Apint(4, 5), new Apint(3, 5), new Apint(19, 5));
assertEquals("a radix 5", new Apint(7, 5), EllipticCurveGroup.getA());
assertEquals("b radix 5", new Apint(11, 5), EllipticCurveGroup.getB());
}
public static void testSetEdwardsParameters()
{
EllipticCurveGroup.setEdwardsParameters(new Apint(3, 5), new Apint(4, 5), new Apint(19, 5));
assertEquals("a radix 5", new Apint(13, 5), EllipticCurveGroup.getA());
assertEquals("b radix 5", new Apint(15, 5), EllipticCurveGroup.getB());
}
public static void testJInvariant()
{
Apint q = ApintMath.pow(new Apint(2), 255).subtract(new Apint(19));
EllipticCurveGroup.setMontgomeryParameters(new Apint(1), new Apint(486662), q);
Apint curve22519J = EllipticCurveGroup.getJInvariant();
EllipticCurveGroup.setEdwardsParameters(new Apint(-1), new ModuloApintField(new Apint(-121665)).times(new ModuloApintField(new Apint(121666)).inverse()).value(), q);
Apint ed22519J = EllipticCurveGroup.getJInvariant();
assertEquals("Curve22519 == Ed25519 j-invariant", curve22519J, ed22519J);
}
public static void testWeierstrassAliceBob()
{
// P-521
// Curve parameters and g are public
EllipticCurveGroup.setWeierstrassParameters(new Apint("1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc", 16),
new Apint("51953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00", 16),
new Apint("1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16));
EllipticCurveGroup g = new EllipticCurveGroup(new Apint("c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66", 16),
new Apint("11839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650", 16));
// Private keys, generated as random
Apint alicePrivateKey = ApintMath.random(130, 16);
Apint bobPrivateKey = ApintMath.random(130, 16);
// Key exchange
EllipticCurveGroup alicePublicKey = g.times(alicePrivateKey);
EllipticCurveGroup bobPublicKey = g.times(bobPrivateKey);
// Shared secret
EllipticCurveGroup aliceSharedSecret = bobPublicKey.times(alicePrivateKey);
EllipticCurveGroup bobSharedSecret = alicePublicKey.times(bobPrivateKey);
assertEquals("Alice shared secret == Bob shared secret", aliceSharedSecret, bobSharedSecret);
}
public static void testMontgomeryAliceBob()
{
// Curve25519
// Curve parameters and g are public
EllipticCurveGroup.setMontgomeryParameters(new Apint("1", 16),
new Apint("76d06", 16),
new Apint("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed", 16));
EllipticCurveGroup g = EllipticCurveGroup.fromMontgomeryPoint(new Apint("9", 16),
new Apint("20ae19a1b8a086b4e01edd2c7748d14c923d4d7e6d7c61b229e9c5a27eced3d9", 16));
// Private keys, generated as random
Apint alicePrivateKey = ApintMath.random(63, 16);
Apint bobPrivateKey = ApintMath.random(63, 16);
// Key exchange
EllipticCurveGroup alicePublicKey = g.times(alicePrivateKey);
EllipticCurveGroup bobPublicKey = g.times(bobPrivateKey);
// Shared secret
EllipticCurveGroup aliceSharedSecret = bobPublicKey.times(alicePrivateKey);
EllipticCurveGroup bobSharedSecret = alicePublicKey.times(bobPrivateKey);
assertEquals("Alice shared secret == Bob shared secret", aliceSharedSecret, bobSharedSecret);
}
public static void testEdwardsAliceBob()
{
// Ed448
// Curve parameters and g are public
EllipticCurveGroup.setEdwardsParameters(new Apint("1", 16),
new Apint("d78b4bdc7f0daf19f24f38c29373a2ccad46157242a50f37809b1da3412a12e79ccc9c81264cfe9ad080997058fb61c4243cc32dbaa156b9", 16),
new Apint("fffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16));
EllipticCurveGroup g = EllipticCurveGroup.fromEdwardsPoint(new Apint("79a70b2b70400553ae7c9df416c792c61128751ac92969240c25a07d728bdc93e21f7787ed6972249de732f38496cd11698713093e9c04fc", 16),
new Apint("7fffffffffffffffffffffffffffffffffffffffffffffffffffffff80000000000000000000000000000000000000000000000000000001", 16));
// Private keys, generated as random
Apint alicePrivateKey = ApintMath.random(111, 16);
Apint bobPrivateKey = ApintMath.random(111, 16);
// Key exchange
EllipticCurveGroup alicePublicKey = g.times(alicePrivateKey);
EllipticCurveGroup bobPublicKey = g.times(bobPrivateKey);
// Shared secret
EllipticCurveGroup aliceSharedSecret = bobPublicKey.times(alicePrivateKey);
EllipticCurveGroup bobSharedSecret = alicePublicKey.times(bobPrivateKey);
assertEquals("Alice shared secret == Bob shared secret", aliceSharedSecret, bobSharedSecret);
}
public static void testXmlSerialization()
throws XMLStreamException
{
EllipticCurveGroup.setWeierstrassParameters(new Apint(486662, 36), new Apint(1, 36), ApintMath.pow(new Apint(2, 36), 255).subtract(new Apint(19, 36)));
EllipticCurveGroup group = new EllipticCurveGroup(new Apint("12ez0", 36), new Apint("1", 36));
StringWriter out = new StringWriter();
XMLObjectWriter xmlWriter = XMLObjectWriter.newInstance(out);
xmlWriter.write(group);
xmlWriter.close();
String xml = out.toString();
assertEquals("XML", "", xml);
StringReader in = new StringReader(xml);
XMLObjectReader xmlReader = XMLObjectReader.newInstance(in);
group = xmlReader.read();
assertEquals("x", new Apint("12ez0", 36), group.getX());
assertEquals("y", new Apint("1", 36), group.getY());
assertEquals("Radix", 36, group.getX().radix());
EllipticCurveGroup.setEdwardsParameters(new Apint(5, 2), new Apint(6, 2), new Apint(7, 2));
group = new EllipticCurveGroup(new Apint("0", 2), new Apint("0", 2));
out = new StringWriter();
xmlWriter = XMLObjectWriter.newInstance(out);
xmlWriter.write(group);
xmlWriter.close();
xml = out.toString();
assertEquals("XML 0", "", xml);
in = new StringReader(xml);
xmlReader = XMLObjectReader.newInstance(in);
group = xmlReader.read();
assertEquals("x", new Apint("0", 2), group.getX());
assertEquals("y", new Apint("0", 2), group.getY());
assertEquals("Radix", 2, group.getX().radix());
}
private static EllipticCurveGroup valueOf(int x, int y)
{
return new EllipticCurveGroup(new Apint(x), new Apint(y));
}
}
FixedPrecisionApcomplexFieldTest.java 0000664 0000000 0000000 00000016663 15113064030 0034303 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-jscience/src/test/java/org/apfloat/jscience /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.HashSet;
import org.apfloat.*;
import org.jscience.mathematics.function.*;
import org.jscience.mathematics.vector.*;
import javolution.text.*;
import javolution.xml.*;
import javolution.xml.stream.*;
import junit.framework.TestSuite;
/**
* @since 1.8.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class FixedPrecisionApcomplexFieldTest
extends ApfloatTestCase
{
public FixedPrecisionApcomplexFieldTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new FixedPrecisionApcomplexFieldTest("testBasic"));
suite.addTest(new FixedPrecisionApcomplexFieldTest("testXmlSerialization"));
suite.addTest(new FixedPrecisionApcomplexFieldTest("testMatrixInverse"));
suite.addTest(new FixedPrecisionApcomplexFieldTest("testRationalFunction"));
return suite;
}
public static void testBasic()
{
FixedPrecisionApcomplexField a = valueOf("(0,100)");
FixedPrecisionApcomplexField b = valueOf("(0,200)");
FixedPrecisionApcomplexField c = valueOf("(0,200)");
FixedPrecisionApcomplexField zero = valueOf("0");
assertEquals("100 + 200", valueOf("(0,300)"), a.plus(b));
assertEquals("-100", valueOf("(0,-100)"), a.opposite());
assertEquals("100 - 200", valueOf("(0,-100)"), a.minus(b));
assertEquals("100 * 200", valueOf("-20000"), a.times(b));
assertEquals("1 / 100", valueOf("(0,-0.01)"), a.inverse());
assertEquals("copy", a, a.copy());
assertEquals("doubleValue", 0.0, a.doubleValue());
assertEquals("longValue", 0L, a.longValue());
assertEquals("String", "(0, 1e2)", a.toString());
assertEquals("Text", new Text("(0, 1e2)"), a.toText());
assertTrue("isLargerThan", b.isLargerThan(a));
assertEquals("compareTo", -1, a.compareTo(b));
HashSet set = new HashSet<>();
set.add(b);
set.add(c);
assertEquals("hashCode", 1, set.size());
try
{
zero.inverse();
fail("Zero divisor accepted");
}
catch (ApfloatArithmeticException aae)
{
// OK, modulus is not set
}
try
{
new FixedPrecisionApcomplexField(null, HELPER);
fail("null value accepted");
}
catch (NullPointerException npe)
{
// OK, illegal
}
try
{
new FixedPrecisionApcomplexField(Apcomplex.ZERO, null);
fail("null helper accepted");
}
catch (NullPointerException npe)
{
// OK, illegal
}
}
public static void testXmlSerialization()
throws XMLStreamException
{
FixedPrecisionApcomplexField field = new FixedPrecisionApcomplexField(new Apcomplex("(1.23,-45.6789)"), new FixedPrecisionApcomplexHelper(20));
StringWriter out = new StringWriter();
XMLObjectWriter xmlWriter = XMLObjectWriter.newInstance(out);
xmlWriter.write(field);
xmlWriter.close();
String xml = out.toString();
assertEquals("XML", "", xml);
StringReader in = new StringReader(xml);
XMLObjectReader xmlReader = XMLObjectReader.newInstance(in);
field = xmlReader.read();
assertEquals("Value", new Apcomplex("(1.23,-45.6789)"), field.value());
assertEquals("Real precision", 3, field.value().real().precision());
assertEquals("Imag precision", 6, field.value().imag().precision());
assertEquals("Helper precision", 20, field.helper().precision());
}
public static void testMatrixInverse()
{
FixedPrecisionApcomplexField[][] elements = { { valueOf("1"), valueOf("(0,2)"), valueOf("3") },
{ valueOf("4"), valueOf("5"), valueOf("(0,6)") },
{ valueOf("(0,7)"), valueOf("8"), valueOf("9") } };
Matrix m = DenseMatrix.valueOf(elements);
Vector vectorization = m.minus(m.inverse().inverse()).vectorization();
Apfloat sum = Apfloat.ZERO;
for (int i = 0; i < vectorization.getDimension(); i++)
{
sum = sum.add(ApcomplexMath.abs(vectorization.get(i).value()));
}
assertEquals("Double inverse error", Apfloat.ZERO, sum, new Apfloat(5e-28));
}
public static void testRationalFunction()
{
Variable.Local x = new Variable.Local("x");
Polynomial dividend = Polynomial.valueOf(valueOf("(1,2)"), Term.valueOf(x, 2)).plus(Polynomial.valueOf(valueOf("(3,4)"), x));
Polynomial divisor = Polynomial.valueOf(valueOf("(5,6)"), x).plus(valueOf("(7,8)"));
RationalFunction function = RationalFunction.valueOf(dividend, divisor);
assertEquals("Function value", new Apcomplex("(0.570962479608482871125611745514,0.983686786296900489396411092985)"), function.evaluate(valueOf("(2,3)")).value(), new Apfloat("5e-30"));
assertEquals("Function plus inverse, value", new Apcomplex("(1.01232439638023570845221956392,0.22328325540156631537371248012)"), function.plus(function.inverse()).evaluate(valueOf("(2,3)")).value(), new Apfloat("5e-29"));
}
private static FixedPrecisionApcomplexField valueOf(String value)
{
return new FixedPrecisionApcomplexField(new Apcomplex(value), HELPER);
}
private static final FixedPrecisionApcomplexHelper HELPER = new FixedPrecisionApcomplexHelper(30);
}
FixedPrecisionApfloatFieldTest.java 0000664 0000000 0000000 00000017565 15113064030 0033743 0 ustar 00root root 0000000 0000000 apfloat-1.15.0/apfloat-jscience/src/test/java/org/apfloat/jscience /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.HashSet;
import org.apfloat.*;
import org.jscience.mathematics.function.*;
import org.jscience.mathematics.vector.*;
import javolution.text.*;
import javolution.xml.*;
import javolution.xml.stream.*;
import junit.framework.TestSuite;
/**
* @since 1.8.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class FixedPrecisionApfloatFieldTest
extends ApfloatTestCase
{
public FixedPrecisionApfloatFieldTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new FixedPrecisionApfloatFieldTest("testBasic"));
suite.addTest(new FixedPrecisionApfloatFieldTest("testXmlSerialization"));
suite.addTest(new FixedPrecisionApfloatFieldTest("testMatrixInverse"));
suite.addTest(new FixedPrecisionApfloatFieldTest("testRationalFunction"));
return suite;
}
public static void testBasic()
{
FixedPrecisionApfloatField a = valueOf("100");
FixedPrecisionApfloatField b = valueOf("200");
FixedPrecisionApfloatField c = valueOf("200");
FixedPrecisionApfloatField zero = valueOf("0");
assertEquals("100 + 200", valueOf("300"), a.plus(b));
assertEquals("-100", valueOf("-100"), a.opposite());
assertEquals("100 - 200", valueOf("-100"), a.minus(b));
assertEquals("100 * 200", valueOf("20000"), a.times(b));
assertEquals("1 / 100", valueOf("0.01"), a.inverse());
assertEquals("copy", a, a.copy());
assertEquals("doubleValue", 100.0, a.doubleValue(), 0.00000000000005);
assertEquals("longValue", 100L, a.longValue());
assertEquals("String", "1e2", a.toString());
assertEquals("Text", new Text("1e2"), a.toText());
assertTrue("isLargerThan", b.isLargerThan(a));
assertEquals("compareTo", -1, a.compareTo(b));
HashSet set = new HashSet<>();
set.add(b);
set.add(c);
assertEquals("hashCode", 1, set.size());
try
{
zero.inverse();
fail("Zero divisor accepted");
}
catch (ApfloatArithmeticException aae)
{
// OK, modulus is not set
}
try
{
new FixedPrecisionApfloatField(null, HELPER);
fail("null value accepted");
}
catch (NullPointerException npe)
{
// OK, illegal
}
try
{
new FixedPrecisionApfloatField(Apcomplex.ZERO, null);
fail("null helper accepted");
}
catch (NullPointerException npe)
{
// OK, illegal
}
}
public static void testXmlSerialization()
throws XMLStreamException
{
FixedPrecisionApfloatField field = new FixedPrecisionApfloatField(new Apfloat("1.234", 5, 11), new FixedPrecisionApfloatHelper(17));
StringWriter out = new StringWriter();
XMLObjectWriter xmlWriter = XMLObjectWriter.newInstance(out);
xmlWriter.write(field);
xmlWriter.close();
String xml = out.toString();
assertEquals("XML", "", xml);
StringReader in = new StringReader(xml);
XMLObjectReader xmlReader = XMLObjectReader.newInstance(in);
field = xmlReader.read();
assertEquals("Value", new Apfloat("1.234", 5, 11), field.value());
assertEquals("Precision", Apfloat.INFINITE, field.value().imag().precision());
assertEquals("Helper precision", 17, field.helper().precision());
field = new FixedPrecisionApfloatField(new Apfloat("0", Apfloat.INFINITE, 11), new FixedPrecisionApfloatHelper(17));
out = new StringWriter();
xmlWriter = XMLObjectWriter.newInstance(out);
xmlWriter.write(field);
xmlWriter.close();
xml = out.toString();
assertEquals("XML 0", "", xml);
in = new StringReader(xml);
xmlReader = XMLObjectReader.newInstance(in);
field = xmlReader.read();
assertEquals("Value", new Apfloat("0", Apfloat.INFINITE, 11), field.value());
assertEquals("Precision", Apfloat.INFINITE, field.value().imag().precision());
assertEquals("Helper precision", 17, field.helper().precision());
}
public static void testMatrixInverse()
{
FixedPrecisionApfloatField[][] elements = { { valueOf("1"), valueOf("2"), valueOf("3") },
{ valueOf("4"), valueOf("5"), valueOf("6") },
{ valueOf("7"), valueOf("8"), valueOf("10") } };
Matrix m = DenseMatrix.valueOf(elements);
Vector vectorization = m.minus(m.inverse().inverse()).vectorization();
Apfloat sum = Apfloat.ZERO;
for (int i = 0; i < vectorization.getDimension(); i++)
{
sum = sum.add(ApfloatMath.abs(vectorization.get(i).value()));
}
assertEquals("Double inverse error", Apfloat.ZERO, sum, new Apfloat(5e-28));
}
public static void testRationalFunction()
{
Variable.Local x = new Variable.Local("x");
Polynomial dividend = Polynomial.valueOf(valueOf("2"), Term.valueOf(x, 2)).plus(Polynomial.valueOf(valueOf("3"), x));
Polynomial divisor = Polynomial.valueOf(valueOf("5"), x).plus(valueOf("6"));
RationalFunction function = RationalFunction.valueOf(dividend, divisor);
assertEquals("Function value", new Apfloat("0.875"), function.evaluate(valueOf("2")).value(), new Apfloat("5e-30"));
assertEquals("Function plus inverse, value", new Apfloat("2.017857142857142857142857142857"), function.plus(function.inverse()).evaluate(valueOf("2")).value(), new Apfloat("5e-29"));
}
private static FixedPrecisionApfloatField valueOf(String value)
{
return new FixedPrecisionApfloatField(new Apfloat(value), HELPER);
}
private static final FixedPrecisionApfloatHelper HELPER = new FixedPrecisionApfloatHelper(30);
}
apfloat-1.15.0/apfloat-jscience/src/test/java/org/apfloat/jscience/ModuloApintFieldTest.java 0000664 0000000 0000000 00000021124 15113064030 0032015 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import java.io.StringReader;
import java.io.StringWriter;
import java.math.BigInteger;
import java.util.HashSet;
import java.util.Random;
import org.apfloat.*;
import org.jscience.mathematics.function.*;
import org.jscience.mathematics.vector.*;
import javolution.text.*;
import javolution.xml.*;
import javolution.xml.stream.*;
import junit.framework.TestSuite;
/**
* @since 1.8.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class ModuloApintFieldTest
extends ApfloatTestCase
{
public ModuloApintFieldTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new ModuloApintFieldTest("testBasic"));
suite.addTest(new ModuloApintFieldTest("testNoModulus"));
suite.addTest(new ModuloApintFieldTest("testXmlSerialization"));
suite.addTest(new ModuloApintFieldTest("testMatrixInverse"));
suite.addTest(new ModuloApintFieldTest("testRationalFunction"));
suite.addTest(new ModuloApintFieldTest("testAliceBob"));
return suite;
}
public static void testBasic()
{
ModuloApintField.setModulus(new Apint(65537));
ModuloApintField a = valueOf(100);
ModuloApintField b = valueOf(200);
ModuloApintField c = valueOf(200);
ModuloApintField zero = valueOf(0);
assertEquals("100 + 200", valueOf(300), a.plus(b));
assertEquals("-100", valueOf(65537 - 100), a.opposite());
assertEquals("100 - 200", valueOf(65537 - 100), a.minus(b));
assertEquals("100 * 200", valueOf(20000), a.times(b));
assertEquals("1 / 100", valueOf(17695), a.inverse());
assertEquals("100 ^2", valueOf(10000), a.pow(new Apint(2)));
assertEquals("copy", a, a.copy());
assertEquals("doubleValue", 100.0, a.doubleValue(), 0.00000000000005);
assertEquals("longValue", 100L, a.longValue());
assertEquals("String", "100", a.toString());
assertEquals("Text", new Text("100"), a.toText());
assertTrue("isLargerThan", b.isLargerThan(a));
assertEquals("compareTo", -1, a.compareTo(b));
HashSet set = new HashSet<>();
set.add(b);
set.add(c);
assertEquals("hashCode", 1, set.size());
try
{
zero.inverse();
fail("Zero divisor accepted");
}
catch (ApfloatArithmeticException aae)
{
// OK, modulus is not set
}
try
{
new ModuloApintField(null);
fail("null accepted");
}
catch (NullPointerException npe)
{
// OK, illegal
}
}
public static void testNoModulus()
{
ModuloApintField.setModulus(null);
ModuloApintField a = valueOf(100),
b = valueOf(200);
assertEquals("100 + 200", valueOf(300), a.plus(b));
assertEquals("-100", valueOf(-100), a.opposite());
assertEquals("100 - 200", valueOf(-100), a.minus(b));
assertEquals("100 * 200", valueOf(20000), a.times(b));
assertEquals("copy", a, a.copy());
try
{
a.inverse();
fail("No divisor accepted");
}
catch (ApfloatArithmeticException aae)
{
// OK, modulus is not set
}
}
public static void testXmlSerialization()
throws XMLStreamException
{
ModuloApintField field = new ModuloApintField(new Apint("12ez0", 36));
StringWriter out = new StringWriter();
XMLObjectWriter xmlWriter = XMLObjectWriter.newInstance(out);
xmlWriter.write(field);
xmlWriter.close();
String xml = out.toString();
assertEquals("XML", "", xml);
StringReader in = new StringReader(xml);
XMLObjectReader xmlReader = XMLObjectReader.newInstance(in);
field = xmlReader.read();
assertEquals("Value", new Apint("12ez0", 36), field.value());
assertEquals("Radix", 36, field.value().radix());
field = new ModuloApintField(new Apint("0", 2));
out = new StringWriter();
xmlWriter = XMLObjectWriter.newInstance(out);
xmlWriter.write(field);
xmlWriter.close();
xml = out.toString();
assertEquals("XML 0", "", xml);
in = new StringReader(xml);
xmlReader = XMLObjectReader.newInstance(in);
field = xmlReader.read();
assertEquals("Value", new Apint("0", 2), field.value());
assertEquals("Radix", 2, field.value().radix());
}
public static void testMatrixInverse()
{
ModuloApintField.setModulus(new Apint(43));
ModuloApintField[][] elements = { { valueOf(1), valueOf(2), valueOf(3) },
{ valueOf(4), valueOf(5), valueOf(6) },
{ valueOf(7), valueOf(8), valueOf(10) } };
Matrix m = DenseMatrix.valueOf(elements);
Vector vectorization = m.minus(m.inverse().inverse()).vectorization();
for (int i = 0; i < vectorization.getDimension(); i++)
{
assertEquals("Element " + i, 0, vectorization.get(i).value().signum());
}
}
public static void testRationalFunction()
{
ModuloApintField.setModulus(new Apint(43));
Variable.Local x = new Variable.Local("x");
Polynomial dividend = Polynomial.valueOf(valueOf(17), Term.valueOf(x, 2)).plus(Polynomial.valueOf(valueOf(23), x));
Polynomial divisor = Polynomial.valueOf(valueOf(37), x).plus(valueOf(26));
RationalFunction function = RationalFunction.valueOf(dividend, divisor);
assertEquals("Function value", new Apint(2), function.evaluate(valueOf(2)).value());
assertEquals("Function plus inverse, value", new Apint(24), function.plus(function.inverse()).evaluate(valueOf(2)).value());
}
public static void testAliceBob()
{
// Modulus and g are public
ModuloApintField.setModulus(new Apint(BigInteger.probablePrime(4096, new Random()), 2));
ModuloApintField g = new ModuloApintField(ApintMath.random(4096, 2));
// Private keys, generated as random
Apint alicePrivateKey = ApintMath.random(4096, 2);
Apint bobPrivateKey = ApintMath.random(4096, 2);
// Key exchange
ModuloApintField alicePublicKey = g.pow(alicePrivateKey);
ModuloApintField bobPublicKey = g.pow(bobPrivateKey);
// Shared secret
ModuloApintField aliceSharedSecret = bobPublicKey.pow(alicePrivateKey);
ModuloApintField bobSharedSecret = alicePublicKey.pow(bobPrivateKey);
assertEquals("Alice shared secret == Bob shared secret", aliceSharedSecret, bobSharedSecret);
}
private static ModuloApintField valueOf(int value)
{
return new ModuloApintField(new Apint(value));
}
}
apfloat-1.15.0/apfloat-jscience/src/test/java/org/apfloat/jscience/ModuloPolynomialFieldTest.java 0000664 0000000 0000000 00000041124 15113064030 0033067 0 ustar 00root root 0000000 0000000 /*
* MIT License
*
* Copyright (c) 2002-2025 Mikko Tommila
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.apfloat.jscience;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.function.BiFunction;
import java.util.function.IntFunction;
import java.util.stream.IntStream;
import org.apfloat.*;
import org.jscience.mathematics.function.*;
import org.jscience.mathematics.vector.*;
import javolution.text.*;
import junit.framework.TestSuite;
/**
* @since 1.15.0
* @version 1.15.0
* @author Mikko Tommila
*/
public class ModuloPolynomialFieldTest
extends ApfloatTestCase
{
public ModuloPolynomialFieldTest(String methodName)
{
super(methodName);
}
public static void main(String[] args)
{
junit.textui.TestRunner.run(suite());
}
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTest(new ModuloPolynomialFieldTest("testBasic"));
suite.addTest(new ModuloPolynomialFieldTest("testNoModulus"));
suite.addTest(new ModuloPolynomialFieldTest("testMatrixInverse"));
suite.addTest(new ModuloPolynomialFieldTest("testAliceBob"));
return suite;
}
public static void testBasic()
{
ModuloPolynomialField.setModulus(rationalPolynomialOf(2, 1, 1));
ModuloPolynomialField r = rationalOf(1, 2, 3);
assertEquals("1 / (y^2 + 2y + 3)", "[-3/11]y + [7/22]", r.inverse().toString());
ModuloApintField.setModulus(new Apint(3329));
ModuloPolynomialField.setModulus(polynomialOf(1, 1, 1));
ModuloPolynomialField a = valueOf(100),
b = valueOf(200),
c = valueOf(200),
zero = valueOf(0);
assertEquals("modulus", polynomialOf(1, 1, 1), ModuloPolynomialField.getModulus());
assertEquals("reduce 1", polynomialOf(1), ModuloPolynomialField.reduce(polynomialOf(1, 1, 2)));
assertEquals("reduce 100", polynomialOf(100), ModuloPolynomialField.reduce(a.value()));
assertEquals("100 + 200", valueOf(300), a.plus(b));
assertEquals("-100", valueOf(3329 - 100), a.opposite());
assertEquals("100 - 200", valueOf(3229), a.minus(b));
assertEquals("100 * 200", valueOf(20000), a.times(b));
assertEquals("1 / 100", valueOf(1032), a.inverse());
assertEquals("String", "[100]", a.toString());
assertEquals("Text", new Text("[100]"), a.toText());
HashSet> set = new HashSet<>();
set.add(b);
set.add(c);
assertEquals("hashCode", 1, set.size());
assertEquals("equals", false, a.equals(null));
a = valueOf(2, 0, 1);
b = valueOf(3, 1, 2, 1);
c = valueOf(1, 0, 0, 0, 1);
assertEquals("2x^2+1 + 3x^3+x^2+2x+1", valueOf(3, 3, 2, 2), a.plus(b));
assertEquals("-(2x^2+1)", valueOf(2, 1), a.opposite());
assertEquals("(2x^2+1) * (3x^3+x^2+2x+1)", valueOf(3324, 3328), a.times(b));
assertEquals("1 / (2x^2+1)", valueOf(2220, 1110), a.inverse());
assertEquals("copy", a, a.copy());
assertEquals("String", "[3327]x + [3328]", a.toString());
assertEquals("Text", new Text("[3327]x + [3328]"), a.toText());
try
{
zero.inverse();
fail("Zero divisor accepted");
}
catch (ApfloatArithmeticException aae)
{
// OK, modulus is not set
}
try
{
new ModuloPolynomialField<>(null);
fail("null accepted");
}
catch (NullPointerException npe)
{
// OK, illegal
}
try
{
ModuloPolynomialField.setModulus(polynomialOf(0));
}
catch (IllegalArgumentException iae)
{
// OK, zero modulus
}
try
{
ModuloPolynomialField.setModulus(polynomialOf(0, 5));
}
catch (IllegalArgumentException iae)
{
// OK, zero degree modulus
}
try
{
ModuloPolynomialField.setModulus(Polynomial.valueOf(new ModuloApintField(Apint.ONE), X).times(Polynomial.valueOf(new ModuloApintField(Apint.ONE), new Variable.Local("x"))));
}
catch (IllegalArgumentException iae)
{
// OK, multi-variable polynomial
}
try
{
ModuloPolynomialField.setModulus(Polynomial.valueOf(new ModuloApintField(Apint.ONE), X).plus(Polynomial.valueOf(new ModuloApintField(Apint.ONE), new Variable.Local("y"))));
}
catch (IllegalArgumentException iae)
{
// OK, multi-variable polynomial
}
}
public static void testNoModulus()
{
ModuloApintField.setModulus(null);
ModuloPolynomialField.setModulus(null);
ModuloPolynomialField a = valueOf(100),
b = valueOf(200);
assertEquals("modulus", null, ModuloPolynomialField.getModulus());
assertEquals("reduce", polynomialOf(100), ModuloPolynomialField.reduce(polynomialOf(100)));
assertEquals("100 + 200", valueOf(300), a.plus(b));
assertEquals("-100", valueOf(-100), a.opposite());
assertEquals("100 - 200", valueOf(-100), a.minus(b));
assertEquals("100 * 200", valueOf(20000), a.times(b));
assertEquals("copy", a, a.copy());
try
{
a.inverse();
fail("No divisor accepted");
}
catch (ApfloatArithmeticException aae)
{
// OK, modulus is not set
}
}
public static void testMatrixInverse()
{
ModuloApintField.setModulus(new Apint(3329));
ModuloPolynomialField.setModulus(polynomialOf(1, 1, 1));
ModuloPolynomialField[][] elements = { { valueOf(9, 1), valueOf(4, 2), valueOf(3, 3) },
{ valueOf(8, 4), valueOf(5, 5), valueOf(2, 6) },
{ valueOf(7, 7), valueOf(6, 8), valueOf(1, 10) } };
@SuppressWarnings("unchecked")
Matrix> matrix = DenseMatrix.valueOf((ModuloPolynomialField[][]) elements);
Vector> vectorization = matrix.minus(matrix.inverse().inverse()).vectorization();
for (int i = 0; i < vectorization.getDimension(); i++)
{
assertEquals("Element " + i, valueOf(0), vectorization.get(i));
}
int q = 3329,
k = 2,
m = 25,
n = 256;
Random random = new Random();
ModuloApintField.setModulus(new Apint(q));
int[] coefficients = new int[n + 1];
coefficients[0] = 1;
coefficients[m] = 1;
coefficients[n] = 1;
ModuloPolynomialField.setModulus(polynomialOf(coefficients));
ModuloPolynomialField[][] elementsBig = IntStream.range(0, k).mapToObj(i -> IntStream.range(0, k).mapToObj(i2 -> valueOf(IntStream.range(0, n).map(i3 -> random.nextInt(q)).toArray())).toArray(ModuloPolynomialField[]::new)).toArray(ModuloPolynomialField[][]::new);
@SuppressWarnings("unchecked")
Matrix> matrixBig = DenseMatrix.valueOf((ModuloPolynomialField[][]) elementsBig);
Vector> vectorizationBig = matrixBig.minus(matrixBig.inverse().inverse()).vectorization();
for (int i = 0; i < vectorizationBig.getDimension(); i++)
{
assertEquals("Element " + i, valueOf(0), vectorizationBig.get(i));
}
ModuloPolynomialField.setModulus(rationalPolynomialOf(2, 1, 1));
ModuloPolynomialField[][] elementsRational = { { rationalOf(9, 1), rationalOf(4, 2), rationalOf(3, 3) },
{ rationalOf(8, 4), rationalOf(5, 5), rationalOf(2, 6) },
{ rationalOf(7, 7), rationalOf(6, 8), rationalOf(1, 10) } };
@SuppressWarnings("unchecked")
Matrix> matrixRational = DenseMatrix.valueOf((ModuloPolynomialField[][]) elementsRational);
Vector> vectorizationRational = matrixRational.minus(matrixRational.inverse().inverse()).vectorization();
for (int i = 0; i < vectorizationRational.getDimension(); i++)
{
assertEquals("Element " + i, rationalOf(0), vectorizationRational.get(i));
}
}
public static void testAliceBob()
{
// ML-KEM
// See e.g. https://thibautprobst.fr/en/posts/ml-kem/#ml-kem for an explanation
Random random = new Random();
IntFunction cbd = η -> IntStream.range(0, η).map(i -> random.nextInt(2)).sum() - IntStream.range(0, η).map(i -> random.nextInt(2)).sum();
BiFunction> cbdPolynomial = (n, η) -> valueOf(IntStream.range(0, n).map(i -> cbd.apply(η)).toArray());
TriFunction