Package org.jcsp.plugNplay.ints

This provides an assortment of plug-and-play CSP components to wire together (with int-carrying wires) and reuse.

See:
Description

Class Summary

AndInt	Bitwise ands two integer streams to one stream.
BlackHoleInt	Black holes anything sent to it.
Delta2Int	This process broadcasts integers arriving on its input channel in parallel to its two output channels.
DeltaInt	This process broadcasts integers arriving on its input channel in parallel to its array of output channels.
DemultiplexInt	This demultiplexes data from its input channel to its output channel array.
DeparaplexInt	This demultiplexes data from its input channel to its output channel array.
DynamicDeltaInt	This process broadcasts integers arriving on its input channel in parallel to its output channel array -- those output channels can be changed dynamically.
FibonacciInt	This generates the Fibonacci sequence on its output channel.
FixedDelayInt	This holds on to data from its input channel for a fixed delay before passing it on to its output channel.
GenerateInt	Generates an infinite (constant) sequence of ints.
IdentityInt	This copies its input stream to its output stream unchanged.
IntegrateInt	This is a running-sum integrator of the ints on its input stream to its output stream.
Merge2Int	Merges two strictly increasing int input streams into one strictly increasing output stream.
MergeInt	Merges an array of strictly increasing int input streams into one strictly increasing output stream.
MultInt	Scales an integer stream.
MultiplexInt	Fair multiplexes its input integer stream array into one output stream (carrying source channel and data pairs).
NandInt	Bitwise nands two integer streams to one stream.
NorInt	Bitwise nors two integer streams to one stream.
NumbersInt	Plugs together a network of low-level stateless components to generate the sequence of natural numbers.
OrInt	Bitwise ors two integer streams to one stream.
PairsInt	Generates sums of successive pairs of input values.
ParaplexInt	Parallel multiplexes its input integer stream array on to one output stream.
Plex2Int	Fair multiplexes two integer streams into one.
PlexInt	Fair multiplexes its input integer stream array into one output stream.
PlusInt	Sums two integer streams to one stream.
PrefixInt	Prefixes a user-supplied integer to the int stream flowing through.
PrinterInt	Prints each int from its input channel to a PrintStream.
ProcessReadInt	Reads one int from its input channel.
ProcessWriteInt	Writes one int to its output channel.
RegularInt	This process generates a constant stream of Integers at a regular rate.
RegulateInt	This process controls the rate of flow of traffic from its input to output channels.
SignInt	Converts each input int to a String, prefixing it with a user-defined sign.
SquaresInt	Generates the integer stream 1*1, 2*2, 3*3, etc by a somewhat unusual route.
SubstituteInt	Substitutes a user-configured constant for each integer in the stream flowing through.
SuccessorInt	Adds one to each integer in the stream flowing through.
TailInt	The output stream is the tail of its input stream.
TimesInt	Multiplies two integer streams to one stream.
XorInt	Bitwise xors two integer streams to one stream.

Package org.jcsp.plugNplay.ints Description

This provides an assortment of plug-and-play CSP components to wire together (with int-carrying wires) and reuse. Primarilly they are for education/demonstration purposes, but some have value for general applications (e.g. DeltaInt, DynamicDeltaInt, PlexInt, MultiplexInt, DemultiplexInt, ProcessReadInt, ProcessWriteInt, ...).

The educational purpose is to demonstrate how simple it is to build layered networks of communicating processes. Each component works to a clean channel interface. Component instances can just be wired together. A network of such components is itself another (CSP) component. Network design and analysis takes place independently at each level - we do not have to think about the whole network hierarchy to reason about each level. This enables us to construct components with arbitrarilly rich behaviour without running into combinatorial explosions of complexity.

Examples are given of networks with 20-30 processes (threads). Because of the component layering, we never need to consider more than about 5 at a time and it is easy to see what they do and that they are without deadlock, livelock, starvation or race-hazard problems.