+/EE360P

distributed systems

git clone https://git.julia.blue/+/EE360P

vijaygarg1Java RMI example87dd79b

master
4.4 KiB126 linesraw
1/*
2 * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 *   - Redistributions of source code must retain the above copyright
9 *     notice, this list of conditions and the following disclaimer.
10 *
11 *   - Redistributions in binary form must reproduce the above copyright
12 *     notice, this list of conditions and the following disclaimer in the
13 *     documentation and/or other materials provided with the distribution.
14 *
15 *   - Neither the name of Oracle or the names of its
16 *     contributors may be used to endorse or promote products derived
17 *     from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
20 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */ 
31
32package client;
33
34import compute.Task;
35import java.io.Serializable;
36import java.math.BigDecimal;
37
38public class Pi implements Task<BigDecimal>, Serializable {
39
40    private static final long serialVersionUID = 227L;
41
42    /** constants used in pi computation */
43    private static final BigDecimal FOUR =
44        BigDecimal.valueOf(4);
45
46    /** rounding mode to use during pi computation */
47    private static final int roundingMode = 
48        BigDecimal.ROUND_HALF_EVEN;
49
50    /** digits of precision after the decimal point */
51    private final int digits;
52    
53    /**
54     * Construct a task to calculate pi to the specified
55     * precision.
56     */
57    public Pi(int digits) {
58        this.digits = digits;
59    }
60
61    /**
62     * Calculate pi.
63     */
64    public BigDecimal execute() {
65        return computePi(digits);
66    }
67
68    /**
69     * Compute the value of pi to the specified number of 
70     * digits after the decimal point.  The value is 
71     * computed using Machin's formula:
72     *
73     *          pi/4 = 4*arctan(1/5) - arctan(1/239)
74     *
75     * and a power series expansion of arctan(x) to 
76     * sufficient precision.
77     */
78    public static BigDecimal computePi(int digits) {
79        int scale = digits + 5;
80        BigDecimal arctan1_5 = arctan(5, scale);
81        BigDecimal arctan1_239 = arctan(239, scale);
82        BigDecimal pi = arctan1_5.multiply(FOUR).subtract(
83                                  arctan1_239).multiply(FOUR);
84        return pi.setScale(digits, 
85                           BigDecimal.ROUND_HALF_UP);
86    }
87    /**
88     * Compute the value, in radians, of the arctangent of 
89     * the inverse of the supplied integer to the specified
90     * number of digits after the decimal point.  The value
91     * is computed using the power series expansion for the
92     * arc tangent:
93     *
94     * arctan(x) = x - (x^3)/3 + (x^5)/5 - (x^7)/7 + 
95     *     (x^9)/9 ...
96     */   
97    public static BigDecimal arctan(int inverseX, 
98                                    int scale) 
99    {
100        BigDecimal result, numer, term;
101        BigDecimal invX = BigDecimal.valueOf(inverseX);
102        BigDecimal invX2 = 
103            BigDecimal.valueOf(inverseX * inverseX);
104
105        numer = BigDecimal.ONE.divide(invX,
106                                      scale, roundingMode);
107
108        result = numer;
109        int i = 1;
110        do {
111            numer = 
112                numer.divide(invX2, scale, roundingMode);
113            int denom = 2 * i + 1;
114            term = 
115                numer.divide(BigDecimal.valueOf(denom),
116                             scale, roundingMode);
117            if ((i % 2) != 0) {
118                result = result.subtract(term);
119            } else {
120                result = result.add(term);
121            }
122            i++;
123        } while (term.compareTo(BigDecimal.ZERO) != 0);
124        return result;
125    }
126}