Class 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  
    • 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)