pylib.mathematics module

Mathematical functions and objects.

Date

2019-12-12

lcm(a, b)

Compute the lowest common multiple of a and b

class matrix

Bases: list

Use/create matrix like list of lists

__getitem__(index)

For index return value, for range return new vector object.

Example

>>> m = matrix([[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], \
                [0, 0, 0, 0]])
>>> print(m[:])
[[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 0]]
>>> print(m[2])
[7, 8, 9, 0]
>>> print(m[2, :])
[7, 8, 9, 0]
>>> print(m[:, 2])
[3, 6, 9, 0]
>>> print(m[2, 2])
9
>>> print(m[:, 1:3])
[[2, 3], [5, 6], [8, 9], [0, 0]]
>>> print(m[0:2, 1:3])
[[2, 3], [5, 6]]
>>> print(m[::2, ::2])
[[1, 3], [7, 9]]

__mul__(other)

Scalar multiplication, dot product (inner product) or matrix-vector multiplication. (new object)

\[\begin{split}\mathbf{C} &= \mathbf{A} \cdot b \\ \mathbf{c} &= \mathbf{A} \cdot \mathbf{b} \\ \mathbf{C} &= \mathbf{A} \cdot \mathbf{B}\end{split}\]

Note

No size checking will be conducted, therefore no exceptions for wrong usage (result will be nonsense).

Example

>>> m = matrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], \
                [0, 0, 0, 1]]) * 5
>>> print(m)
[[5, 10, 15, 20], [25, 30, 35, 40], [45, 50, 55, 60], [0, 0, 0, 5]]
>>> m = matrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], \
                [0, 0, 0, 1]]) * 5.
>>> print(m)
[[5.0, 10.0, 15.0, 20.0], [25.0, 30.0, 35.0, 40.0], [45.0, 50.0, 55.0, 60.0], [0.0, 0.0, 0.0, 5.0]]
>>> v = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * \
    vector([12, 12, 13])
>>> print(v)
[75, 186, 297]
>>> m = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) * \
    matrix([[12, 12, 13], [14, 15, 16], [17, 18, 19]])
>>> print(m)
[[91, 96, 102], [220, 231, 246], [349, 366, 390]]

See also

__rmul__()

__repr__()

Return repr(self).

__rmul__(other)

Scalar multiplication, dot product (inner product) or vector-matrix multiplication. (new object)

\[\begin{split}\mathbf{C} &= a \cdot \mathbf{B} \\ \mathbf{c} &= \mathbf{a} \cdot \mathbf{B} \\ \mathbf{C} &= \mathbf{A} \cdot \mathbf{B}\end{split}\]

Note

No size checking will be conducted, therefore no exceptions for wrong usage (result will be nonsense).

Example

>>> m = 5 * matrix([[1, 2, 3, 4], [5, 6, 7, 8], \
                    [9, 10, 11, 12], [0, 0, 0, 1]])
>>> print(m)
[[5, 10, 15, 20], [25, 30, 35, 40], [45, 50, 55, 60], [0, 0, 0, 5]]
>>> m = 5. * matrix([[1, 2, 3, 4], [5, 6, 7, 8], \
                     [9, 10, 11, 12], [0, 0, 0, 1]])
>>> print(m)
[[5.0, 10.0, 15.0, 20.0], [25.0, 30.0, 35.0, 40.0], [45.0, 50.0, 55.0, 60.0], [0.0, 0.0, 0.0, 5.0]]

See also

__mul__() and vector.__mul__() for vector * matrix

__setitem__(index, value)

Set self[key] to value.

__str__()

Return str(self).

rotate_x(theta)

Rotation about the x dirction.

\[\begin{split}\begin{bmatrix} xx & xy & xz & t_x \\ yx' & yy' & yz' & t_y' \\ zx' & zy' & zz' & t_z' \\ 0 & 0 & 0 & h \end{bmatrix} = \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & \cos \theta & -\sin \theta & 0 \\ 0 & \sin \theta & \cos \theta & 0 \\ 0 & 0 & 0 & h \end{bmatrix} \begin{bmatrix} xx & xy & xz & t_x \\ yx & yy & yz & t_y \\ zx & zy & zz & t_z \\ 0 & 0 & 0 & h \end{bmatrix}\end{split}\]

rotate_y(theta)

Rotation about the y dirction.

