Class MultiplyLeft

    • Constructor Summary

      Constructors 
      Constructor Description
      MultiplyLeft()  
    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method Description
      (package private) static void add1xN​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void add1xN​(float[] product, Access1D<?> left, int complexity, float[] right)  
      (package private) static void addMx1​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void addMx1​(float[] product, Access1D<?> left, int complexity, float[] right)  
      (package private) static <N extends Scalar<N>>
      void
      addMx1​(N[] product, Access1D<N> left, int complexity, N[] right, Scalar.Factory<N> scalar)  
      (package private) static void addMxC​(double[] product, int firstColumn, int columnLimit, Access1D<?> left, int complexity, double[] right)  
      (package private) static void addMxC​(float[] product, int firstColumn, int columnLimit, Access1D<?> left, int complexity, float[] right)  
      (package private) static <N extends Scalar<N>>
      void
      addMxC​(N[] product, int firstColumn, int columnLimit, Access1D<N> left, int complexity, N[] right, Scalar.Factory<N> scalar)  
      (package private) static void addMxN_MT​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void addMxN_MT​(float[] product, Access1D<?> left, int complexity, float[] right)  
      (package private) static <N extends Scalar<N>>
      void
      addMxN_MT​(N[] product, Access1D<N> left, int complexity, N[] right, Scalar.Factory<N> scalar)  
      private static void base​(double[] product, Access1D<?> left, int complexity, double[] right)
      Not running code.
      (package private) static void divide​(int first, int limit, DivideAndConquer.Conquerer conquerer)  
      (package private) static void fill0xN​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fill1x1​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fill1xN​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fill1xN​(float[] product, Access1D<?> left, int complexity, float[] right)  
      (package private) static <N extends Scalar<N>>
      void
      fill1xN​(N[] product, Access1D<N> left, int complexity, N[] right, Scalar.Factory<N> scalar)  
      (package private) static void fill2x2​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fill3x3​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fill4x4​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fill5x5​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fill6xN​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fill7xN​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fill8xN​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fill9xN​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fillMx1​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fillMx1​(float[] product, Access1D<?> left, int complexity, float[] right)  
      (package private) static <N extends Scalar<N>>
      void
      fillMx1​(N[] product, Access1D<N> left, int complexity, N[] right, Scalar.Factory<N> scalar)  
      (package private) static void fillMxN​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fillMxN​(float[] product, Access1D<?> left, int complexity, float[] right)  
      (package private) static <N extends Scalar<N>>
      void
      fillMxN​(N[] product, Access1D<N> left, int complexity, N[] right, Scalar.Factory<N> scalar)  
      (package private) static void fillMxN_MT​(double[] product, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fillMxN_MT​(float[] product, Access1D<?> left, int complexity, float[] right)  
      (package private) static <N extends Scalar<N>>
      void
      fillMxN_MT​(N[] product, Access1D<N> left, int complexity, N[] right, Scalar.Factory<N> scalar)  
      (package private) static void fillRxN​(double[] product, int firstRow, int rowLimit, Access1D<?> left, int complexity, double[] right)  
      (package private) static void fillRxN​(float[] product, int firstRow, int rowLimit, Access1D<?> left, int complexity, float[] right)  
      (package private) static <N extends Scalar<N>>
      void
      fillRxN​(N[] product, int firstRow, int rowLimit, Access1D<N> left, int complexity, N[] right, Scalar.Factory<N> scalar)  
      static <N extends Scalar<N>>
      MultiplyLeft.Generic<N>
      newGeneric​(long rows, long columns)  
      static MultiplyLeft.Primitive32 newPrimitive32​(long rows, long columns)  
      static MultiplyLeft.Primitive64 newPrimitive64​(long rows, long columns)  
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • PARALLELISM

        public static java.util.function.IntSupplier PARALLELISM
      • THRESHOLD

        public static int THRESHOLD
    • Constructor Detail

      • MultiplyLeft

        public MultiplyLeft()
    • Method Detail

      • base

        private static void base​(double[] product,
                                 Access1D<?> left,
                                 int complexity,
                                 double[] right)
        Not running code. Copies used as a starting point when coding various variants
      • add1xN

        static void add1xN​(double[] product,
                           Access1D<?> left,
                           int complexity,
                           double[] right)
      • add1xN

        static void add1xN​(float[] product,
                           Access1D<?> left,
                           int complexity,
                           float[] right)
      • addMx1

        static void addMx1​(double[] product,
                           Access1D<?> left,
                           int complexity,
                           double[] right)
      • addMx1

        static void addMx1​(float[] product,
                           Access1D<?> left,
                           int complexity,
                           float[] right)
      • addMx1

        static <N extends Scalar<N>> void addMx1​(N[] product,
                                                 Access1D<N> left,
                                                 int complexity,
                                                 N[] right,
                                                 Scalar.Factory<N> scalar)
      • addMxC

        static void addMxC​(double[] product,
                           int firstColumn,
                           int columnLimit,
                           Access1D<?> left,
                           int complexity,
                           double[] right)
      • addMxC

        static void addMxC​(float[] product,
                           int firstColumn,
                           int columnLimit,
                           Access1D<?> left,
                           int complexity,
                           float[] right)
      • addMxC

        static <N extends Scalar<N>> void addMxC​(N[] product,
                                                 int firstColumn,
                                                 int columnLimit,
                                                 Access1D<N> left,
                                                 int complexity,
                                                 N[] right,
                                                 Scalar.Factory<N> scalar)
      • addMxN_MT

        static void addMxN_MT​(double[] product,
                              Access1D<?> left,
                              int complexity,
                              double[] right)
      • addMxN_MT

        static void addMxN_MT​(float[] product,
                              Access1D<?> left,
                              int complexity,
                              float[] right)
      • addMxN_MT

        static <N extends Scalar<N>> void addMxN_MT​(N[] product,
                                                    Access1D<N> left,
                                                    int complexity,
                                                    N[] right,
                                                    Scalar.Factory<N> scalar)
      • fill0xN

        static void fill0xN​(double[] product,
                            Access1D<?> left,
                            int complexity,
                            double[] right)
      • fill1x1

        static void fill1x1​(double[] product,
                            Access1D<?> left,
                            int complexity,
                            double[] right)
      • fill1xN

        static void fill1xN​(double[] product,
                            Access1D<?> left,
                            int complexity,
                            double[] right)
      • fill1xN

        static void fill1xN​(float[] product,
                            Access1D<?> left,
                            int complexity,
                            float[] right)
      • fill1xN

        static <N extends Scalar<N>> void fill1xN​(N[] product,
                                                  Access1D<N> left,
                                                  int complexity,
                                                  N[] right,
                                                  Scalar.Factory<N> scalar)
      • fill2x2

        static void fill2x2​(double[] product,
                            Access1D<?> left,
                            int complexity,
                            double[] right)
      • fill3x3

        static void fill3x3​(double[] product,
                            Access1D<?> left,
                            int complexity,
                            double[] right)
      • fill4x4

        static void fill4x4​(double[] product,
                            Access1D<?> left,
                            int complexity,
                            double[] right)
      • fill5x5

        static void fill5x5​(double[] product,
                            Access1D<?> left,
                            int complexity,
                            double[] right)
      • fill6xN

        static void fill6xN​(double[] product,
                            Access1D<?> left,
                            int complexity,
                            double[] right)
      • fill7xN

        static void fill7xN​(double[] product,
                            Access1D<?> left,
                            int complexity,
                            double[] right)
      • fill8xN

        static void fill8xN​(double[] product,
                            Access1D<?> left,
                            int complexity,
                            double[] right)
      • fill9xN

        static void fill9xN​(double[] product,
                            Access1D<?> left,
                            int complexity,
                            double[] right)
      • fillMx1

        static void fillMx1​(double[] product,
                            Access1D<?> left,
                            int complexity,
                            double[] right)
      • fillMx1

        static void fillMx1​(float[] product,
                            Access1D<?> left,
                            int complexity,
                            float[] right)
      • fillMx1

        static <N extends Scalar<N>> void fillMx1​(N[] product,
                                                  Access1D<N> left,
                                                  int complexity,
                                                  N[] right,
                                                  Scalar.Factory<N> scalar)
      • fillMxN

        static void fillMxN​(double[] product,
                            Access1D<?> left,
                            int complexity,
                            double[] right)
      • fillMxN

        static void fillMxN​(float[] product,
                            Access1D<?> left,
                            int complexity,
                            float[] right)
      • fillMxN

        static <N extends Scalar<N>> void fillMxN​(N[] product,
                                                  Access1D<N> left,
                                                  int complexity,
                                                  N[] right,
                                                  Scalar.Factory<N> scalar)
      • fillMxN_MT

        static void fillMxN_MT​(double[] product,
                               Access1D<?> left,
                               int complexity,
                               double[] right)
      • fillMxN_MT

        static void fillMxN_MT​(float[] product,
                               Access1D<?> left,
                               int complexity,
                               float[] right)
      • fillMxN_MT

        static <N extends Scalar<N>> void fillMxN_MT​(N[] product,
                                                     Access1D<N> left,
                                                     int complexity,
                                                     N[] right,
                                                     Scalar.Factory<N> scalar)
      • fillRxN

        static void fillRxN​(double[] product,
                            int firstRow,
                            int rowLimit,
                            Access1D<?> left,
                            int complexity,
                            double[] right)
      • fillRxN

        static void fillRxN​(float[] product,
                            int firstRow,
                            int rowLimit,
                            Access1D<?> left,
                            int complexity,
                            float[] right)
      • fillRxN

        static <N extends Scalar<N>> void fillRxN​(N[] product,
                                                  int firstRow,
                                                  int rowLimit,
                                                  Access1D<N> left,
                                                  int complexity,
                                                  N[] right,
                                                  Scalar.Factory<N> scalar)