java.lang.Object
- org.ojalgo.array.operation.CorePrimitiveOperation

All Implemented Interfaces:: ArrayOperation

public abstract class CorePrimitiveOperation
extends java.lang.Object
implements ArrayOperation

Field Summary

Fields
Modifier and Type Field Description

static int THRESHOLD

Constructor Summary

Constructors
Constructor Description

CorePrimitiveOperation()

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static void`	`add(byte[] data, int first, int limit, int step, byte[] left, byte right)`
`static void`	`add(byte[] data, int first, int limit, int step, byte[] left, byte[] right)`
`static void`	`add(byte[] data, int first, int limit, int step, byte left, byte[] right)`
`static void`	`add(double[] data, int first, int limit, int step, double[] left, double right)`
`static void`	`add(double[] data, int first, int limit, int step, double[] left, double[] right)`
`static void`	`add(double[] data, int first, int limit, int step, double left, double[] right)`
`static void`	`add(float[] data, int first, int limit, int step, float[] left, float right)`
`static void`	`add(float[] data, int first, int limit, int step, float[] left, float[] right)`
`static void`	`add(float[] data, int first, int limit, int step, float left, float[] right)`
`static void`	`add(int[] data, int first, int limit, int step, int[] left, int right)`
`static void`	`add(int[] data, int first, int limit, int step, int[] left, int[] right)`
`static void`	`add(int[] data, int first, int limit, int step, int left, int[] right)`
`static void`	`add(long[] data, int first, int limit, int step, long[] left, long right)`
`static void`	`add(long[] data, int first, int limit, int step, long[] left, long[] right)`
`static void`	`add(long[] data, int first, int limit, int step, long left, long[] right)`
`static void`	`add(short[] data, int first, int limit, int step, short[] left, short right)`
`static void`	`add(short[] data, int first, int limit, int step, short[] left, short[] right)`
`static void`	`add(short[] data, int first, int limit, int step, short left, short[] right)`
`static <N extends java.lang.Comparable<N>> void`	`add(BasicArray<N> data, long first, long limit, long step, java.lang.Comparable<?> left, Access1D<N> right)`
`static <N extends java.lang.Comparable<N>> void`	`add(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, java.lang.Comparable<?> right)`
`static <N extends java.lang.Comparable<N>> void`	`add(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, Access1D<N> right)`
`static void`	`divide(byte[] data, int first, int limit, int step, byte[] left, byte right)`
`static void`	`divide(byte[] data, int first, int limit, int step, byte[] left, byte[] right)`
`static void`	`divide(byte[] data, int first, int limit, int step, byte left, byte[] right)`
`static void`	`divide(double[] data, int first, int limit, int step, double[] left, double right)`
`static void`	`divide(double[] data, int first, int limit, int step, double[] left, double[] right)`
`static void`	`divide(double[] data, int first, int limit, int step, double left, double[] right)`
`static void`	`divide(float[] data, int first, int limit, int step, float[] left, float right)`
`static void`	`divide(float[] data, int first, int limit, int step, float[] left, float[] right)`
`static void`	`divide(float[] data, int first, int limit, int step, float left, float[] right)`
`static void`	`divide(int[] data, int first, int limit, int step, int[] left, int right)`
`static void`	`divide(int[] data, int first, int limit, int step, int[] left, int[] right)`
`static void`	`divide(int[] data, int first, int limit, int step, int left, int[] right)`
`static void`	`divide(long[] data, int first, int limit, int step, long[] left, long right)`
`static void`	`divide(long[] data, int first, int limit, int step, long[] left, long[] right)`
`static void`	`divide(long[] data, int first, int limit, int step, long left, long[] right)`
`static void`	`divide(short[] data, int first, int limit, int step, short[] left, short right)`
`static void`	`divide(short[] data, int first, int limit, int step, short[] left, short[] right)`
`static void`	`divide(short[] data, int first, int limit, int step, short left, short[] right)`
`static <N extends java.lang.Comparable<N>> void`	`divide(BasicArray<N> data, long first, long limit, long step, java.lang.Comparable<?> left, Access1D<N> right)`
`static <N extends java.lang.Comparable<N>> void`	`divide(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, java.lang.Comparable<?> right)`
`static <N extends java.lang.Comparable<N>> void`	`divide(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, Access1D<N> right)`
`static void`	`multiply(byte[] data, int first, int limit, int step, byte[] left, byte right)`
`static void`	`multiply(byte[] data, int first, int limit, int step, byte[] left, byte[] right)`
`static void`	`multiply(byte[] data, int first, int limit, int step, byte left, byte[] right)`
`static void`	`multiply(double[] data, int first, int limit, int step, double[] left, double right)`
`static void`	`multiply(double[] data, int first, int limit, int step, double[] left, double[] right)`
`static void`	`multiply(double[] data, int first, int limit, int step, double left, double[] right)`
`static void`	`multiply(float[] data, int first, int limit, int step, float[] left, float right)`
`static void`	`multiply(float[] data, int first, int limit, int step, float[] left, float[] right)`
`static void`	`multiply(float[] data, int first, int limit, int step, float left, float[] right)`
`static void`	`multiply(int[] data, int first, int limit, int step, int[] left, int right)`
`static void`	`multiply(int[] data, int first, int limit, int step, int[] left, int[] right)`
`static void`	`multiply(int[] data, int first, int limit, int step, int left, int[] right)`
`static void`	`multiply(long[] data, int first, int limit, int step, long[] left, long right)`
`static void`	`multiply(long[] data, int first, int limit, int step, long[] left, long[] right)`
`static void`	`multiply(long[] data, int first, int limit, int step, long left, long[] right)`
`static void`	`multiply(short[] data, int first, int limit, int step, short[] left, short right)`
`static void`	`multiply(short[] data, int first, int limit, int step, short[] left, short[] right)`
`static void`	`multiply(short[] data, int first, int limit, int step, short left, short[] right)`
`static <N extends java.lang.Comparable<N>> void`	`multiply(BasicArray<N> data, long first, long limit, long step, java.lang.Comparable<?> left, Access1D<N> right)`
`static <N extends java.lang.Comparable<N>> void`	`multiply(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, java.lang.Comparable<?> right)`
`static <N extends java.lang.Comparable<N>> void`	`multiply(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, Access1D<N> right)`
`static void`	`negate(byte[] data, int first, int limit, int step, byte[] values)`
`static void`	`negate(double[] data, int first, int limit, int step, double[] values)`
`static void`	`negate(float[] data, int first, int limit, int step, float[] values)`
`static void`	`negate(int[] data, int first, int limit, int step, int[] values)`
`static void`	`negate(long[] data, int first, int limit, int step, long[] values)`
`static void`	`negate(short[] data, int first, int limit, int step, short[] values)`
`static <N extends java.lang.Comparable<N>> void`	`negate(BasicArray<N> data, long first, long limit, long step, Access1D<N> values)`
`static void`	`subtract(byte[] data, int first, int limit, int step, byte[] left, byte right)`
`static void`	`subtract(byte[] data, int first, int limit, int step, byte[] left, byte[] right)`
`static void`	`subtract(byte[] data, int first, int limit, int step, byte left, byte[] right)`
`static void`	`subtract(double[] data, int first, int limit, int step, double[] left, double right)`
`static void`	`subtract(double[] data, int first, int limit, int step, double[] left, double[] right)`
`static void`	`subtract(double[] data, int first, int limit, int step, double left, double[] right)`
`static void`	`subtract(float[] data, int first, int limit, int step, float[] left, float right)`
`static void`	`subtract(float[] data, int first, int limit, int step, float[] left, float[] right)`
`static void`	`subtract(float[] data, int first, int limit, int step, float left, float[] right)`
`static void`	`subtract(int[] data, int first, int limit, int step, int[] left, int right)`
`static void`	`subtract(int[] data, int first, int limit, int step, int[] left, int[] right)`
`static void`	`subtract(int[] data, int first, int limit, int step, int left, int[] right)`
`static void`	`subtract(long[] data, int first, int limit, int step, long[] left, long right)`
`static void`	`subtract(long[] data, int first, int limit, int step, long[] left, long[] right)`
`static void`	`subtract(long[] data, int first, int limit, int step, long left, long[] right)`
`static void`	`subtract(short[] data, int first, int limit, int step, short[] left, short right)`
`static void`	`subtract(short[] data, int first, int limit, int step, short[] left, short[] right)`
`static void`	`subtract(short[] data, int first, int limit, int step, short left, short[] right)`
`static <N extends java.lang.Comparable<N>> void`	`subtract(BasicArray<N> data, long first, long limit, long step, java.lang.Comparable<?> left, Access1D<N> right)`
`static <N extends java.lang.Comparable<N>> void`	`subtract(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, java.lang.Comparable<?> right)`
`static <N extends java.lang.Comparable<N>> void`	`subtract(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, Access1D<N> right)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- THRESHOLD
```
public static int THRESHOLD
```