\[\begin{split}\begin{bmatrix} xx' & xy' & xz' & t_x' \\ yx & yy & yz & t_y \\ zx' & zy' & zz' & t_z' \\ 0 & 0 & 0 & h \end{bmatrix} = \begin{bmatrix} \cos \theta & 0 & \sin \theta & 0 \\ 0 & 1 & 0 & 0 \\ -\sin \theta & 0 & \cos \theta & 0 \\ 0 & 0 & 0 & h \end{bmatrix} \begin{bmatrix} xx & xy & xz & t_x \\ yx & yy & yz & t_y \\ zx & zy & zz & t_z \\ 0 & 0 & 0 & h \end{bmatrix}\end{split}\]

rotate_z(theta)

Rotation about the z dirction.

\[\begin{split}\begin{bmatrix} xx' & xy' & xz' & t_x' \\ yx' & yy' & yz' & t_y' \\ zx & zy & zz & t_z \\ 0 & 0 & 0 & h \end{bmatrix} = \begin{bmatrix} \cos \theta & -\sin \theta & 0 & 0 \\ \sin \theta & \cos \theta & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} xx & xy & xz & t_x \\ yx & yy & yz & t_y \\ zx & zy & zz & t_z \\ 0 & 0 & 0 & h \end{bmatrix}\end{split}\]

static rx(theta)

Rotation matrix about the x direction.

Rotates the coordinate system of vectors

\[\begin{split}\mathbf{R}_{x}(\theta) = \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & \cos \theta & -\sin \theta & 0 \\ 0 & \sin \theta & \cos \theta & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix}\end{split}\]

static ry(theta)

Rotation matrix about the y direction.

Rotates the coordinate system of vectors

\[\begin{split}\mathbf{R}_{y}(\theta) = \begin{bmatrix} \cos \theta & 0 & \sin \theta & 0 \\ 0 & 1 & 0 & 0 \\ -\sin \theta & 0 & \cos \theta & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix}\end{split}\]

static rz(theta)

Rotation matrix about the z direction.

Rotates the coordinate system of vectors

\[\begin{split}\mathbf{R}_{z}(\theta) = \begin{bmatrix} \cos \theta & -\sin \theta & 0 & 0 \\ \sin \theta & \cos \theta & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix}\end{split}\]

Example

\[\begin{split}\mathbf{R}_{z}(\theta) \begin{bmatrix}1 \\ 0 \\ 0 \\ 1\end{bmatrix} &= \begin{bmatrix} \cos 90° & -\sin 90° & 0 & 0 \\ \sin 90° & \cos 90° & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix}1 \\ 0 \\ 0 \\ 1\end{bmatrix} \\ &= \begin{bmatrix} 0 & -1 & 0 & 0 \\ 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix}1 \\ 0 \\ 0 \\ 1\end{bmatrix} = \begin{bmatrix}0 \\ 1 \\ 0 \\ 1\end{bmatrix}\end{split}\]

static s(sx, sy=None, sz=None)

Scaling matrix

uniform scaling if sx=sy=sz=s. Note that scaling happens around the origin, so objects not centered at the origin will have their centers move. To avoid this, either scale the object when it’s located at the origin, or perform a translation afterwards to move the object back to where it should be.

\[\begin{split}\mathbf{S} = \begin{bmatrix} s_x & 0 & 0 & 0 \\ 0 & s_y & 0 & 0 \\ 0 & 0 & s_z & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix}\end{split}\]

scale(sx, sy=None, sz=None)

Scaling

uniform scaling if sx=sy=sz=s. Note that scaling happens around the origin, so objects not centered at the origin will have their centers move. To avoid this, either scale the object when it’s located at the origin, or perform a translation afterwards to move the object back to where it should be.

\[\begin{split}\begin{bmatrix} xx' & xy' & xz' & t_x' \\ yx' & yy' & yz' & t_y' \\ zx' & zy' & zz' & t_z' \\ 0 & 0 & 0 & h \end{bmatrix} = \begin{bmatrix} s_x & 0 & 0 & 0 \\ 0 & s_y & 0 & 0 \\ 0 & 0 & s_z & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} xx & xy & xz & t_x \\ yx & yy & yz & t_y \\ zx & zy & zz & t_z \\ 0 & 0 & 0 & h \end{bmatrix}\end{split}\]

static t(tx, ty, tz)

Translation matrix

