typerig.core.objects.matrix

x.__contains__(y) <==> y in x

delitem(...)

x.__delitem__(y) <==> del x[y]

x.__delslice__(i, j) <==> del x[i:j]

Use of negative indices is not supported.

ge(...)

x.__ge__(y) <==> x>=y

x.__getattribute__('name') <==> x.name

getitem(...)

x.__getitem__(y) <==> x[y]

gt(...)

x.__gt__(y) <==> x>y

iadd(...)

x.__iadd__(y) <==> x+=y

imul(...)

x.__imul__(y) <==> x*=y

iter(...)

x.__iter__() <==> iter(x)

le(...)

x.__le__(y) <==> x<=y

len(...)

x.__len__() <==> len(x)

lt(...)

x.__lt__(y) <==> x

ne(...)

x.__ne__(y) <==> x!=y

repr(...)

x.__repr__() <==> repr(x)

L.__reversed__() -- return a reverse iterator over the list

setitem(...)

x.__setitem__(i, y) <==> x[i]=y

x.__setslice__(i, j, y) <==> x[i:j]=y

Use  of negative indices is not supported.

sizeof(...)

L.__sizeof__() -- size of L in memory, in bytes

append(...)

L.append(object) -- append object to end

count(...)

L.count(value) -> integer -- return number of occurrences of value

extend(...)

L.extend(iterable) -- extend list by appending elements from the iterable

index(...)

L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.

insert(...)

L.insert(index, object) -- insert object before index

pop(...)

L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.

remove(...)

L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.

reverse(...)

L.reverse() -- reverse *IN PLACE*

sort(...)

L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1

Attributes from builtin.list

hash = None

new = <built-in method new of type object>

T.__new__(S, ...) -> a new object with type S, a subtype of T

class Matrix(Table)

Method resolution order:: Matrix; Table; builtin.list; builtin.object

Methods

init(self, elems)

Form a matrix from a list of lists or a list of Vecs

augment(self, otherMat)

Make a new matrix with the two original matrices laid side by side

diag(self)

Return a vector composed of elements on the matrix diagonal

mmul(self, other)

Matrix multiply by another matrix or a column vector

qr(self, ROnly=0)

QR decomposition using Householder reflections: Q*R==self, Q.tr()*Q==I(n), R upper triangular

rank(self)

solve(self, b)

Divide matrix into a column vector or matrix and iterate to improve the solution

star(self)

Return the Hermetian adjoint so that Star[i][j] = Original[j][i].conjugate()

tr(self)

Tranpose elements so that Transposed[i][j] = Original[j][i]

trace(self)

Descriptors

cols

rows

size

Methods from Table

abs(self)

add(self, rhs)

div(self, rhs)

eq(self, rhs)

getslice(self, i, j)

mul(self, rhs)

neg(self)

radd(self, lhs)

rdiv(self, lhs)

rmul(self, lhs)

rsub(self, lhs)

str(self)

sub(self, rhs)

concat = add(...)

x.__add__(y) <==> x+y

conjugate(self)

exists(self, predicate)

flatten(self)

forall(self, predicate)

imag(self)

map(self, op, rhs=None)

Apply a unary operator to every element in the matrix or a binary operator to corresponding
elements in two arrays.  If the dimensions are different, broadcast the smaller dimension over
the larger (i.e. match a scalar to every element in a vector or a vector to a matrix).

prod(self)

real(self)

sum(self)

Descriptors from Table

dict

dictionary for instance variables (if defined)

weakref

list of weak references to the object (if defined)

Attributes from Table

dim = 1

Methods from builtin.list

x.__contains__(y) <==> y in x

delitem(...)

x.__delitem__(y) <==> del x[y]

x.__delslice__(i, j) <==> del x[i:j]

Use of negative indices is not supported.

ge(...)

x.__ge__(y) <==> x>=y

x.__getattribute__('name') <==> x.name

getitem(...)

x.__getitem__(y) <==> x[y]

gt(...)

x.__gt__(y) <==> x>y

iadd(...)

x.__iadd__(y) <==> x+=y

imul(...)

x.__imul__(y) <==> x*=y

iter(...)

x.__iter__() <==> iter(x)

le(...)

x.__le__(y) <==> x<=y

len(...)

x.__len__() <==> len(x)

lt(...)

x.__lt__(y) <==> x

ne(...)

x.__ne__(y) <==> x!=y

repr(...)

x.__repr__() <==> repr(x)

L.__reversed__() -- return a reverse iterator over the list

setitem(...)

x.__setitem__(i, y) <==> x[i]=y

