com.github.jessemull.microflexinteger.math

Class MathOperationBinary

java.lang.Object

com.github.jessemull.microflexinteger.math.MathOperationBinary

Direct Known Subclasses:

Addition, AND, Division, Modulus, Multiplication, OR, Subtraction, XOR

public abstract class MathOperationBinary
extends Object

This class performs mathematical operations with two arguments for integer plate stacks, plates, wells and well sets. To create a custom mathematical operation extend this class and override the calculate methods using the appropriate operation. Operations can be performed on stacks, plates, sets or wells of uneven length using standard or strict functions. Standard functions treat all values missing from a data set as zeroes and combine all stacks, plates, sets and wells from both input objects. Strict functions omit all values, stacks, plates, wells and sets missing from one of the input objects:

Operation	Output
Standard	Treats missing values as zeroes Combines stacks, plates, sets, wells and values from both input objects
Strict	Omits all missing values Combines stacks, plates, sets, wells and values present in both input objects only

The functions within the MicroFlex library are designed to be flexible and the math operation binary object supports operations using two stacks, plates, sets and well objects as input. In addition, it supports operations using a single stack, plate, set or well object and a collection, array or constant. It also allows the developer to limit the operation to a subset of data:

Input 1	Input 2	Beginning Index	Length of Subset	Operation
Well	Well	+/-	+/-	Performs the operation using the values in the two wells
Well	Array	+/-	+/-	Performs the operation using the values in the array and the values in the well
Well	Collection	+/-	+/-	Performs the operation using the values in the collection and the values in the well
Well	Constant	+/-	+/-	Performs the operation using the constant value and each value in the well
Set	Set	+/-	+/-	Performs the operation on the values in each matching pair of wells in the two sets
Set	Array	+/-	+/-	Performs the operation using the values in the array and the values in each well of the set
Set	Collection	+/-	+/-	Performs the operation using the values in the collection and the values in each well of the set
Set	Constant	+/-	+/-	Performs the operation using the constant and each value in each well of the set
Plate	Plate	+/-	+/-	Performs the operation on the values in each matching pair of wells in the two plates
Plate	Array	+/-	+/-	Performs the operation using the values in the array and the values in each well of the plate
Plate	Collection	+/-	+/-	Performs the operation using the values in the collection and the values in each well of the plate
Plate	Constant	+/-	+/-	Performs the operation using the constant and each value in each well of the plate
Stack	Stack	+/-	+/-	Performs the operation on the values in each matching pair of wells in each matching plate in the stack
Stack	Array	+/-	+/-	Performs the operation using the values in the array and the values in each well of each plate in the stack
Stack	Collection	+/-	+/-	Performs the operation using the values in the collection and the values in each well of each plate in the stack
Stack	Constant	+/-	+/-	Performs the operation using the constant and each value in each well of each plate in the stack

MicroFlex currently supports the following binary mathematical operations for integer values:

Operations
Addition
Subtraction
Multiplication
Division
Modulus
Logical AND
Logical OR
Logical XOR

Author:

Jesse L. Mull

Constructor Summary

Constructors

Constructor and Description
MathOperationBinary() Creates a new math operation.

Method Summary

