You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by ma...@apache.org on 2021/07/20 11:56:58 UTC
[commons-geometry] 01/02: GEOMETRY-136: removing DoubleFormats
utility that has been moved to commons-text
This is an automated email from the ASF dual-hosted git repository.
mattjuntunen pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-geometry.git
commit 79e741d806d04a009cd48401d882cb17a5c027cd
Author: Matthew Juntunen <ma...@maxar.com>
AuthorDate: Mon Jul 19 22:12:39 2021 -0400
GEOMETRY-136: removing DoubleFormats utility that has been moved to commons-text
---
.../jmh/io/core/DoubleFormatsPerformance.java | 183 -----
.../examples/jmh/io/core/package-info.java | 23 -
.../io/core/utils/AbstractTextFormatWriter.java | 2 +-
.../geometry/io/core/utils/DoubleFormats.java | 369 ---------
.../geometry/io/core/utils/ParsedDouble.java | 514 ------------
.../core/utils/AbstractTextFormatWriterTest.java | 9 +-
.../geometry/io/core/utils/DoubleFormatsTest.java | 894 ---------------------
.../geometry/io/core/utils/ParsedDoubleTest.java | 464 -----------
.../threed/obj/ObjBoundaryWriteHandler3D.java | 3 +-
.../txt/AbstractTextBoundaryWriteHandler3D.java | 3 +-
.../threed/obj/ObjBoundaryWriteHandler3DTest.java | 30 +-
.../io/euclidean/threed/obj/ObjWriterTest.java | 20 +-
.../io/euclidean/threed/stl/TextStlWriterTest.java | 11 +-
.../threed/txt/TextBoundaryWriteHandler3DTest.java | 17 +-
.../threed/txt/TextFacetDefinitionWriterTest.java | 15 +-
15 files changed, 81 insertions(+), 2476 deletions(-)
diff --git a/commons-geometry-examples/examples-jmh/src/main/java/org/apache/commons/geometry/examples/jmh/io/core/DoubleFormatsPerformance.java b/commons-geometry-examples/examples-jmh/src/main/java/org/apache/commons/geometry/examples/jmh/io/core/DoubleFormatsPerformance.java
deleted file mode 100644
index dc83014..0000000
--- a/commons-geometry-examples/examples-jmh/src/main/java/org/apache/commons/geometry/examples/jmh/io/core/DoubleFormatsPerformance.java
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.geometry.examples.jmh.io.core;
-
-import java.math.BigDecimal;
-import java.math.RoundingMode;
-import java.text.DecimalFormat;
-import java.util.concurrent.TimeUnit;
-import java.util.function.DoubleFunction;
-
-import org.apache.commons.geometry.examples.jmh.BenchmarkUtils;
-import org.apache.commons.geometry.io.core.utils.DoubleFormats;
-import org.apache.commons.rng.simple.RandomSource;
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.BenchmarkMode;
-import org.openjdk.jmh.annotations.Fork;
-import org.openjdk.jmh.annotations.Level;
-import org.openjdk.jmh.annotations.Measurement;
-import org.openjdk.jmh.annotations.Mode;
-import org.openjdk.jmh.annotations.OutputTimeUnit;
-import org.openjdk.jmh.annotations.Param;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.Setup;
-import org.openjdk.jmh.annotations.State;
-import org.openjdk.jmh.annotations.Warmup;
-import org.openjdk.jmh.infra.Blackhole;
-
-/** Benchmarks for the {@link DoubleFormats} class.
- */
-@BenchmarkMode(Mode.AverageTime)
-@OutputTimeUnit(TimeUnit.NANOSECONDS)
-@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
-@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
-@Fork(value = 1, jvmArgs = {"-server", "-Xms512M", "-Xmx512M"})
-public class DoubleFormatsPerformance {
-
- /** Benchmark input providing a source of random double values. */
- @State(Scope.Thread)
- public static class DoubleInput {
-
- /** The number of doubles in the input array. */
- @Param({"10000"})
- private int size;
-
- /** Minimum base 2 exponent for random input doubles. */
- @Param("-20")
- private int minExp;
-
- /** Maximum base 2 exponent for random input doubles. */
- @Param("20")
- private int maxExp;
-
- /** Double input array. */
- private double[] input;
-
- /** Get the input doubles.
- * @return the input doubles
- */
- public double[] getInput() {
- return input;
- }
-
- /** Set up the instance for the benchmark. */
- @Setup(Level.Iteration)
- public void setup() {
- input = BenchmarkUtils.randomDoubleArray(size, minExp, maxExp,
- RandomSource.create(RandomSource.XO_RO_SHI_RO_128_PP));
- }
- }
-
- /** Run a benchmark test on a function accepting a double argument.
- * @param <T> function output type
- * @param input double array
- * @param bh jmh blackhole for consuming output
- * @param fn function to call
- */
- private static <T> void runDoubleFunction(final DoubleInput input, final Blackhole bh,
- final DoubleFunction<T> fn) {
- for (final double d : input.getInput()) {
- bh.consume(fn.apply(d));
- }
- }
-
- /** Benchmark testing just the overhead of the benchmark harness.
- * @param input benchmark state input
- * @param bh jmh blackhole for consuming output
- */
- @Benchmark
- public void baseline(final DoubleInput input, final Blackhole bh) {
- runDoubleFunction(input, bh, d -> "");
- }
-
- /** Benchmark testing the {@link Double#toString()} method.
- * @param input benchmark state input
- * @param bh jmh blackhole for consuming output
- */
- @Benchmark
- public void doubleToString(final DoubleInput input, final Blackhole bh) {
- runDoubleFunction(input, bh, Double::toString);
- }
-
- /** Benchmark testing the {@link String#format(String, Object...)} method.
- * @param input benchmark state input
- * @param bh jmh blackhole for consuming output
- */
- @Benchmark
- public void stringFormat(final DoubleInput input, final Blackhole bh) {
- runDoubleFunction(input, bh, d -> String.format("%d", d));
- }
-
- /** Benchmark testing the BigDecimal formatting performance.
- * @param input benchmark state input
- * @param bh jmh blackhole for consuming output
- */
- @Benchmark
- public void bigDecimal(final DoubleInput input, final Blackhole bh) {
- final DoubleFunction<String> fn = d -> BigDecimal.valueOf(d)
- .setScale(3, RoundingMode.HALF_EVEN)
- .stripTrailingZeros()
- .toString();
- runDoubleFunction(input, bh, fn);
- }
-
- /** Benchmark testing the {@link DecimalFormat} class.
- * @param input benchmark state input
- * @param bh jmh blackhole for consuming output
- */
- @Benchmark
- public void decimalFormat(final DoubleInput input, final Blackhole bh) {
- final DecimalFormat fmt = new DecimalFormat("0.###");
- runDoubleFunction(input, bh, fmt::format);
- }
-
- /** Benchmark testing the {@link DoubleFormats#createDefault(int, int)} method.
- * @param input benchmark state input
- * @param bh jmh blackhole for consuming output
- */
- @Benchmark
- public void doubleFormatsDefault(final DoubleInput input, final Blackhole bh) {
- runDoubleFunction(input, bh, DoubleFormats.createDefault(0, -3));
- }
-
- /** Benchmark testing the {@link DoubleFormats#createPlain(int, int)} method.
- * @param input benchmark state input
- * @param bh jmh blackhole for consuming output
- */
- @Benchmark
- public void doubleFormatsPlain(final DoubleInput input, final Blackhole bh) {
- runDoubleFunction(input, bh, DoubleFormats.createPlain(0, -3));
- }
-
- /** Benchmark testing the {@link DoubleFormats#createScientific(int, int)} method.
- * @param input benchmark state input
- * @param bh jmh blackhole for consuming output
- */
- @Benchmark
- public void doubleFormatsScientific(final DoubleInput input, final Blackhole bh) {
- runDoubleFunction(input, bh, DoubleFormats.createScientific(0, -3));
- }
-
- /** Benchmark testing the {@link DoubleFormats#createEngineering(int, int)} method.
- * @param input benchmark state input
- * @param bh jmh blackhole for consuming output
- */
- @Benchmark
- public void doubleFormatsEngineering(final DoubleInput input, final Blackhole bh) {
- runDoubleFunction(input, bh, DoubleFormats.createEngineering(0, -3));
- }
-}
diff --git a/commons-geometry-examples/examples-jmh/src/main/java/org/apache/commons/geometry/examples/jmh/io/core/package-info.java b/commons-geometry-examples/examples-jmh/src/main/java/org/apache/commons/geometry/examples/jmh/io/core/package-info.java
deleted file mode 100644
index 6f2beb2..0000000
--- a/commons-geometry-examples/examples-jmh/src/main/java/org/apache/commons/geometry/examples/jmh/io/core/package-info.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Benchmarks for the components in the {@code org.apache.commons.geometry.io.core}
- * package.
- */
-
-package org.apache.commons.geometry.examples.jmh.io.core;
diff --git a/commons-geometry-io-core/src/main/java/org/apache/commons/geometry/io/core/utils/AbstractTextFormatWriter.java b/commons-geometry-io-core/src/main/java/org/apache/commons/geometry/io/core/utils/AbstractTextFormatWriter.java
index fdd94c0..f4eb918 100644
--- a/commons-geometry-io-core/src/main/java/org/apache/commons/geometry/io/core/utils/AbstractTextFormatWriter.java
+++ b/commons-geometry-io-core/src/main/java/org/apache/commons/geometry/io/core/utils/AbstractTextFormatWriter.java
@@ -42,7 +42,7 @@ public abstract class AbstractTextFormatWriter implements Closeable {
* @param writer writer instance
*/
protected AbstractTextFormatWriter(final Writer writer) {
- this(writer, DoubleFormats.DOUBLE_TO_STRING);
+ this(writer, Double::toString);
}
/** Construct a new instance that writes content to the given writer and uses the
diff --git a/commons-geometry-io-core/src/main/java/org/apache/commons/geometry/io/core/utils/DoubleFormats.java b/commons-geometry-io-core/src/main/java/org/apache/commons/geometry/io/core/utils/DoubleFormats.java
deleted file mode 100644
index 62768b8..0000000
--- a/commons-geometry-io-core/src/main/java/org/apache/commons/geometry/io/core/utils/DoubleFormats.java
+++ /dev/null
@@ -1,369 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.geometry.io.core.utils;
-
-import java.util.function.DoubleFunction;
-
-/** Class containing static utility methods and constants for formatting double values
- * as strings. All instances returned by methods in this class are guaranteed to be
- * thread-safe.
- */
-public final class DoubleFormats {
-
- /** Double format function that simply calls {@link Double#toString(double)}.
- */
- public static final DoubleFunction<String> DOUBLE_TO_STRING = Double::toString;
-
- /** Double format function that converts the argument to a float and calls
- * {@link Float#toString(float)}.
- */
- public static final DoubleFunction<String> FLOAT_TO_STRING = d -> Float.toString((float) d);
-
- /** Minimum possible decimal exponent for double values. */
- private static final int MIN_DOUBLE_EXPONENT = -325;
-
- /** Utility class; no instantiation. */
- private DoubleFormats() {}
-
- /** Return a double format function that provides similar behavior to {@link Double#toString(double)}
- * but with a configurable max precision. For values with an absolute magnitude less than
- * 10<sup>7</sup> and greater than or equal to 10<sup>-3</sup> (after any necessary rounding), the returned
- * string is in plain, non-scientific format. All other values are in scientific format. Rounding is performed
- * using {@link java.math.RoundingMode#HALF_EVEN half even} rounding.
- * <table>
- * <caption>Format Examples</caption>
- * <tr><th>Value</th><th>(maxPrecision= 0)</th><th>(maxPrecision= 4)</th></tr>
- * <tr><td>1.0E-4</td><td>1.0E-4</td><td>1.0E-4</td></tr>
- * <tr><td>-0.0635</td><td>-0.0635</td><td>-0.0635</td></tr>
- * <tr><td>510.751</td><td>510.751</td><td>510.8</td></tr>
- * <tr><td>-123456.0</td><td>-123456.0</td><td>-123500.0</td></tr>
- * <tr><td>4.20785E7</td><td>4.20785E7</td><td>4.208E7</td></tr>
- * </table>
- * @param maxPrecision Maximum number of significant decimal digits in strings produced by the returned formatter.
- * Numbers are rounded as necessary so that the number of significant digits does not exceed this value. A
- * value of {@code 0} indicates no maximum precision.
- * @return double format function
- * @throws IllegalArgumentException if {@code maxPrecision} is less than zero
- */
- public static DoubleFunction<String> createDefault(final int maxPrecision) {
- return createDefault(maxPrecision, MIN_DOUBLE_EXPONENT);
- }
-
- /** Return a double format function that provides similar behavior to {@link Double#toString(double)}
- * but with a configurable max precision and min exponent. For values with an absolute magnitude less than
- * 10<sup>7</sup> and greater than or equal to 10<sup>-3</sup> (after any necessary rounding), the returned
- * string is in plain, non-scientific format. All other values are in scientific format. Rounding is performed
- * using {@link java.math.RoundingMode#HALF_EVEN half even} rounding.
- * <table>
- * <caption>Format Examples</caption>
- * <tr><th>Value</th><th>(maxPrecision= 0, minExponent= -2)</th><th>(maxPrecision= 4, minExponent= -2)</th></tr>
- * <tr><td>1.0E-4</td><td>0.0</td><td>0.0</td></tr>
- * <tr><td>-0.0635</td><td>-0.06</td><td>-0.06</td></tr>
- * <tr><td>510.751</td><td>510.75</td><td>510.8</td></tr>
- * <tr><td>-123456.0</td><td>-123456.0</td><td>-123500.0</td></tr>
- * <tr><td>4.20785E7</td><td>4.20785E7</td><td>4.208E7</td></tr>
- * </table>
- * @param maxPrecision Maximum number of significant decimal digits in strings produced by the returned formatter.
- * Numbers are rounded as necessary so that the number of significant digits does not exceed this value. A
- * value of {@code 0} indicates no maximum precision.
- * @param minExponent Minimum decimal exponent in strings produced by the returned formatter.
- * @return double format function
- * @throws IllegalArgumentException if {@code maxPrecision} is less than zero
- */
- public static DoubleFunction<String> createDefault(final int maxPrecision, final int minExponent) {
- return new DefaultFormat(maxPrecision, minExponent);
- }
-
- /** Return a double format function that produces strings in plain, non-scientific format.
- * Rounding is performed using {@link java.math.RoundingMode#HALF_EVEN half even} rounding.
- * <table>
- * <caption>Format Examples</caption>
- * <tr><th>Value</th><th>(maxPrecision= 0)</th><th>(maxPrecision= 4)</th></tr>
- * <tr><td>1.0E-4</td><td>0.0001</td><td>0.0001</td></tr>
- * <tr><td>-0.0635</td><td>-0.0635</td><td>-0.0635</td></tr>
- * <tr><td>510.751</td><td>510.751</td><td>510.8</td></tr>
- * <tr><td>-123456.0</td><td>-123456.0</td><td>-123500.0</td></tr>
- * <tr><td>4.20785E7</td><td>42078500.0</td><td>42080000.0</td></tr>
- * </table>
- * @param maxPrecision Maximum number of significant decimal digits in strings produced by the returned formatter.
- * Numbers are rounded as necessary so that the number of significant digits does not exceed this value. A
- * value of {@code 0} indicates no maximum precision.
- * @return double format function
- */
- public static DoubleFunction<String> createPlain(final int maxPrecision) {
- return createPlain(maxPrecision, MIN_DOUBLE_EXPONENT);
- }
-
- /** Return a double format function that produces strings in plain, non-scientific format.
- * Rounding is performed using {@link java.math.RoundingMode#HALF_EVEN half even} rounding.
- * <table>
- * <caption>Format Examples</caption>
- * <tr><th>Value</th><th>(maxPrecision= 0, minExponent= -2)</th><th>(maxPrecision= 4, minExponent= -2)</th></tr>
- * <tr><td>1.0E-4</td><td>0.0</td><td>0.0</td></tr>
- * <tr><td>-0.0635</td><td>-0.06</td><td>-0.06</td></tr>
- * <tr><td>510.751</td><td>510.75</td><td>510.8</td></tr>
- * <tr><td>-123456.0</td><td>-123456.0</td><td>-123500.0</td></tr>
- * <tr><td>4.20785E7</td><td>42078500.0</td><td>42080000.0</td></tr>
- * </table>
- * @param maxPrecision Maximum number of significant decimal digits in strings produced by the returned formatter.
- * Numbers are rounded as necessary so that the number of significant digits does not exceed this value. A
- * value of {@code 0} indicates no maximum precision.
- * @param minExponent Minimum decimal exponent in strings produced by the returned formatter.
- * @return double format function
- */
- public static DoubleFunction<String> createPlain(final int maxPrecision, final int minExponent) {
- return new PlainFormat(maxPrecision, minExponent);
- }
-
- /** Return a double format function that produces strings in scientific format. Exponents of
- * zero are not included in formatted strings. Rounding is performed using
- * {@link java.math.RoundingMode#HALF_EVEN half even} rounding.
- * <table>
- * <caption>Format Examples</caption>
- * <tr><th>Value</th><th>(maxPrecision= 0)</th><th>(maxPrecision= 4)</th></tr>
- * <tr><td>1.0E-4</td><td>1.0E-4</td><td>1.0E-4</td></tr>
- * <tr><td>-0.0635</td><td>-6.35E-2</td><td>-6.35E-2</td></tr>
- * <tr><td>510.751</td><td>5.10751E2</td><td>5.108E2</td></tr>
- * <tr><td>-123456.0</td><td>-1.23456E5</td><td>-1.235E5</td></tr>
- * <tr><td>4.20785E7</td><td>4.20785E7</td><td>4.208E7</td></tr>
- * </table>
- * @param maxPrecision Maximum number of significant decimal digits in strings produced by the returned formatter.
- * Numbers are rounded as necessary so that the number of significant digits does not exceed this value. A
- * value of {@code 0} indicates no maximum precision.
- * @return double format function
- */
- public static DoubleFunction<String> createScientific(final int maxPrecision) {
- return createScientific(maxPrecision, MIN_DOUBLE_EXPONENT);
- }
-
- /** Return a double format function that produces strings in scientific format. Exponents of
- * zero are not included in formatted strings. Rounding is performed using
- * {@link java.math.RoundingMode#HALF_EVEN half even} rounding.
- * <table>
- * <caption>Format Examples</caption>
- * <tr><th>Value</th><th>(maxPrecision= 0, minExponent= -2)</th><th>(maxPrecision= 4, minExponent= -2)</th></tr>
- * <tr><td>1.0E-4</td><td>0.0</td><td>0.0</td></tr>
- * <tr><td>-0.0635</td><td>-6.0E-2</td><td>-6.0E-2</td></tr>
- * <tr><td>510.751</td><td>5.1075E2</td><td>5.108E2</td></tr>
- * <tr><td>-123456.0</td><td>-1.23456E5</td><td>-1.235E5</td></tr>
- * <tr><td>4.20785E7</td><td>4.20785E7</td><td>4.208E7</td></tr>
- * </table>
- * @param maxPrecision Maximum number of significant decimal digits in strings produced by the returned formatter.
- * Numbers are rounded as necessary so that the number of significant digits does not exceed this value. A
- * value of {@code 0} indicates no maximum precision.
- * @param minExponent Minimum decimal exponent in strings produced by the returned formatter.
- * @return double format function
- */
- public static DoubleFunction<String> createScientific(final int maxPrecision, final int minExponent) {
- return new ScientificFormat(maxPrecision, minExponent);
- }
-
- /** Return a double format function that produces strings in
- * <a href="https://en.wikipedia.org/wiki/Engineering_notation">engineering notation</a> where any exponents
- * are adjusted to be multiples of 3. Exponents of zero are not included in formatted strings. Rounding is
- * performed using {@link java.math.RoundingMode#HALF_EVEN half even} rounding.
- * <table>
- * <caption>Format Examples</caption>
- * <tr><th>Value</th><th>(maxPrecision= 0)</th><th>(maxPrecision= 4)</th></tr>
- * <tr><td>1.0E-4</td><td>100.0E-6</td><td>100.0E-6</td></tr>
- * <tr><td>-0.0635</td><td>-63.5E-3</td><td>-63.5E-3</td></tr>
- * <tr><td>510.751</td><td>510.751</td><td>510.8</td></tr>
- * <tr><td>-123456.0</td><td>-123.456E3</td><td>-123.5E3</td></tr>
- * <tr><td>4.20785E7</td><td>42.0785E6</td><td>42.08E6</td></tr>
- * </table>
- * @param maxPrecision Maximum number of significant decimal digits in strings produced by the returned formatter.
- * Numbers are rounded as necessary so that the number of significant digits does not exceed this value. A
- * value of {@code 0} indicates no maximum precision.
- * @return double format function
- */
- public static DoubleFunction<String> createEngineering(final int maxPrecision) {
- return createEngineering(maxPrecision, MIN_DOUBLE_EXPONENT);
- }
-
- /** Return a double format function that produces strings in
- * <a href="https://en.wikipedia.org/wiki/Engineering_notation">engineering notation</a>, where exponents
- * are adjusted to be multiples of 3. Exponents of zero are not included in formatted strings. Rounding is
- * performed using {@link java.math.RoundingMode#HALF_EVEN half even} rounding.
- * <table>
- * <caption>Format Examples</caption>
- * <tr><th>Value</th><th>(maxPrecision= 0, minExponent= -2)</th><th>(maxPrecision= 4, minExponent= -2)</th></tr>
- * <tr><td>1.0E-4</td><td>0.0</td><td>0.0</td></tr>
- * <tr><td>-0.0635</td><td>-60.0E-3</td><td>-60.0E-3</td></tr>
- * <tr><td>510.751</td><td>510.75</td><td>510.8</td></tr>
- * <tr><td>-123456.0</td><td>-123.456E3</td><td>-123.5E3</td></tr>
- * <tr><td>4.20785E7</td><td>42.0785E6</td><td>42.08E6</td></tr>
- * </table>
- * @param maxPrecision Maximum number of significant decimal digits in strings produced by the returned formatter.
- * Numbers are rounded as necessary so that the number of significant digits does not exceed this value. A
- * value of {@code 0} indicates no maximum precision.
- * @param minExponent Minimum decimal exponent in strings produced by the returned formatter.
- * @return double format function
- */
- public static DoubleFunction<String> createEngineering(final int maxPrecision, final int minExponent) {
- return new EngineeringFormat(maxPrecision, minExponent);
- }
-
- /** Base class for standard double formatting classes.
- */
- private abstract static class AbstractFormat implements DoubleFunction<String> {
-
- /** Maximum precision to use when formatting values. */
- private final int maxPrecision;
-
- /** The minimum exponent to allow in the result. Value with exponents less than this are
- * rounded to positive zero.
- */
- private final int minExponent;
-
- /** Construct a new instance with the given maximum precision and minimum exponent.
- * @param maxPrecision maximum number of significant decimal digits
- * @param minExponent minimum decimal exponent; values less than this that do not round up
- * are considered to be zero
- * @throws IllegalArgumentException if {@code maxPrecision} is less than zero
- */
- AbstractFormat(final int maxPrecision, final int minExponent) {
- if (maxPrecision < 0) {
- throw new IllegalArgumentException(
- "Max precision must be greater than or equal to zero; was " + maxPrecision);
- }
-
- this.maxPrecision = maxPrecision;
- this.minExponent = minExponent;
- }
-
- /** {@inheritDoc} */
- @Override
- public String apply(final double d) {
- if (Double.isFinite(d)) {
- final ParsedDouble n = ParsedDouble.from(d);
-
- int roundExponent = Math.max(n.getExponent(), minExponent);
- if (maxPrecision > 0) {
- roundExponent = Math.max(n.getScientificExponent() - maxPrecision + 1, roundExponent);
- }
-
- final ParsedDouble rounded = n.round(roundExponent);
-
- return formatInternal(rounded);
- }
-
- return Double.toString(d); // NaN or infinite; use default Double toString() method
- }
-
- /** Format the given parsed double value.
- * @param val value to format
- * @return formatted double value
- */
- protected abstract String formatInternal(ParsedDouble val);
- }
-
- /** Format class that produces plain decimal strings that do not use
- * scientific notation.
- */
- private static class PlainFormat extends AbstractFormat {
-
- /** Construct a new instance with the given maximum precision and minimum exponent.
- * @param maxPrecision maximum number of significant decimal digits
- * @param minExponent minimum decimal exponent; values less than this that do not round up
- * are considered to be zero
- * @throws IllegalArgumentException if {@code maxPrecision} is less than zero
- */
- PlainFormat(final int maxPrecision, final int minExponent) {
- super(maxPrecision, minExponent);
- }
-
- /** {@inheritDoc} */
- @Override
- protected String formatInternal(final ParsedDouble val) {
- return val.toPlainString(true);
- }
- }
-
- /** Format class producing results similar to {@link Double#toString()}, with
- * plain decimal notation for small numbers relatively close to zero and scientific
- * notation otherwise.
- */
- private static class DefaultFormat extends AbstractFormat {
-
- /** Decimal exponent upper bound for use of plain formatted strings. */
- private static final int UPPER_PLAIN_EXP = 7;
-
- /** Decimal exponent lower bound for use of plain formatted strings. */
- private static final int LOWER_PLAIN_EXP = -4;
-
- /** Construct a new instance with the given maximum precision and minimum exponent.
- * @param maxPrecision maximum number of significant decimal digits
- * @param minExponent minimum decimal exponent; values less than this that do not round up
- * are considered to be zero
- * @throws IllegalArgumentException if {@code maxPrecision} is less than zero
- */
- DefaultFormat(final int maxPrecision, final int minExponent) {
- super(maxPrecision, minExponent);
- }
-
- /** {@inheritDoc} */
- @Override
- protected String formatInternal(final ParsedDouble val) {
- final int sciExp = val.getScientificExponent();
- return sciExp < UPPER_PLAIN_EXP && sciExp > LOWER_PLAIN_EXP ?
- val.toPlainString(true) :
- val.toScientificString(true);
- }
- }
-
- /** Format class that uses scientific notation for all values.
- */
- private static class ScientificFormat extends AbstractFormat {
-
- /** Construct a new instance with the given maximum precision and minimum exponent.
- * @param maxPrecision maximum number of significant decimal digits
- * @param minExponent minimum decimal exponent; values less than this that do not round up
- * are considered to be zero
- * @throws IllegalArgumentException if {@code maxPrecision} is less than zero
- */
- ScientificFormat(final int maxPrecision, final int minExponent) {
- super(maxPrecision, minExponent);
- }
-
- /** {@inheritDoc} */
- @Override
- public String formatInternal(final ParsedDouble val) {
- return val.toScientificString(true);
- }
- }
-
- /** Format class that uses engineering notation for all values.
- */
- private static class EngineeringFormat extends AbstractFormat {
-
- /** Construct a new instance with the given maximum precision and minimum exponent.
- * @param maxPrecision maximum number of significant decimal digits
- * @param minExponent minimum decimal exponent; values less than this that do not round up
- * are considered to be zero
- * @throws IllegalArgumentException if {@code maxPrecision} is less than zero
- */
- EngineeringFormat(final int maxPrecision, final int minExponent) {
- super(maxPrecision, minExponent);
- }
-
- /** {@inheritDoc} */
- @Override
- public String formatInternal(final ParsedDouble val) {
- return val.toEngineeringString(true);
- }
- }
-}
diff --git a/commons-geometry-io-core/src/main/java/org/apache/commons/geometry/io/core/utils/ParsedDouble.java b/commons-geometry-io-core/src/main/java/org/apache/commons/geometry/io/core/utils/ParsedDouble.java
deleted file mode 100644
index d6d4057..0000000
--- a/commons-geometry-io-core/src/main/java/org/apache/commons/geometry/io/core/utils/ParsedDouble.java
+++ /dev/null
@@ -1,514 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.geometry.io.core.utils;
-
-/** Simple class representing a double value parsed into separate decimal components. Each double
- * is represented with
- * <ul>
- * <li>a boolean flag for the sign,</li>
- * <li> a sequence of the digits '0' - '10' representing an unsigned integer with leading and trailing zeros
- * removed, and</li>
- * <li>an exponent value that when applied to the base 10 digits produces a floating point value with the
- * correct magnitude.</li>
- * </ul>
- * <p><strong>Examples</strong></p>
- * <table>
- * <tr><th>Double</th><th>Negative</th><th>Digits</th><th>Exponent</th></tr>
- * <tr><td>0.0</td><td>false</td><td>"0"</td><td>0</td></tr>
- * <tr><td>1.2</td><td>false</td><td>"12"</td><td>-1</td></tr>
- * <tr><td>-0.00971</td><td>true</td><td>"971"</td><td>-5</td></tr>
- * <tr><td>56300</td><td>true</td><td>"563"</td><td>2</td></tr>
- * </table>
- */
-final class ParsedDouble {
-
- /** Minus sign character. */
- private static final char MINUS_CHAR = '-';
-
- /** Plus sign character. */
- private static final char PLUS_CHAR = '+';
-
- /** Decimal separator character. */
- private static final char DECIMAL_SEP_CHAR = '.';
-
- /** Exponent character. */
- private static final char EXPONENT_CHAR = 'E';
-
- /** Zero digit character. */
- private static final char ZERO_CHAR = '0';
-
- /** One digit character. */
- private static final char ONE_CHAR = '1';
-
- /** String containing the decimal digits '0' - '9' in sequence. */
- private static final String DECIMAL_DIGITS = "0123456789";
-
- /** Initial size to use for string builder instances. */
- private static final int INITIAL_STR_BUILDER_SIZE = 32;
-
- /** Shared instance representing the positive zero double value. */
- private static final ParsedDouble POS_ZERO = new ParsedDouble(false, String.valueOf(ZERO_CHAR), 0);
-
- /** Shared instance representing the negative zero double value. */
- private static final ParsedDouble NEG_ZERO = new ParsedDouble(true, String.valueOf(ZERO_CHAR), 0);
-
- /** True if the value is negative. */
- private final boolean negative;
-
- /** String containing the significant base-10 digits for the value. */
- private final String digits;
-
- /** Exponent for the value. */
- private final int exponent;
-
- /** Construct a new instance from its parts.
- * @param negative true if the value is negative
- * @param digits string containing significant digits
- * @param exponent exponent value
- */
- ParsedDouble(final boolean negative, final String digits, final int exponent) {
- this.negative = negative;
- this.digits = digits;
- this.exponent = exponent;
- }
-
- /** Return true if the value is negative.
- * @return true if the value is negative
- */
- public boolean isNegative() {
- return negative;
- }
-
- /** Get a string containing the significant digits of the value. If the value is
- * {@code 0}, then the returned string is {@code "0"}. Otherwise, the string contains
- * one or more characters with the first and last characters not equal to {@code '0'}.
- * @return string containing the significant digits of the value
- */
- public String getDigits() {
- return digits;
- }
-
- /** Get the exponent value. This exponent produces a floating point value with the
- * correct magnitude when applied to the unsigned integer represented by the {@link #getDigits() digit}
- * string.
- * @return exponent value
- */
- public int getExponent() {
- return exponent;
- }
-
- /** Return true if the value is equal to zero. The sign field is ignored,
- * meaning that this method will return true for both {@code +0} and {@code -0}.
- * @return true if the value is equal to zero
- */
- public boolean isZero() {
- return getPrecision() == 1 && digits.charAt(0) == ZERO_CHAR;
- }
-
- /** Return the precision of this instance, meaning the number of significant decimal
- * digits in the representation.
- * @return the precision of this instance
- */
- public int getPrecision() {
- return digits.length();
- }
-
- /** Get the exponent that would be used when representing this number in scientific
- * notation (i.e., with a single non-zero digit in front of the decimal point.
- * @return the exponent that would be used when representing this number in scientific
- * notation
- */
- public int getScientificExponent() {
- return getPrecision() + exponent - 1;
- }
-
- /** Round the instance to the given decimal exponent position using
- * {@link java.math.RoundingMode#HALF_EVEN half-even rounding}. For example, a value of {@code -2}
- * will round the instance to the digit at the position 10<sup>-2</sup> (i.e. to the closest multiple of 0.01).
- * A new instance is returned if the rounding operation results in a new value.
- * @param roundExponent exponent defining the decimal place to round to
- * @return result of the rounding operation
- */
- public ParsedDouble round(final int roundExponent) {
- if (roundExponent > exponent) {
- final int precision = getPrecision();
- final int max = precision + exponent;
-
- if (roundExponent < max) {
- return maxPrecision(max - roundExponent);
- } else if (roundExponent == max && shouldRoundUp(0)) {
- return new ParsedDouble(negative, "1", roundExponent);
- }
-
- return POS_ZERO;
- }
-
- return this;
- }
-
- /** Return the value as close as possible to this instance with <em>at most</em> the given number
- * of significant digits (i.e. precision). If this instance already has a precision less than or equal
- * to the argument, it is returned directly. If the given precision requires a reduction in the number
- * of digits, then the value is rounded using {@link java.math.RoundingMode#HALF_EVEN half-even rounding}
- * and a new instance is returned with the rounded value.
- * @param precision maximum number of significant digits to include
- * @return the instance as close as possible to this value with at most the given number of
- * significant digits
- * @throws IllegalArgumentException if {@code precision} is less than 1
- */
- public ParsedDouble maxPrecision(final int precision) {
- if (precision < 1) {
- throw new IllegalArgumentException("Precision must be greater than zero; was " + precision);
- }
-
- final int currentPrecision = getPrecision();
- if (currentPrecision > precision) {
- // we need to round to reduce the number of digits
- String resultDigits = shouldRoundUp(precision) ?
- addOne(digits, precision) :
- digits.substring(0, precision);
-
- // compute the initial result exponent
- int resultExponent = exponent + (currentPrecision - precision);
-
- // remove zeros from the end of the integer if present, adjusting the
- // exponent as needed
- final int lastNonZeroIdx = findLastNonZero(resultDigits);
- if (lastNonZeroIdx < resultDigits.length() - 1) {
- resultExponent += resultDigits.length() - 1 - lastNonZeroIdx;
- resultDigits = resultDigits.substring(0, lastNonZeroIdx + 1);
- }
-
- return new ParsedDouble(negative, resultDigits, resultExponent);
- }
-
- return this; // no change needed
- }
-
- /** Return a string representation of the value with no exponent field. Ex:
- * <pre>
- * 10 = "10.0"
- * 1e-6 = "0.000001"
- * 1e11 = "100000000000.0"
- * </pre>
- * @param includeDecimalPlaceholder if true, then the returned string will contain
- * the decimal placeholder ".0" when no fractional value is present, similar
- * to {@link Double#toString(double)}
- * @return a string representation of the value with no exponent field
- */
- public String toPlainString(final boolean includeDecimalPlaceholder) {
- final int precision = getPrecision();
-
- final StringBuilder sb = new StringBuilder(INITIAL_STR_BUILDER_SIZE);
- if (negative) {
- sb.append(MINUS_CHAR);
- }
-
- if (exponent < 0) {
- final int diff = precision + exponent;
-
- // add whole digits, using a beginning placeholder zero if
- // needed
- int i;
- for (i = 0; i < diff; ++i) {
- sb.append(digits.charAt(i));
- }
- if (i == 0) {
- sb.append(ZERO_CHAR);
- }
-
- // decimal separator
- sb.append(DECIMAL_SEP_CHAR);
-
- // add placeholder fraction zeros if needed
- for (int j = 0; j > diff; --j) {
- sb.append(ZERO_CHAR);
- }
-
- // fraction digits
- sb.append(digits, i, precision);
- } else {
- sb.append(digits);
-
- for (int i = 0; i < exponent; ++i) {
- sb.append(ZERO_CHAR);
- }
-
- if (includeDecimalPlaceholder) {
- sb.append(DECIMAL_SEP_CHAR)
- .append(ZERO_CHAR);
- }
- }
-
- return sb.toString();
- }
-
- /** Return a string representation of the value in scientific notation. If the exponent field
- * is equal to zero, it is not included in the result. Ex:
- * <pre>
- * 0 = "0.0"
- * 10 = "1.0E1"
- * 1e-6 = "1.0E-6"
- * 1e11 = "1.0E11"
- * </pre>
- * @param includeDecimalPlaceholder if true, then the returned string will contain
- * the decimal placeholder ".0" when no fractional value is present, similar
- * to {@link Double#toString(double)}
- * @return a string representation of the value in scientific notation
- */
- public String toScientificString(final boolean includeDecimalPlaceholder) {
- return toScientificString(1, includeDecimalPlaceholder);
- }
-
- /** Return a string representation of the value in engineering notation. This is similar
- * to {@link #toScientificString(boolean) scientific notation} but with the exponent forced
- * to be a multiple of 3, allowing easier alignment with SI prefixes. If the exponent field
- * is equal to zero, it is not included in the result.
- * <pre>
- * 0 = "0.0"
- * 10 = "10.0"
- * 1e-6 = "1.0E-6"
- * 1e11 = "100.0E9"
- * </pre>
- * @param includeDecimalPlaceholder if true, then the returned string will contain
- * the decimal placeholder ".0" when no fractional value is present, similar
- * to {@link Double#toString(double)}
- * @return a string representation of the value in engineering notation
- */
- public String toEngineeringString(final boolean includeDecimalPlaceholder) {
- final int wholeDigits = 1 + Math.floorMod(getPrecision() + exponent - 1, 3);
- return toScientificString(wholeDigits, includeDecimalPlaceholder);
- }
-
- /** Return a string representation of the value in scientific notation using the
- * given number of whole digits. If the exponent field of the result is zero, it
- * is not included in the returned string.
- * @param wholeDigits number of whole digits to use in the output
- * @param includeDecimalPlaceholder if true, then the returned string will contain
- * the decimal placeholder ".0" when no fractional value is present, similar
- * to {@link Double#toString(double)}
- * @return a string representation of the value in scientific notation using the
- * given number of whole digits
- */
- private String toScientificString(final int wholeDigits, final boolean includeDecimalPlaceholder) {
- final int precision = getPrecision();
-
- final StringBuilder sb = new StringBuilder(INITIAL_STR_BUILDER_SIZE);
- if (negative) {
- sb.append(MINUS_CHAR);
- }
-
- if (precision <= wholeDigits) {
- // not enough digits to meet the requested number of whole digits;
- // we'll need to pad with zeros
- sb.append(digits);
-
- for (int i = precision; i < wholeDigits; ++i) {
- sb.append(ZERO_CHAR);
- }
-
- if (includeDecimalPlaceholder) {
- sb.append(DECIMAL_SEP_CHAR)
- .append(ZERO_CHAR);
- }
- } else {
- // we'll need a fractional portion
- sb.append(digits, 0, wholeDigits)
- .append(DECIMAL_SEP_CHAR)
- .append(digits, wholeDigits, precision);
- }
-
- // add the exponent but only if non-zero
- final int resultExponent = exponent + precision - wholeDigits;
- if (resultExponent != 0) {
- sb.append(EXPONENT_CHAR)
- .append(resultExponent);
- }
-
- return sb.toString();
- }
-
- /** Return true if a rounding operation at the given index should round up.
- * @param idx index of the digit to round; must be a valid index into {@code digits}
- * @return true if a rounding operation at the given index should round up
- */
- private boolean shouldRoundUp(final int idx) {
- // Round up in the following cases:
- // 1. The digit at the index is greater than 5.
- // 2. The digit at the index is 5 and there are additional (non-zero)
- // digits after it.
- // 3. The digit is 5, there are no additional digits afterward,
- // and the digit before it is odd (half-even rounding).
- final int precision = getPrecision();
- final int roundValue = digitValue(digits.charAt(idx));
-
- return roundValue > 5 || (roundValue == 5 &&
- (idx < precision - 1 || (idx > 0 && digitValue(digits.charAt(idx - 1)) % 2 != 0)));
- }
-
- /** Construct a new instance from the given double value.
- * @param d double value
- * @return a new instance containing the parsed components of the given double value
- * @throws IllegalArgumentException if {@code d} is {@code NaN} or infinite
- */
- public static ParsedDouble from(final double d) {
- if (!Double.isFinite(d)) {
- throw new IllegalArgumentException("Double is not finite");
- }
-
- final String str = Double.toString(d);
- final char[] strChars = str.toCharArray();
-
- // extract the different portions of the string representation
- // (since double is finite, str is guaranteed to not be empty and to contain a
- // single decimal point according to the Double.toString() API)
- final boolean negative = strChars[0] == MINUS_CHAR;
- final int digitStartIdx = negative ? 1 : 0;
-
- final char[] digitChars = new char[strChars.length];
-
- int decimalSepIdx = -1;
- int exponentIdx = -1;
- int digitCount = 0;
- int firstNonZeroDigitIdx = -1;
- int lastNonZeroDigitIdx = -1;
-
- for (int i = digitStartIdx; i < strChars.length; ++i) {
- final char ch = strChars[i];
-
- if (ch == DECIMAL_SEP_CHAR) {
- decimalSepIdx = i;
- } else if (ch == EXPONENT_CHAR) {
- exponentIdx = i;
- } else if (exponentIdx < 0) {
- // this is a significand digit
- if (ch != ZERO_CHAR) {
- if (firstNonZeroDigitIdx < 0) {
- firstNonZeroDigitIdx = digitCount;
- }
- lastNonZeroDigitIdx = digitCount;
- }
-
- digitChars[digitCount++] = ch;
- }
- }
-
- if (firstNonZeroDigitIdx > -1) {
- // determine the exponent
- final int explicitExponent = exponentIdx > -1 ?
- parseExponent(str, exponentIdx + 1) :
- 0;
- final int exponent = explicitExponent + decimalSepIdx - digitStartIdx - lastNonZeroDigitIdx - 1;
-
- // get the digit string without any leading or trailing zeros
- final String digits = String.valueOf(
- digitChars,
- firstNonZeroDigitIdx,
- lastNonZeroDigitIdx - firstNonZeroDigitIdx + 1);
-
- return new ParsedDouble(negative, digits, exponent);
- }
-
- // no non-zero digits, so value is zero
- return negative ?
- NEG_ZERO :
- POS_ZERO;
- }
-
- /** Parse a double exponent value from {@code seq}, starting at the {@code start}
- * index and continuing through the end of the sequence.
- * @param seq sequence to part a double exponent value from
- * @param start start index
- * @return parsed exponent value
- */
- private static int parseExponent(final CharSequence seq, final int start) {
- int exp = 0;
- boolean neg = false;
-
- final int len = seq.length();
- for (int i = start; i < len; ++i) {
- final char ch = seq.charAt(i);
- if (ch == MINUS_CHAR) {
- neg = !neg;
- } else if (ch != PLUS_CHAR) {
- exp = (exp * 10) + digitValue(ch);
- }
- }
-
- return neg ? -exp : exp;
- }
-
- /** Return the index of the last character in the argument not equal
- * to {@code '0'} or {@code -1} if no such character can be found.
- * @param seq sequence to search
- * @return the index of the last non-zero character or {@code -1} if not found
- */
- private static int findLastNonZero(final CharSequence seq) {
- int i;
- char ch;
- for (i = seq.length() - 1; i >= 0; --i) {
- ch = seq.charAt(i);
- if (ch != ZERO_CHAR) {
- break;
- }
- }
-
- return i;
- }
-
- /** Get the numeric value of the given digit character. No validation of the
- * character type is performed.
- * @param ch digit character
- * @return numeric value of the digit character, ex: '1' = 1
- */
- private static int digitValue(final char ch) {
- return ch - ZERO_CHAR;
- }
-
- /** Add one to the value of the integer represented by the substring of length {@code len}
- * starting at index {@code 0}, returning the result as another string. The input is assumed
- * to contain only digit characters
- * (i.e. '0' - '9'). No validation is performed.
- * @param digitStr string containing a representation of an integer
- * @param len number of characters to use from {@code str}
- * @return string representation of the result of adding 1 to the integer represented
- * by the input substring
- */
- private static String addOne(final String digitStr, final int len) {
- final char[] resultChars = new char[len + 1];
-
- boolean carrying = true;
- for (int i = len - 1; i >= 0; --i) {
- final char inChar = digitStr.charAt(i);
- final char outChar = carrying ?
- DECIMAL_DIGITS.charAt((digitValue(inChar) + 1) % DECIMAL_DIGITS.length()) :
- inChar;
- resultChars[i + 1] = outChar;
-
- if (carrying && outChar != ZERO_CHAR) {
- carrying = false;
- }
- }
-
- if (carrying) {
- resultChars[0] = ONE_CHAR;
- return String.valueOf(resultChars);
- }
-
- return String.valueOf(resultChars, 1, len);
- }
-}
diff --git a/commons-geometry-io-core/src/test/java/org/apache/commons/geometry/io/core/utils/AbstractTextFormatWriterTest.java b/commons-geometry-io-core/src/test/java/org/apache/commons/geometry/io/core/utils/AbstractTextFormatWriterTest.java
index 316804a..5f9516f 100644
--- a/commons-geometry-io-core/src/test/java/org/apache/commons/geometry/io/core/utils/AbstractTextFormatWriterTest.java
+++ b/commons-geometry-io-core/src/test/java/org/apache/commons/geometry/io/core/utils/AbstractTextFormatWriterTest.java
@@ -19,6 +19,9 @@ package org.apache.commons.geometry.io.core.utils;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.util.Locale;
import java.util.function.DoubleFunction;
import org.apache.commons.geometry.io.core.test.CloseCountWriter;
@@ -35,7 +38,7 @@ class AbstractTextFormatWriterTest {
try (TestWriter writer = new TestWriter(out)) {
// assert
Assertions.assertEquals("\n", writer.getLineSeparator());
- Assertions.assertSame(DoubleFormats.DOUBLE_TO_STRING, writer.getDoubleFormat());
+ Assertions.assertNotNull(writer.getDoubleFormat());
Assertions.assertSame(out, writer.getWriter());
}
}
@@ -71,7 +74,9 @@ class AbstractTextFormatWriterTest {
writer.setLineSeparator("\r\n");
- final DoubleFunction<String> df = DoubleFormats.createPlain(0, -2);
+ final DecimalFormat fmt = new DecimalFormat("0.00", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
+
+ final DoubleFunction<String> df = fmt::format;
writer.setDoubleFormat(df);
// act
diff --git a/commons-geometry-io-core/src/test/java/org/apache/commons/geometry/io/core/utils/DoubleFormatsTest.java b/commons-geometry-io-core/src/test/java/org/apache/commons/geometry/io/core/utils/DoubleFormatsTest.java
deleted file mode 100644
index ce1ad2d..0000000
--- a/commons-geometry-io-core/src/test/java/org/apache/commons/geometry/io/core/utils/DoubleFormatsTest.java
+++ /dev/null
@@ -1,894 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.geometry.io.core.utils;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.function.BiFunction;
-import java.util.function.DoubleFunction;
-import java.util.function.IntFunction;
-
-import org.apache.commons.geometry.core.GeometryTestUtils;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.Test;
-
-class DoubleFormatsTest {
-
- private static final double[] EXAMPLE_VALUES = {
- 0.0001, -0.0635, 510.751, -123456.0, 42078500.0
- };
-
- @Test
- void testDoubleToString() {
- // arrange
- final DoubleFunction<String> fmt = DoubleFormats.DOUBLE_TO_STRING;
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "1.0E-5");
- checkFormat(fmt, -0.0001, "-1.0E-4");
- checkFormat(fmt, 0.001, "0.001");
- checkFormat(fmt, -0.01, "-0.01");
- checkFormat(fmt, 0.1, "0.1");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "10.0");
- checkFormat(fmt, -100.0, "-100.0");
- checkFormat(fmt, 1000.0, "1000.0");
- checkFormat(fmt, -10000.0, "-10000.0");
- checkFormat(fmt, 100000.0, "100000.0");
- checkFormat(fmt, -1000000.0, "-1000000.0");
- checkFormat(fmt, 10000000.0, "1.0E7");
- checkFormat(fmt, -100000000.0, "-1.0E8");
-
- checkFormat(fmt, 0.5 * Float.MAX_VALUE, "1.7014117331926443E38");
- checkFormat(fmt, -1.0 / 1.9175e20, "-5.2151238591916555E-21");
-
- checkFormat(fmt, Double.MAX_VALUE, "1.7976931348623157E308");
- checkFormat(fmt, Double.MIN_VALUE, "4.9E-324");
- checkFormat(fmt, Double.MIN_NORMAL, "2.2250738585072014E-308");
- checkFormat(fmt, Math.PI, "3.141592653589793");
- checkFormat(fmt, Math.E, "2.718281828459045");
- }
-
- @Test
- void testFloatToString() {
- // arrange
- final DoubleFunction<String> fmt = DoubleFormats.FLOAT_TO_STRING;
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "1.0E-5");
- checkFormat(fmt, -0.0001, "-1.0E-4");
- checkFormat(fmt, 0.001, "0.001");
- checkFormat(fmt, -0.01, "-0.01");
- checkFormat(fmt, 0.1, "0.1");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "10.0");
- checkFormat(fmt, -100.0, "-100.0");
- checkFormat(fmt, 1000.0, "1000.0");
- checkFormat(fmt, -10000.0, "-10000.0");
- checkFormat(fmt, 100000.0, "100000.0");
- checkFormat(fmt, -1000000.0, "-1000000.0");
- checkFormat(fmt, 10000000.0, "1.0E7");
- checkFormat(fmt, -100000000.0, "-1.0E8");
-
- checkFormat(fmt, 0.5 * Float.MAX_VALUE, "1.7014117E38");
- checkFormat(fmt, -1.0 / 1.9175e20, "-5.2151238E-21");
-
- checkFormat(fmt, Double.MAX_VALUE, "Infinity");
- checkFormat(fmt, Double.MIN_VALUE, "0.0");
- checkFormat(fmt, Double.MIN_NORMAL, "0.0");
- checkFormat(fmt, Math.PI, "3.1415927");
- checkFormat(fmt, Math.E, "2.7182817");
- }
-
- @Test
- void testDefault_noPrecisionLimit_noMinExponent() {
- // arrange
- final int maxPrecision = 0;
-
- // act
- final DoubleFunction<String> fmt = DoubleFormats.createDefault(maxPrecision);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "1.0E-5");
- checkFormat(fmt, -0.0001, "-1.0E-4");
- checkFormat(fmt, 0.001, "0.001");
- checkFormat(fmt, -0.01, "-0.01");
- checkFormat(fmt, 0.1, "0.1");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "10.0");
- checkFormat(fmt, -100.0, "-100.0");
- checkFormat(fmt, 1000.0, "1000.0");
- checkFormat(fmt, -10000.0, "-10000.0");
- checkFormat(fmt, 100000.0, "100000.0");
- checkFormat(fmt, -1000000.0, "-1000000.0");
- checkFormat(fmt, 10000000.0, "1.0E7");
- checkFormat(fmt, -100000000.0, "-1.0E8");
-
- checkFormat(fmt, 1.25e-3, "0.00125");
- checkFormat(fmt, -9.975e-4, "-9.975E-4");
- checkFormat(fmt, -9_999_999, "-9999999.0");
- checkFormat(fmt, 1.00001e7, "1.00001E7");
-
- checkFormat(fmt, Double.MAX_VALUE, "1.7976931348623157E308");
- checkFormat(fmt, Double.MIN_VALUE, "4.9E-324");
- checkFormat(fmt, Double.MIN_NORMAL, "2.2250738585072014E-308");
- checkFormat(fmt, Math.PI, "3.141592653589793");
- checkFormat(fmt, Math.E, "2.718281828459045");
- }
-
- @Test
- void testDefault_noPrecisionLimit_withMinExponent() {
- // arrange
- final int maxPrecision = 0;
- final int minExponent = -3;
-
- final DoubleFunction<String> fmt = DoubleFormats.createDefault(maxPrecision, minExponent);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "0.0");
- checkFormat(fmt, -0.0001, "0.0");
- checkFormat(fmt, 0.001, "0.001");
- checkFormat(fmt, -0.01, "-0.01");
- checkFormat(fmt, 0.1, "0.1");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "10.0");
- checkFormat(fmt, -100.0, "-100.0");
- checkFormat(fmt, 1000.0, "1000.0");
- checkFormat(fmt, -10000.0, "-10000.0");
- checkFormat(fmt, 100000.0, "100000.0");
- checkFormat(fmt, -1000000.0, "-1000000.0");
- checkFormat(fmt, 10000000.0, "1.0E7");
- checkFormat(fmt, -100000000.0, "-1.0E8");
-
- checkFormat(fmt, 1.25e-3, "0.001");
- checkFormat(fmt, -9.975e-4, "-0.001");
- checkFormat(fmt, -9_999_999, "-9999999.0");
- checkFormat(fmt, 1.00001e7, "1.00001E7");
-
- checkFormat(fmt, Double.MAX_VALUE, "1.7976931348623157E308");
- checkFormat(fmt, Double.MIN_VALUE, "0.0");
- checkFormat(fmt, Double.MIN_NORMAL, "0.0");
- checkFormat(fmt, Math.PI, "3.142");
- checkFormat(fmt, Math.E, "2.718");
- }
-
- @Test
- void testDefault_withPrecisionLimit_noMinExponent() {
- // arrange
- final int maxPrecision = 4;
- final int minExponent = Integer.MIN_VALUE;
-
- final DoubleFunction<String> fmt = DoubleFormats.createDefault(maxPrecision, minExponent);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "1.0E-5");
- checkFormat(fmt, -0.0001, "-1.0E-4");
- checkFormat(fmt, 0.001, "0.001");
- checkFormat(fmt, -0.01, "-0.01");
- checkFormat(fmt, 0.1, "0.1");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "10.0");
- checkFormat(fmt, -100.0, "-100.0");
- checkFormat(fmt, 1000.0, "1000.0");
- checkFormat(fmt, -10000.0, "-10000.0");
- checkFormat(fmt, 100000.0, "100000.0");
- checkFormat(fmt, -1000000.0, "-1000000.0");
- checkFormat(fmt, 10000000.0, "1.0E7");
- checkFormat(fmt, -100000000.0, "-1.0E8");
-
- checkFormat(fmt, 12345.01, "12350.0");
- checkFormat(fmt, 1.2345, "1.234");
-
- checkFormat(fmt, 1.25e-3, "0.00125");
- checkFormat(fmt, -9.975e-4, "-9.975E-4");
- checkFormat(fmt, -9_999_999, "-1.0E7");
- checkFormat(fmt, 1.00001e7, "1.0E7");
-
- checkFormat(fmt, Double.MAX_VALUE, "1.798E308");
- checkFormat(fmt, Double.MIN_VALUE, "4.9E-324");
- checkFormat(fmt, Double.MIN_NORMAL, "2.225E-308");
- checkFormat(fmt, Math.PI, "3.142");
- checkFormat(fmt, Math.E, "2.718");
- }
-
- @Test
- void testDefault_withPrecisionLimit_withMinExponent() {
- // arrange
- final int maxPrecision = 3;
- final int minExponent = -3;
-
- final DoubleFunction<String> fmt = DoubleFormats.createDefault(maxPrecision, minExponent);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "0.0");
- checkFormat(fmt, -0.0001, "0.0");
- checkFormat(fmt, 0.001, "0.001");
- checkFormat(fmt, -0.01, "-0.01");
- checkFormat(fmt, 0.1, "0.1");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "10.0");
- checkFormat(fmt, -100.0, "-100.0");
- checkFormat(fmt, 1000.0, "1000.0");
- checkFormat(fmt, -10000.0, "-10000.0");
- checkFormat(fmt, 100000.0, "100000.0");
- checkFormat(fmt, -1000000.0, "-1000000.0");
- checkFormat(fmt, 10000000.0, "1.0E7");
- checkFormat(fmt, -100000000.0, "-1.0E8");
-
- checkFormat(fmt, 1.25e-3, "0.001");
- checkFormat(fmt, -9.975e-4, "-0.001");
- checkFormat(fmt, -9_999_999, "-1.0E7");
- checkFormat(fmt, 1.00001e7, "1.0E7");
-
- checkFormat(fmt, Double.MAX_VALUE, "1.8E308");
- checkFormat(fmt, Double.MIN_VALUE, "0.0");
- checkFormat(fmt, Double.MIN_NORMAL, "0.0");
- checkFormat(fmt, Math.PI, "3.14");
- checkFormat(fmt, Math.E, "2.72");
- }
-
- @Test
- void testPlain_noPrecisionLimit_noMinExponent() {
- // arrange
- final int maxPrecision = 0;
-
- final DoubleFunction<String> fmt = DoubleFormats.createPlain(maxPrecision);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "0.00001");
- checkFormat(fmt, -0.0001, "-0.0001");
- checkFormat(fmt, 0.001, "0.001");
- checkFormat(fmt, -0.01, "-0.01");
- checkFormat(fmt, 0.1, "0.1");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "10.0");
- checkFormat(fmt, -100.0, "-100.0");
- checkFormat(fmt, 1000.0, "1000.0");
- checkFormat(fmt, -10000.0, "-10000.0");
- checkFormat(fmt, 100000.0, "100000.0");
- checkFormat(fmt, -1000000.0, "-1000000.0");
- checkFormat(fmt, 10000000.0, "10000000.0");
- checkFormat(fmt, -100000000.0, "-100000000.0");
-
- checkFormat(fmt, 1.25e-3, "0.00125");
- checkFormat(fmt, -9.975e-4, "-0.0009975");
- checkFormat(fmt, -9_999_999, "-9999999.0");
- checkFormat(fmt, 1.00001e7, "10000100.0");
-
- checkFormat(fmt, Float.MAX_VALUE, "340282346638528860000000000000000000000.0");
- checkFormat(fmt, Float.MIN_VALUE, "0.000000000000000000000000000000000000000000001401298464324817");
- checkFormat(fmt, Float.MIN_NORMAL, "0.000000000000000000000000000000000000011754943508222875");
- checkFormat(fmt, Math.PI, "3.141592653589793");
- checkFormat(fmt, Math.E, "2.718281828459045");
- }
-
- @Test
- void testPlain_noPrecisionLimit_withMinExponent() {
- // arrange
- final int maxPrecision = 0;
- final int minExponent = -2;
-
- final DoubleFunction<String> fmt = DoubleFormats.createPlain(maxPrecision, minExponent);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "0.0");
- checkFormat(fmt, -0.0001, "0.0");
- checkFormat(fmt, 0.001, "0.0");
- checkFormat(fmt, -0.01, "-0.01");
- checkFormat(fmt, 0.1, "0.1");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "10.0");
- checkFormat(fmt, -100.0, "-100.0");
- checkFormat(fmt, 1000.0, "1000.0");
- checkFormat(fmt, -10000.0, "-10000.0");
- checkFormat(fmt, 100000.0, "100000.0");
- checkFormat(fmt, -1000000.0, "-1000000.0");
- checkFormat(fmt, 10000000.0, "10000000.0");
- checkFormat(fmt, -100000000.0, "-100000000.0");
-
- checkFormat(fmt, 1.25e-3, "0.0");
- checkFormat(fmt, -9.975e-4, "0.0");
- checkFormat(fmt, -9_999_999, "-9999999.0");
- checkFormat(fmt, 1.00001e7, "10000100.0");
-
- checkFormat(fmt, Float.MAX_VALUE, "340282346638528860000000000000000000000.0");
- checkFormat(fmt, Float.MIN_VALUE, "0.0");
- checkFormat(fmt, Float.MIN_NORMAL, "0.0");
- checkFormat(fmt, Math.PI, "3.14");
- checkFormat(fmt, Math.E, "2.72");
- }
-
- @Test
- void testPlain_withPrecisionLimit_noMinExponent() {
- // arrange
- final int maxPrecision = 3;
- final int minExponent = Integer.MIN_VALUE;
-
- final DoubleFunction<String> fmt = DoubleFormats.createPlain(maxPrecision, minExponent);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "0.00001");
- checkFormat(fmt, -0.0001, "-0.0001");
- checkFormat(fmt, 0.001, "0.001");
- checkFormat(fmt, -0.01, "-0.01");
- checkFormat(fmt, 0.1, "0.1");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "10.0");
- checkFormat(fmt, -100.0, "-100.0");
- checkFormat(fmt, 1000.0, "1000.0");
- checkFormat(fmt, -10000.0, "-10000.0");
- checkFormat(fmt, 100000.0, "100000.0");
- checkFormat(fmt, -1000000.0, "-1000000.0");
- checkFormat(fmt, 10000000.0, "10000000.0");
- checkFormat(fmt, -100000000.0, "-100000000.0");
-
- checkFormat(fmt, 1.25e-3, "0.00125");
- checkFormat(fmt, -9.975e-4, "-0.000998");
- checkFormat(fmt, -9_999_999, "-10000000.0");
- checkFormat(fmt, 1.00001e7, "10000000.0");
-
- checkFormat(fmt, Float.MAX_VALUE, "340000000000000000000000000000000000000.0");
- checkFormat(fmt, Float.MIN_VALUE, "0.0000000000000000000000000000000000000000000014");
- checkFormat(fmt, Float.MIN_NORMAL, "0.0000000000000000000000000000000000000118");
- checkFormat(fmt, Math.PI, "3.14");
- checkFormat(fmt, Math.E, "2.72");
- }
-
- @Test
- void testPlain_withPrecisionLimit_withMinExponent() {
- // arrange
- final int maxPrecision = 4;
- final int minExponent = -2;
-
- final DoubleFunction<String> fmt = DoubleFormats.createPlain(maxPrecision, minExponent);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "0.0");
- checkFormat(fmt, -0.0001, "0.0");
- checkFormat(fmt, 0.001, "0.0");
- checkFormat(fmt, -0.01, "-0.01");
- checkFormat(fmt, 0.1, "0.1");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "10.0");
- checkFormat(fmt, -100.0, "-100.0");
- checkFormat(fmt, 1000.0, "1000.0");
- checkFormat(fmt, -10000.0, "-10000.0");
- checkFormat(fmt, 100000.0, "100000.0");
- checkFormat(fmt, -1000000.0, "-1000000.0");
- checkFormat(fmt, 10000000.0, "10000000.0");
- checkFormat(fmt, -100000000.0, "-100000000.0");
-
- checkFormat(fmt, 1.25e-3, "0.0");
- checkFormat(fmt, -9.975e-4, "0.0");
- checkFormat(fmt, -9_999_999, "-10000000.0");
- checkFormat(fmt, 1.00001e7, "10000000.0");
-
- checkFormat(fmt, Float.MAX_VALUE, "340300000000000000000000000000000000000.0");
- checkFormat(fmt, Float.MIN_VALUE, "0.0");
- checkFormat(fmt, Float.MIN_NORMAL, "0.0");
- checkFormat(fmt, Math.PI, "3.14");
- checkFormat(fmt, Math.E, "2.72");
- }
-
- @Test
- void testScientific_noPrecisionLimit_noMinExponent() {
- // arrange
- final int maxPrecision = 0;
-
- // act
- final DoubleFunction<String> fmt = DoubleFormats.createScientific(maxPrecision);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "1.0E-5");
- checkFormat(fmt, -0.0001, "-1.0E-4");
- checkFormat(fmt, 0.001, "1.0E-3");
- checkFormat(fmt, -0.01, "-1.0E-2");
- checkFormat(fmt, 0.1, "1.0E-1");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "1.0E1");
- checkFormat(fmt, -100.0, "-1.0E2");
- checkFormat(fmt, 1000.0, "1.0E3");
- checkFormat(fmt, -10000.0, "-1.0E4");
- checkFormat(fmt, 100000.0, "1.0E5");
- checkFormat(fmt, -1000000.0, "-1.0E6");
- checkFormat(fmt, 10000000.0, "1.0E7");
- checkFormat(fmt, -100000000.0, "-1.0E8");
-
- checkFormat(fmt, 1.25e-3, "1.25E-3");
- checkFormat(fmt, -9.975e-4, "-9.975E-4");
- checkFormat(fmt, -9_999_999, "-9.999999E6");
- checkFormat(fmt, 1.00001e7, "1.00001E7");
-
- checkFormat(fmt, Double.MAX_VALUE, "1.7976931348623157E308");
- checkFormat(fmt, Double.MIN_VALUE, "4.9E-324");
- checkFormat(fmt, Double.MIN_NORMAL, "2.2250738585072014E-308");
- checkFormat(fmt, Math.PI, "3.141592653589793");
- checkFormat(fmt, Math.E, "2.718281828459045");
- }
-
- @Test
- void testScientific_noPrecisionLimit_withMinExponent() {
- // arrange
- final int maxPrecision = 0;
- final int minExponent = -3;
-
- final DoubleFunction<String> fmt = DoubleFormats.createScientific(maxPrecision, minExponent);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "0.0");
- checkFormat(fmt, -0.0001, "0.0");
- checkFormat(fmt, 0.001, "1.0E-3");
- checkFormat(fmt, -0.01, "-1.0E-2");
- checkFormat(fmt, 0.1, "1.0E-1");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "1.0E1");
- checkFormat(fmt, -100.0, "-1.0E2");
- checkFormat(fmt, 1000.0, "1.0E3");
- checkFormat(fmt, -10000.0, "-1.0E4");
- checkFormat(fmt, 100000.0, "1.0E5");
- checkFormat(fmt, -1000000.0, "-1.0E6");
- checkFormat(fmt, 10000000.0, "1.0E7");
- checkFormat(fmt, -100000000.0, "-1.0E8");
-
- checkFormat(fmt, 1.25e-3, "1.0E-3");
- checkFormat(fmt, -9.975e-4, "-1.0E-3");
- checkFormat(fmt, -9_999_999, "-9.999999E6");
- checkFormat(fmt, 1.00001e7, "1.00001E7");
-
- checkFormat(fmt, Double.MAX_VALUE, "1.7976931348623157E308");
- checkFormat(fmt, Double.MIN_VALUE, "0.0");
- checkFormat(fmt, Double.MIN_NORMAL, "0.0");
- checkFormat(fmt, Math.PI, "3.142");
- checkFormat(fmt, Math.E, "2.718");
- }
-
- @Test
- void testScientific_withPrecisionLimit_noMinExponent() {
- // arrange
- final int maxPrecision = 3;
- final int minExponent = Integer.MIN_VALUE;
-
- final DoubleFunction<String> fmt = DoubleFormats.createScientific(maxPrecision, minExponent);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "1.0E-5");
- checkFormat(fmt, -0.0001, "-1.0E-4");
- checkFormat(fmt, 0.001, "1.0E-3");
- checkFormat(fmt, -0.01, "-1.0E-2");
- checkFormat(fmt, 0.1, "1.0E-1");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "1.0E1");
- checkFormat(fmt, -100.0, "-1.0E2");
- checkFormat(fmt, 1000.0, "1.0E3");
- checkFormat(fmt, -10000.0, "-1.0E4");
- checkFormat(fmt, 100000.0, "1.0E5");
- checkFormat(fmt, -1000000.0, "-1.0E6");
- checkFormat(fmt, 10000000.0, "1.0E7");
- checkFormat(fmt, -100000000.0, "-1.0E8");
-
- checkFormat(fmt, 12345.01, "1.23E4");
- checkFormat(fmt, 1.2345, "1.23");
-
- checkFormat(fmt, 1.25e-3, "1.25E-3");
- checkFormat(fmt, -9.975e-4, "-9.98E-4");
- checkFormat(fmt, -9_999_999, "-1.0E7");
- checkFormat(fmt, 1.00001e7, "1.0E7");
-
- checkFormat(fmt, Double.MAX_VALUE, "1.8E308");
- checkFormat(fmt, Double.MIN_VALUE, "4.9E-324");
- checkFormat(fmt, Double.MIN_NORMAL, "2.23E-308");
- checkFormat(fmt, Math.PI, "3.14");
- checkFormat(fmt, Math.E, "2.72");
- }
-
- @Test
- void testScientific_withPrecisionLimit_withMinExponent() {
- // arrange
- final int maxPrecision = 3;
- final int minExponent = -3;
-
- final DoubleFunction<String> fmt = DoubleFormats.createScientific(maxPrecision, minExponent);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "0.0");
- checkFormat(fmt, -0.0001, "0.0");
- checkFormat(fmt, 0.001, "1.0E-3");
- checkFormat(fmt, -0.01, "-1.0E-2");
- checkFormat(fmt, 0.1, "1.0E-1");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "1.0E1");
- checkFormat(fmt, -100.0, "-1.0E2");
- checkFormat(fmt, 1000.0, "1.0E3");
- checkFormat(fmt, -10000.0, "-1.0E4");
- checkFormat(fmt, 100000.0, "1.0E5");
- checkFormat(fmt, -1000000.0, "-1.0E6");
- checkFormat(fmt, 10000000.0, "1.0E7");
- checkFormat(fmt, -100000000.0, "-1.0E8");
-
- checkFormat(fmt, 1.25e-3, "1.0E-3");
- checkFormat(fmt, -9.975e-4, "-1.0E-3");
- checkFormat(fmt, -9_999_999, "-1.0E7");
- checkFormat(fmt, 1.00001e7, "1.0E7");
-
- checkFormat(fmt, Double.MAX_VALUE, "1.8E308");
- checkFormat(fmt, Double.MIN_VALUE, "0.0");
- checkFormat(fmt, Double.MIN_NORMAL, "0.0");
- checkFormat(fmt, Math.PI, "3.14");
- checkFormat(fmt, Math.E, "2.72");
- }
-
- @Test
- void testEngineering_noPrecisionLimit_noMinExponent() {
- // arrange
- final int maxPrecision = 0;
-
- // act
- final DoubleFunction<String> fmt = DoubleFormats.createEngineering(maxPrecision);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "10.0E-6");
- checkFormat(fmt, -0.0001, "-100.0E-6");
- checkFormat(fmt, 0.001, "1.0E-3");
- checkFormat(fmt, -0.01, "-10.0E-3");
- checkFormat(fmt, 0.1, "100.0E-3");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "10.0");
- checkFormat(fmt, -100.0, "-100.0");
- checkFormat(fmt, 1000.0, "1.0E3");
- checkFormat(fmt, -10000.0, "-10.0E3");
- checkFormat(fmt, 100000.0, "100.0E3");
- checkFormat(fmt, -1000000.0, "-1.0E6");
- checkFormat(fmt, 10000000.0, "10.0E6");
- checkFormat(fmt, -100000000.0, "-100.0E6");
-
- checkFormat(fmt, 1.25e-3, "1.25E-3");
- checkFormat(fmt, -9.975e-4, "-997.5E-6");
- checkFormat(fmt, -9_999_999, "-9.999999E6");
- checkFormat(fmt, 1.00001e7, "10.0001E6");
-
- checkFormat(fmt, Double.MAX_VALUE, "179.76931348623157E306");
- checkFormat(fmt, Double.MIN_VALUE, "4.9E-324");
- checkFormat(fmt, Double.MIN_NORMAL, "22.250738585072014E-309");
- checkFormat(fmt, Math.PI, "3.141592653589793");
- checkFormat(fmt, Math.E, "2.718281828459045");
- }
-
- @Test
- void testEngineering_noPrecisionLimit_withMinExponent() {
- // arrange
- final int maxPrecision = 0;
- final int minExponent = -3;
-
- final DoubleFunction<String> fmt = DoubleFormats.createEngineering(maxPrecision, minExponent);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "0.0");
- checkFormat(fmt, -0.0001, "0.0");
- checkFormat(fmt, 0.001, "1.0E-3");
- checkFormat(fmt, -0.01, "-10.0E-3");
- checkFormat(fmt, 0.1, "100.0E-3");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "10.0");
- checkFormat(fmt, -100.0, "-100.0");
- checkFormat(fmt, 1000.0, "1.0E3");
- checkFormat(fmt, -10000.0, "-10.0E3");
- checkFormat(fmt, 100000.0, "100.0E3");
- checkFormat(fmt, -1000000.0, "-1.0E6");
- checkFormat(fmt, 10000000.0, "10.0E6");
- checkFormat(fmt, -100000000.0, "-100.0E6");
-
- checkFormat(fmt, 1.25e-3, "1.0E-3");
- checkFormat(fmt, -9.975e-4, "-1.0E-3");
- checkFormat(fmt, -9_999_999, "-9.999999E6");
- checkFormat(fmt, 1.00001e7, "10.0001E6");
-
- checkFormat(fmt, Double.MAX_VALUE, "179.76931348623157E306");
- checkFormat(fmt, Double.MIN_VALUE, "0.0");
- checkFormat(fmt, Double.MIN_NORMAL, "0.0");
- checkFormat(fmt, Math.PI, "3.142");
- checkFormat(fmt, Math.E, "2.718");
- }
-
- @Test
- void testEngineering_withPrecisionLimit_noMinExponent() {
- // arrange
- final int maxPrecision = 3;
- final int minExponent = Integer.MIN_VALUE;
-
- final DoubleFunction<String> fmt = DoubleFormats.createEngineering(maxPrecision, minExponent);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "10.0E-6");
- checkFormat(fmt, -0.0001, "-100.0E-6");
- checkFormat(fmt, 0.001, "1.0E-3");
- checkFormat(fmt, -0.01, "-10.0E-3");
- checkFormat(fmt, 0.1, "100.0E-3");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "10.0");
- checkFormat(fmt, -100.0, "-100.0");
- checkFormat(fmt, 1000.0, "1.0E3");
- checkFormat(fmt, -10000.0, "-10.0E3");
- checkFormat(fmt, 100000.0, "100.0E3");
- checkFormat(fmt, -1000000.0, "-1.0E6");
- checkFormat(fmt, 10000000.0, "10.0E6");
- checkFormat(fmt, -100000000.0, "-100.0E6");
-
- checkFormat(fmt, 1.25e-3, "1.25E-3");
- checkFormat(fmt, -9.975e-4, "-998.0E-6");
- checkFormat(fmt, -9_999_999, "-10.0E6");
- checkFormat(fmt, 1.00001e7, "10.0E6");
-
- checkFormat(fmt, Double.MAX_VALUE, "180.0E306");
- checkFormat(fmt, Double.MIN_VALUE, "4.9E-324");
- checkFormat(fmt, Double.MIN_NORMAL, "22.3E-309");
- checkFormat(fmt, Math.PI, "3.14");
- checkFormat(fmt, Math.E, "2.72");
- }
-
- @Test
- void testEngineering_withPrecisionLimit_withMinExponent() {
- // arrange
- final int maxPrecision = 3;
- final int minExponent = -3;
-
- final DoubleFunction<String> fmt = DoubleFormats.createEngineering(maxPrecision, minExponent);
-
- // act/assert
- checkFormatSpecial(fmt);
-
- checkFormat(fmt, 0.00001, "0.0");
- checkFormat(fmt, -0.0001, "0.0");
- checkFormat(fmt, 0.001, "1.0E-3");
- checkFormat(fmt, -0.01, "-10.0E-3");
- checkFormat(fmt, 0.1, "100.0E-3");
- checkFormat(fmt, -0.0, "-0.0");
- checkFormat(fmt, 0.0, "0.0");
- checkFormat(fmt, -1.0, "-1.0");
- checkFormat(fmt, 10.0, "10.0");
- checkFormat(fmt, -100.0, "-100.0");
- checkFormat(fmt, 1000.0, "1.0E3");
- checkFormat(fmt, -10000.0, "-10.0E3");
- checkFormat(fmt, 100000.0, "100.0E3");
- checkFormat(fmt, -1000000.0, "-1.0E6");
- checkFormat(fmt, 10000000.0, "10.0E6");
- checkFormat(fmt, -100000000.0, "-100.0E6");
-
- checkFormat(fmt, 1.25e-3, "1.0E-3");
- checkFormat(fmt, -9.975e-4, "-1.0E-3");
- checkFormat(fmt, -9_999_999, "-10.0E6");
- checkFormat(fmt, 1.00001e7, "10.0E6");
-
- checkFormat(fmt, Double.MAX_VALUE, "180.0E306");
- checkFormat(fmt, Double.MIN_VALUE, "0.0");
- checkFormat(fmt, Double.MIN_NORMAL, "0.0");
- checkFormat(fmt, Math.PI, "3.14");
- checkFormat(fmt, Math.E, "2.72");
- }
-
- @Test
- void testPrecisionValidation() {
- // arrange
- final List<IntFunction<DoubleFunction<String>>> fns = Arrays.asList(
- DoubleFormats::createDefault,
- p -> DoubleFormats.createDefault(p, Integer.MIN_VALUE),
- DoubleFormats::createPlain,
- p -> DoubleFormats.createPlain(p, Integer.MIN_VALUE),
- DoubleFormats::createScientific,
- p -> DoubleFormats.createScientific(p, Integer.MIN_VALUE),
- DoubleFormats::createEngineering,
- p -> DoubleFormats.createEngineering(p, Integer.MIN_VALUE)
- );
-
- final String msg = "Max precision must be greater than or equal to zero; was -1";
-
- // act/assert
- for (final IntFunction<DoubleFunction<String>> fn : fns) {
- GeometryTestUtils.assertThrowsWithMessage(
- () -> fn.apply(-1),
- IllegalArgumentException.class, msg);
- }
- }
-
- /** Utility method used to generate the tables of format examples in the Javadocs.
- * This helps to ensure accuracy and consistency in the documentation. The HTML tables
- * are printed to a file and can then be copied into the correct locations in the source.
- * @throws IOException
- */
- // @Test
- public void generateExampleTables() throws IOException {
- final Path output = Paths.get("target/format-examples.txt");
-
- final List<String> lines = new ArrayList<>();
-
- lines.add("Default - one arg");
- lines.add(generateOneArgExamplesTable(DoubleFormats::createDefault));
-
- lines.add("Default - two arg");
- lines.add(generateTwoArgExamplesTable(DoubleFormats::createDefault));
-
- lines.add("Plain - one arg");
- lines.add(generateOneArgExamplesTable(DoubleFormats::createPlain));
-
- lines.add("Plain - two arg");
- lines.add(generateTwoArgExamplesTable(DoubleFormats::createPlain));
-
- lines.add("Scientific - one arg");
- lines.add(generateOneArgExamplesTable(DoubleFormats::createScientific));
-
- lines.add("Scientific - two arg");
- lines.add(generateTwoArgExamplesTable(DoubleFormats::createScientific));
-
- lines.add("Engineering - one arg");
- lines.add(generateOneArgExamplesTable(DoubleFormats::createEngineering));
-
- lines.add("Engineering - two arg");
- lines.add(generateTwoArgExamplesTable(DoubleFormats::createEngineering));
-
- Files.write(output, lines);
- }
-
- private static String generateOneArgExamplesTable(final IntFunction<DoubleFunction<String>> fn) {
- final int aMaxPrecision = 0;
- final int bMaxPrecision = 4;
-
- final DoubleFunction<String> aFmt = fn.apply(aMaxPrecision);
- final DoubleFunction<String> bFmt = fn.apply(bMaxPrecision);
-
- final String descTemplate = "(maxPrecision= %d)";
-
- return generateExamplesTable(
- Arrays.asList(aFmt, bFmt),
- Arrays.asList(String.format(descTemplate, aMaxPrecision), String.format(descTemplate, bMaxPrecision))
- );
- }
-
- private static String generateTwoArgExamplesTable(final BiFunction<Integer, Integer, DoubleFunction<String>> fn) {
- final int aMaxPrecision = 0;
- final int aMinExponent = -2;
-
- final int bMaxPrecision = 4;
- final int bMinExponent = -2;
-
- final DoubleFunction<String> aFmt = fn.apply(aMaxPrecision, aMinExponent);
- final DoubleFunction<String> bFmt = fn.apply(bMaxPrecision, bMinExponent);
-
- final String descTemplate = "(maxPrecision= %d, minExponent= %d)";
-
- return generateExamplesTable(
- Arrays.asList(aFmt, bFmt),
- Arrays.asList(
- String.format(descTemplate, aMaxPrecision, aMinExponent),
- String.format(descTemplate, bMaxPrecision, bMinExponent))
- );
- }
-
- private static String generateExamplesTable(final List<DoubleFunction<String>> fmts,
- final List<String> fmtDescriptions) {
- final StringBuilder sb = new StringBuilder();
-
- sb.append("<table>\n")
- .append(" <tr><th>Value</th>");
-
- for (String desc : fmtDescriptions) {
- sb.append("<th>")
- .append(desc)
- .append("</th>");
- }
- sb.append("</tr>\n");
-
- for (double value : EXAMPLE_VALUES) {
- sb.append(" <tr><td>")
- .append(value)
- .append("</td>");
-
- for (DoubleFunction<String> fmt : fmts) {
- sb.append("<td>")
- .append(fmt.apply(value))
- .append("</td>");
- }
-
- sb.append("</tr>\n");
- }
-
- sb.append("</table>");
-
- return sb.toString();
- }
-
- private static void checkFormat(final DoubleFunction<String> fmt, final double d, final String str) {
- Assertions.assertEquals(str, fmt.apply(d));
- }
-
- private static void checkFormatSpecial(final DoubleFunction<String> fmt) {
- checkFormat(fmt, Double.NaN, "NaN");
- checkFormat(fmt, Double.POSITIVE_INFINITY, "Infinity");
- checkFormat(fmt, Double.NEGATIVE_INFINITY, "-Infinity");
- }
-}
diff --git a/commons-geometry-io-core/src/test/java/org/apache/commons/geometry/io/core/utils/ParsedDoubleTest.java b/commons-geometry-io-core/src/test/java/org/apache/commons/geometry/io/core/utils/ParsedDoubleTest.java
deleted file mode 100644
index 975c09f..0000000
--- a/commons-geometry-io-core/src/test/java/org/apache/commons/geometry/io/core/utils/ParsedDoubleTest.java
+++ /dev/null
@@ -1,464 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.geometry.io.core.utils;
-
-import java.math.BigDecimal;
-import java.math.MathContext;
-import java.math.RoundingMode;
-import java.util.function.BiFunction;
-
-import org.apache.commons.geometry.core.GeometryTestUtils;
-import org.apache.commons.rng.UniformRandomProvider;
-import org.apache.commons.rng.simple.RandomSource;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.Test;
-
-class ParsedDoubleTest {
-
- @Test
- void testFrom() {
- // act/assert
- checkFrom(0.0, "0", 0);
-
- checkFrom(1.0, "1", 0);
- checkFrom(10.0, "1", 1);
- checkFrom(100.0, "1", 2);
- checkFrom(1000.0, "1", 3);
- checkFrom(10000.0, "1", 4);
-
- checkFrom(0.1, "1", -1);
- checkFrom(0.01, "1", -2);
- checkFrom(0.001, "1", -3);
- checkFrom(0.0001, "1", -4);
- checkFrom(0.00001, "1", -5);
-
- checkFrom(1.2, "12", -1);
- checkFrom(0.00971, "971", -5);
- checkFrom(56300, "563", 2);
-
- checkFrom(123.0, "123", 0);
- checkFrom(1230.0, "123", 1);
- checkFrom(12300.0, "123", 2);
- checkFrom(123000.0, "123", 3);
-
- checkFrom(12.3, "123", -1);
- checkFrom(1.23, "123", -2);
- checkFrom(0.123, "123", -3);
- checkFrom(0.0123, "123", -4);
-
- checkFrom(1.987654321e270, "1987654321", 261);
- checkFrom(1.987654321e-270, "1987654321", -279);
-
- checkFrom(Math.PI, "3141592653589793", -15);
- checkFrom(Math.E, "2718281828459045", -15);
-
- checkFrom(Double.MAX_VALUE, "17976931348623157", 292);
- checkFrom(Double.MIN_VALUE, "49", -325);
- checkFrom(Double.MIN_NORMAL, "22250738585072014", -324);
- }
-
- @Test
- void testFrom_notFinite() {
- // arrange
- final String msg = "Double is not finite";
-
- // act/assert
- GeometryTestUtils.assertThrowsWithMessage(() -> ParsedDouble.from(Double.NaN),
- IllegalArgumentException.class, msg);
- GeometryTestUtils.assertThrowsWithMessage(() -> ParsedDouble.from(Double.NEGATIVE_INFINITY),
- IllegalArgumentException.class, msg);
- GeometryTestUtils.assertThrowsWithMessage(() -> ParsedDouble.from(Double.POSITIVE_INFINITY),
- IllegalArgumentException.class, msg);
- }
-
- @Test
- void testIsZero() {
- // act/assert
- Assertions.assertTrue(ParsedDouble.from(0.0).isZero());
- Assertions.assertTrue(ParsedDouble.from(-0.0).isZero());
-
- Assertions.assertFalse(ParsedDouble.from(1.0).isZero());
- Assertions.assertFalse(ParsedDouble.from(-1.0).isZero());
-
- Assertions.assertFalse(ParsedDouble.from(Double.MIN_NORMAL).isZero());
- Assertions.assertFalse(ParsedDouble.from(-Double.MIN_NORMAL).isZero());
-
- Assertions.assertFalse(ParsedDouble.from(Double.MAX_VALUE).isZero());
- Assertions.assertFalse(ParsedDouble.from(-Double.MIN_VALUE).isZero());
- }
-
- @Test
- void testRound_one() {
- // arrange
- final ParsedDouble a = ParsedDouble.from(1e-10);
- final ParsedDouble b = ParsedDouble.from(-1);
- final ParsedDouble c = ParsedDouble.from(1e10);
-
- // act/assert
- assertParsedDouble(a.round(-11), false, "1", -10);
- assertParsedDouble(a.round(-10), false, "1", -10);
- assertParsedDouble(a.round(-9), false, "0", 0);
-
- assertParsedDouble(b.round(-1), true, "1", 0);
- assertParsedDouble(b.round(0), true, "1", 0);
- assertParsedDouble(b.round(1), false, "0", 0);
-
- assertParsedDouble(c.round(9), false, "1", 10);
- assertParsedDouble(c.round(10), false, "1", 10);
- assertParsedDouble(c.round(11), false, "0", 0);
- }
-
- @Test
- void testRound_nine() {
- // arrange
- final ParsedDouble a = ParsedDouble.from(9e-10);
- final ParsedDouble b = ParsedDouble.from(-9);
- final ParsedDouble c = ParsedDouble.from(9e10);
-
- // act/assert
- assertParsedDouble(a.round(-11), false, "9", -10);
- assertParsedDouble(a.round(-10), false, "9", -10);
- assertParsedDouble(a.round(-9), false, "1", -9);
-
- assertParsedDouble(b.round(-1), true, "9", 0);
- assertParsedDouble(b.round(0), true, "9", 0);
- assertParsedDouble(b.round(1), true, "1", 1);
-
- assertParsedDouble(c.round(9), false, "9", 10);
- assertParsedDouble(c.round(10), false, "9", 10);
- assertParsedDouble(c.round(11), false, "1", 11);
- }
-
- @Test
- void testRound_mixed() {
- // arrange
- final ParsedDouble a = ParsedDouble.from(9.94e-10);
- final ParsedDouble b = ParsedDouble.from(-3.1415);
- final ParsedDouble c = ParsedDouble.from(5.55e10);
-
- // act/assert
- assertParsedDouble(a.round(-13), false, "994", -12);
- assertParsedDouble(a.round(-12), false, "994", -12);
- assertParsedDouble(a.round(-11), false, "99", -11);
- assertParsedDouble(a.round(-10), false, "1", -9);
- assertParsedDouble(a.round(-9), false, "1", -9);
- assertParsedDouble(a.round(-8), false, "0", 0);
-
- assertParsedDouble(b.round(-5), true, "31415", -4);
- assertParsedDouble(b.round(-4), true, "31415", -4);
- assertParsedDouble(b.round(-3), true, "3142", -3);
- assertParsedDouble(b.round(-2), true, "314", -2);
- assertParsedDouble(b.round(-1), true, "31", -1);
- assertParsedDouble(b.round(0), true, "3", 0);
- assertParsedDouble(b.round(1), false, "0", 0);
- assertParsedDouble(b.round(2), false, "0", 0);
-
- assertParsedDouble(c.round(7), false, "555", 8);
- assertParsedDouble(c.round(8), false, "555", 8);
- assertParsedDouble(c.round(9), false, "56", 9);
- assertParsedDouble(c.round(10), false, "6", 10);
- assertParsedDouble(c.round(11), false, "1", 11);
- assertParsedDouble(c.round(12), false, "0", 0);
- }
-
- @Test
- void testMaxPrecision() {
- // arrange
- final ParsedDouble d = ParsedDouble.from(1.02576552);
-
- // act
- assertParsedDouble(d.maxPrecision(10), false, "102576552", -8);
- assertParsedDouble(d.maxPrecision(9), false, "102576552", -8);
- assertParsedDouble(d.maxPrecision(8), false, "10257655", -7);
- assertParsedDouble(d.maxPrecision(7), false, "1025766", -6);
- assertParsedDouble(d.maxPrecision(6), false, "102577", -5);
- assertParsedDouble(d.maxPrecision(5), false, "10258", -4);
- assertParsedDouble(d.maxPrecision(4), false, "1026", -3);
- assertParsedDouble(d.maxPrecision(3), false, "103", -2);
- assertParsedDouble(d.maxPrecision(2), false, "1", 0);
- assertParsedDouble(d.maxPrecision(1), false, "1", 0);
- }
-
- @Test
- void testMaxPrecision_carry() {
- // arrange
- final ParsedDouble d = ParsedDouble.from(-999.0999e50);
-
- // act
- assertParsedDouble(d.maxPrecision(8), true, "9990999", 46);
- assertParsedDouble(d.maxPrecision(7), true, "9990999", 46);
- assertParsedDouble(d.maxPrecision(6), true, "9991", 49);
- assertParsedDouble(d.maxPrecision(5), true, "9991", 49);
- assertParsedDouble(d.maxPrecision(4), true, "9991", 49);
- assertParsedDouble(d.maxPrecision(3), true, "999", 50);
- assertParsedDouble(d.maxPrecision(2), true, "1", 53);
- assertParsedDouble(d.maxPrecision(1), true, "1", 53);
- }
-
- @Test
- void testMaxPrecision_halfEvenRounding() {
- // act/assert
- // Test values taken from RoundingMode.HALF_EVEN javadocs
- assertParsedDouble(ParsedDouble.from(5.5).maxPrecision(1), false, "6", 0);
- assertParsedDouble(ParsedDouble.from(2.5).maxPrecision(1), false, "2", 0);
- assertParsedDouble(ParsedDouble.from(1.6).maxPrecision(1), false, "2", 0);
- assertParsedDouble(ParsedDouble.from(1.1).maxPrecision(1), false, "1", 0);
- assertParsedDouble(ParsedDouble.from(1.0).maxPrecision(1), false, "1", 0);
-
- assertParsedDouble(ParsedDouble.from(-1.0).maxPrecision(1), true, "1", 0);
- assertParsedDouble(ParsedDouble.from(-1.1).maxPrecision(1), true, "1", 0);
- assertParsedDouble(ParsedDouble.from(-1.6).maxPrecision(1), true, "2", 0);
- assertParsedDouble(ParsedDouble.from(-2.5).maxPrecision(1), true, "2", 0);
- assertParsedDouble(ParsedDouble.from(-5.5).maxPrecision(1), true, "6", 0);
- }
-
- @Test
- void testMaxPrecision_singleDigits() {
- // act
- assertParsedDouble(ParsedDouble.from(9.0).maxPrecision(1), false, "9", 0);
- assertParsedDouble(ParsedDouble.from(1.0).maxPrecision(1), false, "1", 0);
- assertParsedDouble(ParsedDouble.from(0.0).maxPrecision(1), false, "0", 0);
- assertParsedDouble(ParsedDouble.from(-0.0).maxPrecision(1), true, "0", 0);
- assertParsedDouble(ParsedDouble.from(-1.0).maxPrecision(1), true, "1", 0);
- assertParsedDouble(ParsedDouble.from(-9.0).maxPrecision(1), true, "9", 0);
- }
-
- @Test
- void testMaxPrecision_random() {
- // arrange
- final UniformRandomProvider rand = RandomSource.create(RandomSource.XO_RO_SHI_RO_128_PP, 0L);
-
- double d;
- int precision;
- ParsedDouble result;
- MathContext ctx;
- for (int i = 0; i < 10_000; ++i) {
- d = createRandomDouble(rand);
- precision = rand.nextInt(20) + 1;
- ctx = new MathContext(precision, RoundingMode.HALF_EVEN);
-
- // act
- result = ParsedDouble.from(d).maxPrecision(precision);
-
- // assert
- Assertions.assertEquals(new BigDecimal(Double.toString(d), ctx).doubleValue(),
- Double.parseDouble(result.toScientificString(true)));
- }
- }
-
- @Test
- void testMaxPrecision_invalidArg() {
- // arrange
- final ParsedDouble d = ParsedDouble.from(10);
- final String baseMsg = "Precision must be greater than zero; was ";
-
- // act/assert
- GeometryTestUtils.assertThrowsWithMessage(
- () -> d.maxPrecision(0), IllegalArgumentException.class, baseMsg + "0");
- GeometryTestUtils.assertThrowsWithMessage(
- () -> d.maxPrecision(-1), IllegalArgumentException.class, baseMsg + "-1");
- }
-
- @Test
- void testToPlainString() {
- // act/assert
- checkToPlainString(0.0, "0.0", "0");
- checkToPlainString(1.0, "1.0", "1");
- checkToPlainString(1.5, "1.5");
-
- checkToPlainString(0.000123, "0.000123");
- checkToPlainString(12300, "12300.0", "12300");
-
- checkToPlainString(Math.PI, "3.141592653589793");
- checkToPlainString(Math.E, "2.718281828459045");
-
- checkToPlainString(12345.6789, "12345.6789");
- checkToPlainString(1.23e12, "1230000000000.0", "1230000000000");
- checkToPlainString(1.23e-12, "0.00000000000123");
- }
-
- @Test
- void testToScientificString() {
- // act/assert
- checkToScientificString(0.0, "0.0", "0");
- checkToScientificString(1.0, "1.0", "1");
- checkToScientificString(1.5, "1.5");
-
- checkToScientificString(0.000123, "1.23E-4");
- checkToScientificString(12300, "1.23E4");
-
- checkToScientificString(Math.PI, "3.141592653589793");
- checkToScientificString(Math.E, "2.718281828459045");
-
- checkToScientificString(Double.MAX_VALUE, "1.7976931348623157E308");
- checkToScientificString(Double.MIN_VALUE, "4.9E-324");
- checkToScientificString(Double.MIN_NORMAL, "2.2250738585072014E-308");
- }
-
- @Test
- void testToEngineeringString() {
- // act/assert
- checkToEngineeringString(0.0, "0.0", "0");
- checkToEngineeringString(1.0, "1.0", "1");
- checkToEngineeringString(1.5, "1.5");
-
- checkToEngineeringString(10, "10.0", "10");
-
- checkToEngineeringString(0.000000123, "123.0E-9", "123E-9");
- checkToEngineeringString(12300000, "12.3E6");
-
- checkToEngineeringString(Math.PI, "3.141592653589793");
- checkToEngineeringString(Math.E, "2.718281828459045");
-
- checkToEngineeringString(Double.MAX_VALUE, "179.76931348623157E306");
- checkToEngineeringString(Double.MIN_VALUE, "4.9E-324");
- checkToEngineeringString(Double.MIN_NORMAL, "22.250738585072014E-309");
- }
-
- @Test
- void testStringMethodAccuracy_sequence() {
- // arrange
- final double min = -1000;
- final double max = 1000;
- final double delta = 0.1;
-
- Assertions.assertEquals(10.0, Double.parseDouble(ParsedDouble.from(10.0).toEngineeringString(true)));
-
- for (double d = min; d <= max; d += delta) {
- // act/assert
- Assertions.assertEquals(d, Double.parseDouble(ParsedDouble.from(d).toScientificString(true)));
- Assertions.assertEquals(d, Double.parseDouble(ParsedDouble.from(d).toScientificString(false)));
-
- Assertions.assertEquals(d, Double.parseDouble(ParsedDouble.from(d).toEngineeringString(true)));
- Assertions.assertEquals(d, Double.parseDouble(ParsedDouble.from(d).toEngineeringString(false)));
-
- Assertions.assertEquals(d, Double.parseDouble(ParsedDouble.from(d).toPlainString(true)));
- Assertions.assertEquals(d, Double.parseDouble(ParsedDouble.from(d).toPlainString(false)));
- }
- }
-
- @Test
- void testStringMethodAccuracy_random() {
- // arrange
- final UniformRandomProvider rand = RandomSource.create(RandomSource.XO_RO_SHI_RO_128_PP, 0L);
-
- double d;
- for (int i = 0; i < 10_000; ++i) {
- d = createRandomDouble(rand);
-
- // act/assert
- Assertions.assertEquals(d, Double.parseDouble(ParsedDouble.from(d).toScientificString(true)));
- Assertions.assertEquals(d, Double.parseDouble(ParsedDouble.from(d).toScientificString(false)));
-
- Assertions.assertEquals(d, Double.parseDouble(ParsedDouble.from(d).toEngineeringString(true)));
- Assertions.assertEquals(d, Double.parseDouble(ParsedDouble.from(d).toEngineeringString(false)));
-
- Assertions.assertEquals(d, Double.parseDouble(ParsedDouble.from(d).toPlainString(true)));
- Assertions.assertEquals(d, Double.parseDouble(ParsedDouble.from(d).toPlainString(false)));
- }
- }
-
- private static void checkFrom(final double d, final String digits, final int exponent) {
- final boolean negative = Math.signum(d) < 0;
-
- assertParsedDouble(ParsedDouble.from(d), negative, digits, exponent);
- assertParsedDouble(ParsedDouble.from(-d), !negative, digits, exponent);
- }
-
- private static void checkToPlainString(final double d, final String expected) {
- checkToPlainString(d, expected, expected);
- }
-
- private static void checkToPlainString(final double d, final String withPlaceholder,
- final String withoutPlaceholder) {
- checkToStringMethod(d, withPlaceholder, withoutPlaceholder, ParsedDouble::toPlainString);
- }
-
- private static void checkToScientificString(final double d, final String expected) {
- checkToScientificString(d, expected, expected);
- }
-
- private static void checkToScientificString(final double d, final String withPlaceholder,
- final String withoutPlaceholder) {
- checkToStringMethod(d, withPlaceholder, withoutPlaceholder, ParsedDouble::toScientificString);
- }
-
- private static void checkToEngineeringString(final double d, final String expected) {
- checkToEngineeringString(d, expected, expected);
- }
-
- private static void checkToEngineeringString(final double d, final String withPlaceholder,
- final String withoutPlaceholder) {
- checkToStringMethod(d, withPlaceholder, withoutPlaceholder, ParsedDouble::toEngineeringString);
-
- // check the exponent value to make sure it is a multiple of 3
- final String pos = ParsedDouble.from(d).toEngineeringString(true);
- final int posEIdx = pos.indexOf('E');
- if (posEIdx > -1) {
- Assertions.assertEquals(0, Integer.parseInt(pos.substring(posEIdx + 1)) % 3);
- }
-
- final String neg = ParsedDouble.from(-d).toEngineeringString(true);
- final int negEIdx = neg.indexOf('E');
- if (negEIdx > -1) {
- Assertions.assertEquals(0, Integer.parseInt(neg.substring(negEIdx + 1)) % 3);
- }
- }
-
- private static void checkToStringMethod(final double d, final String withPlaceholder,
- final String withoutPlaceholder, final BiFunction<ParsedDouble, Boolean, String> fn) {
- final ParsedDouble pos = ParsedDouble.from(d);
-
- final String posWith = fn.apply(pos, true);
- Assertions.assertEquals(withPlaceholder, posWith);
- assertDoubleString(d, posWith);
-
- final String posWithout = fn.apply(pos, false);
- Assertions.assertEquals(withoutPlaceholder, posWithout);
- assertDoubleString(d, posWithout);
-
- final ParsedDouble neg = ParsedDouble.from(-d);
-
- final String negWith = fn.apply(neg, true);
- Assertions.assertEquals("-" + withPlaceholder, negWith);
- assertDoubleString(-d, negWith);
-
- final String negWithout = fn.apply(neg, false);
- Assertions.assertEquals("-" + withoutPlaceholder, negWithout);
- assertDoubleString(-d, negWithout);
- }
-
- private static void assertDoubleString(final double d, final String str) {
- Assertions.assertEquals(d, Double.parseDouble(str), 0.0);
- }
-
- private static void assertParsedDouble(final ParsedDouble parsed, final boolean negative, final String digits,
- final int exponent) {
- Assertions.assertEquals(negative, parsed.isNegative());
- Assertions.assertEquals(digits, parsed.getDigits());
- Assertions.assertEquals(exponent, parsed.getExponent());
- Assertions.assertEquals(digits.length(), parsed.getPrecision());
- Assertions.assertEquals(exponent, parsed.getScientificExponent() - digits.length() + 1);
- }
-
- private static double createRandomDouble(final UniformRandomProvider rng) {
- final long mask = ((1L << 52) - 1) | 1L << 63;
- final long bits = rng.nextLong() & mask;
- final long exp = rng.nextInt(2045) + 1;
- return Double.longBitsToDouble(bits | (exp << 52));
- }
-}
diff --git a/commons-geometry-io-euclidean/src/main/java/org/apache/commons/geometry/io/euclidean/threed/obj/ObjBoundaryWriteHandler3D.java b/commons-geometry-io-euclidean/src/main/java/org/apache/commons/geometry/io/euclidean/threed/obj/ObjBoundaryWriteHandler3D.java
index 0d7218f..b9d3f60 100644
--- a/commons-geometry-io-euclidean/src/main/java/org/apache/commons/geometry/io/euclidean/threed/obj/ObjBoundaryWriteHandler3D.java
+++ b/commons-geometry-io-euclidean/src/main/java/org/apache/commons/geometry/io/euclidean/threed/obj/ObjBoundaryWriteHandler3D.java
@@ -29,7 +29,6 @@ import org.apache.commons.geometry.euclidean.threed.PlaneConvexSubset;
import org.apache.commons.geometry.euclidean.threed.mesh.Mesh;
import org.apache.commons.geometry.io.core.GeometryFormat;
import org.apache.commons.geometry.io.core.output.GeometryOutput;
-import org.apache.commons.geometry.io.core.utils.DoubleFormats;
import org.apache.commons.geometry.io.euclidean.threed.AbstractBoundaryWriteHandler3D;
import org.apache.commons.geometry.io.euclidean.threed.FacetDefinition;
import org.apache.commons.geometry.io.euclidean.threed.GeometryFormat3D;
@@ -52,7 +51,7 @@ public class ObjBoundaryWriteHandler3D extends AbstractBoundaryWriteHandler3D {
private String lineSeparator = DEFAULT_LINE_SEPARATOR;
/** Double format function. */
- private DoubleFunction<String> doubleFormat = DoubleFormats.DOUBLE_TO_STRING;
+ private DoubleFunction<String> doubleFormat = Double::toString;
/** Batch size used for mesh buffer creation. */
private int meshBufferBatchSize = DEFAULT_MESH_BUFFER_BATCH_SIZE;
diff --git a/commons-geometry-io-euclidean/src/main/java/org/apache/commons/geometry/io/euclidean/threed/txt/AbstractTextBoundaryWriteHandler3D.java b/commons-geometry-io-euclidean/src/main/java/org/apache/commons/geometry/io/euclidean/threed/txt/AbstractTextBoundaryWriteHandler3D.java
index a3f424b..58408b4 100644
--- a/commons-geometry-io-euclidean/src/main/java/org/apache/commons/geometry/io/euclidean/threed/txt/AbstractTextBoundaryWriteHandler3D.java
+++ b/commons-geometry-io-euclidean/src/main/java/org/apache/commons/geometry/io/euclidean/threed/txt/AbstractTextBoundaryWriteHandler3D.java
@@ -27,7 +27,6 @@ import java.util.stream.Stream;
import org.apache.commons.geometry.euclidean.threed.PlaneConvexSubset;
import org.apache.commons.geometry.io.core.output.GeometryOutput;
-import org.apache.commons.geometry.io.core.utils.DoubleFormats;
import org.apache.commons.geometry.io.euclidean.threed.AbstractBoundaryWriteHandler3D;
import org.apache.commons.geometry.io.euclidean.threed.FacetDefinition;
@@ -47,7 +46,7 @@ public abstract class AbstractTextBoundaryWriteHandler3D extends AbstractBoundar
private String lineSeparator = DEFAULT_LINE_SEPARATOR;
/** Double format function. */
- private DoubleFunction<String> doubleFormat = DoubleFormats.DOUBLE_TO_STRING;
+ private DoubleFunction<String> doubleFormat = Double::toString;
/** Get the text output default charset, used if the output does not
* specify a charset.
diff --git a/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/obj/ObjBoundaryWriteHandler3DTest.java b/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/obj/ObjBoundaryWriteHandler3DTest.java
index 2c54d7e..b3b474f 100644
--- a/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/obj/ObjBoundaryWriteHandler3DTest.java
+++ b/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/obj/ObjBoundaryWriteHandler3DTest.java
@@ -19,15 +19,17 @@ package org.apache.commons.geometry.io.euclidean.threed.obj;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
import java.util.Arrays;
import java.util.List;
+import java.util.Locale;
import java.util.stream.Collectors;
import org.apache.commons.geometry.euclidean.threed.BoundarySource3D;
import org.apache.commons.geometry.euclidean.threed.Vector3D;
import org.apache.commons.geometry.euclidean.threed.mesh.SimpleTriangleMesh;
import org.apache.commons.geometry.io.core.output.StreamGeometryOutput;
-import org.apache.commons.geometry.io.core.utils.DoubleFormats;
import org.apache.commons.geometry.io.euclidean.threed.FacetDefinition;
import org.apache.commons.geometry.io.euclidean.threed.FacetDefinitions;
import org.apache.commons.geometry.io.euclidean.threed.GeometryFormat3D;
@@ -57,14 +59,18 @@ class ObjBoundaryWriteHandler3DTest {
Assertions.assertEquals(GeometryFormat3D.OBJ, handler.getFormat());
Assertions.assertEquals(StandardCharsets.UTF_8, handler.getDefaultCharset());
Assertions.assertEquals("\n", handler.getLineSeparator());
- Assertions.assertSame(DoubleFormats.DOUBLE_TO_STRING, handler.getDoubleFormat());
+ Assertions.assertNotNull(handler.getDoubleFormat());
Assertions.assertEquals(-1, handler.getMeshBufferBatchSize());
}
@Test
void testWriteFacets() throws IOException {
+ // arrange
+ final DecimalFormat fmt =
+ new DecimalFormat("0.0#####", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
+
// act
- handler.setDoubleFormat(DoubleFormats.createDefault(0, -6));
+ handler.setDoubleFormat(fmt::format);
handler.writeFacets(FACETS, new StreamGeometryOutput(out));
// assert
@@ -80,8 +86,12 @@ class ObjBoundaryWriteHandler3DTest {
@Test
void testWriteFacets_usesOutputCharset() throws IOException {
+ // arrange
+ final DecimalFormat fmt =
+ new DecimalFormat("0.0#####", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
+
// act
- handler.setDoubleFormat(DoubleFormats.createDefault(0, -6));
+ handler.setDoubleFormat(fmt::format);
handler.writeFacets(FACETS, new StreamGeometryOutput(out, null, StandardCharsets.UTF_16));
// assert
@@ -98,9 +108,13 @@ class ObjBoundaryWriteHandler3DTest {
@Test
void testWriteFacets_customConfig() throws IOException {
// arrange
+ // arrange
+ final DecimalFormat fmt =
+ new DecimalFormat("0.0", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
+
handler.setDefaultCharset(StandardCharsets.UTF_16);
handler.setLineSeparator("\r\n");
- handler.setDoubleFormat(DoubleFormats.createDefault(0, -1));
+ handler.setDoubleFormat(fmt::format);
handler.setMeshBufferBatchSize(1);
// act
@@ -147,9 +161,13 @@ class ObjBoundaryWriteHandler3DTest {
.map(f -> FacetDefinitions.toPolygon(f, TEST_PRECISION))
.collect(Collectors.toList()));
+ // arrange
+ final DecimalFormat fmt =
+ new DecimalFormat("0.0", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
+
handler.setDefaultCharset(StandardCharsets.UTF_16);
handler.setLineSeparator("\r\n");
- handler.setDoubleFormat(DoubleFormats.createDefault(0, -1));
+ handler.setDoubleFormat(fmt::format);
handler.setMeshBufferBatchSize(1);
// act
diff --git a/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/obj/ObjWriterTest.java b/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/obj/ObjWriterTest.java
index 5e32a16..61d58cc 100644
--- a/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/obj/ObjWriterTest.java
+++ b/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/obj/ObjWriterTest.java
@@ -19,7 +19,10 @@ package org.apache.commons.geometry.io.euclidean.threed.obj;
import java.io.IOException;
import java.io.StringWriter;
import java.io.UncheckedIOException;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
import java.util.Arrays;
+import java.util.Locale;
import java.util.regex.Pattern;
import org.apache.commons.geometry.core.GeometryTestUtils;
@@ -27,7 +30,6 @@ import org.apache.commons.geometry.euclidean.threed.BoundarySource3D;
import org.apache.commons.geometry.euclidean.threed.Planes;
import org.apache.commons.geometry.euclidean.threed.Vector3D;
import org.apache.commons.geometry.euclidean.threed.mesh.SimpleTriangleMesh;
-import org.apache.commons.geometry.io.core.utils.DoubleFormats;
import org.apache.commons.geometry.io.euclidean.threed.SimpleFacetDefinition;
import org.apache.commons.numbers.core.Precision;
import org.junit.jupiter.api.Assertions;
@@ -48,7 +50,7 @@ class ObjWriterTest {
// act/assert
try (ObjWriter objWriter = new ObjWriter(writer)) {
Assertions.assertEquals("\n", objWriter.getLineSeparator());
- Assertions.assertSame(DoubleFormats.DOUBLE_TO_STRING, objWriter.getDoubleFormat());
+ Assertions.assertNotNull(objWriter.getDoubleFormat());
Assertions.assertEquals(0, objWriter.getVertexCount());
Assertions.assertEquals(0, objWriter.getVertexNormalCount());
}
@@ -92,10 +94,12 @@ class ObjWriterTest {
void testSetDecimalFormat() throws IOException {
// arrange
final StringWriter writer = new StringWriter();
+ final DecimalFormat fmt =
+ new DecimalFormat("0.0", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
// act
try (ObjWriter objWriter = new ObjWriter(writer)) {
- objWriter.setDoubleFormat(DoubleFormats.createDefault(0, -1));
+ objWriter.setDoubleFormat(fmt::format);
objWriter.writeVertex(Vector3D.of(1.09, 2.05, 3.06));
}
@@ -156,12 +160,16 @@ class ObjWriterTest {
// arrange
final StringWriter writer = new StringWriter();
+ // arrange
+ final DecimalFormat fmt =
+ new DecimalFormat("0.0", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
+
// act
final int index1;
final int index2;
final int count;
try (ObjWriter objWriter = new ObjWriter(writer)) {
- objWriter.setDoubleFormat(DoubleFormats.createDefault(0, -1));
+ objWriter.setDoubleFormat(fmt::format);
index1 = objWriter.writeVertex(Vector3D.of(1.09, 2.1, 3.005));
index2 = objWriter.writeVertex(Vector3D.of(0.06, 10, 12));
@@ -182,13 +190,15 @@ class ObjWriterTest {
void testWriteNormal() throws IOException {
// arrange
final StringWriter writer = new StringWriter();
+ final DecimalFormat fmt =
+ new DecimalFormat("0.0", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
// act
final int index1;
final int index2;
final int count;
try (ObjWriter objWriter = new ObjWriter(writer)) {
- objWriter.setDoubleFormat(DoubleFormats.createDefault(0, -1));
+ objWriter.setDoubleFormat(fmt::format);
index1 = objWriter.writeVertexNormal(Vector3D.of(1.09, 2.1, 3.005));
index2 = objWriter.writeVertexNormal(Vector3D.of(0.06, 10, 12));
diff --git a/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/stl/TextStlWriterTest.java b/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/stl/TextStlWriterTest.java
index 4f9eba3..8cf53d9 100644
--- a/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/stl/TextStlWriterTest.java
+++ b/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/stl/TextStlWriterTest.java
@@ -18,16 +18,18 @@ package org.apache.commons.geometry.io.euclidean.threed.stl;
import java.io.IOException;
import java.io.StringWriter;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.Locale;
import org.apache.commons.geometry.core.GeometryTestUtils;
import org.apache.commons.geometry.euclidean.threed.ConvexPolygon3D;
import org.apache.commons.geometry.euclidean.threed.Planes;
import org.apache.commons.geometry.euclidean.threed.Vector3D;
import org.apache.commons.geometry.io.core.test.CloseCountWriter;
-import org.apache.commons.geometry.io.core.utils.DoubleFormats;
import org.apache.commons.geometry.io.euclidean.threed.FacetDefinition;
import org.apache.commons.geometry.io.euclidean.threed.SimpleFacetDefinition;
import org.apache.commons.numbers.core.Precision;
@@ -47,7 +49,7 @@ class TextStlWriterTest {
void testDefaultProperties() throws IOException {
// act/assert
try (TextStlWriter writer = new TextStlWriter(out)) {
- Assertions.assertSame(DoubleFormats.DOUBLE_TO_STRING, writer.getDoubleFormat());
+ Assertions.assertNotNull(writer.getDoubleFormat());
Assertions.assertEquals("\n", writer.getLineSeparator());
}
}
@@ -540,9 +542,12 @@ class TextStlWriterTest {
Vector3D.ZERO, Vector3D.of(1.0 / 3.0, 0, 0), Vector3D.of(0, 1.0 / 3.0, 0));
final Vector3D normal = Vector3D.Unit.PLUS_Z;
+ final DecimalFormat fmt =
+ new DecimalFormat("0.0##", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
+
try (TextStlWriter writer = new TextStlWriter(out)) {
- writer.setDoubleFormat(DoubleFormats.createDefault(0, -3));
+ writer.setDoubleFormat(fmt::format);
writer.setLineSeparator("\r\n");
// act
diff --git a/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/txt/TextBoundaryWriteHandler3DTest.java b/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/txt/TextBoundaryWriteHandler3DTest.java
index 575e39f..8b6e21f 100644
--- a/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/txt/TextBoundaryWriteHandler3DTest.java
+++ b/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/txt/TextBoundaryWriteHandler3DTest.java
@@ -19,15 +19,17 @@ package org.apache.commons.geometry.io.euclidean.threed.txt;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
import java.util.Arrays;
import java.util.List;
+import java.util.Locale;
import org.apache.commons.geometry.euclidean.threed.BoundarySource3D;
import org.apache.commons.geometry.euclidean.threed.Planes;
import org.apache.commons.geometry.euclidean.threed.Vector3D;
import org.apache.commons.geometry.io.core.output.StreamGeometryOutput;
import org.apache.commons.geometry.io.core.test.CloseCountOutputStream;
-import org.apache.commons.geometry.io.core.utils.DoubleFormats;
import org.apache.commons.geometry.io.euclidean.threed.FacetDefinition;
import org.apache.commons.geometry.io.euclidean.threed.GeometryFormat3D;
import org.apache.commons.geometry.io.euclidean.threed.SimpleFacetDefinition;
@@ -66,7 +68,7 @@ class TextBoundaryWriteHandler3DTest {
Assertions.assertEquals("\n", handler.getLineSeparator());
Assertions.assertEquals(" ", handler.getVertexComponentSeparator());
Assertions.assertEquals("; ", handler.getVertexSeparator());
- Assertions.assertSame(DoubleFormats.DOUBLE_TO_STRING, handler.getDoubleFormat());
+ Assertions.assertNotNull(handler.getDoubleFormat());
Assertions.assertEquals(-1, handler.getFacetVertexCount());
}
@@ -103,10 +105,13 @@ class TextBoundaryWriteHandler3DTest {
@Test
void testWriteFacets_customConfiguration() throws IOException {
// arrange
+ final DecimalFormat fmt =
+ new DecimalFormat("0.0", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
+
final TextBoundaryWriteHandler3D handler = new TextBoundaryWriteHandler3D();
handler.setDefaultCharset(StandardCharsets.UTF_16);
handler.setLineSeparator("\r\n");
- handler.setDoubleFormat(DoubleFormats.createDefault(0, -1));
+ handler.setDoubleFormat(fmt::format);
handler.setVertexComponentSeparator("|");
handler.setVertexSeparator(" | ");
handler.setFacetVertexCount(4);
@@ -140,10 +145,14 @@ class TextBoundaryWriteHandler3DTest {
@Test
void testWriteBoundarySource_customConfiguration() throws IOException {
// arrange
+ // arrange
+ final DecimalFormat fmt =
+ new DecimalFormat("0.0", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
+
final TextBoundaryWriteHandler3D handler = new TextBoundaryWriteHandler3D();
handler.setDefaultCharset(StandardCharsets.UTF_16);
handler.setLineSeparator("\r\n");
- handler.setDoubleFormat(DoubleFormats.createDefault(0, -1));
+ handler.setDoubleFormat(fmt::format);
handler.setVertexComponentSeparator("|");
handler.setVertexSeparator(" | ");
handler.setFacetVertexCount(4);
diff --git a/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/txt/TextFacetDefinitionWriterTest.java b/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/txt/TextFacetDefinitionWriterTest.java
index 9329e37..8d0b516 100644
--- a/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/txt/TextFacetDefinitionWriterTest.java
+++ b/commons-geometry-io-euclidean/src/test/java/org/apache/commons/geometry/io/euclidean/threed/txt/TextFacetDefinitionWriterTest.java
@@ -18,9 +18,12 @@ package org.apache.commons.geometry.io.euclidean.threed.txt;
import java.io.IOException;
import java.io.StringWriter;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.Locale;
import org.apache.commons.geometry.core.GeometryTestUtils;
import org.apache.commons.geometry.euclidean.threed.BoundarySource3D;
@@ -28,7 +31,6 @@ import org.apache.commons.geometry.euclidean.threed.ConvexPolygon3D;
import org.apache.commons.geometry.euclidean.threed.PlaneConvexSubset;
import org.apache.commons.geometry.euclidean.threed.Planes;
import org.apache.commons.geometry.euclidean.threed.Vector3D;
-import org.apache.commons.geometry.io.core.utils.DoubleFormats;
import org.apache.commons.geometry.io.euclidean.threed.SimpleFacetDefinition;
import org.apache.commons.numbers.core.Precision;
import org.junit.jupiter.api.Assertions;
@@ -56,7 +58,7 @@ class TextFacetDefinitionWriterTest {
void testPropertyDefaults() {
// act/assert
Assertions.assertEquals("\n", fdWriter.getLineSeparator());
- Assertions.assertSame(DoubleFormats.DOUBLE_TO_STRING, fdWriter.getDoubleFormat());
+ Assertions.assertNotNull(fdWriter.getDoubleFormat());
Assertions.assertEquals(" ", fdWriter.getVertexComponentSeparator());
Assertions.assertEquals("; ", fdWriter.getVertexSeparator());
Assertions.assertEquals(-1, fdWriter.getFacetVertexCount());
@@ -188,12 +190,15 @@ class TextFacetDefinitionWriterTest {
@Test
void testWriteFacetDefinition() throws IOException {
// arrange
+ final DecimalFormat fmt =
+ new DecimalFormat("0.0##", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
+
final SimpleFacetDefinition f1 = new SimpleFacetDefinition(Arrays.asList(
Vector3D.ZERO, Vector3D.of(0.5, 0, 0), Vector3D.of(0, -0.5, 0)));
final SimpleFacetDefinition f2 = new SimpleFacetDefinition(Arrays.asList(
Vector3D.of(0.5, 0.7, 1.2), Vector3D.of(10.01, -4, 2), Vector3D.of(-10.0 / 3.0, 0, 0), Vector3D.ZERO));
- fdWriter.setDoubleFormat(DoubleFormats.createDefault(0, -3));
+ fdWriter.setDoubleFormat(fmt::format);
// act
fdWriter.write(f1);
@@ -299,6 +304,8 @@ class TextFacetDefinitionWriterTest {
@Test
void testWriteBoundarySource_alternativeFormatting() throws IOException {
// arrange
+ final DecimalFormat fmt =
+ new DecimalFormat("0.0", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
final ConvexPolygon3D poly1 = Planes.convexPolygonFromVertices(Arrays.asList(
Vector3D.ZERO, Vector3D.of(0, 0, -0.5901), Vector3D.of(0, -0.501, 0)
), TEST_PRECISION);
@@ -306,7 +313,7 @@ class TextFacetDefinitionWriterTest {
Vector3D.ZERO, Vector3D.of(1, 0, 0), Vector3D.of(1, 1, 0), Vector3D.of(0, 1, 0)
), TEST_PRECISION);
- fdWriter.setDoubleFormat(DoubleFormats.createDefault(0, -1));
+ fdWriter.setDoubleFormat(fmt::format);
fdWriter.setFacetVertexCount(3);
fdWriter.setLineSeparator("\r\n");