Class CorePrimitiveOperation

java.lang.Object
org.ojalgo.array.operation.CorePrimitiveOperation
All Implemented Interfaces:
ArrayOperation

public abstract class CorePrimitiveOperation extends Object implements ArrayOperation
  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static int
     
  • Constructor Summary

    Constructors
    Constructor
    Description
     
  • Method Summary

    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 Comparable<N>>
    void
    add(BasicArray<N> data, long first, long limit, long step, Comparable<?> left, Access1D<N> right)
     
    static <N extends Comparable<N>>
    void
    add(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, Comparable<?> right)
     
    static <N extends 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 Comparable<N>>
    void
    divide(BasicArray<N> data, long first, long limit, long step, Comparable<?> left, Access1D<N> right)
     
    static <N extends Comparable<N>>
    void
    divide(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, Comparable<?> right)
     
    static <N extends 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 Comparable<N>>
    void
    multiply(BasicArray<N> data, long first, long limit, long step, Comparable<?> left, Access1D<N> right)
     
    static <N extends Comparable<N>>
    void
    multiply(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, Comparable<?> right)
     
    static <N extends 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 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 Comparable<N>>
    void
    subtract(BasicArray<N> data, long first, long limit, long step, Comparable<?> left, Access1D<N> right)
     
    static <N extends Comparable<N>>
    void
    subtract(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, Comparable<?> right)
     
    static <N extends 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 Details

    • THRESHOLD

      public static int THRESHOLD
  • Constructor Details

    • CorePrimitiveOperation

      public CorePrimitiveOperation()
  • Method Details

    • add

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

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

      public static <N extends Comparable<N>> void add(BasicArray<N> data, long first, long limit, long step, 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 Comparable<N>> void divide(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, Access1D<N> right)
    • divide

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

      public static <N extends Comparable<N>> void divide(BasicArray<N> data, long first, long limit, long step, 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 Comparable<N>> void multiply(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, Access1D<N> right)
    • multiply

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

      public static <N extends Comparable<N>> void multiply(BasicArray<N> data, long first, long limit, long step, 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 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 Comparable<N>> void subtract(BasicArray<N> data, long first, long limit, long step, Access1D<N> left, Access1D<N> right)
    • subtract

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

      public static <N extends Comparable<N>> void subtract(BasicArray<N> data, long first, long limit, long step, 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)