jhypercomplex

Class BinaryProductStructure

java.lang.Object

jhypercomplex.BinaryProductStructure

Direct Known Subclasses:

BinaryAlgebra, OctonionLoop, SedenionLoop, Vector

public abstract class BinaryProductStructure
extends java.lang.Object

Copyright © 2005-2015 by Markus Maute. All rights reserved. A binary product structure will (loosely speaking) be understood as any mathematical object endowed with solely the operation of a binary multiplication (no addition, etc.). A more concrete structure like a groupoid, a quasigroup, a semigroup or a group is intended to be defined in a subclass, inheriting this class. In particular, algebras also having an operation of addition should inherit methods involving the product only from this class.

Version:

0.1

Author:

Markus Maute (http:///www.jalgebra.com)

Field Summary

Fields

Modifier and Type	Field and Description
int	ARG_NUM
static int	CIRCULAR
int	COMP_NUM
java.lang.String[]	components
static int	HYPERBOLIC
static double	ZERO_PRECISSION

Constructor Summary

Constructors

Constructor and Description
BinaryProductStructure()
BinaryProductStructure(int comp_nr)

Method Summary

Methods

Modifier and Type	Method and Description
java.lang.String	asString()
java.lang.String	asString(boolean with_blanks)
void	collectTerms() Equal terms of the components are added or subtracted wherever possible.
void	compressComponents() Removes all blanks from components as they are algebraically redundant.
BinaryProductStructure	conjugate()
static BinaryProductStructure	dual() // TODO Implementation not clear, as we have to distinguish between a left- and // a right dual ...
abstract java.lang.String[]	getBasis()
java.lang.String	getBasisElementAsString(int n)
java.lang.String	getBasisElementsAsString()
abstract BinaryProductStructure	getClone()
static java.util.HashSet<java.lang.String>	getClosedPairsAsString(BinaryProductStructure[] h)
java.lang.String	getComponent(int comp_nr)
java.lang.String[]	getComponents()
java.lang.String	getComponentsAsString()
java.lang.String	getComponentsAsString(boolean with_blanks)
static BinaryProductStructure	getConjugate(BinaryProductStructure h)
java.lang.String	getDiagonalProducts()
static BinaryProductStructure	getDual(BinaryProductStructure h)
static java.util.LinkedList<java.lang.String>	getExpressionAsList(java.lang.String expression) An expression is split up in respect to the summands.
java.lang.String	getFormattedMultTable()
BinaryProductStructure	getHermitianConjugate() The hermitian conjugate of a hypernumber H is defined as: *H = *(S,S) = (*S,S) where S is the subalgebra from which the hypernumber is constructed via a (Cayley-Dickson) doubling procedure.
static BinaryProductStructure	getImaginaryPart(BinaryProductStructure h)
static BinaryProductStructure	getInstance(java.lang.Class class_)
abstract java.lang.String[][]	getMTab() Multiplication table and basis *
static java.lang.String[][]	getMultiplicationTableAsArray() To be implemented in the classes that inherit from class 'Hypernumber'.
int	getMultiplicativeOrder(BinaryProductStructure h, int max_steps)
int	getMultiplicativeOrder(BinaryProductStructure h, int mult_steps, double zero_precision) Multiplicative order n, defined by: {min n: h1*(h2^n) = l*h1} with l a scalar factor.
java.lang.String	getMultTableDiagonal()
static BinaryProductStructure	getNegated(BinaryProductStructure h)
abstract BinaryProductStructure	getNewInstance()
static java.lang.String	getNextBitmap(java.lang.String bitmap) Used for permuting a bitmap with n 1's.
java.lang.String	getNonzeroComponentsNumbered()
java.lang.String	getNonzeroComponentsNumbered(boolean signed) If the n-th component (numbering starting from 0) is non-zero, "n" is added to a list.
static java.lang.String[][]	getNormedMultiplicationTable(java.lang.String[][] mult_table, java.lang.String[] basis, java.lang.String[] sub_basis) A normed multiplication table is per definition a table where the base elements are numbered according to the order of their occurrence in the basis vector (integers running from 1 upwards).
static BinaryProductStructure	getNormSquared(BinaryProductStructure h)
double	getNormSquaredAsValue() REQUIRES: Invocation in numerical mode.
static int	getNumberOfClosedElements(BinaryProductStructure[] h) In case that the full set of elements is not closed under multiplication, it might be of interest for how many of its elements this property is still given.
static int	getNumberOfClosedPairs(BinaryProductStructure[] h) For every posssible pair of the given set of hypernumbers it is checked if the prodeuct is again contained in the set.
abstract int	getNumberOfComponents()
int	getNumberOfNonzeroComponents()
static BinaryProductStructure	getNumericalInverse(BinaryProductStructure h) The inverse of a hypernumber h is calculated.
static BinaryProductStructure	getProduct(BinaryProductStructure h1, BinaryProductStructure h2) Multiplies two hypernummers according to the order of the arguments of the method.
static BinaryProductStructure	getProductWithScalar(BinaryProductStructure h, java.lang.String scalar)
java.lang.String	getPseudoScalarComponent()
static BinaryProductStructure[]	getRandomClosedPair(BinaryProductStructure[] h) From the given set of hypernumbers a random pair is chosen (non trivial, i.a. the two elements are supposed to be different).
static BinaryProductStructure[]	getRandomNonClosedPair(BinaryProductStructure[] h) From the given set of hypernumbers a random pair is chosen (non trivial, i.a. the two elements are supposed to be different).
java.lang.String	getScalarComponent()
static java.util.HashSet<java.lang.String>	getSubalgebras(java.lang.Class class_, int order) Determines all subalgebras of order n.
static java.lang.String	getSubalgebrasAsString(java.lang.Class<?> class_, int order)
java.util.Collection<java.lang.String>	getSubalgebrasSignatures(java.lang.Class<?> class_, int order)
static BinaryProductStructure	getTrace(BinaryProductStructure h) The trace of a hypernumber is defined as tr(h) = h + conjugate(h) = 2*real part (h).
double	getTraceRespDeterminant(BinaryProductStructure h)
static BinaryProductStructure	getVectorDerivative(BinaryProductStructure direction, BinaryProductStructure function) Derivative in direction of a vector 'a' for a hypernumber-valued function F: (a*d)F with '*' being the inner product and 'd' a
static BinaryProductStructure	getVectorProduct(BinaryProductStructure h1, BinaryProductStructure h2) The vector product "x" of two hypernumbers h1 and h2 is defined as h1 x h2 = Im(Im(h1)*Im(h2)) = 0.5 [h1,h2] It coincides with the conventional vector product in 3 dimensions for the quaternions and the vector product in 7-dimensions for the octonions.
boolean	isAutomorphism(BinaryProductStructure x, BinaryProductStructure y) Checks if given hypernumber is related to the hypernumbers x, y via the automorphism map: (a x a^{-1}) (a y a^{-1}) = l (a xy a^{-1}) with l a constant, i.e. we do not require an appropriate normalisation of the hypernumbers.
boolean	isCayleyDicksonLoop()
boolean	isComponentZero(int nr)
static boolean	isLinearlyDependent(BinaryProductStructure h1, BinaryProductStructure h2, boolean pos_and_neg) Tests linear dependency, i.e. if h1 = c*h2 is satisfied, with "c" a (real) non-zero constant.
boolean	isNumerical()
static boolean	isNumericalityDetected(BinaryProductStructure h) Detects if all the components are numerical.
static boolean	isProductClosed(BinaryProductStructure[] h) REQUIRES: Mode must be set to numerical.
boolean	isZero()
BinaryProductStructure	multiplyWithScalar(java.lang.String scalar) Multiplication with a scalar.
BinaryProductStructure	negate() Negates the hypernumber: h --> -h.
void	resetComponents() Sets all components to zero.
BinaryProductStructure	rightMultiplyWith(BinaryProductStructure h2)
BinaryProductStructure	rightMultiplyWith(BinaryProductStructure h, boolean collect_terms) Multiply with another hypercomplex number.
void	setBasis(java.lang.String[] new_basis) Sets the components of the hypercomplex number.
void	setComponent(int n, java.lang.String value) Sets the value of a single component.
void	setComponentAsBasisNames() The designation of the basis elements is copied to the respective components.
void	setComponentExclusively(int n, java.lang.String value) Sets the value of a single component.
void	setComponents(java.lang.String components) Sets the components of the hypercomplex number.
void	setComponents(java.lang.String[] comps)
void	setIndexedComponents(java.lang.String component_name, int start_index, boolean imaginary_only) REQUIRES: Only non-numerical mode allowed.
static void	setMultiplicationTable(MultiplicationTable mult_table)
static void	setMultiplicationTable(java.lang.String[][] mult_table)
static void	setNumerical()
static void	setNumerical(boolean is_numerical)
void	setPseudoScalarComponent(java.lang.String scalar)
void	setRandomComponents(int n)
void	setRandomComponents(int n, boolean is_imaginary)
void	setRandomComponents(int n, boolean is_imaginary, boolean numerical) Assigns random components to the hypernumber.
void	setRandomComponentsAll() Sets all components randomly.
static void	setRepresentation(java.lang.String representation) Specifies the labeling of the basis elements.
void	setScalarComponent(java.lang.String scalar)
static void	setSignTable(SignTable sign_table) The signs of the multiplication table (i.e. the structure constants) are set.
void	simplifyNumericalFactors() For the components the factors of all terms separated by "+" or "-" are moved to the front and are multiplied with one another.
void	simplifyNumericalSummands() Numerical summands are simplified, i.e. added or subtracted.
void	simplifyPlusMinus() Simplifies the components, replacing any adjacent "+"'s and "-"'s according to: "++" --> "+" "+-" --> "-" "-+" --> "-" "--" --> "+"
BinaryProductStructure	square()

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

CIRCULAR

public static final int CIRCULAR

See Also:

Constant Field Values

HYPERBOLIC

public static final int HYPERBOLIC

See Also:

Constant Field Values

ZERO_PRECISSION

public static double ZERO_PRECISSION

COMP_NUM

public int COMP_NUM

ARG_NUM

public int ARG_NUM

components

public java.lang.String[] components

Constructor Detail

BinaryProductStructure

public BinaryProductStructure()

BinaryProductStructure

public BinaryProductStructure(int comp_nr)

Method Detail

getClone

public abstract BinaryProductStructure getClone()

getNumberOfComponents

public abstract int getNumberOfComponents()

getNewInstance

public abstract BinaryProductStructure getNewInstance()

getInstance

public static BinaryProductStructure getInstance(java.lang.Class class_)
                                          throws java.lang.InstantiationException,
                                                 java.lang.IllegalAccessException

Parameters:

classname - Class name.

Returns:

An instance of the hypernumber with the given class name.

Throws:

java.lang.IllegalAccessException

java.lang.InstantiationException

getMTab

public abstract java.lang.String[][] getMTab()

Multiplication table and basis *

getBasis

public abstract java.lang.String[] getBasis()

getMultiplicationTableAsArray

public static java.lang.String[][] getMultiplicationTableAsArray()
                                                          throws java.lang.Exception

To be implemented in the classes that inherit from class 'Hypernumber'.

Returns:

Throws:

java.lang.Exception

setMultiplicationTable

public static void setMultiplicationTable(java.lang.String[][] mult_table)
                                   throws java.lang.Exception

Throws:

java.lang.Exception

setMultiplicationTable

public static void setMultiplicationTable(MultiplicationTable mult_table)
                                   throws java.lang.Exception

Throws:

java.lang.Exception

setRepresentation

public static void setRepresentation(java.lang.String representation)
                              throws java.lang.Exception

Specifies the labeling of the basis elements.

Parameters:

representation - Basis elements, comma delimited.

Throws:

java.lang.Exception

setSignTable

public static void setSignTable(SignTable sign_table)
                         throws java.lang.Exception

The signs of the multiplication table (i.e. the structure constants) are set.

Parameters:

sign_table - Sign table.

Throws:

java.lang.Exception

setBasis

public void setBasis(java.lang.String[] new_basis)
              throws java.lang.Exception

Sets the components of the hypercomplex number. They are in respect to the base defined by the multiplication table. TODO specify the allowed form of a component

Parameters:

components - E.g. the 8 components of an octonion, "x1,x2,x3,x4,x5,x6,x7,x8".

Throws:

java.lang.Exception - Thrown if the argument is not valid.

getBasisElementsAsString

public java.lang.String getBasisElementsAsString()

Returns:

String with basis elements comma delimited. E.g. "(e1,e2)"

getBasisElementAsString

public java.lang.String getBasisElementAsString(int n)

Parameters:

n - Number of element (counting starts with 0).

Returns:

Name of (n-1)-th basis element.

getFormattedMultTable

public java.lang.String getFormattedMultTable()

Returns:

A very rudimentary implementation (yet) for for text-formatting the multiplication table.

setComponents

public void setComponents(java.lang.String components)
                   throws java.lang.Exception

Sets the components of the hypercomplex number. They are in respect to the base defined by the multiplication table. TODO specify the allowed form of a component

Parameters:

components - E.g. the 8 components of an octonion, "x1,x2,x3,x4,x5,x6,x7,x8".

Throws:

java.lang.Exception - Thrown if the argument is not valid.

setIndexedComponents

public void setIndexedComponents(java.lang.String component_name,
                        int start_index,
                        boolean imaginary_only)
                          throws java.lang.Exception

REQUIRES: Only non-numerical mode allowed. Every component (or every imaginary component respectively) is assigned an indexed value. E.g. given a component name "a" and a starting index "0", one gets the components "a0", "a1",....

Parameters:

component_name - Name of component to be indexed.

start_index - Number from which indexing starts.

imaginary_only - Only imaginary components are considered.

Throws:

java.lang.Exception

setNumerical

public static void setNumerical()

setNumerical

public static void setNumerical(boolean is_numerical)

Parameters:

is_numerical - 'true': Mathematical operations are carried out numerically. 'false': -- " -- algebraically.

isNumerical

public boolean isNumerical()

isComponentZero

public boolean isComponentZero(int nr)
                        throws java.lang.Exception

Parameters:

nr - Number of component (counting starting with "1").

Returns:

'true' if component is zero, 'false' else.

Throws:

java.lang.Exception

setComponents

public void setComponents(java.lang.String[] comps)
                   throws java.lang.Exception

Throws:

java.lang.Exception

setScalarComponent

public void setScalarComponent(java.lang.String scalar)

getScalarComponent

public java.lang.String getScalarComponent()

setPseudoScalarComponent

public void setPseudoScalarComponent(java.lang.String scalar)

getPseudoScalarComponent

public java.lang.String getPseudoScalarComponent()

resetComponents

public void resetComponents()

Sets all components to zero.

setComponent

public void setComponent(int n,
                java.lang.String value)
                  throws java.lang.Exception

Sets the value of a single component.

Parameters:

n - Component number (counting starts with "0").

value - Value.

Throws:

java.lang.Exception

setComponentAsBasisNames

public void setComponentAsBasisNames()
                              throws java.lang.Exception

The designation of the basis elements is copied to the respective components.

Throws:

java.lang.Exception

setComponentExclusively

public void setComponentExclusively(int n,
                           java.lang.String value)
                             throws java.lang.Exception

Sets the value of a single component. All other components are reset.

Parameters:

n - Component number (counting starts with "0").

value - Value.

Throws:

java.lang.Exception

getComponents

public java.lang.String[] getComponents()

getComponent

public java.lang.String getComponent(int comp_nr)

Parameters:

comp_nr -

Returns:

N-th component, numbering starting with '0'.

getComponentsAsString

public java.lang.String getComponentsAsString()

Returns:

Components, comma delimited. E.g. "1,2,5,2".

isNumericalityDetected

public static boolean isNumericalityDetected(BinaryProductStructure h)

Detects if all the components are numerical.

Returns:

'true' if so. 'false' else.

getComponentsAsString

public java.lang.String getComponentsAsString(boolean with_blanks)

setRandomComponentsAll

public void setRandomComponentsAll()
                            throws java.lang.Exception

Sets all components randomly.

Throws:

java.lang.Exception

setRandomComponents

public void setRandomComponents(int n)
                         throws java.lang.Exception

Throws:

java.lang.Exception

setRandomComponents

public void setRandomComponents(int n,
                       boolean is_imaginary)
                         throws java.lang.Exception

Throws:

java.lang.Exception

setRandomComponents

public void setRandomComponents(int n,
                       boolean is_imaginary,
                       boolean numerical)
                         throws java.lang.Exception

Assigns random components to the hypernumber.

Parameters:

n - Number of components to be set. The others are set to zero.

is_imaginary - Only imaginary components are set, i.e. the first component is ignored.

numerical - the components are numerical (doubles). If the hypernumber is set to numerical anyhow, this flag is ignored.

Throws:

java.lang.Exception

asString

public java.lang.String asString(boolean with_blanks)

Parameters:

no_blanks - 'true' No blanks between summands. 'false' A blank between summands.

Returns:

Representation of the hypernumber with components and base elements. E.g. "x1*e1+x2*e2+x3*e3+x4*e4+x5*e5+x6*e6+x7*e7+x8*e8".

asString

public java.lang.String asString()

getNormedMultiplicationTable

public static java.lang.String[][] getNormedMultiplicationTable(java.lang.String[][] mult_table,
                                                java.lang.String[] basis,
                                                java.lang.String[] sub_basis)

A normed multiplication table is per definition a table where the base elements are numbered according to the order of their occurrence in the basis vector (integers running from 1 upwards). Example: Normed right handed quaternion multiplication table: 1 2 3 4 2 -1 4 -3 3 -4 -1 2 4 3 -2 -1 An equivalent conventional multiplication table would look like that: e i j k i -e k -j j -k -e i k j -i -e We assume that the structure constants are +1, -1 or 0. The normed table is useful for comparing multiplication tables of different hypernumbers.

Parameters:

A - sub table based on the sub basis is projected out.

Returns:

Normed multiplication table.

square

public BinaryProductStructure square()
                              throws java.lang.Exception

Returns:

The hypernumber multiplied with itself.

Throws:

java.lang.Exception

getNormSquaredAsValue

public double getNormSquaredAsValue()
                             throws java.lang.Exception

REQUIRES: Invocation in numerical mode.

Returns:

Norm, defined as N(x) = x*x_conjugate.

Throws:

java.lang.Exception

getNormSquared

public static BinaryProductStructure getNormSquared(BinaryProductStructure h)
                                             throws java.lang.Exception

Parameters:

h - Hypernumber

Returns:

A hypernumber with the norm in the 1-st component.

Throws:

java.lang.Exception

getMultTableDiagonal

public java.lang.String getMultTableDiagonal()

getDiagonalProducts

public java.lang.String getDiagonalProducts()

negate

public BinaryProductStructure negate()
                              throws java.lang.Exception

Negates the hypernumber: h --> -h.

Returns:

Negated hypernumber h.

Throws:

java.lang.Exception

conjugate

public BinaryProductStructure conjugate()
                                 throws java.lang.Exception

Returns:

The conjugate of the hypernumber, i.e. reverses the signs of the imaginary hypercomplex components.

Throws:

java.lang.Exception

getConjugate

public static BinaryProductStructure getConjugate(BinaryProductStructure h)
                                           throws java.lang.Exception

Returns:

A conjugated copy of the hypernumber.

Throws:

java.lang.Exception

dual

public static BinaryProductStructure dual()
                                   throws java.lang.Exception

// TODO Implementation not clear, as we have to distinguish between a left- and // a right dual ...

Returns:

Throws:

java.lang.Exception

getDual

public static BinaryProductStructure getDual(BinaryProductStructure h)
                                      throws java.lang.Exception

Throws:

java.lang.Exception

getHermitianConjugate

public BinaryProductStructure getHermitianConjugate()
                                             throws java.lang.Exception

The hermitian conjugate of a hypernumber H is defined as: *H = *(S,S) = (*S,S) where S is the subalgebra from which the hypernumber is constructed via a (Cayley-Dickson) doubling procedure. The hermitian conjugate obeys *(AB) = *B*A

Returns:

Hermitian conjugate.

Throws:

java.lang.Exception

getMultiplicativeOrder

public int getMultiplicativeOrder(BinaryProductStructure h,
                         int max_steps)
                           throws java.lang.Exception

Throws:

java.lang.Exception

getMultiplicativeOrder

public int getMultiplicativeOrder(BinaryProductStructure h,
                         int mult_steps,
                         double zero_precision)
                           throws java.lang.Exception

Multiplicative order n, defined by: {min n: h1*(h2^n) = l*h1} with l a scalar factor. REQUIRES: Mode must be set to numerical.

Parameters:

h - Hypernumber

mult_steps - Upper limit up to which multiplicative orders are tested.

Returns:

Order if found within the bounds of the limit else: "-2" if a zero divisor was encountered "-3" if NAN TODO "-1" in all other cases, i.e. for the given number of multiplication steps no cyclicity is found.

Throws:

java.lang.Exception

multiplyWithScalar

public BinaryProductStructure multiplyWithScalar(java.lang.String scalar)
                                          throws java.lang.Exception

Multiplication with a scalar.

Parameters:

scalar - Scalar.

Returns:

Hypernumber multiplied with a scalar.

Throws:

java.lang.Exception

rightMultiplyWith

public BinaryProductStructure rightMultiplyWith(BinaryProductStructure h2)
                                         throws java.lang.Exception

Throws:

java.lang.Exception

rightMultiplyWith

public BinaryProductStructure rightMultiplyWith(BinaryProductStructure h,
                                       boolean collect_terms)
                                         throws java.lang.Exception

Multiply with another hypercomplex number. The other hypercomplex number is multiplied from the right side. (Hypercomplex multiplication is non-commutative). (Brackets are not recognized as such). REQUIRES: Preceding invocation of simplifyPlusMinus (), simplifyNumericalFactors ().

Parameters:

h2 - Hypercomplex number to be multiplied with.

collect_terms - true: Terms are added or subtracted if possible. false: Terms are not added or subtracted. (This is interesting if they contain functions and differential operators for which the order is relevant. The simplification procedure ignores the order).

Returns:

Result of the multiplication.

Throws:

java.lang.Exception

getNegated

public static BinaryProductStructure getNegated(BinaryProductStructure h)
                                         throws java.lang.Exception

Throws:

java.lang.Exception

getImaginaryPart

public static BinaryProductStructure getImaginaryPart(BinaryProductStructure h)
                                               throws java.lang.Exception

Parameters:

h - Hypernumber

Returns:

The imaginary part of a Hyoernumner, i.e. the 1st component is set to zero.

Throws:

java.lang.Exception

getProduct

public static BinaryProductStructure getProduct(BinaryProductStructure h1,
                                BinaryProductStructure h2)
                                         throws java.lang.Exception

Multiplies two hypernummers according to the order of the arguments of the method.

Parameters:

h1 - Hypermummer 1.

h2 - Hypernummer 2.

Returns:

h1*h2.

Throws:

java.lang.Exception

getProductWithScalar

public static BinaryProductStructure getProductWithScalar(BinaryProductStructure h,
                                          java.lang.String scalar)
                                                   throws java.lang.Exception

Throws:

java.lang.Exception

getTrace

public static BinaryProductStructure getTrace(BinaryProductStructure h)
                                       throws java.lang.Exception

The trace of a hypernumber is defined as tr(h) = h + conjugate(h) = 2*real part (h).

Parameters:

h - Hypermummer.

Returns:

Trace.

Throws:

java.lang.Exception

getVectorDerivative

public static BinaryProductStructure getVectorDerivative(BinaryProductStructure direction,
                                         BinaryProductStructure function)

Derivative in direction of a vector 'a' for a hypernumber-valued function F: (a*d)F with '*' being the inner product and 'd' a

Parameters:

direction -

function -

Returns:

Derivative.

isLinearlyDependent

public static boolean isLinearlyDependent(BinaryProductStructure h1,
                          BinaryProductStructure h2,
                          boolean pos_and_neg)

Tests linear dependency, i.e. if h1 = c*h2 is satisfied, with "c" a (real) non-zero constant.

Parameters:

h1 - Hypernumber 1.

h2 - Hypernumber 2.

r - pos_and_neg true: "c" may be positive and negative. false: Only positive values for "c" are allowed. REQUIRES: Mode must be set to numerical.

Returns:

'true': if h1 and h2 are linearly dependent. 'false': else.

getVectorProduct

public static BinaryProductStructure getVectorProduct(BinaryProductStructure h1,
                                      BinaryProductStructure h2)
                                               throws java.lang.Exception

The vector product "x" of two hypernumbers h1 and h2 is defined as h1 x h2 = Im(Im(h1)*Im(h2)) = 0.5 [h1,h2] It coincides with the conventional vector product in 3 dimensions for the quaternions and the vector product in 7-dimensions for the octonions. These two vector products fulfill certain constraints and it can be shown that under these conditions they are the only ones. The vector product given here however is more broadly defined. E.g. for the sedenions it can be non alternative. Example: Quaternion h1 = (a0,a1,a2,a3) --> Im(h1) = (0,a1,a2,a3) Quaternion h2 = (b0,b1,b2,b3) --> Im(h2) = (0,b1,b2,b3) Im(h1)*Im(h2) = (...) --> h1xh2 = (0,b1,b2,b3)

Parameters:

h1 - Hypernumber 1.

h2 - Hypernumber 2.

Returns:

Hypernumber with the

Throws:

java.lang.Exception

isZero

public boolean isZero()

Returns:

True if all components are 0.

isProductClosed

public static boolean isProductClosed(BinaryProductStructure[] h)
                               throws java.lang.Exception

REQUIRES: Mode must be set to numerical. Checks if the product of any two elements of the input set is again an element of the set. Normalization of the elements is not required (it is carried out internally).

Parameters:

h - Hypermumbers.

Returns:

'true' the hypernumbers form a closed algebra under the multiplication given by h. 'false' else.

Throws:

java.lang.Exception

getRandomClosedPair

public static BinaryProductStructure[] getRandomClosedPair(BinaryProductStructure[] h)
                                                    throws java.lang.Exception

From the given set of hypernumbers a random pair is chosen (non trivial, i.a. the two elements are supposed to be different). It is then veryfied if the product occurs within the set of hypernumbers. If this is so, the pair of hypernumbers and the product are returned. If not the step is repeated.

Parameters:

h - Hypernumbers.

Returns:

Three hypernumbers that satisfy h1*h2 = h3.

Throws:

java.lang.Exception

getRandomNonClosedPair

public static BinaryProductStructure[] getRandomNonClosedPair(BinaryProductStructure[] h)
                                                       throws java.lang.Exception

From the given set of hypernumbers a random pair is chosen (non trivial, i.a. the two elements are supposed to be different). It is then veryfied if the product occurs within the set of hypernumbers. If this is not so, the pair of hypernumbers and the product are returned. Else the step is repeated.

Parameters:

h - Hypernumbers.

Returns:

Three hypernumbers don't satisfy h1*h2 = h3.

Throws:

java.lang.Exception

getNumberOfClosedElements

public static int getNumberOfClosedElements(BinaryProductStructure[] h)
                                     throws java.lang.Exception

In case that the full set of elements is not closed under multiplication, it might be of interest for how many of its elements this property is still given. The method determines the order of such a subset.

Parameters:

h - Hypernumbers.

Returns:

Number of elements

Throws:

java.lang.Exception - Number of elements of a subset that is closed under multiplication in respect to the full set.

getNumberOfClosedPairs

public static int getNumberOfClosedPairs(BinaryProductStructure[] h)
                                  throws java.lang.Exception

For every posssible pair of the given set of hypernumbers it is checked if the prodeuct is again contained in the set. As there are n^2 pairings, with n the number of elements of the set to be tested, for a set to be closed under multiplication this method must yield n^2.

Parameters:

h - Hypernumbers.

Returns:

Number of elements

Throws:

java.lang.Exception - Number of pairs of elements of the given set of hypernumbers that is closed under multiplication in respect to the full set.

getClosedPairsAsString

public static java.util.HashSet<java.lang.String> getClosedPairsAsString(BinaryProductStructure[] h)
                                                                  throws java.lang.Exception

Throws:

java.lang.Exception

isAutomorphism

public boolean isAutomorphism(BinaryProductStructure x,
                     BinaryProductStructure y)
                       throws java.lang.Exception

Checks if given hypernumber is related to the hypernumbers x, y via the automorphism map: (a x a^{-1}) (a y a^{-1}) = l (a xy a^{-1}) with l a constant, i.e. we do not require an appropriate normalisation of the hypernumbers. The associativity of the conjugacy map: "a X a^{-1} -> X" is assumed. REQUIRES: Mode must be set to numerical.

Parameters:

x - Hypernumber.

y - Hypernumber.

Returns:

'true' if the given hypernumber acts as an isomorphism on x and y, 'false' else.

Throws:

java.lang.Exception

getNumberOfNonzeroComponents

public int getNumberOfNonzeroComponents()

Returns:

Number of non-zero components.

Throws:

java.lang.Exception

getNonzeroComponentsNumbered

public java.lang.String getNonzeroComponentsNumbered(boolean signed)

If the n-th component (numbering starting from 0) is non-zero, "n" is added to a list.

Parameters:

signed - If true, a "-" is added if component < 0.

Returns:

List of numbers (comma delimited).

getNonzeroComponentsNumbered

public java.lang.String getNonzeroComponentsNumbered()

getSubalgebras

public static java.util.HashSet<java.lang.String> getSubalgebras(java.lang.Class class_,
                                                 int order)
                                                          throws java.lang.Exception

Determines all subalgebras of order n. A subalgebra of order n is identified as follows: Two hypernumbers with n non-zero components are multiplied with one another (with the non-zero components in the same positions). If the zero components are mapped to zero components in the resulting product the subbasis defined by the n components is assumed to be a basis of a subalgebra. Example: Basis: {e1,e2,e3,e4,e5,e6} Hypernumber 1: h1 = (1,0,0,1,1,0) Hypernumber 2: h2 = (1,0,0,1,1,0) h1*h2 = (3,0,0,4,2,0) --> subalgera defined by basis {e1,e4,e5}

Parameters:

order - Order.

Returns:

(Closed) subspaces of given order.

Throws:

java.lang.Exception

java.lang.Exception

getSubalgebrasAsString

public static java.lang.String getSubalgebrasAsString(java.lang.Class<?> class_,
                                      int order)
                                               throws java.lang.Exception

Throws:

java.lang.Exception

getSubalgebrasSignatures

public java.util.Collection<java.lang.String> getSubalgebrasSignatures(java.lang.Class<?> class_,
                                                              int order)
                                                                throws java.lang.Exception

Throws:

java.lang.Exception

getNextBitmap

public static java.lang.String getNextBitmap(java.lang.String bitmap)

Used for permuting a bitmap with n 1's. Carries out one step in that the next permutation is generated. Examples: 00100100 --> 00100010 00100001 --> 00011000 Algorithm; i) Find last "10". ii) Flip 0 and 1. iii) Shift all following 1's to the left.

Parameters:

bitmap - Bitmap of 0's and 1's, e.g. "010010010".

Returns:

Bitmap of next permutation step.

getExpressionAsList

public static java.util.LinkedList<java.lang.String> getExpressionAsList(java.lang.String expression)

An expression is split up in respect to the summands. E.g. a1+2*a2-3*a3 |--> (a1,2*a2,-3*a3). REQUIRES: The numerical factors must be in front of the terms.

Parameters:

expression - Expression consisting of terms.

Returns:

Array of the terms.

simplifyPlusMinus

public void simplifyPlusMinus()

Simplifies the components, replacing any adjacent "+"'s and "-"'s according to: "++" --> "+" "+-" --> "-" "-+" --> "-" "--" --> "+"

simplifyNumericalFactors

public void simplifyNumericalFactors()

For the components the factors of all terms separated by "+" or "-" are moved to the front and are multiplied with one another. E.g. 2*x1*4*x2 = 8*x1*x2 or 2*x1*-4*x2 = -8*x1*x2 TODO e.g. 2*x1*-x2 = -2*x1*x2 REQUIRES: Preceding invocation of simplifyPlusMinus ().

simplifyNumericalSummands

public void simplifyNumericalSummands()

Numerical summands are simplified, i.e. added or subtracted. Example: 2*x1+5-6+5*x2 --> 2*x1-1+5*x2

collectTerms

public void collectTerms()

Equal terms of the components are added or subtracted wherever possible. E.g. x1*y1+x2*y2-2*x1*y1 = -x1*y1+x2*y2. REQUIRES: Preceeding invocation of simplifyNumericalFactors ().

getTraceRespDeterminant

public double getTraceRespDeterminant(BinaryProductStructure h)

getNumericalInverse

public static BinaryProductStructure getNumericalInverse(BinaryProductStructure h)
                                                  throws java.lang.NumberFormatException,
                                                         java.lang.Exception

The inverse of a hypernumber h is calculated. This method is only implemented in the numerical mode. The inverse h^-1 is given by h^-1 = conj(h)/(abs(h)^2)

Parameters:

h - Hypernumber

Returns:

Inverse of the hypernumber h.

Throws:

java.lang.NumberFormatException

java.lang.Exception

compressComponents

public void compressComponents()

Removes all blanks from components as they are algebraically redundant.

isCayleyDicksonLoop

public boolean isCayleyDicksonLoop()