\[\begin{split}\mathbf{T} = \begin{bmatrix} 1 & 0 & 0 & t_x \\ 0 & 1 & 0 & t_y \\ 0 & 0 & 1 & t_z \\ 0 & 0 & 0 & 1 \end{bmatrix}\end{split}\]

translate(tx, ty, tz)

Translation

\[\begin{split}\begin{bmatrix} xx & xy & xz & t_x' \\ yx & yy & yz & t_y' \\ zx & zy & zz & t_z' \\ 0 & 0 & 0 & h \end{bmatrix} = \begin{bmatrix} 1 & 0 & 0 & t_x \\ 0 & 1 & 0 & t_y \\ 0 & 0 & 1 & t_z \\ 0 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} xx & xy & xz & t_x \\ yx & yy & yz & t_y \\ zx & zy & zz & t_z \\ 0 & 0 & 0 & h \end{bmatrix}\end{split}\]

transpose()

Transpose

static transposed(a)

Transpose

static zeros(m, n)

Returns a zero matrix of size mxn; m rows and n columns filled with zeros.

Parameters

• m (int) – number of rows of the matrix, e. g. 3

• n (int) – number of columns of the matrix, e. g. 3

Example

>>> m = matrix.zeros(3, 3)
>>> print(m)
[[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]

class vector

Bases: list

Use/create vector like lists

• size, length of a vector use len(a)

• absolute, magntude, norm of a vector use abs(a), see __abs__()

• dot product use a * b, see __mul__() and __rmul__()

• outer product use a @ b, see __matmul__()

__iter__

>>> [i*2 for i in vector([1, 2, 3])]
[2, 4, 6]

__setitem__

>>> v = vector([1, 2, 3, 4, 5])
>>> v[3:5] = [1, 2]
>>> print(v)
[1, 2, 3, 1, 2]
>>> isinstance(v, vector)
True

__eq__(a, b)

>>> vector([1, 2, 3, 1, 2]) == vector([1, 2, 3, 1, 2])
True
>>> vector([1, 2, 3, 1, 2]) == vector([1, 2, 3, 2, 1])
False

__ne__(a, b)

>>> vector([1, 2, 3, 1, 2]) != vector([1, 2, 3, 1, 2])
False
>>> vector([1, 2, 3, 1, 2]) != vector([1, 2, 3, 2, 1])
True

__contains__

>>> 2 in vector([1, 2, 3])
True

__isub__

>>> v = vector([1, 2, 3])
>>> v -= vector([3, 3, 3])
>>> print(v)
[-2, -1, 0]

__imul__

>>> v = vector([1, 2, 3])
>>> v *= vector([3, 3, 3])
>>> print(v)
18

__imatmul__

>>> m = vector([1, 2, 3])
>>> m *= vector([3, 3, 3])
>>> print(v)
[[3, 3, 3], [6, 6, 6], [9, 9, 9]]

__abs__()

Magnitude / norm of a vector

\[b = |\mathbf{a}| = \sqrt{\sum a_i^2} = \sqrt{\mathbf{a} \cdot \mathbf{a}}\]

Example

>>> v = vector([3, 4])
>>> abs(v)
5.0

__add__(other)

a + b (new object)

\[\mathbf{c} = \mathbf{a} + \mathbf{b}\]

Example

>>> v = vector([1, 2, 3]) + vector([1, 2, 3])
>>> print(v)
[2, 4, 6]

__ge__(other)

Test if this object is greater (larger) than or equal the other object.

\[|\mathbf{a}| \ge |\mathbf{b}|\]

Example

>>> vector([1, 2, 3]) >= vector([3, 2, 1])
True
>>> vector([1, 2, 3]) >= vector([4, 2, 1])
False

__getitem__(index)

For index return value, for range return new vector object.

Example

>>> v = vector([1, 2, 3, 4, 5])
>>> v[1:3]
[2, 3]
>>> v = vector([1, 2, 3, 4, 5])
>>> v[3]
4

__gt__(other)

Test if this object is greater (larger) than the other object.

\[|\mathbf{a}| \gt |\mathbf{b}|\]

Example

>>> vector([1, 2, 3]) > vector([3, 2, 1])
False
>>> vector([1, 2, 3]) > vector([2, 2, 1])
True

__iadd__(other)

a += b (new object)

Example

>>> v = vector([1, 2, 3])
>>> v += vector([3, 3, 3])
>>> print(v)
[4, 5, 6]

__le__(other)

Test if this object is lower (smaller) than or equal the other object.

\[|\mathbf{a}| \le |\mathbf{b}|\]

Example

>>> vector([3, 2, 1]) <= vector([1, 2, 3])
True
>>> vector([3, 2, 1]) <= vector([1, 2, 2])
False

__lt__(other)

Test if this object is lower (smaller) than the other object.

\[|\mathbf{a}| \lt |\mathbf{b}|\]

Example

>>> vector([3, 2, 1]) < vector([1, 2, 3])
False
>>> vector([3, 2, 1]) < vector([1, 2, 4])
True

__matmul__(other)

Outer product a @ b (new object)

\[\begin{split}\mathbf{c} = \mathbf{a} \otimes \mathbf{b} = \begin{pmatrix} a_{1}\\ a_{2}\\ a_{3} \end{pmatrix} \otimes \begin{pmatrix} b_{1}\\ b_{2}\\ b_{3} \end{pmatrix} = \begin{pmatrix} a_{1}b_{1}&a_{1}b_{2}&a_{1}b_{3}\\ a_{2}b_{1}&a_{2}b_{2}&a_{2}b_{3}\\ a_{3}b_{1}&a_{3}b_{2}&a_{3}b_{3} \end{pmatrix}\end{split}\]

Example

>>> m = vector([1, 2, 3]) @ vector([1, 2, 4])
>>> print(m)
[[1, 2, 4], [2, 4, 8], [3, 6, 12]]

__mul__(other)

Scalar multiplication, dot product (inner product) or vector-matrix multiplication. (new object)

\[\begin{split}\mathbf{c} &= \mathbf{a} \cdot b \\ \mathbf{c} &= \mathbf{a} \cdot \mathbf{b} \\ \mathbf{c} &= \mathbf{a} \cdot \mathbf{B}\end{split}\]

Note

No size checking will be conducted, therefore no exceptions for wrong usage (result will be nonsense).

Example

>>> v = vector([1, 2, 3, 4, 5]) * 3
>>> print(v)
[3, 6, 9, 12, 15]
>>> v = vector([1, 2, 3, 4, 5]) * 3.
>>> print(v)
[3.0, 6.0, 9.0, 12.0, 15.0]
>>> s = vector([1, 2, 3]) * vector([1, 2, 3])
>>> print(s)
14

See also

__rmul__()

__neg__()

- a (new object)

\[\mathbf{b} = -\mathbf{a}\]

__pos__()

+ a (new object)

\[\mathbf{b} = +\mathbf{a}\]

__repr__()

Return repr(self).

__rmul__(other)

Scalar multiplication, dot product (inner product) or matrix-vector multiplication. (new object)

\[\begin{split}\mathbf{c} &= a \cdot \mathbf{b} \\ \mathbf{c} &= \mathbf{a} \cdot \mathbf{b} \\ \mathbf{c} &= \mathbf{A} \cdot \mathbf{b}\end{split}\]

Note

No size checking will be conducted, therefore no exceptions for wrong usage (result will be nonsense).

Example

>>> v = 3 * vector([1, 2, 3, 4, 5])
>>> print(v)
[3, 6, 9, 12, 15]
>>> v = 3. * vector([1, 2, 3, 4, 5])
>>> print(v)
[3.0, 6.0, 9.0, 12.0, 15.0]

See also

__mul__() and matrix.__mul__() for matrix * vector

__str__()

Return str(self).

__sub__(other)

a - b (new object)

\[\mathbf{c} = \mathbf{a} - \mathbf{b}\]

Example

>>> v = vector([1, 2, 3]) - vector([1, 2, 3])
>>> print(v)
[0, 0, 0]

static abs(a)

Return modulus parts of a complex vector

static ang(a, b)

static arg(a)

Return phase parts of a complex vector

ch_cs(cs)

Transform this vector from its defined coordinate system to a new coordinate system, defined by the given coordinate system (u, v and w direction vectors).

\[\begin{split}\begin{bmatrix}x' \\ y' \\ z' \\ h'\end{bmatrix} = \begin{bmatrix} u_x & u_y & u_z & 0 \\ v_x & v_y & v_z & 0 \\ w_x & w_y & w_z & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix}x \\ y \\ z \\ h\end{bmatrix}\end{split}\]

static conjugate(a)

New vector object

static cross(a, b)

Cross product

c is orthogonal to both a and b. The direction of c can be found with the right-hand rule.

\[\mathbf{c} = \mathbf{a} \times \mathbf{b}\]

static full(length, fill_value)

Returns a vector of length m filled with v.

Parameters

• length (int) – length of the vector, e. g. 3

• fill_value – fill value

Type fill_value

scalar

Example

>>> v = vector.full(3, 7)
>>> print(v)
[7, 7, 7]

static im(a)

Return the imaginary parts of a complex vector

static isclose(a, b, rel_tol=0.05, abs_tol=1e-08)

iscloseto(other)

normalize()

Normalize a vector (i. e. the vector has a length of 1)

\[\mathbf{\hat{a}} = \frac{\mathbf{a}}{|\mathbf{a}|}\]

See also

__abs__() for a norm (magnitude) of a vector

static normalized(a)

Normalize a vector (i. e. the vector has a length of 1)

\[\mathbf{\hat{a}} = \frac{\mathbf{a}}{|\mathbf{a}|}\]

See also

__abs__() for a norm (magnitude) of a vector

static ones(length)

Returns a vector of length m filled with ones.

Parameters

length (int) – lhape of the vector, e. g. 3

Example

>>> v = vector.ones(3)
>>> print(v)
[1.0, 1.0, 1.0]

static random(length, lmin=0.0, lmax=1.0)

Returns a random vector of length n filled with random numbers.

Parameters

length (int) – lhape of the vector, e. g. 3

Example

>>> v = vector.random(3)
>>> print(v)
[0.9172905912930438, 0.8908124278322492, 0.5256002790725927]
>>> v = vector.random(3, 1, 2)
>>> print(v)
[1.2563665665080803, 1.9270454509964547, 1.2381672401270487]

static re(a)

Return the real parts of a complex vector

rotate_x(theta)

Rotation about the x dirction.

\[\begin{split}\begin{bmatrix}x' \\ y' \\ z' \\ h'\end{bmatrix} = \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & \cos \theta & -\sin \theta & 0 \\ 0 & \sin \theta & \cos \theta & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix}x \\ y \\ z \\ h\end{bmatrix}\end{split}\]