Modifier and Type	Method and Description
abstract List<Integer>	calculate(List<Integer> list, Collection<Integer> collection) Performs the mathematical operation for the two lists.
abstract List<Integer>	calculate(List<Integer> list, Collection<Integer> collection, int begin, int length) Performs the mathematical operation for the two lists.
abstract List<Integer>	calculate(List<Integer> list, int constant) Performs the mathematical operation for the two lists.
abstract List<Integer>	calculate(List<Integer> list, int[] array) Performs the mathematical operation for the two lists.
abstract List<Integer>	calculate(List<Integer> list, int[] array, int begin, int length) Performs the mathematical operation for the two lists.
abstract List<Integer>	calculate(List<Integer> list1, List<Integer> list2) Performs the mathematical operation for the two lists.
abstract List<Integer>	calculate(List<Integer> list1, List<Integer> list2, int begin, int length) Performs the mathematical operation for the two lists using the values between the indices.
abstract List<Integer>	calculateStrict(List<Integer> list, Collection<Integer> collection) Performs the mathematical operation for the two lists.
abstract List<Integer>	calculateStrict(List<Integer> list, Collection<Integer> collection, int begin, int length) Performs the mathematical operation for the two lists.
abstract List<Integer>	calculateStrict(List<Integer> list, int[] array) Performs the mathematical operation for the two lists.
abstract List<Integer>	calculateStrict(List<Integer> list, int[] array, int begin, int length) Performs the mathematical operation for the two lists.
abstract List<Integer>	calculateStrict(List<Integer> list1, List<Integer> list2) Performs the mathematical operation for the two lists.
abstract List<Integer>	calculateStrict(List<Integer> list1, List<Integer> list2, int begin, int length) Performs the mathematical operation for the two lists.
Plate	plates(Plate plate, Collection<Integer> collection) Returns the result of the mathematical operation.
Plate	plates(Plate plate, Collection<Integer> collection, int begin, int length) Returns the result of the mathematical operation.
Plate	plates(Plate plate, int constant) Returns the result of the mathematical operation.
Plate	plates(Plate plate, int[] array) Returns the result of the mathematical operation.
Plate	plates(Plate plate, int[] array, int begin, int length) Returns the result of the mathematical operation.
Plate	plates(Plate plate1, Plate plate2) Returns the result of the mathematical operation.
Plate	plates(Plate plate1, Plate plate2, int begin, int length) Returns the result of the mathematical operation using the values between the indices.
Plate	platesStrict(Plate plate, Collection<Integer> collection) Returns the result of the mathematical operation.
Plate	platesStrict(Plate plate, Collection<Integer> collection, int begin, int length) Returns the result of the mathematical operation.
Plate	platesStrict(Plate plate, int[] array) Returns the result of the mathematical operation.
Plate	platesStrict(Plate plate, int[] array, int begin, int length) Returns the result of the mathematical operation.
Plate	platesStrict(Plate plate1, Plate plate2) Returns the result of the mathematical operation.
Plate	platesStrict(Plate plate1, Plate plate2, int begin, int length) Returns the result of the mathematical operation using the values between the indices.
WellSet	sets(WellSet set, Collection<Integer> collection) Returns the result of the mathematical operation.
WellSet	sets(WellSet set, Collection<Integer> collection, int begin, int length) Returns the result of the mathematical operation.
WellSet	sets(WellSet set, int constant) Returns the result of the mathematical operation.
WellSet	sets(WellSet set, int[] array) Returns the result of the mathematical operation.
WellSet	sets(WellSet set, int[] array, int begin, int length) Returns the result of the mathematical operation.
WellSet	sets(WellSet set1, WellSet set2) Returns the result of the mathematical operation.
WellSet	sets(WellSet set1, WellSet set2, int begin, int length) Returns the result of the mathematical operation using the values between the indices.
WellSet	setsStrict(WellSet set, Collection<Integer> collection) Returns the result of the mathematical operation.
WellSet	setsStrict(WellSet set, Collection<Integer> collection, int begin, int length) Returns the result of the mathematical operation.
WellSet	setsStrict(WellSet set, int[] array) Returns the result of the mathematical operation.
WellSet	setsStrict(WellSet set, int[] array, int begin, int length) Returns the result of the mathematical operation.
WellSet	setsStrict(WellSet set1, WellSet set2) Returns the result of the mathematical operation.
WellSet	setsStrict(WellSet set1, WellSet set2, int begin, int length) Returns the result of the mathematical operation using the values between the indices.
Stack	stacks(Stack stack, Collection<Integer> collection) Returns the result of the mathematical operation.
Stack	stacks(Stack stack, Collection<Integer> collection, int begin, int length) Returns the result of the mathematical operation.
Stack	stacks(Stack stack, int constant) Returns the result of the mathematical operation.
Stack	stacks(Stack stack, int[] array) Returns the result of the mathematical operation.
Stack	stacks(Stack stack, int[] array, int begin, int length) Returns the result of the mathematical operation.
Stack	stacks(Stack stack1, Stack stack2) Returns the result of the mathematical operation.
Stack	stacks(Stack stack1, Stack stack2, int begin, int length) Returns the result of the mathematical operation using the values between the indices.
Stack	stacksStrict(Stack stack, Collection<Integer> collection) Returns the result of the mathematical operation.
Stack	stacksStrict(Stack stack, Collection<Integer> collection, int begin, int length) Returns the result of the mathematical operation.
Stack	stacksStrict(Stack stack, int[] array) Returns the result of the mathematical operation.
Stack	stacksStrict(Stack stack, int[] array, int begin, int length) Returns the result of the mathematical operation.
Stack	stacksStrict(Stack stack1, Stack stack2) Returns the result of the mathematical operation.
Stack	stacksStrict(Stack stack1, Stack stack2, int begin, int length) Returns the result of the mathematical operation using the values between the indices.
List<Integer>	wells(Well well, Collection<Integer> collection) Returns the result of the mathematical operation.
List<Integer>	wells(Well well, Collection<Integer> collection, int begin, int length) Returns the result of the mathematical operation.
List<Integer>	wells(Well well, int constant) Returns the result of the mathematical operation.
List<Integer>	wells(Well well, int[] array) Returns the result of the mathematical operation.
List<Integer>	wells(Well well, int[] array, int begin, int length) Returns the result of the mathematical operation.
List<Integer>	wells(Well well1, Well well2) Returns the result of the mathematical operation.
List<Integer>	wells(Well well1, Well well2, int begin, int length) Returns the result of the mathematical operation using the data between the indices.
List<Integer>	wellsStrict(Well well, Collection<Integer> collection) Returns the result of the mathematical operation.
List<Integer>	wellsStrict(Well well, Collection<Integer> collection, int begin, int length) Returns the result of the mathematical operation.
List<Integer>	wellsStrict(Well well, int[] array) Returns the result of the mathematical operation.
List<Integer>	wellsStrict(Well well, int[] array, int begin, int length) Returns the result of the mathematical operation.
List<Integer>	wellsStrict(Well well1, Well well2) Returns the result of the mathematical operation.
List<Integer>	wellsStrict(Well well1, Well well2, int begin, int length) Returns the result of the mathematical operation using the data between the indices.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