Constructor Detail
- CorePrimitiveOperation
```
public CorePrimitiveOperation()
```

Method Detail

add

public static <N extends java.lang.Comparable<N>> void add(BasicArray<N> data,
                                                           long first,
                                                           long limit,
                                                           long step,
                                                           Access1D<N> left,
                                                           Access1D<N> right)

add

public static <N extends java.lang.Comparable<N>> void add(BasicArray<N> data,
                                                           long first,
                                                           long limit,
                                                           long step,
                                                           Access1D<N> left,
                                                           java.lang.Comparable<?> right)

add

public static <N extends java.lang.Comparable<N>> void add(BasicArray<N> data,
                                                           long first,
                                                           long limit,
                                                           long step,
                                                           java.lang.Comparable<?> left,
                                                           Access1D<N> right)

add

public static void add(byte[] data,
                       int first,
                       int limit,
                       int step,
                       byte left,
                       byte[] right)

add

public static void add(byte[] data,
                       int first,
                       int limit,
                       int step,
                       byte[] left,
                       byte right)

add

public static void add(byte[] data,
                       int first,
                       int limit,
                       int step,
                       byte[] left,
                       byte[] right)

add

public static void add(double[] data,
                       int first,
                       int limit,
                       int step,
                       double left,
                       double[] right)