rotate_y(theta)

Rotation about the y dirction.

\[\begin{split}\begin{bmatrix}x' \\ y' \\ z' \\ h'\end{bmatrix} = \begin{bmatrix} \cos \theta & 0 & \sin \theta & 0 \\ 0 & 1 & 0 & 0 \\ -\sin \theta & 0 & \cos \theta & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix}x \\ y \\ z \\ h\end{bmatrix}\end{split}\]

rotate_z(theta)

Rotation about the z dirction.

\[\begin{split}\begin{bmatrix}x' \\ y' \\ z' \\ h'\end{bmatrix} = \begin{bmatrix} \cos \theta & -\sin \theta & 0 & 0 \\ \sin \theta & \cos \theta & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix}x \\ y \\ z \\ h\end{bmatrix}\end{split}\]

scale(sx, sy=None, sz=None)

Scaling

uniform scaling if sx=sy=sz=s. Note that scaling happens around the origin, so objects not centered at the origin will have their centers move. To avoid this, either scale the object when it’s located at the origin, or perform a translation afterwards to move the object back to where it should be.

\[\begin{split}\begin{bmatrix}x' \\ y' \\ z' \\ h'\end{bmatrix} = \begin{bmatrix} s_x & 0 & 0 & 0 \\ 0 & s_y & 0 & 0 \\ 0 & 0 & s_z & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix}x \\ y \\ z \\ h\end{bmatrix}\end{split}\]

translate(tx, ty, tz)

Translation

\[\begin{split}\begin{bmatrix}x' \\ y' \\ z' \\ h'\end{bmatrix} = \begin{bmatrix} 1 & 0 & 0 & t_x \\ 0 & 1 & 0 & t_y \\ 0 & 0 & 1 & t_z \\ 0 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix}x \\ y \\ z \\ h\end{bmatrix}\end{split}\]

static zeros(length)

Returns a zero vector of length m filled with zeros.

Parameters

length (int) – length of the vector, e. g. 3

Example

>>> v = vector.zeros(3)
>>> print(v)
[0.0, 0.0, 0.0]