MathOperationBinary

public MathOperationBinary()

Creates a new math operation.

Method Detail

wells

public List<Integer> wells(Well well1,
                           Well well2)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are treated as zeroes.

Parameters:

Well - the first well

Well - the second well

Returns:

result of the operation

wells

public List<Integer> wells(Well well1,
                           Well well2,
                           int begin,
                           int length)

Returns the result of the mathematical operation using the data between the indices. Missing data points due to uneven data set lengths are treated as zeroes.

Parameters:

Well - the first well

Well - the second well

int - beginning index of the subset

int - length of the subset

Returns:

result of the operation

wellsStrict

public List<Integer> wellsStrict(Well well1,
                                 Well well2)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are omitted.

Parameters:

Well - the first well

Well - the second well

Returns:

result of the operation

wellsStrict

public List<Integer> wellsStrict(Well well1,
                                 Well well2,
                                 int begin,
                                 int length)

Returns the result of the mathematical operation using the data between the indices. Missing data points due to uneven data set lengths are omitted.

Parameters:

Well - the first well

Well - the second well

int - beginning index of the subset

int - length of the subset

Returns:

result of the operation

wells

public List<Integer> wells(Well well,
                           int constant)

Returns the result of the mathematical operation.

Parameters:

Well - the well

int - constant for operation

