用 JAVA BigDecimal -monomial 计算 sin 函数会变大（？）

Question

I'm making sin function with BigDecimal in JAVA, and this is as far as I go:

package taylorSeries;

import java.math.BigDecimal;

public class Sin {

    private static final int cutOff = 20;
    
    public static void main(String[] args) {

        System.out.println(getSin(new BigDecimal(3.14159265358979323846264), 100));
        
    }

    public static BigDecimal getSin(BigDecimal x, int scale) {
        
        BigDecimal sign = new BigDecimal("-1");
        BigDecimal divisor = BigDecimal.ONE;
        BigDecimal i = BigDecimal.ONE;
        BigDecimal num = null;
        
        BigDecimal result = x;
        //System.err.println(x);
        do {
            
            x = x.abs().multiply(x.abs()).multiply(x).multiply(sign);
            
            i = i.add(BigDecimal.ONE);
            divisor = divisor.multiply(i);
            i = i.add(BigDecimal.ONE);
            divisor = divisor.multiply(i);
            
            num = x.divide(divisor, scale + cutOff, BigDecimal.ROUND_HALF_UP);
            
            result = result.add(num);
            //System.out.println("d : " + divisor);
            //System.out.println(divisor.compareTo(x.abs()));
            System.out.println(num.setScale(9, BigDecimal.ROUND_HALF_UP));
        } while(num.abs().compareTo(new BigDecimal("0.1").pow(scale + cutOff)) > 0);
        
        System.err.println(num);
        System.err.println(new BigDecimal("0.1").pow(scale + cutOff));
        return result.setScale(scale, BigDecimal.ROUND_HALF_UP);
        
    }

}

It uses Taylor series : picture of the fomular

The monomial x is added every iteration and always negative number. And the problem is, absolute value of x is getting bigger and bigger, so iteration never ends.

Is there and way to find them or better way to implement it from the first place?

EDIT:
I made this code from scratch with simple interest about trigonometric functions, and now I see lots of childish mistakes.

My intention first was like this:
num is x^(2k+1) / (2k+1)!
divisor is (2k+1)!
i is 2k+1
dividend is x^(2k+1)

So I update divisor and dividend with i and compute num by sign * dividend / divisor and add it to result by result = result.add(num)

so new and good-working code is:

package taylorSeries;

import java.math.BigDecimal;
import java.math.MathContext;

public class Sin {

    private static final int cutOff = 20;
    private static final BigDecimal PI = Pi.getPi(100);
    
    public static void main(String[] args) {

        System.out.println(getSin(Pi.getPi(100).multiply(new BigDecimal("1.5")), 100)); // Should be -1

    }

    public static BigDecimal getSin(final BigDecimal x, int scale) {
        
        if (x.compareTo(PI.multiply(new BigDecimal(2))) > 0) return getSin(x.remainder(PI.multiply(new BigDecimal(2)), new MathContext(x.precision())), scale);
        if (x.compareTo(PI) > 0) return getSin(x.subtract(PI), scale).multiply(new BigDecimal("-1"));
        if (x.compareTo(PI.divide(new BigDecimal(2))) > 0) return getSin(PI.subtract(x), scale);
        
        BigDecimal sign = new BigDecimal("-1");
        BigDecimal divisor = BigDecimal.ONE;
        BigDecimal i = BigDecimal.ONE;
        BigDecimal num = null;
        BigDecimal dividend = x;
        BigDecimal result = dividend;

        do {
            
            dividend = dividend.multiply(x).multiply(x).multiply(sign);
            
            i = i.add(BigDecimal.ONE);
            divisor = divisor.multiply(i);
            i = i.add(BigDecimal.ONE);
            divisor = divisor.multiply(i);
            
            num = dividend.divide(divisor, scale + cutOff, BigDecimal.ROUND_HALF_UP);
            
            result = result.add(num);

        } while(num.abs().compareTo(new BigDecimal("0.1").pow(scale + cutOff)) > 0);
        
        return result.setScale(scale, BigDecimal.ROUND_HALF_UP);
        
    }

}

Answer 1

1. The new BigDecimal(double) constructor is not something you generally want to be using; the whole reason BigDecimal exists in the first place is that double is wonky: There are almost 2^64 unique values that a double can represent, but that's it - (almost) 2^64 distinct values, smeared out logarithmically, with about a quarter of all available numbers between 0 and 1, a quarter from 1 to infinity, and the other half the same but as negative numbers. 3.14159265358979323846264 is not one of the blessed numbers. Use the string constructor instead - just toss " symbols around it.

2. every loop, sign should switch, well, sign. You're not doing that.

3. In the first loop, you overwrite x with x = x.abs().multiply(x.abs()).multiply(x).multiply(sign); , so now the 'x' value is actually -x^3 , and the original x value is gone . Next loop, you repeat this process, and thus you definitely are nowhere near the desired effect. The solution - don't overwrite x. You need x, throughout the calculation. Make it final ( getSin(final BigDecimal x) to help yourself.

Make another BigDecimal value and call it accumulator or what not. It starts out as a copy of x.

Every loop, you multiply x to it twice then toggle the sign. That way, the first time in the loop the accumulator is -x^3 . The second time, it is x^5 . The third time it is -x^7 , and so on.

4. There is more wrong, but at some point I'm just feeding you your homework on a golden spoon.

I strongly suggest you learn to debug. Debugging is simple! All you really do, is follow along with the computer. You calculate by hand and double check that what you get (be it the result of an expression, or whether a while loop loops or not), matches what the computer gets. Check by using a debugger, or if you don't know how to do that, learn, and if you don't want to, add a ton of System.out.println statements as debugging aids. There where your expectations mismatch what the computer is doing? You found a bug. Probably one of many.

Then consider splicing parts of your code up so you can more easily check the computer's work.

For example, here, num is supposed to reflect:

• before first loop: x
• first loop: x - x^3/3!
• second loop: x - x^3/3! + x^5/5! x - x^3/3! + x^5/5!

etcetera. But for debugging it'd be so much simpler if you have those parts separated out. You optimally want:

• first loop: 3 separated concepts: -1 , x^3 , and 3! .
• second loop: +1 , x^5 , and 5! .

That debugs so much simpler.

It also leads to cleaner code, generally, so I suggest you make these separate concepts as variables, describe them, write a loop and test that they are doing what you want (eg you use sysouts or a debugger to actually observe the power accumulator value hopping from x to x^3 to x^5 - this is easily checked), and finally put it all together.

This is a much better way to write code than to just 'write it all, run it, realize it doesn't work, shrug, raise an eyebrow, head over to stack overflow, and pray someone's crystal ball is having a good day and they see my question'.

Answer 2

The fact that the terms are all negative is not the problem (though you must make it alternate to get the correct series).

The term magnitude is x^(2k+1) / (2k+1)! . The numerator is indeed growing, but so is the denominator, and past k = x , the denominator starts to "win" and the series always converges.

Anyway, you should limit yourself to small x s, otherwise the computation will be extremely lengthy, with very large products.

For the computation of the sine, always begin by reducing the argument to the range [0,π] . Even better, if you jointly develop a cosine function, you can reduce to [0,π/2] .