[读者文库]Java Number Cruncher

1. Listing 5-1a. The class that implements the bisection algorithm.
   
2. 
   
3. Code View: Scroll / Show All
   
4. package numbercruncher.mathutils;
   
5. 
   
6. /**
   
7. * The root finder class that implements the bisection algorithm.
   
8. */
   
9. public class BisectionRootFinder extends RootFinder
   
10. {
    
11.     private static final int   MAX_ITERS = 50;
    
12.     private static final float TOLERANCE = 100*Epsilon.floatValue();
    
13. 
    
14.     /** x-negative value */         private float    xNeg;
    
15.     /** x-middle value */           private float    xMid = Float.NaN;
    
16.     /** x-positive value */         private float    xPos;
    
17.     /** previous x-middle value */  private float    prevXMid;
    
18.     /** f(xNeg) */                  private float    fNeg;
    
19.     /** f(xMid) */                  private float    fMid;
    
20.     /** f(xPos) */                  private float    fPos;
    
21. 
    
22.     /**
    
23.      * Constructor.
    
24.      * @param function the functions whose roots to find
    
25.      * @param xMin the initial x-value where the function is negative
    
26.      * @param xMax the initial x-value where the function is positive
    
27.      * @throws RootFinder.InvalidIntervalException
    
28.      */
    
29.     public BisectionRootFinder(Function function,
    
30.                                float xMin, float xMax)
    
31.         throws RootFinder.InvalidIntervalException
    
32.     {
    
33.         super(function, MAX_ITERS);
    
34.         checkInterval(xMin, xMax);
    
35. 
    
36.         float yMin = function.at(xMin);
    
37.         float yMax = function.at(xMax);
    
38. 
    
39.         // Initialize xNeg, fNeg, xPos, and fPos.
    
40.         if (yMin < 0) {
    
41.             xNeg = xMin; xPos = xMax;
    
42.             fNeg = yMin; fPos = yMax;
    
43.         }
    
44.         else {
    
45.             xNeg = xMax; xPos = xMin;
    
46.             fNeg = yMax; fPos = yMin;
    
47.         }
    
48.     }
    
49. 
    
50.     //–––––––––//
    
51.     // Getters //
    
52.     //–––––––––//
    
53. 
    
54.     /**
    
55.      * Return the current value of x-negative.
    
56.      * @return the value
    
57.      */
    
58.     public float getXNeg() { return xNeg; }
    
59. 
    
60.     /**
    
61.      * Return the current value of x-middle.
    
62.      * @return the value
    
63.      */
    
64.     public float getXMid() { return xMid; }
    
65. 
    
66.     /**
    
67.      * Return the current value of x-positive.
    
68.      * @return the value
    
69.      */
    
70.     public float getXPos() { return xPos; }
    
71. 
    
72.     /**
    
73.      * Return the current value of f(x-negative).
    
74.      * @return the value
    
75.      */
    
76.     public float getFNeg() { return fNeg; }
    
77. 
    
78.     /**
    
79.      * Return the current value of f(x-middle).
    
80.      * @return the value
    
81.      */
    
82.     public float getFMid() { return fMid; }
    
83. 
    
84.     /**
    
85.      * Return the current value of f(x-positive).
    
86.      * @return the value
    
87.      */
    
88.     public float getFPos() { return fPos; }
    
89. 
    
90.     //-----------------------------//
    
91.     // RootFinder method overrides //
    
92.     //-----------------------------//
    
93. 
    
94.     /**
    
95.      * Do the bisection iteration procedure.
    
96.      * @param n the iteration count
    
97.      */
    
98.     protected void doIterationProcedure(int n)
    
99.     {
    
100.         if (n == 1) return;     // already initialized
     
101. 
     
102.         if (fMid < 0) {
     
103.             xNeg = xMid;        // the root is in the xPos half
     
104.             fNeg = fMid;
     
105.         }
     
106.         else {
     
107.             xPos = xMid;        // the root is in the xNeg half
     
108.             fPos = fMid;
     
109.         }
     
110.     }
     
111. 
     
112.     /**
     
113.      * Compute the next position of xMid.
     
114.      */
     
115.     protected void computeNextPosition()
     
116.     {
     
117.         prevXMid = xMid;
     
118.         xMid     = (xNeg + xPos)/2;
     
119.         fMid     = function.at(xMid);
     
120.     }
     
121. 
     
122.     /**
     
123.      * Check the position of xMid.
     
124.      * @throws PositionUnchangedException
     
125.      */
     
126.     protected void checkPosition()
     
127.         throws RootFinder.PositionUnchangedException
     
128.     {
     
129.         if (xMid == prevXMid) {
     
130.             throw new RootFinder.PositionUnchangedException();
     
131.         }
     
132.     }
     
133. 
     
134.     /**
     
135.      * Indicate whether or not the algorithm has converged.
     
136.      * @return true if converged, else false
     
137.      */
     
138.     protected boolean hasConverged()
     
139.     {
     
140.         return Math.abs(fMid) < TOLERANCE;
     
141.     }
     
142. }
     
143. 
     
144. 
     
145.                                           

复制代码

1. Listing 5-1b. The noninteractive version of Program 5–1 applies the bisection algorithm to the function f(x) = x2 − 4 in the initial interval [−0.25, 3.25].
   
2. 
   
3. Code View: Scroll / Show All
   
4. package numbercruncher.program5_1;
   
5. 
   
6. import numbercruncher.mathutils.Function;
   
7. import numbercruncher.mathutils.BisectionRootFinder;
   
8. import numbercruncher.mathutils.AlignRight;
   
9. import numbercruncher.rootutils.RootFunctions;
   
10. 
    
11. /**
    
12. * PROGRAM 5–1: Bisection Algorithm
    
13. *
    
14. * Demonstrate the Bisection Algorithm on a function.
    
15. */
    
16. public class BisectionAlgorithm
    
17. {
    
18.     /**
    
19.      * Main program.
    
20.      * @param args the array of runtime arguments
    
21.      */
    
22.     public static void main(String args[])
    
23.     {
    
24.         try {
    
25.             BisectionRootFinder finder =
    
26.                 new BisectionRootFinder(
    
27.                         RootFunctions.function("x^2 - 4"),
    
28.                                                -0.25f, 3.25f);
    
29. 
    
30.             AlignRight ar = new AlignRight();
    
31. 
    
32.             ar.print("n", 2);
    
33.             ar.print("xNeg", 10); ar.print("f(xNeg)", 14);
    
34.             ar.print("xMid", 10); ar.print("f(xMid)", 14);
    
35.             ar.print("xPos", 10); ar.print("f(xPos)", 13);
    
36.             ar.underline();
    
37. 
    
38.             // Loop until convergence or failure.
    
39.             boolean converged;
    
40.             do {
    
41.                 converged = finder.step();
    
42. 
    
43.                 ar.print(finder.getIterationCount(), 2);
    
44.                 ar.print(finder.getXNeg(), 10);
    
45.                 ar.print(finder.getFNeg(), 14);
    
46.                 ar.print(finder.getXMid(), 10);
    
47.                 ar.print(finder.getFMid(), 14);
    
48.                 ar.print(finder.getXPos(), 10);
    
49.                 ar.print(finder.getFPos(), 13);
    
50.                 ar.println();
    
51.             } while (!converged);
    
52.             System.out.println("\nSuccess! Root = " +
    
53.                                finder.getXMid());
    
54.         }
    
55.         catch(Exception ex) {
    
56.             System.out.println("***** Error: " + ex);
    
57.         }
    
58.     }
    
59. }
    
60. 
    
61. 
    
62.                                           

复制代码