add

public static void add(double[] data,
                       int first,
                       int limit,
                       int step,
                       double[] left,
                       double right)

add

public static void add(double[] data,
                       int first,
                       int limit,
                       int step,
                       double[] left,
                       double[] right)

add

public static void add(float[] data,
                       int first,
                       int limit,
                       int step,
                       float left,
                       float[] right)

add

public static void add(float[] data,
                       int first,
                       int limit,
                       int step,
                       float[] left,
                       float right)

add

public static void add(float[] data,
                       int first,
                       int limit,
                       int step,
                       float[] left,
                       float[] right)

add

public static void add(int[] data,
                       int first,
                       int limit,
                       int step,
                       int left,
                       int[] right)

add

public static void add(int[] data,
                       int first,
                       int limit,
                       int step,
                       int[] left,
                       int right)

add

public static void add(int[] data,
                       int first,
                       int limit,
                       int step,
                       int[] left,
                       int[] right)

add

public static void add(long[] data,
                       int first,
                       int limit,
                       int step,
                       long left,
                       long[] right)

add

public static void add(long[] data,
                       int first,
                       int limit,
                       int step,
                       long[] left,
                       long right)

add

public static void add(long[] data,
                       int first,
                       int limit,
                       int step,
                       long[] left,
                       long[] right)

add

public static void add(short[] data,
                       int first,
                       int limit,
                       int step,
                       short left,
                       short[] right)

add

public static void add(short[] data,
                       int first,
                       int limit,
                       int step,
                       short[] left,
                       short right)

add

public static void add(short[] data,
                       int first,
                       int limit,
                       int step,
                       short[] left,
                       short[] right)

divide

public static <N extends java.lang.Comparable<N>> void divide(BasicArray<N> data,
                                                              long first,
                                                              long limit,
                                                              long step,
                                                              Access1D<N> left,
                                                              Access1D<N> right)

divide

public static <N extends java.lang.Comparable<N>> void divide(BasicArray<N> data,
                                                              long first,
                                                              long limit,
                                                              long step,
                                                              Access1D<N> left,
                                                              java.lang.Comparable<?> right)

divide

public static <N extends java.lang.Comparable<N>> void divide(BasicArray<N> data,
                                                              long first,
                                                              long limit,
                                                              long step,
                                                              java.lang.Comparable<?> left,
                                                              Access1D<N> right)

divide

public static void divide(byte[] data,
                          int first,
                          int limit,
                          int step,
                          byte left,
                          byte[] right)

divide

public static void divide(byte[] data,
                          int first,
                          int limit,
                          int step,
                          byte[] left,
                          byte right)

divide

public static void divide(byte[] data,
                          int first,
                          int limit,
                          int step,
                          byte[] left,
                          byte[] right)

divide

public static void divide(double[] data,
                          int first,
                          int limit,
                          int step,
                          double left,
                          double[] right)

divide