Returns:

result of the operation

wells

public List<Integer> wells(Well well,
                           int[] array)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are treated as zeroes.

Parameters:

Well - the well

int[] - array for the operation

Returns:

result of the operation

wells

public List<Integer> wells(Well well,
                           int[] array,
                           int begin,
                           int length)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are treated as zeroes.

Parameters:

Well - the well

int[] - array for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

wells

public List<Integer> wells(Well well,
                           Collection<Integer> collection)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are treated as zeroes.

Parameters:

Well - the well

Collection - collection for the operation

Returns:

result of the operation

wells

public List<Integer> wells(Well well,
                           Collection<Integer> collection,
                           int begin,
                           int length)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are treated as zeroes.

Parameters:

Well - the well

Collection - collection for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

wellsStrict

public List<Integer> wellsStrict(Well well,
                                 int[] array)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are omitted.

Parameters:

Well - the well

int[] - array for the operation

Returns:

result of the operation

wellsStrict

public List<Integer> wellsStrict(Well well,
                                 int[] array,
                                 int begin,
                                 int length)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are omitted.

Parameters:

Well - the well

int[] - array for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

wellsStrict

public List<Integer> wellsStrict(Well well,
                                 Collection<Integer> collection)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are omitted.

Parameters:

Well - the well

Collection - collection for the operation

Returns:

result of the operation

wellsStrict

public List<Integer> wellsStrict(Well well,
                                 Collection<Integer> collection,
                                 int begin,
                                 int length)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are omitted.

Parameters:

Well - the well

Collection - collection for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

plates

public Plate plates(Plate plate1,
                    Plate plate2)

Returns the result of the mathematical operation. Missing data points due to unequal data set lengths are treated as zero values.

Parameters:

Plate - the first plate

Plate - the second plate

Returns:

result of the operation

plates

public Plate plates(Plate plate1,
                    Plate plate2,
                    int begin,
                    int length)

Returns the result of the mathematical operation using the values between the indices. Missing data points due to data sets of unequal length are treated as zero values.

Parameters:

Plate - the first plate

Plate - the second plate

int - beginning index of the subset

int - length of the subset

Returns:

result of the operation

platesStrict

public Plate platesStrict(Plate plate1,
                          Plate plate2)

Returns the result of the mathematical operation. Missing data points due to unequal data set lengths are omitted.

Parameters:

Plate - the first plate

Plate - the second plate

Returns:

result of the operation

platesStrict

public Plate platesStrict(Plate plate1,
                          Plate plate2,
                          int begin,
                          int length)

Returns the result of the mathematical operation using the values between the indices. Missing data points due to unequal data set lengths are omitted.

Parameters:

Plate - the first plate

Plate - the second plate

int - beginning index of the subset

int - length of the subset

Returns:

result of the operation

plates

public Plate plates(Plate plate,
                    int constant)

Returns the result of the mathematical operation.

Parameters:

Plate - the plate

int - constant for operation

Returns:

result of the operation

plates

public Plate plates(Plate plate,
                    int[] array)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are treated as zeroes.

Parameters:

Plate - the plate

int[] - array for the operation

Returns:

result of the operation

plates

public Plate plates(Plate plate,
                    int[] array,
                    int begin,
                    int length)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are treated as zeroes.

Parameters:

Plate - the plate

int[] - array for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

plates

public Plate plates(Plate plate,
                    Collection<Integer> collection)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are treated as zeroes.

Parameters:

Plate - the plate

Collection - collection for the operation

Returns:

result of the operation

plates

public Plate plates(Plate plate,
                    Collection<Integer> collection,
                    int begin,
                    int length)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are treated as zeroes.

Parameters:

Plate - the plate

Collection - collection for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

platesStrict

public Plate platesStrict(Plate plate,
                          int[] array)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are omitted.

Parameters:

