Interface  Description 

Operation<T> 
Interface for implementing arbitrary operations to be executed.

OperationExecutor 
Interface for implementing objects that can execute
Operation s. 
Pi.BinarySplittingSeries 
Terms for the binary splitting series.

PiAWT.StatusIndicator 
Interface to indicate an error status in the application.

Class  Description 

ApfloatHolder 
Simple JavaBean to hold one
Apfloat . 
BackgroundOperation<T> 
Class for running an
Operation in the background in a separate thread. 
LocalOperationExecutor 
Class to execute
Operation s locally. 
OperationServer 
Server for executing
Operation s from remote calls. 
Pi 
Calculates pi using four different algorithms.

Pi.AbstractBinarySplittingSeries 
Abstract base class for the binary splitting series.

Pi.BinarySplittingPiCalculator 
Class for implementing the binary splitting algorithm.

Pi.BinarySplittingProgressIndicator 
Indicates progress of the pi calculation using
the binary splitting algorithm.

Pi.BorweinPiCalculator 
Calculates pi using the Borweins' quartic algorithm.

Pi.ChudnovskyBinarySplittingSeries 
Chudnovskys' algorithm terms for the binary splitting series.

Pi.ChudnovskyPiCalculator 
Basic class for calculating pi using the Chudnovskys' binary splitting algorithm.

Pi.GaussLegendrePiCalculator 
Calculates pi using the GaussLegendre algorithm.

Pi.RamanujanBinarySplittingSeries 
Ramanujan's algorithm terms for the binary splitting series.

Pi.RamanujanPiCalculator 
Basic class for calculating pi using the Ramanujan binary splitting algorithm.

PiApplet 
Applet for calculating pi using four different algorithms.

PiAWT 
Graphical AWT elements for calculating pi using four different algorithms.

PiDistributed 
Calculates pi using a cluster of servers.

PiDistributed.DistributedBinarySplittingPiCalculator 
Distributed version of the binary splitting algorithm.

PiDistributed.DistributedChudnovskyPiCalculator 
Class for calculating pi using the distributed Chudnovskys' binary splitting algorithm.

PiDistributed.DistributedRamanujanPiCalculator 
Class for calculating pi using the distributed Ramanujan's binary splitting algorithm.

PiDistributed.Node 
RemoteOperationExecutor that implements the weight property.

PiGUI 
AWT client application for calculating pi using four different algorithms.

PiParallel 
Calculates pi using multiple threads in parallel.

PiParallel.ParallelBinarySplittingPiCalculator 
Parallel version of the binary splitting algorithm.

PiParallel.ParallelChudnovskyPiCalculator 
Class for calculating pi using the parallel Chudnovskys' binary splitting algorithm.

PiParallel.ParallelRamanujanPiCalculator 
Class for calculating pi using the parallel Ramanujan's binary splitting algorithm.

PiParallel.ThreadLimitedOperation<T> 
Class to execute operations while setting
ApfloatContext.setNumberOfProcessors(int)
to some value. 
PiParallelApplet 
Applet for calculating pi using multiple threads in parallel.

PiParallelAWT 
Graphical AWT elements for calculating pi using multiple threads in parallel.

PiParallelGUI 
AWT client application for calculating pi using multiple threads in parallel.

RemoteOperationExecutor 
Class to call an
OperationServer to execute Operation s remotely. 
Three different versions of an application for calculating π are
included. The simplest, Pi
runs on one
computer using one processor (and one thread) only. PiParallel
executes multiple threads in parallel and has vastly better performance
on multicore computers. Finally, PiDistributed
can use multiple separate computers for calculating pi with even
greater processing power.
As a curiosity, two applets are provided for running Pi
and PiParallel
through a graphical user
interface: PiApplet
and PiParallelApplet
,
correspondingly. These programs can also be run as standalone
Java applications: PiGUI
and PiParallelGUI
.
Compared to the C++ version of apfloat, the Java version pi calculation program is usually just as fast. Even in worst cases the Java version achieves roughly 50% of the performance of the assembleroptimized C++ versions of apfloat. Modern JVMs are nearly as efficient as optimizing C++ compilers in code generation. The advantage that JVMs have over native C++ compilers is obviously that the JVM generates optimal code for every target architecture and runtime profile automatically, from an intermediate portable binary executable format. With C++, the source code must be compiled and profiled manually for every target architecture, which can be difficult and tedious.
On multicore computers the Java parallel pi calculator is often significantly faster than the C++ parallel version. The same applies to the distributed pi calculator. Multithreaded and distributed applications are more efficient to implement in Java due to C++'s historical lack of standard libraries for threading and networking.
Copyright © 2017. All rights reserved.