Module ojalgo

Package org.ojalgo.matrix.operation

Class MultiplyRight

java.lang.Object

org.ojalgo.matrix.operation.MultiplyRight

All Implemented Interfaces:

ArrayOperation, MatrixOperation

public class MultiplyRight
extends java.lang.Object
implements MatrixOperation

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static interface	MultiplyRight.Generic<N extends Scalar<N>>
static interface	MultiplyRight.Primitive32
static interface	MultiplyRight.Primitive64

Field Summary

Fields

Modifier and Type	Field	Description
private static DivideAndConquer.Divider	DIVIDER
static java.util.function.IntSupplier	PARALLELISM
static int	THRESHOLD

Constructor Summary

Constructors

Constructor	Description
MultiplyRight()

Method Summary

Modifier and Type	Method	Description
(package private) static void	add1xN(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	add1xN(float[] product, float[] left, int complexity, Access1D<?> right)
(package private) static void	addMx1(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	addMx1(float[] product, float[] left, int complexity, Access1D<?> right)
(package private) static <N extends Scalar<N>> void	addMx1(N[] product, N[] left, int complexity, Access1D<N> right)
(package private) static void	addMxC(double[] product, int firstColumn, int columnLimit, double[] left, int complexity, Access1D<?> right)
(package private) static void	addMxC(float[] product, int firstColumn, int columnLimit, float[] left, int complexity, Access1D<?> right)
(package private) static <N extends Scalar<N>> void	addMxC(N[] product, int firstColumn, int columnLimit, N[] left, int complexity, Access1D<N> right)
(package private) static void	addMxN_MT(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	addMxN_MT(float[] product, float[] left, int complexity, Access1D<?> right)
(package private) static <N extends Scalar<N>> void	addMxN_MT(N[] product, N[] left, int complexity, Access1D<N> right)
private static void	base(double[] product, double[] left, int complexity, Access1D<?> right)	Not running code.
(package private) static void	divide(int first, int limit, DivideAndConquer.Conquerer conquerer)
(package private) static void	fill0xN(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	fill1x1(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	fill1xN(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	fill1xN(float[] product, float[] left, int complexity, Access1D<?> right)
(package private) static <N extends Scalar<N>> void	fill1xN(N[] product, N[] left, int complexity, Access1D<N> right, Scalar.Factory<N> scalar)
(package private) static void	fill2x2(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	fill3x3(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	fill4x4(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	fill5x5(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	fill6xN(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	fill7xN(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	fill8xN(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	fill9xN(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	fillMx1(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	fillMx1(float[] product, float[] left, int complexity, Access1D<?> right)
(package private) static <N extends Scalar<N>> void	fillMx1(N[] product, N[] left, int complexity, Access1D<N> right, Scalar.Factory<N> scalar)
(package private) static void	fillMxN(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	fillMxN(float[] product, float[] left, int complexity, Access1D<?> right)
(package private) static <N extends Scalar<N>> void	fillMxN(N[] product, N[] left, int complexity, Access1D<N> right, Scalar.Factory<N> scalar)
(package private) static void	fillMxN_MT(double[] product, double[] left, int complexity, Access1D<?> right)
(package private) static void	fillMxN_MT(float[] product, float[] left, int complexity, Access1D<?> right)
(package private) static <N extends Scalar<N>> void	fillMxN_MT(N[] product, N[] left, int complexity, Access1D<N> right, Scalar.Factory<N> scalar)
static <N extends Scalar<N>> MultiplyRight.Generic<N>	newGeneric(long rows, long columns)
static MultiplyRight.Primitive32	newPrimitive32(long rows, long columns)
static MultiplyRight.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

DIVIDER

private static final DivideAndConquer.Divider DIVIDER

Constructor Detail

MultiplyRight

public MultiplyRight()

Method Detail

newGeneric

public static <N extends Scalar<N>> MultiplyRight.Generic<N> newGeneric(long rows,
                                                                        long columns)

newPrimitive32

public static MultiplyRight.Primitive32 newPrimitive32(long rows,
                                                       long columns)

newPrimitive64

public static MultiplyRight.Primitive64 newPrimitive64(long rows,
                                                       long columns)

base

private static void base(double[] product,
                         double[] left,
                         int complexity,
                         Access1D<?> right)

Not running code. Copies used as a starting point when coding various variants

add1xN

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

add1xN

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

addMx1

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

addMx1

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

addMx1

static <N extends Scalar<N>> void addMx1(N[] product,
                                         N[] left,
                                         int complexity,
                                         Access1D<N> right)

addMxC

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

addMxC

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

addMxC

static <N extends Scalar<N>> void addMxC(N[] product,
                                         int firstColumn,
                                         int columnLimit,
                                         N[] left,
                                         int complexity,
                                         Access1D<N> right)

addMxN_MT

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

addMxN_MT

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

addMxN_MT

static <N extends Scalar<N>> void addMxN_MT(N[] product,
                                            N[] left,
                                            int complexity,
                                            Access1D<N> right)

divide

static void divide(int first,
                   int limit,
                   DivideAndConquer.Conquerer conquerer)

fill0xN

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

fill1x1

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

fill1xN

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

fill1xN

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

fill1xN

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

fill2x2

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

fill3x3

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

fill4x4

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

fill5x5

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

fill6xN

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

fill7xN

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

fill8xN

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

fill9xN

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

fillMx1

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

fillMx1

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

fillMx1

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

fillMxN

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

fillMxN

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

fillMxN

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

fillMxN_MT

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

fillMxN_MT

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

fillMxN_MT

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