Plate - the plate

int[] - array for the operation

Returns:

result of the operation

platesStrict

public Plate platesStrict(Plate plate,
                          int[] array,
                          int begin,
                          int length)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are omitted.

Parameters:

Plate - the plate

int[] - array for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

platesStrict

public Plate platesStrict(Plate plate,
                          Collection<Integer> collection)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are omitted.

Parameters:

Plate - the plate

Collection - collection for the operation

Returns:

result of the operation

platesStrict

public Plate platesStrict(Plate plate,
                          Collection<Integer> collection,
                          int begin,
                          int length)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are omitted.

Parameters:

Plate - the plate

Collection - collection for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

sets

public WellSet sets(WellSet set1,
                    WellSet set2)

Returns the result of the mathematical operation. Missing data points due to unequal data set lengths are treated as zero values.

Parameters:

WellSet - the first set

WellSet - the second set

Returns:

result of the operation

sets

public WellSet sets(WellSet set1,
                    WellSet set2,
                    int begin,
                    int length)

Returns the result of the mathematical operation using the values between the indices. Missing data points due to data sets of unequal length are treated as zero values.

Parameters:

WellSet - the first set

WellSet - the second set

int - beginning index of the subset

int - length of the subset

Returns:

result of the operation

setsStrict

public WellSet setsStrict(WellSet set1,
                          WellSet set2)

Returns the result of the mathematical operation. Missing data points due to unequal data set lengths are omitted.

Parameters:

WellSet - the first set

WellSet - the second set

Returns:

result of the operation

setsStrict

public WellSet setsStrict(WellSet set1,
                          WellSet set2,
                          int begin,
                          int length)

Returns the result of the mathematical operation using the values between the indices. Missing data points due to unequal data set lengths are omitted.

Parameters:

WellSet - the first set

WellSet - the second set

int - beginning index of the subset

int - length of the subset

Returns:

result of the operation

sets

public WellSet sets(WellSet set,
                    int constant)

Returns the result of the mathematical operation.

Parameters:

WellSet - the well set

int - constant for operation

Returns:

result of the operation

sets

public WellSet sets(WellSet set,
                    int[] array)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are treated as zeroes.

Parameters:

WellSet - the well set

int[] - array for the operation

Returns:

result of the operation

sets

public WellSet sets(WellSet set,
                    int[] array,
                    int begin,
                    int length)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are treated as zeroes.

Parameters:

WellSet - the well set

int[] - array for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

sets

public WellSet sets(WellSet set,
                    Collection<Integer> collection)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are treated as zeroes.

Parameters:

WellSet - the well set

Collection - collection for the operation

Returns:

result of the operation

sets

public WellSet sets(WellSet set,
                    Collection<Integer> collection,
                    int begin,
                    int length)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are treated as zeroes.

Parameters:

WellSet - the well set

Collection - collection for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

setsStrict

public WellSet setsStrict(WellSet set,
                          int[] array)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are omitted.

Parameters:

WellSet - the well set

int[] - array for the operation

Returns:

result of the operation

setsStrict

public WellSet setsStrict(WellSet set,
                          int[] array,
                          int begin,
                          int length)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are omitted.

Parameters:

WellSet - the well set

int[] - array for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

setsStrict

public WellSet setsStrict(WellSet set,
                          Collection<Integer> collection)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are omitted.

Parameters:

WellSet - the well set

Collection - collection for the operation

Returns:

result of the operation

setsStrict

public WellSet setsStrict(WellSet set,
                          Collection<Integer> collection,
                          int begin,
                          int length)

Returns the result of the mathematical operation. Missing data points due to uneven data set lengths are omitted.

Parameters:

WellSet - the well set

Collection - collection for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

stacks

public Stack stacks(Stack stack1,
                    Stack stack2)

Returns the result of the mathematical operation. Missing data points due to data sets of unequal length are treated as zero values.

Parameters:

Stack - the first stack