public static void divide(double[] data,
                          int first,
                          int limit,
                          int step,
                          double[] left,
                          double right)

divide

public static void divide(double[] data,
                          int first,
                          int limit,
                          int step,
                          double[] left,
                          double[] right)

divide

public static void divide(float[] data,
                          int first,
                          int limit,
                          int step,
                          float left,
                          float[] right)

divide

public static void divide(float[] data,
                          int first,
                          int limit,
                          int step,
                          float[] left,
                          float right)

divide

public static void divide(float[] data,
                          int first,
                          int limit,
                          int step,
                          float[] left,
                          float[] right)

divide

public static void divide(int[] data,
                          int first,
                          int limit,
                          int step,
                          int left,
                          int[] right)

divide

public static void divide(int[] data,
                          int first,
                          int limit,
                          int step,
                          int[] left,
                          int right)

divide

public static void divide(int[] data,
                          int first,
                          int limit,
                          int step,
                          int[] left,
                          int[] right)

divide

public static void divide(long[] data,
                          int first,
                          int limit,
                          int step,
                          long left,
                          long[] right)

divide

public static void divide(long[] data,
                          int first,
                          int limit,
                          int step,
                          long[] left,
                          long right)

divide

public static void divide(long[] data,
                          int first,
                          int limit,
                          int step,
                          long[] left,
                          long[] right)

divide

public static void divide(short[] data,
                          int first,
                          int limit,
                          int step,
                          short left,
                          short[] right)

divide

public static void divide(short[] data,
                          int first,
                          int limit,
                          int step,
                          short[] left,
                          short right)

divide

public static void divide(short[] data,
                          int first,
                          int limit,
                          int step,
                          short[] left,
                          short[] right)

multiply

public static <N extends java.lang.Comparable<N>> void multiply(BasicArray<N> data,
                                                                long first,
                                                                long limit,
                                                                long step,
                                                                Access1D<N> left,
                                                                Access1D<N> right)

multiply

public static <N extends java.lang.Comparable<N>> void multiply(BasicArray<N> data,
                                                                long first,
                                                                long limit,
                                                                long step,
                                                                Access1D<N> left,
                                                                java.lang.Comparable<?> right)

multiply

public static <N extends java.lang.Comparable<N>> void multiply(BasicArray<N> data,
                                                                long first,
                                                                long limit,
                                                                long step,
                                                                java.lang.Comparable<?> left,
                                                                Access1D<N> right)

multiply

public static void multiply(byte[] data,
                            int first,
                            int limit,
                            int step,
                            byte left,
                            byte[] right)

multiply

public static void multiply(byte[] data,
                            int first,
                            int limit,
                            int step,
                            byte[] left,
                            byte right)

multiply

public static void multiply(byte[] data,
                            int first,
                            int limit,
                            int step,
                            byte[] left,
                            byte[] right)

multiply

public static void multiply(double[] data,
                            int first,
                            int limit,
                            int step,
                            double left,
                            double[] right)

multiply

public static void multiply(double[] data,
                            int first,
                            int limit,
                            int step,
                            double[] left,
                            double right)

multiply

public static void multiply(double[] data,
                            int first,
                            int limit,
                            int step,
                            double[] left,
                            double[] right)

multiply

public static void multiply(float[] data,
                            int first,
                            int limit,
                            int step,
                            float left,
                            float[] right)

multiply

public static void multiply(float[] data,
                            int first,
                            int limit,
                            int step,
                            float[] left,
                            float right)

multiply

public static void multiply(float[] data,
                            int first,
                            int limit,
                            int step,
                            float[] left,
                            float[] right)

multiply

public static void multiply(int[] data,
                            int first,
                            int limit,
                            int step,
                            int left,
                            int[] right)

multiply

public static void multiply(int[] data,
                            int first,
                            int limit,
                            int step,
                            int[] left,
                            int right)

multiply

public static void multiply(int[] data,
                            int first,
                            int limit,
                            int step,
                            int[] left,
                            int[] right)

multiply

public static void multiply(long[] data,
                            int first,
                            int limit,
                            int step,
                            long left,
                            long[] right)

multiply

public static void multiply(long[] data,
                            int first,
                            int limit,
                            int step,
                            long[] left,
                            long right)

multiply

public static void multiply(long[] data,
                            int first,
                            int limit,
                            int step,
                            long[] left,
                            long[] right)

multiply

