2
\$\begingroup\$

(See the previous iteration.)

This time, I have refactored my code a bit. It follows immediately:

Code

io.github.coderodde.math.simulation.volumes.NdimensionalBallVolumes.java:

package io.github.coderodde.math.simulation.volumes;

public class NdimensionalBallVolumes {

    private static final int LARGEST_DIMENSION = 50;

    public static void main(String[] args) {
        final Volume[] volumes = generateVolumes(LARGEST_DIMENSION);
        final int maxVolumeExpressionLength = 
                getMaximumVolumeExpressionLength(volumes);
        
        final int maxVolumeAliasLength = 
                Integer.toString(volumes.length).length();
        
        final String lineFormat = 
                String.format("V_{%%%dd} &= %%-%ds \\\\ %%%% n = %%%dd\n",
                              maxVolumeAliasLength,
                              maxVolumeExpressionLength,
                              maxVolumeAliasLength);
        
        System.out.println("$$");
        System.out.println("\\begin{aligned}");

        for (int n = 0; n <= LARGEST_DIMENSION; ++n) {
            System.out.printf(lineFormat,
                              n,
                              volumes[n],
                              n);
        }

        System.out.println("\\end{aligned}");
        System.out.println("$$");
    }
    
    private static int getMaximumVolumeExpressionLength(
            final Volume[] volumes) {
        
        int maxLength = -1;
        
        for (final Volume volume : volumes) {
            maxLength = Math.max(maxLength, volume.toString().length());
        }
        
        return maxLength;
    }
    
    private static Volume[] generateVolumes(final int n) {
        final Volume[] volumes = new Volume[n + 1];
        
        for (int i = 0; i <= n; ++i) {
            volumes[i] = new Volume(i);
        }
        
        return volumes;
    }
}

io.github.coderodde.math.simulation.volumes.Volume.java:

package io.github.coderodde.math.simulation.volumes;

import java.math.BigInteger;

/**
 *
 * @version 1.0.0 (Jul 10, 2025)
 * @since 1.0.0 (Jul 10, 2025)
 */
public class Volume {
    
    protected BigInteger numerator;
    protected BigInteger denominator;
    protected int piExponent;
    protected final int dimension;
    
    public Volume(final int dimension) {
        this.dimension   = checkDimension(dimension);
        this.piExponent  = dimension / 2;
        this.numerator   = BigInteger.ONE;
        this.denominator = BigInteger.ONE;
        
        if (dimension % 2 == 0) {
            for (int k = 1; k <= dimension / 2; ++k) {
                this.denominator = 
                        this.denominator.multiply(BigInteger.valueOf(k));
            }
        } else {
            for (int k = 1; k <= dimension; k += 2) {
                this.numerator = this.numerator.multiply(BigInteger.valueOf(2));
                this.denominator = 
                        this.denominator.multiply(BigInteger.valueOf(k));
            }
        }
    }
    
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        
        if (denominator.equals(BigInteger.ONE)) {
            appendNumeratorString(sb);
        } else {
            sb.append("\\frac{");
            appendNumeratorString(sb);
            sb.append("}{")
              .append(denominator)
              .append("}");
        }
        
        return sb.toString();
    }
    
    private void appendNumeratorString(final StringBuilder sb) {
        
        if (dimension == 0) {
            sb.append("0");
            return;
        }
        
        if (numerator.compareTo(BigInteger.ONE) > 0) {
            sb.append(numerator)
              .append(" ");
        }
        
        if (piExponent > 0) {
            sb.append("\\pi");
            
            if (piExponent > 1) {
                sb.append("^{")
                  .append(piExponent)
                  .append("}");
            }
            
            sb.append(" ");
        }
        
        if (dimension > 0) {
            sb.append("R");
            
            if (dimension > 1) {
                sb.append("^{")
                  .append(dimension)
                  .append("}");
            }
        }
    }
    
    private static int checkDimension(final int dimension) {
        if (dimension < 0) {
            final String exceptionMessage = String.format("dimension(%d) < 0",
                                                           dimension);
            
            throw new IllegalArgumentException(exceptionMessage);
        }
        
        return dimension;
    }
}

