K iK~ d dl mZ ddlZdZdZ G d de Z G d d e Zed
k( rddl Z e j yy) )xrange N
z c 4 e Zd ZdZd Zd Zd(dZd Zd)dZd Z d Z
d
Z d Z d Z
d
Zd Zd Zd Zd Zd Zd ZeZd Zd Zd Zd Zd Zd Zd Z d Z d Z d Z e e e d Z!d Z"d! Z# e e"e#d" Z$d# Z% e e% Z&d$ Z'd% Z( e e( Z)d& Z*e*Z+d' Z,y)*_matrixa#
Numerical matrix.
Specify the dimensions or the data as a nested list.
Elements default to zero.
Use a flat list to create a column vector easily.
The datatype of the context (mpf for mp, mpi for iv, and float for fp) is used to store the data.
Creating matrices
-----------------
Matrices in mpmath are implemented using dictionaries. Only non-zero values
are stored, so it is cheap to represent sparse matrices.
The most basic way to create one is to use the ``matrix`` class directly.
You can create an empty matrix specifying the dimensions:
>>> from mpmath import *
>>> mp.dps = 15
>>> matrix(2)
matrix(
[['0.0', '0.0'],
['0.0', '0.0']])
>>> matrix(2, 3)
matrix(
[['0.0', '0.0', '0.0'],
['0.0', '0.0', '0.0']])
Calling ``matrix`` with one dimension will create a square matrix.
To access the dimensions of a matrix, use the ``rows`` or ``cols`` keyword:
>>> A = matrix(3, 2)
>>> A
matrix(
[['0.0', '0.0'],
['0.0', '0.0'],
['0.0', '0.0']])
>>> A.rows
3
>>> A.cols
2
You can also change the dimension of an existing matrix. This will set the
new elements to 0. If the new dimension is smaller than before, the
concerning elements are discarded:
>>> A.rows = 2
>>> A
matrix(
[['0.0', '0.0'],
['0.0', '0.0']])
Internally ``mpmathify`` is used every time an element is set. This
is done using the syntax A[row,column], counting from 0:
>>> A = matrix(2)
>>> A[1,1] = 1 + 1j
>>> A
matrix(
[['0.0', '0.0'],
['0.0', mpc(real='1.0', imag='1.0')]])
A more comfortable way to create a matrix lets you use nested lists:
>>> matrix([[1, 2], [3, 4]])
matrix(
[['1.0', '2.0'],
['3.0', '4.0']])
Convenient advanced functions are available for creating various standard
matrices, see ``zeros``, ``ones``, ``diag``, ``eye``, ``randmatrix`` and
``hilbert``.
Vectors
.......
Vectors may also be represented by the ``matrix`` class (with rows = 1 or cols = 1).
For vectors there are some things which make life easier. A column vector can
be created using a flat list, a row vectors using an almost flat nested list::
>>> matrix([1, 2, 3])
matrix(
[['1.0'],
['2.0'],
['3.0']])
>>> matrix([[1, 2, 3]])
matrix(
[['1.0', '2.0', '3.0']])
Optionally vectors can be accessed like lists, using only a single index::
>>> x = matrix([1, 2, 3])
>>> x[1]
mpf('2.0')
>>> x[1,0]
mpf('2.0')
Other
.....
Like you probably expected, matrices can be printed::
>>> print randmatrix(3) # doctest:+SKIP
[ 0.782963853573023 0.802057689719883 0.427895717335467]
[0.0541876859348597 0.708243266653103 0.615134039977379]
[ 0.856151514955773 0.544759264818486 0.686210904770947]
Use ``nstr`` or ``nprint`` to specify the number of digits to print::
>>> nprint(randmatrix(5), 3) # doctest:+SKIP
[2.07e-1 1.66e-1 5.06e-1 1.89e-1 8.29e-1]
[6.62e-1 6.55e-1 4.47e-1 4.82e-1 2.06e-2]
[4.33e-1 7.75e-1 6.93e-2 2.86e-1 5.71e-1]
[1.01e-1 2.53e-1 6.13e-1 3.32e-1 2.59e-1]
[1.56e-1 7.27e-2 6.05e-1 6.67e-2 2.79e-1]
As matrices are mutable, you will need to copy them sometimes::
>>> A = matrix(2)
>>> A
matrix(
[['0.0', '0.0'],
['0.0', '0.0']])
>>> B = A.copy()
>>> B[0,0] = 1
>>> B
matrix(
[['1.0', '0.0'],
['0.0', '0.0']])
>>> A
matrix(
[['0.0', '0.0'],
['0.0', '0.0']])
Finally, it is possible to convert a matrix to a nested list. This is very useful,
as most Python libraries involving matrices or arrays (namely NumPy or SymPy)
support this format::
>>> B.tolist()
[[mpf('1.0'), mpf('0.0')], [mpf('0.0'), mpf('0.0')]]
Matrix operations
-----------------
You can add and subtract matrices of compatible dimensions::
>>> A = matrix([[1, 2], [3, 4]])
>>> B = matrix([[-2, 4], [5, 9]])
>>> A + B
matrix(
[['-1.0', '6.0'],
['8.0', '13.0']])
>>> A - B
matrix(
[['3.0', '-2.0'],
['-2.0', '-5.0']])
>>> A + ones(3) # doctest:+ELLIPSIS
Traceback (most recent call last):
...
ValueError: incompatible dimensions for addition
It is possible to multiply or add matrices and scalars. In the latter case the
operation will be done element-wise::
>>> A * 2
matrix(
[['2.0', '4.0'],
['6.0', '8.0']])
>>> A / 4
matrix(
[['0.25', '0.5'],
['0.75', '1.0']])
>>> A - 1
matrix(
[['0.0', '1.0'],
['2.0', '3.0']])
Of course you can perform matrix multiplication, if the dimensions are
compatible, using ``@`` (for Python >= 3.5) or ``*``. For clarity, ``@`` is
recommended (`PEP 465 `), because
the meaning of ``*`` is different in many other Python libraries such as NumPy.
>>> A @ B # doctest:+SKIP
matrix(
[['8.0', '22.0'],
['14.0', '48.0']])
>>> A * B # same as A @ B
matrix(
[['8.0', '22.0'],
['14.0', '48.0']])
>>> matrix([[1, 2, 3]]) * matrix([[-6], [7], [-2]])
matrix(
[['2.0']])
..
COMMENT: TODO: the above "doctest:+SKIP" may be removed as soon as we
have dropped support for Python 3.5 and below.
You can raise powers of square matrices::
>>> A**2
matrix(
[['7.0', '10.0'],
['15.0', '22.0']])
Negative powers will calculate the inverse::
>>> A**-1
matrix(
[['-2.0', '1.0'],
['1.5', '-0.5']])
>>> A * A**-1
matrix(
[['1.0', '1.0842021724855e-19'],
['-2.16840434497101e-19', '1.0']])
Matrix transposition is straightforward::
>>> A = ones(2, 3)
>>> A
matrix(
[['1.0', '1.0', '1.0'],
['1.0', '1.0', '1.0']])
>>> A.T
matrix(
[['1.0', '1.0'],
['1.0', '1.0'],
['1.0', '1.0']])
Norms
.....
Sometimes you need to know how "large" a matrix or vector is. Due to their
multidimensional nature it's not possible to compare them, but there are
several functions to map a matrix or a vector to a positive real number, the
so called norms.
For vectors the p-norm is intended, usually the 1-, the 2- and the oo-norm are
used.
>>> x = matrix([-10, 2, 100])
>>> norm(x, 1)
mpf('112.0')
>>> norm(x, 2)
mpf('100.5186549850325')
>>> norm(x, inf)
mpf('100.0')
Please note that the 2-norm is the most used one, though it is more expensive
to calculate than the 1- or oo-norm.
It is possible to generalize some vector norms to matrix norm::
>>> A = matrix([[1, -1000], [100, 50]])
>>> mnorm(A, 1)
mpf('1050.0')
>>> mnorm(A, inf)
mpf('1001.0')
>>> mnorm(A, 'F')
mpf('1006.2310867787777')
The last norm (the "Frobenius-norm") is an approximation for the 2-norm, which
is hard to calculate and not available. The Frobenius-norm lacks some
mathematical properties you might expect from a norm.
c i | _ d | _ d|v rt j d t |d t
t f rt |d d t
t f rV|d }t | | _ t |d | _ t | D ] \ }}t | D ] \ }}|| ||f< ! y |d }t | | _ d| _ t | D ] \ }} | | |df< y t |d t rSt | dk( r|d x| _ | _ y t |d t s t d |d | _ |d | _ y t |d t rh|d }|j | _ |j | _ t |j D ]( }t |j D ] }|||f | ||f< * y t |d d r`| j j# |d j% }|j | _ |j | _ |j | _ y t d )N
force_typea# The force_type argument was removed, it did not work properly anyway. If you want to force floating-point or interval computations, use the respective methods from `fp` or `mp` instead, e.g., `fp.matrix()` or `iv.matrix()`. If you want to truncate values to integer, use .apply(int) instead.r z expected inttolistz#could not interpret given arguments)
_matrix__data_LUwarningswarn
isinstancelisttuplelen
_matrix__rows
_matrix__cols enumerateint TypeErrorr r hasattrctxmatrixr )
selfargskwargsAirowjaves
^/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/mpmath/matrices/matrices.py__init__z_matrix.__init__ s 6 ! MM W
X
d1ge} -$q'!*tUm4G !!f !!A$i 'l 'FAs )# '1%&QT
'' G !!f %aL #DAq!"DAJ#
Q
%4yA~,0G3 dk!$q'3/#N33 "1g "1g
Q
)QA//DK//DKAHH%
) ) )A!"1a4DAJ)
) T!Wh
'Q 01A//DK//DK//DK AB B c | j j | j | j }t | j D ]. }t | j D ] } || ||f |||f< 0 |S )zR
Return a copy of self with the function `f` applied elementwise.
)r r r r r )r fnewr r" s r& applyz
_matrix.applyN sp hhoodkk4;;7 $ (ADKK(
( T!A#Y<AaC
( (
r( Nc Z g }dg| j z }t | j D ] }|j g t | j D ]g }|r$ | j j
| ||f |fi |}nt
| ||f }|d j | t t | || ||< i t | D ]M \ }}t | D ] \ }} | j || ||< dt j | z dz ||< O t j | S )Nr [])colsrangerowsappendr nstrstrmaxr r rjustcolsepjoinrowsep)
r nr resmaxlenr r" stringr! elems
r& __nstr__z_matrix.__nstr__X s% tyy tyy! 8A JJrN499%
8 *TXX]]4!9a B6 BF ac^FBv& F VAY 7q
8 8 n 2FAs$S>
/4 F1I.A
/ 6;;s++c1CF 2
{{3 r( c " | j S N)rA r s r& __str__z_matrix.__str__n s }} r( c T | j j }d}t | j D ]m }|dz
}t | j D ]D }|rt | ||f | st
| ||f }ndt | ||f z dz }||dz z
}F |dd }|dz
}o |dd }|dz
}|S ) zd
Create a list string from a matrix.
If avoid_type: avoid multiple 'mpf's.
r/ 'z, Nz],
r0 )r mpfr r r r reprr6 )r
avoid_typetypsr r" r# s r&
_toliststrz_matrix._toliststrq s hhll $ A
HADKK(
!D1Is)C T!A#YAc$qs)n,s2AQX
#2A
LA
crF Sr( c
t | j D cg c]* }t | j D cg c] }| ||f c}, c}}S c c}w c c}}w )z6
Convert the matrix to a nested list.
)r2 r r r r r" s r& r z_matrix.tolist sB BGt{{ASTAE$++$67qac7TT7Ts AA A Ac | j j r| j S d}|| j d dz z
}|S )Nzmatrix(
T)rL ))r prettyrE rO )r rN s r& __repr__z_matrix.__repr__ s= 88??<<> ! T___
-
33r( c h || j v r| j | S | j j S )a
Fast extraction of the i,j element from the matrix
This function is for private use only because is unsafe:
1. Does not check on the value of key it expects key to be a integer tuple (i,j)
2. Does not check bounds
)r r zero)r keys r&
__get_elementz_matrix.__get_element s- $++ ;;s# #88== r( c ` |r|| j |< y|| j v r| j |= yy)aQ
Fast assignment of the i,j element in the matrix
This function is unsafe:
1. Does not check on the value of key it expects key to be a integer tuple (i,j)
2. Does not check bounds
3. Does not check the value type
4. Does not reset the LU cache
N)r )r rX values r&
__set_elementz_matrix.__set_element s2 $DKK
DKK
C r( c t |t st |t r3| j dk( rd|f}n | j dk( r|df}n t d t |d t st |d t rt |d t r|d j |d j dk\ rS|d j |d j | j dz k r%t |d j | j }nt d |d g}t |d t r|d j |d j dk\ rS|d j |d j | j dz k r%t |d j | j }nt d |d g}| j j t | t | }t | D ]= \ }}t | D ]* \ }}|j ||f| j ||f , ? |S |d | j k\ s|d | j k\ r t d || j v r| j | S | j j" S )z
Getitem function for mp matrix class with slice index enabled
it allows the following assingments
scalar to a slice of the matrix
B = A[:,2:6]
r
r insufficient indices for matrixRow index out of boundsColumn index out of boundsmatrix index out of range)r r slicer r
IndexErrorstartstopr indicesr r r r _matrix__set_element_matrix__get_elementr rW ) r rX r3 columnsmr xr" ys r& __getitem__z_matrix.__getitem__ sE c3 :c%#8{{a #h!Ah !BCC c!fU #z#a&'? #a&'FLL(CFLLA,=V[[(CFKK4;;q=,H!3q6>>$++#>?D$%>?? Ax #a&'FLL(CFLLA,=V[[(CFKK4;;q=,H $c!fnnT[[&A BG$%ABB q6( D #g,7A !
E!$W- ECAaOOQqE$*<*>$++#>?D$%>?? Ax#a&'FLL(CFLLA,=V[[(CFKK4;;q=,H $c!fnnT[[&A BG$%ABB q6(%0t9
*s7|uzz/I ( R!#,W#5 RCAa . .!ue6I6I1Q%6P QRR %%>?? ((/ 9A $ 9 **Aa5%899 1v$A$++(= !<==HH$$U+E#( C #KK$ 88DHr( c # K t | j D ]% }t | j D ] }| ||f
' y wrC )r r r rQ s r& __iter__z_matrix.__iter__: sC $ ADKK(
1Q3i
s ?Ac
t || j j r#| j |j k7 r t d | j j | j |j }| j j | j j |j j |j j t | j D ]] t |j D ]C | j j fdt |j D |f< E _ |S | j j | j | j }t | j D ]+ t | j D ] || f z |f< - |S )Nz,dimensions not compatible for multiplicationc 3 J K | ] } |f |f f y wrC ).0kr r" other_get
other_zeroself_get self_zeros r& z"_matrix.__mul__..K s: .D)* 081y/I9VWXYUZ\fKg.h .Ds #) r r r r r ro rW r getr fdot) r otherr+ r r" ry rz r{ r| s @@@@@@r& __mul__z_matrix.__mul__? sf eTXX__ -{{ell* !OPP((//$++u||99
YY!^99 99 r( c | j S rC )r rD s r& __getrowsz_matrix.__getrows {{r( c | | j j D ] }|d |k\ s | j |= || _ y )Nr )r r r r r[ rX s r& __setrowsz_matrix.__setrows > ;;##% %C1vKK$ % r( znumber of rows)docc | j S rC )r rD s r& __getcolsz_matrix.__getcols r r( c | | j j D ] }|d |k\ s | j |= || _ y r )r r r r s r& __setcolsz_matrix.__setcols r r( znumber of columnsc | j j | j | j }t | j D ]( }t | j D ] }| ||f |||f< * |S rC )r r r r r )r r+ r r" s r& transposez_matrix.transpose sj hhoodkk4;;7 $ %ADKK(
% !9AaC
% %
r( c L | j | j j S rC )r, r conjrD s r& conjugatez_matrix.conjugate s zz$((--((r( c > | j j S rC )r r rD s r& transpose_conjz_matrix.transpose_conj s ~~ ))++r( c | j j | j | j }| j j |_ |S rC )r r r r r r )r r+ s r& r z _matrix.copy s7 hhoodkk4;;7[[%%'
r( c | j j | j d }t | j D ] }| ||f ||< |S r )r r r3 r2 )r r< rj r s r& columnz_matrix.column sH HHOODIIq )tyy! A!9AaD r( rC )F)-__name__
__module__ __qualname____doc__r' r, rA rE rO r rU rh rg rm rq rs r r r r r __truediv__r r r r r r r r _matrix__getrows_matrix__setrowspropertyr3 _matrix__getcols_matrix__setcolsr1 r Tr r Hr __copy__r rv r( r& r r s M^3Cj , .U
! ! ?%BGR
.## 6 K"#* / Iy.> ?D Iy.A BD A), A
Hr( r c V e Zd Zd Zd Zd Zd Zd Zd
dZddZ d Z
d
Z dd Z dd Z
y)
MatrixMethodsc t dt fi | _ | | j _ | j | j _ y )Nr )typer r r rp )r s r& r' zMatrixMethods.__init__ s/ (WJ3
[[
r( c Z | j |fi |}t | D ] }d|||f< |S )z6
Create square identity matrix n x n.
r
)r r )r r< r r r s r& r zMatrixMethods.eye s>
CJJq #F # AAacF r( c | j t | fi |}t t | D ] }|| |||f< |S )a&
Create square diagonal matrix using given list.
Example:
>>> from mpmath import diag, mp
>>> mp.pretty = False
>>> diag([1, 2, 3])
matrix(
[['1.0', '0.0', '0.0'],
['0.0', '2.0', '0.0'],
['0.0', '0.0', '3.0']])
)r r r )r diagonalr r r s r& diagzMatrixMethods.diag sK
CJJs8} / /H
& !A a[AacF !r( c t | dk( r|d x}}n0t | dk( r |d }|d }nt dt | z | j ||fi |}t | D ] }t | D ] }d|||f< |S )a&
Create matrix m x n filled with zeros.
One given dimension will create square matrix n x n.
Example:
>>> from mpmath import zeros, mp
>>> mp.pretty = False
>>> zeros(2)
matrix(
[['0.0', '0.0'],
['0.0', '0.0']])
r
r r z*zeros expected at most 2 arguments, got %ir r r r r r r rj r< r r r" s r& zeroszMatrixMethods.zeros s t9>GOA
Y!^QAQA H3t9 TU U CJJq! &v & AAY
!A#
r( c t | dk( r|d x}}n0t | dk( r |d }|d }nt dt | z | j ||fi |}t | D ] }t | D ] }d|||f< |S )a#
Create matrix m x n filled with ones.
One given dimension will create square matrix n x n.
Example:
>>> from mpmath import ones, mp
>>> mp.pretty = False
>>> ones(2)
matrix(
[['1.0', '1.0'],
['1.0', '1.0']])
r
r r z)ones expected at most 2 arguments, got %ir r s r& oneszMatrixMethods.ones( s t9>GOA
Y!^QAQA G#d) ST T CJJq! &v & AAY
!A#
r( Nc ||}| j || }t | D ], }t | D ] }| j ||z dz z |||f< . |S )z
Create (pseudo) hilbert matrix m x n.
One given dimension will create hilbert matrix n x n.
The matrix is very ill-conditioned and symmetric, positive definite if
square.
r
)r r one)r rj r< r r r" s r& hilbertzMatrixMethods.hilbertB si
9A JJq! /AAY
/ AEAI.!A#
/ / r( c |s|} | j ||fi |}t | D ]0 }t | D ] }| j ||z
z |z |||f< " 2 |S )aZ
Create a random m x n matrix.
All values are >= min and >> from mpmath import randmatrix
>>> randmatrix(2) # doctest:+SKIP
matrix(
[['0.53491598236191806', '0.57195669543302752'],
['0.85589992269513615', '0.82444367501382143']])
)r r rand) r rj r< minr7 r r r r" s r&
randmatrixzMatrixMethods.randmatrixR sq A CJJq! &v & 8AAY
8 sSy1C7!A#
8 8 r( c ||k( ryt || j r4t |j D ] }|||f |||f c|||f< |||f< yt |t r|| || c||< ||< yt d )z(
Swap row i with row j.
Nzcould not interpret type)r r r r1 r r )r r r r" rx s r& swap_rowzMatrixMethods.swap_rowh s
6 a $AFF^
0!"1Q31Q3!A#!A#
0
4
1qtJAaD!A$ 67 7r( c : t || j s t d |j t | k7 r t d |j
}|xj dz
c_ t |j D ] }|| |||j dz
f< |S )zB
Extend matrix A with column b and return result.
z A should be a type of ctx.matrixz Value should be equal to len(b)r
) r r r r3 r ro r r1 r )r r br s r& extendzMatrixMethods.extendv s !SZZ( >? ? 66SV >? ?
FFH ! "A qTAakN "r( c t | t t ur j j k( rt fd|D S dk( r j |d S dk( r# j j |dd S dkD r* j j fd|D S t d # t $ r j | cY S w xY w)a
Gives the entrywise `p`-norm of an iterable *x*, i.e. the vector norm
`\left(\sum_k |x_k|^p\right)^{1/p}`, for any given `1 \le p \le \infty`.
Special cases:
If *x* is not iterable, this just returns ``absmax(x)``.
``p=1`` gives the sum of absolute values.
``p=2`` is the standard Euclidean vector norm.
``p=inf`` gives the magnitude of the largest element.
For *x* a matrix, ``p=2`` is the Frobenius norm.
For operator matrix norms, use :func:`~mpmath.mnorm` instead.
You can use the string 'inf' as well as float('inf') or mpf('inf')
to specify the infinity norm.
**Examples**
>>> from mpmath import *
>>> mp.dps = 15; mp.pretty = False
>>> x = matrix([-10, 2, 100])
>>> norm(x, 1)
mpf('112.0')
>>> norm(x, 2)
mpf('100.5186549850325')
>>> norm(x, inf)
mpf('100.0')
c 3 @ K | ] }j | y wrC )absmax)rw r r s r& r} z%MatrixMethods.norm.. s 0szz!}0s r
absoluter )r squaredc 3 : K | ] }t | z y wrC )abs)rw r ps r& r} z%MatrixMethods.norm.. s '=aA '=s zp has to be >= 1) iterr r r r rp infr7 fsumsqrtnthrootro )r rk r s ` `r& normzMatrixMethods.norm s D ! G 7# AA <0a00 0
!V88A8* *
!V88CHHQAH >? ?
U;;sxx'=1'= =qA A /0 0 !::a= !s C C+*C+c j t | t urSt | t u r1dj |j r j
d S j | }j j c|dk( r t fdt D S | j k( r t fdt D S t d )a
Gives the matrix (operator) `p`-norm of A. Currently ``p=1`` and ``p=inf``
are supported:
``p=1`` gives the 1-norm (maximal column sum)
``p=inf`` gives the `\infty`-norm (maximal row sum).
You can use the string 'inf' as well as float('inf') or mpf('inf')
``p=2`` (not implemented) for a square matrix is the usual spectral
matrix norm, i.e. the largest singular value.
``p='f'`` (or 'F', 'fro', 'Frobenius, 'frobenius') gives the
Frobenius norm, which is the elementwise 2-norm. The Frobenius norm is an
approximation of the spectral norm and satisfies
.. math ::
\frac{1}{\sqrt{\mathrm{rank}(A)}} \|A\|_F \le \|A\|_2 \le \|A\|_F
The Frobenius norm lacks some mathematical properties that might
be expected of a norm.
For general elementwise `p`-norms, use :func:`~mpmath.norm` instead.
**Examples**
>>> from mpmath import *
>>> mp.dps = 15; mp.pretty = False
>>> A = matrix([[1, -1000], [100, 50]])
>>> mnorm(A, 1)
mpf('1050.0')
>>> mnorm(A, inf)
mpf('1001.0')
>>> mnorm(A, 'F')
mpf('1006.2310867787777')
frobeniusr r
c 3 l K | ]* j fd t D d , yw)c 3 , K | ] }|f
y wrC rv )rw r r r" s r& r} z0MatrixMethods.mnorm... ;A1Q3 ; r
r Nr r )rw r" r r rj s @r& r} z&MatrixMethods.mnorm.. ( \Qsxx ; ;axH\ 04c 3 l K | ]* j fd t D d , yw)c 3 , K | ] }|f
y wrC rv )rw r" r r s r& r} z0MatrixMethods.mnorm... r r r
r Nr )rw r r r r< s @r& r} z&MatrixMethods.mnorm.. r r z matrix p-norm for arbitrary p)r r r r6
startswithlowerr rp r3 r1 r7 r r NotImplementedError)r r r rj r< s `` @@r& mnormzMatrixMethods.mnorm s N
JJqM 7# Aw#~+"8"8"Cxx1~% AAvvqvv1 6\RXYZR[\\ \
#''\\RXYZR[\\ \%&EF Fr( rC )Nr r
)r )r
)r r r r' r r r r r r r r r r rv r( r& r r s; ) $44 , 8 11f2Gr( r __main__)
libmp.backendr r r; r9 objectr r r doctesttestmodrv r( r& r sU "
` f ` D~GF ~G@ zGOO r(