x.__setslice__(i, j, y) <==> x[i:j]=y

Use  of negative indices is not supported.

sizeof(...)

L.__sizeof__() -- size of L in memory, in bytes

append(...)

L.append(object) -- append object to end

count(...)

L.count(value) -> integer -- return number of occurrences of value

extend(...)

L.extend(iterable) -- extend list by appending elements from the iterable

index(...)

L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.

insert(...)

L.insert(index, object) -- insert object before index

pop(...)

L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.

remove(...)

L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.

reverse(...)

L.reverse() -- reverse *IN PLACE*

sort(...)

L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1

Attributes from builtin.list

hash = None

new = <built-in method new of type object>

T.__new__(S, ...) -> a new object with type S, a subtype of T

class Square(Matrix)

Method resolution order:: Square; Matrix; Table; builtin.list; builtin.object

Methods

pow(self, exp)

Raise a square matrix to an integer power (i.e. A**3 is the same as A.mmul(A.mmul(A))

det(self)

eigs(self)

Estimate principal eigenvalues using the QR with shifts method

hessenberg(self)

Householder reduction to Hessenberg Form (zeroes below the diagonal)
while keeping the same eigenvalues as self.

inverse(self)

lu(self)

Factor a square matrix into lower and upper triangular form such that L.mmul(U)==A

Methods from Matrix

init(self, elems)

Form a matrix from a list of lists or a list of Vecs

augment(self, otherMat)

Make a new matrix with the two original matrices laid side by side

diag(self)

Return a vector composed of elements on the matrix diagonal

mmul(self, other)

Matrix multiply by another matrix or a column vector

qr(self, ROnly=0)

QR decomposition using Householder reflections: Q*R==self, Q.tr()*Q==I(n), R upper triangular

rank(self)

solve(self, b)

Divide matrix into a column vector or matrix and iterate to improve the solution

star(self)

Return the Hermetian adjoint so that Star[i][j] = Original[j][i].conjugate()

tr(self)

Tranpose elements so that Transposed[i][j] = Original[j][i]

trace(self)

Descriptors from Matrix

cols

rows

size

Methods from Table

abs(self)

add(self, rhs)

div(self, rhs)

eq(self, rhs)

getslice(self, i, j)

mul(self, rhs)

neg(self)

radd(self, lhs)

rdiv(self, lhs)

rmul(self, lhs)

rsub(self, lhs)

str(self)

sub(self, rhs)

concat = add(...)

x.__add__(y) <==> x+y

conjugate(self)

exists(self, predicate)

flatten(self)

forall(self, predicate)

imag(self)

map(self, op, rhs=None)

Apply a unary operator to every element in the matrix or a binary operator to corresponding
elements in two arrays.  If the dimensions are different, broadcast the smaller dimension over
the larger (i.e. match a scalar to every element in a vector or a vector to a matrix).

prod(self)

real(self)

sum(self)

Descriptors from Table

dict

dictionary for instance variables (if defined)

weakref

list of weak references to the object (if defined)

Attributes from Table

dim = 1

Methods from builtin.list

x.__contains__(y) <==> y in x

delitem(...)

x.__delitem__(y) <==> del x[y]

x.__delslice__(i, j) <==> del x[i:j]

Use of negative indices is not supported.

ge(...)

x.__ge__(y) <==> x>=y

x.__getattribute__('name') <==> x.name

getitem(...)

x.__getitem__(y) <==> x[y]

gt(...)

x.__gt__(y) <==> x>y

iadd(...)

x.__iadd__(y) <==> x+=y

imul(...)

x.__imul__(y) <==> x*=y

iter(...)

x.__iter__() <==> iter(x)

le(...)

x.__le__(y) <==> x<=y

len(...)

x.__len__() <==> len(x)

lt(...)

x.__lt__(y) <==> x

ne(...)

x.__ne__(y) <==> x!=y

repr(...)

x.__repr__() <==> repr(x)

L.__reversed__() -- return a reverse iterator over the list

setitem(...)

x.__setitem__(i, y) <==> x[i]=y

class Table(builtin.list)

x.__setslice__(i, j, y) <==> x[i:j]=y

Use  of negative indices is not supported.

sizeof(...)

L.__sizeof__() -- size of L in memory, in bytes

append(...)

L.append(object) -- append object to end

count(...)

L.count(value) -> integer -- return number of occurrences of value

extend(...)

L.extend(iterable) -- extend list by appending elements from the iterable

index(...)

L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.

insert(...)

L.insert(index, object) -- insert object before index

pop(...)

L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.

remove(...)

L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.

reverse(...)

L.reverse() -- reverse *IN PLACE*

sort(...)

L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1

Attributes from builtin.list

hash = None

new = <built-in method new of type object>

T.__new__(S, ...) -> a new object with type S, a subtype of T

# - Classes ------------------------------

Method resolution order:: Table; builtin.list; builtin.object

Methods

abs(self)

add(self, rhs)

div(self, rhs)

eq(self, rhs)

getslice(self, i, j)

init(self, elems)

mul(self, rhs)

neg(self)

radd(self, lhs)

rdiv(self, lhs)

rmul(self, lhs)

rsub(self, lhs)

str(self)

sub(self, rhs)

concat = add(...)

x.__add__(y) <==> x+y

conjugate(self)

exists(self, predicate)

flatten(self)

forall(self, predicate)

imag(self)

map(self, op, rhs=None)

Apply a unary operator to every element in the matrix or a binary operator to corresponding
elements in two arrays.  If the dimensions are different, broadcast the smaller dimension over
the larger (i.e. match a scalar to every element in a vector or a vector to a matrix).

prod(self)

real(self)

sum(self)

Descriptors

dict

dictionary for instance variables (if defined)

weakref

list of weak references to the object (if defined)

Attributes

dim = 1

Methods from builtin.list

x.__contains__(y) <==> y in x

delitem(...)

x.__delitem__(y) <==> del x[y]

x.__delslice__(i, j) <==> del x[i:j]

Use of negative indices is not supported.

ge(...)

x.__ge__(y) <==> x>=y

x.__getattribute__('name') <==> x.name

getitem(...)

x.__getitem__(y) <==> x[y]

gt(...)

x.__gt__(y) <==> x>y

iadd(...)

x.__iadd__(y) <==> x+=y

imul(...)

x.__imul__(y) <==> x*=y

iter(...)

x.__iter__() <==> iter(x)

le(...)

x.__le__(y) <==> x<=y

len(...)

x.__len__() <==> len(x)

lt(...)

x.__lt__(y) <==> x

ne(...)

x.__ne__(y) <==> x!=y

repr(...)

x.__repr__() <==> repr(x)

L.__reversed__() -- return a reverse iterator over the list

setitem(...)

x.__setitem__(i, y) <==> x[i]=y

class Triangular(Square)

x.__setslice__(i, j, y) <==> x[i:j]=y

Use  of negative indices is not supported.

sizeof(...)

L.__sizeof__() -- size of L in memory, in bytes

append(...)

L.append(object) -- append object to end

count(...)

L.count(value) -> integer -- return number of occurrences of value

extend(...)

L.extend(iterable) -- extend list by appending elements from the iterable

index(...)

L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.

insert(...)

L.insert(index, object) -- insert object before index

pop(...)

L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.

remove(...)

L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.

reverse(...)

L.reverse() -- reverse *IN PLACE*

sort(...)

L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1

Attributes from builtin.list

hash = None

new = <built-in method new of type object>

T.__new__(S, ...) -> a new object with type S, a subtype of T

Method resolution order:: Triangular; Square; Matrix; Table; builtin.list; builtin.object

Methods

det(self)

eigs(self)

Methods from Square

pow(self, exp)

Raise a square matrix to an integer power (i.e. A**3 is the same as A.mmul(A.mmul(A))

hessenberg(self)

Householder reduction to Hessenberg Form (zeroes below the diagonal)
while keeping the same eigenvalues as self.

inverse(self)

lu(self)

Factor a square matrix into lower and upper triangular form such that L.mmul(U)==A

Methods from Matrix

init(self, elems)

Form a matrix from a list of lists or a list of Vecs

augment(self, otherMat)

Make a new matrix with the two original matrices laid side by side

diag(self)

Return a vector composed of elements on the matrix diagonal

mmul(self, other)

Matrix multiply by another matrix or a column vector

qr(self, ROnly=0)

QR decomposition using Householder reflections: Q*R==self, Q.tr()*Q==I(n), R upper triangular

rank(self)

solve(self, b)

Divide matrix into a column vector or matrix and iterate to improve the solution

star(self)

Return the Hermetian adjoint so that Star[i][j] = Original[j][i].conjugate()

tr(self)

Tranpose elements so that Transposed[i][j] = Original[j][i]

trace(self)

Descriptors from Matrix

cols

rows

size

Methods from Table

abs(self)

add(self, rhs)

div(self, rhs)

eq(self, rhs)

getslice(self, i, j)

mul(self, rhs)

neg(self)

radd(self, lhs)

rdiv(self, lhs)

rmul(self, lhs)

rsub(self, lhs)

str(self)

sub(self, rhs)

concat = add(...)

x.__add__(y) <==> x+y

conjugate(self)

exists(self, predicate)

flatten(self)

forall(self, predicate)

imag(self)

map(self, op, rhs=None)

Apply a unary operator to every element in the matrix or a binary operator to corresponding
elements in two arrays.  If the dimensions are different, broadcast the smaller dimension over
the larger (i.e. match a scalar to every element in a vector or a vector to a matrix).

prod(self)

real(self)

sum(self)

Descriptors from Table

dict

dictionary for instance variables (if defined)

weakref

list of weak references to the object (if defined)

Attributes from Table

dim = 1

Methods from builtin.list

x.__contains__(y) <==> y in x

delitem(...)

x.__delitem__(y) <==> del x[y]

x.__delslice__(i, j) <==> del x[i:j]

Use of negative indices is not supported.

ge(...)

x.__ge__(y) <==> x>=y

x.__getattribute__('name') <==> x.name

getitem(...)

x.__getitem__(y) <==> x[y]

gt(...)

x.__gt__(y) <==> x>y

iadd(...)

x.__iadd__(y) <==> x+=y

imul(...)

x.__imul__(y) <==> x*=y

iter(...)

x.__iter__() <==> iter(x)

le(...)

x.__le__(y) <==> x<=y

len(...)

x.__len__() <==> len(x)

lt(...)

x.__lt__(y) <==> x

ne(...)

x.__ne__(y) <==> x!=y

repr(...)

x.__repr__() <==> repr(x)

L.__reversed__() -- return a reverse iterator over the list

setitem(...)

x.__setitem__(i, y) <==> x[i]=y

class UpperTri(Triangular)

x.__setslice__(i, j, y) <==> x[i:j]=y

Use  of negative indices is not supported.

sizeof(...)

L.__sizeof__() -- size of L in memory, in bytes

append(...)

L.append(object) -- append object to end

count(...)

L.count(value) -> integer -- return number of occurrences of value

extend(...)

L.extend(iterable) -- extend list by appending elements from the iterable

index(...)

L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.

insert(...)

L.insert(index, object) -- insert object before index

pop(...)

L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.

remove(...)

L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.

reverse(...)

L.reverse() -- reverse *IN PLACE*

sort(...)

L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1

Attributes from builtin.list

hash = None

new = <built-in method new of type object>

T.__new__(S, ...) -> a new object with type S, a subtype of T

Method resolution order:: UpperTri; Triangular; Square; Matrix; Table; builtin.list; builtin.object

Methods from Triangular

det(self)

eigs(self)

Methods from Square

pow(self, exp)

Raise a square matrix to an integer power (i.e. A**3 is the same as A.mmul(A.mmul(A))

hessenberg(self)

Householder reduction to Hessenberg Form (zeroes below the diagonal)
while keeping the same eigenvalues as self.

inverse(self)

lu(self)

Factor a square matrix into lower and upper triangular form such that L.mmul(U)==A

Methods from Matrix

init(self, elems)

Form a matrix from a list of lists or a list of Vecs

augment(self, otherMat)

Make a new matrix with the two original matrices laid side by side

diag(self)

Return a vector composed of elements on the matrix diagonal

mmul(self, other)

Matrix multiply by another matrix or a column vector

qr(self, ROnly=0)

QR decomposition using Householder reflections: Q*R==self, Q.tr()*Q==I(n), R upper triangular

rank(self)

solve(self, b)

Divide matrix into a column vector or matrix and iterate to improve the solution

star(self)

Return the Hermetian adjoint so that Star[i][j] = Original[j][i].conjugate()

tr(self)

Tranpose elements so that Transposed[i][j] = Original[j][i]

trace(self)

Descriptors from Matrix

cols

rows

size

Methods from Table

abs(self)

add(self, rhs)

div(self, rhs)

eq(self, rhs)

getslice(self, i, j)

mul(self, rhs)

neg(self)

radd(self, lhs)

rdiv(self, lhs)

rmul(self, lhs)

rsub(self, lhs)

str(self)

sub(self, rhs)

concat = add(...)

x.__add__(y) <==> x+y

conjugate(self)

exists(self, predicate)

flatten(self)

forall(self, predicate)

imag(self)

map(self, op, rhs=None)

Apply a unary operator to every element in the matrix or a binary operator to corresponding
elements in two arrays.  If the dimensions are different, broadcast the smaller dimension over
the larger (i.e. match a scalar to every element in a vector or a vector to a matrix).

prod(self)

real(self)

sum(self)

Descriptors from Table

dict

dictionary for instance variables (if defined)

weakref

list of weak references to the object (if defined)

Attributes from Table

dim = 1

Methods from builtin.list

x.__contains__(y) <==> y in x

delitem(...)

x.__delitem__(y) <==> del x[y]

x.__delslice__(i, j) <==> del x[i:j]

Use of negative indices is not supported.

ge(...)

x.__ge__(y) <==> x>=y

x.__getattribute__('name') <==> x.name

getitem(...)

x.__getitem__(y) <==> x[y]

gt(...)

x.__gt__(y) <==> x>y

iadd(...)

x.__iadd__(y) <==> x+=y

imul(...)

x.__imul__(y) <==> x*=y

iter(...)

x.__iter__() <==> iter(x)

le(...)

x.__le__(y) <==> x<=y

len(...)

x.__len__() <==> len(x)

lt(...)

x.__lt__(y) <==> x

ne(...)

x.__ne__(y) <==> x!=y

repr(...)

x.__repr__() <==> repr(x)

L.__reversed__() -- return a reverse iterator over the list

setitem(...)

x.__setitem__(i, y) <==> x[i]=y

x.__setslice__(i, j, y) <==> x[i:j]=y

Use  of negative indices is not supported.

sizeof(...)

L.__sizeof__() -- size of L in memory, in bytes

append(...)

L.append(object) -- append object to end

count(...)

L.count(value) -> integer -- return number of occurrences of value

extend(...)

L.extend(iterable) -- extend list by appending elements from the iterable

index(...)

L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.

insert(...)

L.insert(index, object) -- insert object before index

pop(...)

L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.

remove(...)

L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.

reverse(...)

L.reverse() -- reverse *IN PLACE*

sort(...)

L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1

Attributes from builtin.list

hash = None

new = <built-in method new of type object>

T.__new__(S, ...) -> a new object with type S, a subtype of T

class Vec(Table)

Method resolution order:: Vec; Table; builtin.list; builtin.object

Methods

cross(self, otherVec)

Compute a Vector or Cross Product with another vector

dot(self, otherVec)

house(self, index)

Compute a Householder vector which zeroes all but the index element after a reflection

norm(self)

normalize(self)

outer(self, otherVec)

polyval(self, x)

Vec([6,3,4]).polyval(5) evaluates to 6*x**2 + 3*x + 4 at x=5

ratval(self, x)

Vec([10,20,30,40,50]).ratfit(5) evaluates to (10*x**2 + 20*x + 30) / (40*x**2 + 50*x + 1) at x=5.

Methods from Table

abs(self)

add(self, rhs)

div(self, rhs)

eq(self, rhs)

getslice(self, i, j)

init(self, elems)

mul(self, rhs)

neg(self)

radd(self, lhs)

rdiv(self, lhs)

rmul(self, lhs)

rsub(self, lhs)

str(self)

sub(self, rhs)

concat = add(...)

x.__add__(y) <==> x+y

conjugate(self)

exists(self, predicate)

flatten(self)

forall(self, predicate)

imag(self)

map(self, op, rhs=None)

Apply a unary operator to every element in the matrix or a binary operator to corresponding
elements in two arrays.  If the dimensions are different, broadcast the smaller dimension over
the larger (i.e. match a scalar to every element in a vector or a vector to a matrix).

prod(self)

real(self)

sum(self)

Descriptors from Table

dict

dictionary for instance variables (if defined)

weakref

list of weak references to the object (if defined)

Attributes from Table

dim = 1

Methods from builtin.list

x.__contains__(y) <==> y in x

delitem(...)

x.__delitem__(y) <==> del x[y]

x.__delslice__(i, j) <==> del x[i:j]

Use of negative indices is not supported.

ge(...)

x.__ge__(y) <==> x>=y

x.__getattribute__('name') <==> x.name

getitem(...)

x.__getitem__(y) <==> x[y]

gt(...)

x.__gt__(y) <==> x>y

iadd(...)

x.__iadd__(y) <==> x+=y

imul(...)

x.__imul__(y) <==> x*=y

iter(...)

x.__iter__() <==> iter(x)

le(...)

x.__le__(y) <==> x<=y

len(...)

x.__len__() <==> len(x)

lt(...)

x.__lt__(y) <==> x

ne(...)

x.__ne__(y) <==> x!=y

repr(...)

x.__repr__() <==> repr(x)

L.__reversed__() -- return a reverse iterator over the list

setitem(...)

x.__setitem__(i, y) <==> x[i]=y