Program output in \$\LaTeX\$

$$
\begin{aligned}
V_{ 0} &= 0                                                                 \\ % n =  0
V_{ 1} &= 2 R                                                               \\ % n =  1
V_{ 2} &= \pi R^{2}                                                         \\ % n =  2
V_{ 3} &= \frac{4 \pi R^{3}}{3}                                             \\ % n =  3
V_{ 4} &= \frac{\pi^{2} R^{4}}{2}                                           \\ % n =  4
V_{ 5} &= \frac{8 \pi^{2} R^{5}}{15}                                        \\ % n =  5
V_{ 6} &= \frac{\pi^{3} R^{6}}{6}                                           \\ % n =  6
V_{ 7} &= \frac{16 \pi^{3} R^{7}}{105}                                      \\ % n =  7
V_{ 8} &= \frac{\pi^{4} R^{8}}{24}                                          \\ % n =  8
V_{ 9} &= \frac{32 \pi^{4} R^{9}}{945}                                      \\ % n =  9
V_{10} &= \frac{\pi^{5} R^{10}}{120}                                        \\ % n = 10
V_{11} &= \frac{64 \pi^{5} R^{11}}{10395}                                   \\ % n = 11
V_{12} &= \frac{\pi^{6} R^{12}}{720}                                        \\ % n = 12
V_{13} &= \frac{128 \pi^{6} R^{13}}{135135}                                 \\ % n = 13
V_{14} &= \frac{\pi^{7} R^{14}}{5040}                                       \\ % n = 14
V_{15} &= \frac{256 \pi^{7} R^{15}}{2027025}                                \\ % n = 15
V_{16} &= \frac{\pi^{8} R^{16}}{40320}                                      \\ % n = 16
V_{17} &= \frac{512 \pi^{8} R^{17}}{34459425}                               \\ % n = 17
V_{18} &= \frac{\pi^{9} R^{18}}{362880}                                     \\ % n = 18
V_{19} &= \frac{1024 \pi^{9} R^{19}}{654729075}                             \\ % n = 19
V_{20} &= \frac{\pi^{10} R^{20}}{3628800}                                   \\ % n = 20
V_{21} &= \frac{2048 \pi^{10} R^{21}}{13749310575}                          \\ % n = 21
V_{22} &= \frac{\pi^{11} R^{22}}{39916800}                                  \\ % n = 22
V_{23} &= \frac{4096 \pi^{11} R^{23}}{316234143225}                         \\ % n = 23
V_{24} &= \frac{\pi^{12} R^{24}}{479001600}                                 \\ % n = 24
V_{25} &= \frac{8192 \pi^{12} R^{25}}{7905853580625}                        \\ % n = 25
V_{26} &= \frac{\pi^{13} R^{26}}{6227020800}                                \\ % n = 26
V_{27} &= \frac{16384 \pi^{13} R^{27}}{213458046676875}                     \\ % n = 27
V_{28} &= \frac{\pi^{14} R^{28}}{87178291200}                               \\ % n = 28
V_{29} &= \frac{32768 \pi^{14} R^{29}}{6190283353629375}                    \\ % n = 29
V_{30} &= \frac{\pi^{15} R^{30}}{1307674368000}                             \\ % n = 30
V_{31} &= \frac{65536 \pi^{15} R^{31}}{191898783962510625}                  \\ % n = 31
V_{32} &= \frac{\pi^{16} R^{32}}{20922789888000}                            \\ % n = 32
V_{33} &= \frac{131072 \pi^{16} R^{33}}{6332659870762850625}                \\ % n = 33
V_{34} &= \frac{\pi^{17} R^{34}}{355687428096000}                           \\ % n = 34
V_{35} &= \frac{262144 \pi^{17} R^{35}}{221643095476699771875}              \\ % n = 35
V_{36} &= \frac{\pi^{18} R^{36}}{6402373705728000}                          \\ % n = 36
V_{37} &= \frac{524288 \pi^{18} R^{37}}{8200794532637891559375}             \\ % n = 37
V_{38} &= \frac{\pi^{19} R^{38}}{121645100408832000}                        \\ % n = 38
V_{39} &= \frac{1048576 \pi^{19} R^{39}}{319830986772877770815625}          \\ % n = 39
V_{40} &= \frac{\pi^{20} R^{40}}{2432902008176640000}                       \\ % n = 40
V_{41} &= \frac{2097152 \pi^{20} R^{41}}{13113070457687988603440625}        \\ % n = 41
V_{42} &= \frac{\pi^{21} R^{42}}{51090942171709440000}                      \\ % n = 42
V_{43} &= \frac{4194304 \pi^{21} R^{43}}{563862029680583509947946875}       \\ % n = 43
V_{44} &= \frac{\pi^{22} R^{44}}{1124000727777607680000}                    \\ % n = 44
V_{45} &= \frac{8388608 \pi^{22} R^{45}}{25373791335626257947657609375}     \\ % n = 45
V_{46} &= \frac{\pi^{23} R^{46}}{25852016738884976640000}                   \\ % n = 46
V_{47} &= \frac{16777216 \pi^{23} R^{47}}{1192568192774434123539907640625}  \\ % n = 47
V_{48} &= \frac{\pi^{24} R^{48}}{620448401733239439360000}                  \\ % n = 48
V_{49} &= \frac{33554432 \pi^{24} R^{49}}{58435841445947272053455474390625} \\ % n = 49
V_{50} &= \frac{\pi^{25} R^{50}}{15511210043330985984000000}                \\ % n = 50
\end{aligned}
$$