public static void multiply(short[] data,
                            int first,
                            int limit,
                            int step,
                            short left,
                            short[] right)

multiply

public static void multiply(short[] data,
                            int first,
                            int limit,
                            int step,
                            short[] left,
                            short right)

multiply

public static void multiply(short[] data,
                            int first,
                            int limit,
                            int step,
                            short[] left,
                            short[] right)

negate

public static <N extends java.lang.Comparable<N>> void negate(BasicArray<N> data,
                                                              long first,
                                                              long limit,
                                                              long step,
                                                              Access1D<N> values)

negate

public static void negate(byte[] data,
                          int first,
                          int limit,
                          int step,
                          byte[] values)

negate

public static void negate(double[] data,
                          int first,
                          int limit,
                          int step,
                          double[] values)

negate

public static void negate(float[] data,
                          int first,
                          int limit,
                          int step,
                          float[] values)

negate

public static void negate(int[] data,
                          int first,
                          int limit,
                          int step,
                          int[] values)

negate

public static void negate(long[] data,
                          int first,
                          int limit,
                          int step,
                          long[] values)

negate

public static void negate(short[] data,
                          int first,
                          int limit,
                          int step,
                          short[] values)

subtract

public static <N extends java.lang.Comparable<N>> void subtract(BasicArray<N> data,
                                                                long first,
                                                                long limit,
                                                                long step,
                                                                Access1D<N> left,
                                                                Access1D<N> right)

subtract

public static <N extends java.lang.Comparable<N>> void subtract(BasicArray<N> data,
                                                                long first,
                                                                long limit,
                                                                long step,
                                                                Access1D<N> left,
                                                                java.lang.Comparable<?> right)

subtract

public static <N extends java.lang.Comparable<N>> void subtract(BasicArray<N> data,
                                                                long first,
                                                                long limit,
                                                                long step,
                                                                java.lang.Comparable<?> left,
                                                                Access1D<N> right)

subtract

public static void subtract(byte[] data,
                            int first,
                            int limit,
                            int step,
                            byte left,
                            byte[] right)

subtract

public static void subtract(byte[] data,
                            int first,
                            int limit,
                            int step,
                            byte[] left,
                            byte right)

subtract

public static void subtract(byte[] data,
                            int first,
                            int limit,
                            int step,
                            byte[] left,
                            byte[] right)

subtract

public static void subtract(double[] data,
                            int first,
                            int limit,
                            int step,
                            double left,
                            double[] right)

subtract

public static void subtract(double[] data,
                            int first,
                            int limit,
                            int step,
                            double[] left,
                            double right)

subtract

public static void subtract(double[] data,
                            int first,
                            int limit,
                            int step,
                            double[] left,
                            double[] right)

subtract

public static void subtract(float[] data,
                            int first,
                            int limit,
                            int step,
                            float left,
                            float[] right)

subtract

public static void subtract(float[] data,
                            int first,
                            int limit,
                            int step,
                            float[] left,
                            float right)

subtract

public static void subtract(float[] data,
                            int first,
                            int limit,
                            int step,
                            float[] left,
                            float[] right)

subtract

public static void subtract(int[] data,
                            int first,
                            int limit,
                            int step,
                            int left,
                            int[] right)

subtract

public static void subtract(int[] data,
                            int first,
                            int limit,
                            int step,
                            int[] left,
                            int right)

subtract

public static void subtract(int[] data,
                            int first,
                            int limit,
                            int step,
                            int[] left,
                            int[] right)

subtract

public static void subtract(long[] data,
                            int first,
                            int limit,
                            int step,
                            long left,
                            long[] right)

subtract

public static void subtract(long[] data,
                            int first,
                            int limit,
                            int step,
                            long[] left,
                            long right)

subtract

public static void subtract(long[] data,
                            int first,
                            int limit,
                            int step,
                            long[] left,
                            long[] right)

subtract

public static void subtract(short[] data,
                            int first,
                            int limit,
                            int step,
                            short left,
                            short[] right)

subtract

public static void subtract(short[] data,
                            int first,
                            int limit,
                            int step,
                            short[] left,
                            short right)

subtract

public static void subtract(short[] data,
                            int first,
                            int limit,
                            int step,
                            short[] left,
                            short[] right)

Class CorePrimitiveOperation

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

THRESHOLD

Constructor Detail

CorePrimitiveOperation

Method Detail

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

add

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

divide

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

negate

negate

negate

negate

negate

negate

negate