entries

func Add ¶

func Add(h Helper, S1 Interface, S2 Interface) (Interface, error)

Add returns the sum S1 + S2. If h satisfies the interface:

type Adder interface {
	Add(S1 Interface, S2 Interface) (Interface, error) // Add
	   returns the sum S1 + S2.
}

then h's Add method will be used.

func EchelonForm ¶

func EchelonForm(h Helper, S Interface) (Interface, error)

EchelonForm returns the reduced row echelon form of S, or an error if reduced row echelon form is not defined or not implemented over this ground ring.

func IdentitySlice ¶

func IdentitySlice(h Helper, n int) (Interface, error)

IdentitySlice returns a slice representing the n x n identity matrix, using the given helper. If h satisfies the interface:

type IdentitySlicer interface {
	IdentitySlice(n int) (Interface, error) // IdentitySlice returns
	   a slice representing the n x n identity matrix.
}

then h's IdentitySlice method will be used.

func Negate ¶

func Negate(h Helper, S Interface) (Interface, error)

Negate returns the negation -S. If S satisfies the interface:

type Negater interface {
	Negate() Interface // Negate returns the negation of the
		entries.
}

then S's Negate method will be used.

func RowRowMultiply ¶

func RowRowMultiply(h Helper, S1 Interface, S2 Interface) (Interface, error)

RowRowMultiply returns the slice of entries of pair-wise dot-products of the rows of S1 and S2. That is, the returned slice has (i,j)-th entry equal to the dot-product of the i-th row of S1 with the j-th row of S2. This is equivalent to the matrix multiplication represented by S1 * Transpose(S2). Requires that S1 and S2 have the same number of columns. The returned slice will represent an nrows1 x nrow2 matrix, where nrows1 is the number of rows of S1, and nrows2 is the number of rows of S2. If h satisfies the interface:

type RowRowMultiplier interface {
	RowRowMultiply(S1 Interface, S2 Interface) (Interface, error)
		// RowRowMultiply returns the slice of entries of
		   pair-wise dot-products of the rows of S1 and S2. That
		   is, the returned slice has (i,j)-th entry equal to
		   the dot-product of the i-th row of S1 with the j-th
		   row of S2. This is equivalent to the matrix
		   multiplication represented by S1 * Transpose(S2).
		   Requires that S1 and S2 have the same number of
		   columns. The returned slice will represent an
		   nrows1 x nrow2 matrix, where nrows1 is the number of
		   rows of S1, and nrows2 is the number of rows of S2.
}

then h's RowRowMultiply method will be used. Otherwise, if h satisfies the interface:

type DotProducter interface {
	DotProduct(S1 Interface, S2 Interface) (DotProductFunc, error)
		// DotProduct returns a dot-product function to compute
		   S1[i] \dot S2[j] of the i-th row of S1 with the j-th
		   row of S2, where S1 and S2 are slices of entries. S1
		   and S2 must have the same number of columns.
}

then h's DotProduct method will be used to assist with the calculation.

func ScalarMultiplyByCoefficient ¶

func ScalarMultiplyByCoefficient(h Helper, c object.Element, S Interface) (Interface, error)

ScalarMultiplyByCoefficient returns c * S, where c is an element in the ring containing the entries of S. If S satisfies the interface:

type ScalarMultiplyByCoefficienter interface {
	ScalarMultiplyByCoefficient(c object.Element) (Interface, error)
		// ScalarMultiplyByCoefficient of a slice S returns
		   c * S, where c is an element in the  ring containing
		   the entries of S.
}

then S's ScalarMultiplyByInteger method will be used.

func ScalarMultiplyByInteger ¶

func ScalarMultiplyByInteger(h Helper, n *integer.Element, S Interface) (Interface, error)

ScalarMultiplyByInteger returns n * S, where this is defined to be S + ... + S (n times) if n is positive, -S - ... - S (|n| times) if n is negative, and 0 if n is zero. If S satisfies the interface:

type ScalarMultiplyByIntegerer interface {
	ScalarMultiplyByInteger(n *integer.Element) Interface
		// ScalarMultiplyByInteger of a slice S returns n * S,
		   where this is defined to be S + ... + S (n times) if
		   n is positive, -S - ... - S (|n| times) if n is
		   negative, and 0 if n is zero.
}

then S's ScalarMultiplyByInteger method will be used.

func Subtract ¶

func Subtract(h Helper, S1 Interface, S2 Interface) (Interface, error)

Subtract returns the difference S1 - S2. If h satisfies the interface:

type Subtracter interface {
	Subtract(S1 Interface, S2 Interface) (Interface, error)
	   // Subtract returns the difference S1 - S2.
}

then h's Subtract method will be used.

func Sum ¶

func Sum(h Helper, Es []Interface) (Interface, error)

Sum returns the sum of the matrices described by the slices of entries Es. The slice Es must not be empty. If h satisfies the interface:

type Sumer interface {
	Sum(Es []Interface) (Interface, error) // Sum returns the sum of
		   the matrices described by the slices of entries Es.
		   The slice Es must not be empty.
}

then h's Sum method will be used.

func Transpose ¶

func Transpose(h Helper, S Interface) (Interface, error)

Transpose returns the transpose of S. If S satisfies the interface:

type Transposer interface {
	Transpose() Interface // Transpose returns the transpose of the
	   matrix described by the slice of entries.
}

then S's Transpose method will be used.

func ZeroSlice ¶

func ZeroSlice(h Helper, nrows int, ncols int) (Interface, error)

ZeroSlice returns a slice representing the nrows x ncols zero matrix, using the given helper. If h satisfies the interface:

type ZeroSlicer interface {
	ZeroSlice(nrows int, ncols int) (Interface, error) // ZeroSlice
	   returns a slice representing the nrows x ncols zero matrix.
}

then h's ZeroSlice method will be used.