Critique request

As always, I am eager to hear any constructive commentary on my work.

\$\endgroup\$
0

3 Answers 3

Reset to default
4
\$\begingroup\$

Your Volume.appendNumeratorString method has a special case for dimension zero:

if (dimension == 0) {
    sb.append("0");
    return;
}

which is wrong for two reasons:

  • The volume of a zero-dimensional ball is \$ 1 \$ and not \$ 0 \$ (by definition, see N-sphere: Volume and area).

  • That method should not need knowledge about the computation of the volume for particular dimensions, it should only use the values of the member variables which are computed in the constructor.

And Volume(0) correctly sets numerator = 1, denominator = 1, and piExponent = 0. With a small change in appendNumeratorString this is converted to the string "1" as desired:

private void appendNumeratorString(final StringBuilder sb) {
    
    boolean isOne = true;
    
    if (numerator.compareTo(BigInteger.ONE) > 0) {
        isOne = false;
        / ... Append numerator ...
    }
  
    if (piExponent > 0) {
        isOne = false;
        / ... Append pi^piExponent ...
    }
  
    if (dimension > 0) {
        isOne = false;
        / ... Append R^dimension ...
    }
    
    if (isOne) {
        sb.append(1);
    }
}
\$\endgroup\$
3
\$\begingroup\$

Don’t Repeat Yourself

This code:

        if (piExponent > 0) {
            sb.append("\\pi");
            
            if (piExponent > 1) {
                sb.append("^{")
                  .append(piExponent)
                  .append("}");
            }
            
            sb.append(" ");
        }

looks an awful lot like this code:

        if (dimension > 0) {
            sb.append("R");
            
            if (dimension > 1) {
                sb.append("^{")
                  .append(dimension)
                  .append("}");
            }
        }

You could make a function that takes the base and power, and emits the resulting term. The only pesky issue is the trailing space in one version and not the other, but you could simply always emit the space. Or, emit the space before the term and remove the trailing space from the numerator:

        if (numerator.compareTo(BigInteger.ONE) > 0) {
            sb.append(numerator);
        }
        
        appendBaseAndPower(sb, "\\pi", piExponent);
        appendBaseAndPower(sb, "R", dimension);
\$\endgroup\$
1
\$\begingroup\$