Stack - the second stack

Returns:

the result of the operation

stacks

public Stack stacks(Stack stack1,
                    Stack stack2,
                    int begin,
                    int length)

Returns the result of the mathematical operation using the values between the indices. Missing data points due to data sets of unequal length are treated as zero values.

Parameters:

Stack - the first stack

Stack - the second stack

int - beginning index of the subset

int - length of the subset

Returns:

the result of the addition

stacksStrict

public Stack stacksStrict(Stack stack1,
                          Stack stack2)

Returns the result of the mathematical operation. Missing data points due to data sets of unequal length are omitted.

Parameters:

Stack - the first stack

Stack - the second stack

Returns:

the result of the operation

stacksStrict

public Stack stacksStrict(Stack stack1,
                          Stack stack2,
                          int begin,
                          int length)

Returns the result of the mathematical operation using the values between the indices. Missing data points due to data sets of unequal length are omitted.

Parameters:

Stack - the first stack

Stack - the second stack

int - beginning index of the subset

int - length of the subset

Returns:

the result of the addition

stacks

public Stack stacks(Stack stack,
                    int constant)

Returns the result of the mathematical operation.

Parameters:

Stack - the stack

int - constant for operation

Returns:

result of the operation

stacks

public Stack stacks(Stack stack,
                    int[] array)

Returns the result of the mathematical operation. Missing data points due to uneven data stack lengths are treated as zeroes.

Parameters:

Stack - the stack

int[] - array for the operation

Returns:

result of the operation

stacks

public Stack stacks(Stack stack,
                    int[] array,
                    int begin,
                    int length)

Returns the result of the mathematical operation. Missing data points due to uneven data stack lengths are treated as zeroes.

Parameters:

Stack - the stack

int[] - array for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

stacks

public Stack stacks(Stack stack,
                    Collection<Integer> collection)

Returns the result of the mathematical operation. Missing data points due to uneven data stack lengths are treated as zeroes.

Parameters:

Stack - the stack

Collection - collection for the operation

Returns:

result of the operation

stacks

public Stack stacks(Stack stack,
                    Collection<Integer> collection,
                    int begin,
                    int length)

Returns the result of the mathematical operation. Missing data points due to uneven data stack lengths are treated as zeroes.

Parameters:

Stack - the stack

Collection - collection for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

stacksStrict

public Stack stacksStrict(Stack stack,
                          int[] array)

Returns the result of the mathematical operation. Missing data points due to uneven data stack lengths are omitted.

Parameters:

Stack - the stack

int[] - array for the operation

Returns:

result of the operation

stacksStrict

public Stack stacksStrict(Stack stack,
                          int[] array,
                          int begin,
                          int length)

Returns the result of the mathematical operation. Missing data points due to uneven data stack lengths are omitted.

Parameters:

Stack - the stack

int[] - array for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

stacksStrict

public Stack stacksStrict(Stack stack,
                          Collection<Integer> collection)

Returns the result of the mathematical operation. Missing data points due to uneven data stack lengths are omitted.

Parameters:

Stack - the stack

Collection - collection for the operation

Returns:

result of the operation

stacksStrict

public Stack stacksStrict(Stack stack,
                          Collection<Integer> collection,
                          int begin,
                          int length)

Returns the result of the mathematical operation. Missing data points due to uneven data stack lengths are omitted.

Parameters:

Stack - the stack

Collection - collection for the operation

int - beginning index of subset

int - length of the subset

Returns:

result of the operation

calculate

public abstract List<Integer> calculate(List<Integer> list1,
                                        List<Integer> list2)

Performs the mathematical operation for the two lists. Missing data points due to data sets of unequal length are treated as zero values.

Parameters:

List - the first list

List - the second list

Returns:

result of the mathematical operation

calculateStrict

public abstract List<Integer> calculateStrict(List<Integer> list1,
                                              List<Integer> list2)