The toString method of Volume class dynamically builds the pattern of the string to return and it could get improved readability by making the pattern it's building easier to read. With the improvements from the other answers the toString method of Volume class could get to:

@Override
public String toString() {
    
    StringBuilder sb = new StringBuilder();
    if ( numerator.compareTo(BigInteger.ONE) > 0 ) {
        sb.append(numerator).append(" ");
    }          
    if ( appendBaseAndPower(sb, "\\pi", piExponent) ) {
        sb.append(" ");
    }
    if ( !appendBaseAndPower(sb, "R", dimension) ) {
        sb.append("1");
    } 

    boolean plain = denominator.compareTo(BigInteger.ONE) == 0;
    String pattern = plain ? "%s" : "\\frac{%s}{%d}";

    return String.format(pattern, argument(sb.toString())
                                  .argument(denominator, !plain)
                                  .array());
}

... by enhancing the Volume class with next changes:

public static class Volume {

    private final BigInteger numerator;
    private final BigInteger denominator;
    private final int piExponent;
    public final int dimension;

    Volume(int dimension) {

        this.dimension   = checkDimension(dimension);
        this.piExponent  = dimension / 2;
        BigInteger divisor = BigInteger.ONE;;
        BigInteger dividend = BigInteger.ONE;;
        if (dimension % 2 == 0) {
            
            for (int k = 1; k <= dimension / 2; ++k) {
                divisor = divisor.multiply(BigInteger.valueOf(k));
            }
        } else {
            for (int k = 1; k <= dimension; k += 2) {
                dividend = dividend.multiply(BigInteger.valueOf(2));
                divisor = divisor.multiply(BigInteger.valueOf(k));
            }
        }
        this.numerator = dividend;
        this.denominator = divisor;
    }

    @Override
    public String toString() {
        
        StringBuilder sb = new StringBuilder();
        if ( numerator.compareTo(BigInteger.ONE) > 0 ) {
            sb.append(numerator).append(" ");
        }          
        if ( appendBaseAndPower(sb, "\\pi", piExponent) ) {
            sb.append(" ");
        }
        if ( !appendBaseAndPower(sb, "R", dimension) ) {
            sb.append("1");
        } 

        boolean plain = denominator.compareTo(BigInteger.ONE) == 0;
        String pattern = plain ? "%s" : "\\frac{%s}{%d}";

        return String.format(pattern, argument(sb.toString())
                                      .argument(denominator, !plain)
                                      .array());
    }
    
    private boolean appendBaseAndPower(StringBuilder sb
                                     , String base
                                     , int power) {
        if (power > 0) {
            sb.append(base);
            if (power > 1) {
                sb.append("^{").append(power).append("}");
            }
        }
        return power > 0;
    }

    private static int checkDimension(final int dimension) {
        if (dimension < 0) {
            final String exceptionMessage = String.format("dimension(%d) < 0"
                                                         , dimension);

            throw new IllegalArgumentException(exceptionMessage);
        }

        return dimension;
    }
    
    private static class Argument {
        
        public static final Argument from(Object object) {
            return new Argument(object);
        }
        
        private final Object[] initial;
        
        private Argument(Object object) {
            this.initial = new Object[] { object };
        }
        
        private Argument(Object object, Object... initials) {
            Object[] array = new Object[initials.length + 1];
            array[initials.length] = object;
            for ( int i = 0; i < initials.length; i++ ) {
                array[i] = initials[i];
            }
            this.initial = array;
        }
        
        public Argument argument(Object object, boolean required) {
            
            return required && object != null ? this.and(object)
                                              : this;
        }
        
        public Argument compulsory(Object object) {
            return object == null ? this : this.and(object);
        }
        
        public Object[] array() {
            return returnee(this.initial);
        }
        
        private Argument and(Object object) {
            return new Argument(object, this.initial);
        }
        
        private Object[] returnee(Object... objects) {
            return objects;
        }
    }
    
    private static Argument argument(Object object) {
        return Argument.from(object);
    }
}
\$\endgroup\$

You must log in to answer this question.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.