Performs the mathematical operation for the two lists. Missing data points due to data sets of unequal length are omitted.

Parameters:

List - the first list

List - the second list

Returns:

result of the mathematical operation

calculate

public abstract List<Integer> calculate(List<Integer> list1,
                                        List<Integer> list2,
                                        int begin,
                                        int length)

Performs the mathematical operation for the two lists using the values between the indices. Missing data points due to data sets of unequal length are treated as zero values.

Parameters:

List - the first list

List - the second list

int - the beginning index of the subset

int - the length of the subset

Returns:

result of the mathematical operation

calculateStrict

public abstract List<Integer> calculateStrict(List<Integer> list1,
                                              List<Integer> list2,
                                              int begin,
                                              int length)

Performs the mathematical operation for the two lists. Missing data points due to data sets of unequal length are omitted.

Parameters:

List - the first list

List - the second list

int - the beginning index of the subset

int - the length of the subset

Returns:

result of the mathematical operation

calculate

public abstract List<Integer> calculate(List<Integer> list,
                                        int constant)

Performs the mathematical operation for the two lists. Missing data points due to data sets of unequal length are treated as zero values.

Parameters:

List - the first list

int - the constant value

Returns:

result of the mathematical operation

calculate

public abstract List<Integer> calculate(List<Integer> list,
                                        int[] array)

Performs the mathematical operation for the two lists. Missing data points due to data sets of unequal length are treated as zero values.

Parameters:

List - the first list

int[] - the array values

Returns:

result of the mathematical operation

calculate

public abstract List<Integer> calculate(List<Integer> list,
                                        int[] array,
                                        int begin,
                                        int length)

Performs the mathematical operation for the two lists. Missing data points due to data sets of unequal length are treated as zero values.

Parameters:

List - the first list

int[] - the array values

int - beginning index of the subset

int - length of the subset

Returns:

result of the mathematical operation

calculate

public abstract List<Integer> calculate(List<Integer> list,
                                        Collection<Integer> collection)

Performs the mathematical operation for the two lists. Missing data points due to data sets of unequal length are treated as zero values.

Parameters:

List - the first list

Collection - the array values

Returns:

result of the mathematical operation

calculate

public abstract List<Integer> calculate(List<Integer> list,
                                        Collection<Integer> collection,
                                        int begin,
                                        int length)

Performs the mathematical operation for the two lists. Missing data points due to data sets of unequal length are treated as zero values.

Parameters:

List - the first list

Collection - the array values

int - beginning index of the subset

int - length of the subset

Returns:

result of the mathematical operation

calculateStrict

public abstract List<Integer> calculateStrict(List<Integer> list,
                                              int[] array)

Performs the mathematical operation for the two lists. Missing data points due to data sets of unequal length are omitted.

Parameters:

List - the first list

int[] - the array values

Returns:

result of the mathematical operation

calculateStrict

public abstract List<Integer> calculateStrict(List<Integer> list,
                                              int[] array,
                                              int begin,
                                              int length)

Performs the mathematical operation for the two lists. Missing data points due to data sets of unequal length are omitted.

Parameters:

List - the first list

int[] - the array values

int - beginning index of the subset

int - length of the subset

Returns:

result of the mathematical operation

calculateStrict

public abstract List<Integer> calculateStrict(List<Integer> list,
                                              Collection<Integer> collection)

Performs the mathematical operation for the two lists. Missing data points due to data sets of unequal length are omitted.

Parameters:

List - the first list

Collection - the array values

Returns:

result of the mathematical operation

calculateStrict

public abstract List<Integer> calculateStrict(List<Integer> list,
                                              Collection<Integer> collection,
                                              int begin,
                                              int length)

Performs the mathematical operation for the two lists. Missing data points due to data sets of unequal length are omitted.

Parameters:

List - the first list

Collection - the array values

int - beginning index of the subset

int - length of the subset

Returns:

result of the mathematical operation