def nullspace_GF(n=300, p=16411, system='sage'):
"""
Given a n+1 x n matrix over GF(p) with random
entries, compute the nullspace.
INPUT:
- ``n`` - matrix dimension (default: 300)
- ``p`` - prime number (default: ``16411``)
- ``system`` - either 'magma' or 'sage' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.nullspace_GF(300)
sage: tm = b.nullspace_GF(300, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(GF(p), n, n+1)
t = cputime()
v = A.kernel()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := Random(RMatrixSpace(GF(%s), n, n+1));
t := Cputime();
K := Kernel(A);
s := Cputime(t);
"""%(n,p)
if verbose: print code
magma.eval(code)
return magma.eval('s')
else:
raise ValueError, 'unknown system "%s"'%system
def rank2_GF(n=500, p=16411, system='sage'):
"""
Rank over GF(p): Given a (n + 10) x n matrix over GF(p) with
random entries, compute the rank.
INPUT:
- ``n`` - matrix dimension (default: 300)
- ``p`` - prime number (default: ``16411``)
- ``system`` - either 'magma' or 'sage' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.rank2_GF(500)
sage: tm = b.rank2_GF(500, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(GF(p), n+10, n)
t = cputime()
v = A.rank()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := Random(MatrixAlgebra(GF(%s), n));
t := Cputime();
K := Rank(A);
s := Cputime(t);
"""%(n,p)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError, 'unknown system "%s"'%system
def charpoly_GF(n=100, p=16411, system='sage'):
"""
Given a n x n matrix over GF with random entries, compute the
charpoly.
INPUT:
- ``n`` - matrix dimension (default: 100)
- ``p`` - prime number (default: ``16411``)
- ``system`` - either 'magma' or 'sage' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.charpoly_GF(100)
sage: tm = b.charpoly_GF(100, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(GF(p), n, n)
t = cputime()
v = A.charpoly()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := Random(MatrixAlgebra(GF(%s), n));
t := Cputime();
K := CharacteristicPolynomial(A);
s := Cputime(t);
"""%(n,p)
if verbose: print code
magma.eval(code)
return magma.eval('s')
else:
raise ValueError, 'unknown system "%s"'%system
def rank2_GF(n=500, p=16411, system='sage'):
"""
Rank over GF(p): Given a (n + 10) x n matrix over GF(p) with
random entries, compute the rank.
INPUT:
- ``n`` - matrix dimension (default: 300)
- ``p`` - prime number (default: ``16411``)
- ``system`` - either 'magma' or 'sage' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.rank2_GF(500)
sage: tm = b.rank2_GF(500, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(GF(p), n + 10, n)
t = cputime()
v = A.rank()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := Random(MatrixAlgebra(GF(%s), n));
t := Cputime();
K := Rank(A);
s := Cputime(t);
""" % (n, p)
if verbose: print(code)
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError('unknown system "%s"' % system)
def nullspace_GF(n=300, p=16411, system='sage'):
"""
Given a n+1 x n matrix over GF(p) with random
entries, compute the nullspace.
INPUT:
- ``n`` - matrix dimension (default: 300)
- ``p`` - prime number (default: ``16411``)
- ``system`` - either 'magma' or 'sage' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.nullspace_GF(300)
sage: tm = b.nullspace_GF(300, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(GF(p), n, n + 1)
t = cputime()
v = A.kernel()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := Random(RMatrixSpace(GF(%s), n, n+1));
t := Cputime();
K := Kernel(A);
s := Cputime(t);
""" % (n, p)
if verbose: print(code)
magma.eval(code)
return magma.eval('s')
else:
raise ValueError('unknown system "%s"' % system)
def charpoly_GF(n=100, p=16411, system='sage'):
"""
Given a n x n matrix over GF with random entries, compute the
charpoly.
INPUT:
- ``n`` - matrix dimension (default: 100)
- ``p`` - prime number (default: ``16411``)
- ``system`` - either 'magma' or 'sage' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.charpoly_GF(100)
sage: tm = b.charpoly_GF(100, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(GF(p), n, n)
t = cputime()
v = A.charpoly()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := Random(MatrixAlgebra(GF(%s), n));
t := Cputime();
K := CharacteristicPolynomial(A);
s := Cputime(t);
""" % (n, p)
if verbose: print(code)
magma.eval(code)
return magma.eval('s')
else:
raise ValueError('unknown system "%s"' % system)
def matrix_add_ZZ(n=200, min=-9, max=9, system='sage', times=50):
"""
Matrix addition over ZZ
Given an n x n matrix A and B over ZZ with random entries between
``min`` and ``max``, inclusive, compute A + B ``times`` times.
INPUT:
- ``n`` - matrix dimension (default: ``200``)
- ``min`` - minimal value for entries of matrix (default: ``-9``)
- ``max`` - maximal value for entries of matrix (default: ``9``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
- ``times`` - number of experiments (default: ``50``)
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.matrix_add_ZZ(200)
sage: tm = b.matrix_add_ZZ(200, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n, n, x=min, y=max + 1)
B = random_matrix(ZZ, n, n, x=min, y=max + 1)
t = cputime()
for z in range(times):
v = A + B
return cputime(t) / times
elif system == 'magma':
code = """
n := %s;
min := %s;
max := %s;
A := MatrixAlgebra(IntegerRing(), n)![Random(min,max) : i in [1..n^2]];
B := MatrixAlgebra(IntegerRing(), n)![Random(min,max) : i in [1..n^2]];
t := Cputime();
for z in [1..%s] do
K := A + B;
end for;
s := Cputime(t);
""" % (n, min, max, times)
if verbose: print(code)
magma.eval(code)
return float(magma.eval('s')) / times
else:
raise ValueError('unknown system "%s"' % system)
def matrix_add_ZZ(n=200, min=-9, max=9, system='sage', times=50):
"""
Matrix addition over ZZ
Given an n x n matrix A and B over ZZ with random entries between
``min`` and ``max``, inclusive, compute A + B ``times`` times.
INPUT:
- ``n`` - matrix dimension (default: ``200``)
- ``min`` - minimal value for entries of matrix (default: ``-9``)
- ``max`` - maximal value for entries of matrix (default: ``9``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
- ``times`` - number of experiments (default: ``50``)
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.matrix_add_ZZ(200)
sage: tm = b.matrix_add_ZZ(200, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n, n, x=min, y=max+1)
B = random_matrix(ZZ, n, n, x=min, y=max+1)
t = cputime()
for z in range(times):
v = A + B
return cputime(t)/times
elif system == 'magma':
code = """
n := %s;
min := %s;
max := %s;
A := MatrixAlgebra(IntegerRing(), n)![Random(min,max) : i in [1..n^2]];
B := MatrixAlgebra(IntegerRing(), n)![Random(min,max) : i in [1..n^2]];
t := Cputime();
for z in [1..%s] do
K := A + B;
end for;
s := Cputime(t);
"""%(n,min,max,times)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))/times
else:
raise ValueError, 'unknown system "%s"'%system
def matrix_multiply_QQ(n=100, bnd=2, system='sage', times=1):
"""
Given an n x n matrix A over QQ with random entries
whose numerators and denominators are bounded by bnd,
compute A * (A+1).
INPUT:
- ``n`` - matrix dimension (default: ``300``)
- ``bnd`` - numerator and denominator bound (default: ``bnd``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
- ``times`` - number of experiments (default: ``1``)
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.matrix_multiply_QQ(100)
sage: tm = b.matrix_multiply_QQ(100, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(QQ, n, n, num_bound=bnd, den_bound=bnd)
B = A + 1
t = cputime()
for z in range(times):
v = A * B
return cputime(t) / times
elif system == 'magma':
A = magma(random_matrix(QQ, n, n, num_bound=bnd, den_bound=bnd))
code = """
n := %s;
A := %s;
B := A + 1;
t := Cputime();
for z in [1..%s] do
K := A * B;
end for;
s := Cputime(t);
""" % (n, A.name(), times)
if verbose: print(code)
magma.eval(code)
return float(magma.eval('s')) / times
else:
raise ValueError('unknown system "%s"' % system)
def matrix_multiply_QQ(n=100, bnd=2, system='sage', times=1):
"""
Given an n x n matrix A over QQ with random entries
whose numerators and denominators are bounded by bnd,
compute A * (A+1).
INPUT:
- ``n`` - matrix dimension (default: ``300``)
- ``bnd`` - numerator and denominator bound (default: ``bnd``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
- ``times`` - number of experiments (default: ``1``)
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.matrix_multiply_QQ(100)
sage: tm = b.matrix_multiply_QQ(100, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(QQ, n, n, num_bound=bnd, den_bound=bnd)
B = A + 1
t = cputime()
for z in range(times):
v = A * B
return cputime(t)/times
elif system == 'magma':
A = magma(random_matrix(QQ, n, n, num_bound=bnd, den_bound=bnd))
code = """
n := %s;
A := %s;
B := A + 1;
t := Cputime();
for z in [1..%s] do
K := A * B;
end for;
s := Cputime(t);
"""%(n, A.name(), times)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))/times
else:
raise ValueError, 'unknown system "%s"'%system
def matrix_add_GF(n=1000, p=16411, system='sage', times=100):
"""
Given two n x n matrix over GF(p) with random entries, add them.
INPUT:
- ``n`` - matrix dimension (default: 300)
- ``p`` - prime number (default: ``16411``)
- ``system`` - either 'magma' or 'sage' (default: 'sage')
- ``times`` - number of experiments (default: ``100``)
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.matrix_add_GF(500, p=19)
sage: tm = b.matrix_add_GF(500, p=19, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(GF(p), n, n)
B = random_matrix(GF(p), n, n)
t = cputime()
for n in range(times):
v = A + B
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := Random(MatrixAlgebra(GF(%s), n));
B := Random(MatrixAlgebra(GF(%s), n));
t := Cputime();
for z in [1..%s] do
K := A + B;
end for;
s := Cputime(t);
""" % (n, p, p, times)
if verbose: print(code)
magma.eval(code)
return magma.eval('s')
else:
raise ValueError('unknown system "%s"' % system)
def matrix_add_GF(n=1000, p=16411, system='sage',times=100):
"""
Given two n x n matrix over GF(p) with random entries, add them.
INPUT:
- ``n`` - matrix dimension (default: 300)
- ``p`` - prime number (default: ``16411``)
- ``system`` - either 'magma' or 'sage' (default: 'sage')
- ``times`` - number of experiments (default: ``100``)
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.matrix_add_GF(500, p=19)
sage: tm = b.matrix_add_GF(500, p=19, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(GF(p), n, n)
B = random_matrix(GF(p), n, n)
t = cputime()
for n in range(times):
v = A + B
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := Random(MatrixAlgebra(GF(%s), n));
B := Random(MatrixAlgebra(GF(%s), n));
t := Cputime();
for z in [1..%s] do
K := A + B;
end for;
s := Cputime(t);
"""%(n,p,p,times)
if verbose: print code
magma.eval(code)
return magma.eval('s')
else:
raise ValueError, 'unknown system "%s"'%system
def vecmat_ZZ(n=300, min=-9, max=9, system='sage', times=200):
"""
Vector matrix multiplication over ZZ.
Given an n x n matrix A over ZZ with random entries
between min and max, inclusive, and v the first row of A,
compute the product v * A.
INPUT:
- ``n`` - matrix dimension (default: ``300``)
- ``min`` - minimal value for entries of matrix (default: ``-9``)
- ``max`` - maximal value for entries of matrix (default: ``9``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
- ``times`` - number of runs (default: ``200``)
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.vecmat_ZZ(300) # long time
sage: tm = b.vecmat_ZZ(300, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n, n, x=min, y=max+1)
v = A.row(0)
t = cputime()
for z in range(times):
w = v * A
return cputime(t)/times
elif system == 'magma':
code = """
n := %s;
A := MatrixAlgebra(IntegerRing(), n)![Random(%s,%s) : i in [1..n^2]];
v := A[1];
t := Cputime();
for z in [1..%s] do
K := v * A;
end for;
s := Cputime(t);
"""%(n,min,max,times)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))/times
else:
raise ValueError, 'unknown system "%s"'%system
def vecmat_ZZ(n=300, min=-9, max=9, system='sage', times=200):
"""
Vector matrix multiplication over ZZ.
Given an n x n matrix A over ZZ with random entries
between min and max, inclusive, and v the first row of A,
compute the product v * A.
INPUT:
- ``n`` - matrix dimension (default: ``300``)
- ``min`` - minimal value for entries of matrix (default: ``-9``)
- ``max`` - maximal value for entries of matrix (default: ``9``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
- ``times`` - number of runs (default: ``200``)
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.vecmat_ZZ(300) # long time
sage: tm = b.vecmat_ZZ(300, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n, n, x=min, y=max + 1)
v = A.row(0)
t = cputime()
for z in range(times):
w = v * A
return cputime(t) / times
elif system == 'magma':
code = """
n := %s;
A := MatrixAlgebra(IntegerRing(), n)![Random(%s,%s) : i in [1..n^2]];
v := A[1];
t := Cputime();
for z in [1..%s] do
K := v * A;
end for;
s := Cputime(t);
""" % (n, min, max, times)
if verbose: print(code)
magma.eval(code)
return float(magma.eval('s')) / times
else:
raise ValueError('unknown system "%s"' % system)
def MatrixVector_QQ(n=1000,h=100,system='sage',times=1):
"""
Compute product of square ``n`` matrix by random vector with num and
denom bounded by ``h`` the given number of ``times``.
INPUT:
- ``n`` - matrix dimension (default: ``300``)
- ``h`` - numerator and denominator bound (default: ``bnd``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
- ``times`` - number of experiments (default: ``1``)
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.MatrixVector_QQ(500)
sage: tm = b.MatrixVector_QQ(500, system='magma') # optional - magma
"""
if system=='sage':
V=QQ**n
v=V.random_element(h)
M=random_matrix(QQ,n)
t=cputime()
for i in range(times):
w=M*v
return cputime(t)
elif system == 'magma':
code = """
n:=%s;
h:=%s;
times:=%s;
v:=VectorSpace(RationalField(),n)![Random(h)/(Random(h)+1) : i in [1..n]];
M:=MatrixAlgebra(RationalField(),n)![Random(h)/(Random(h)+1) : i in [1..n^2]];
t := Cputime();
for z in [1..times] do
W:=v*M;
end for;
s := Cputime(t);
"""%(n,h,times)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError, 'unknown system "%s"'%system
def MatrixVector_QQ(n=1000, h=100, system='sage', times=1):
"""
Compute product of square ``n`` matrix by random vector with num and
denom bounded by ``h`` the given number of ``times``.
INPUT:
- ``n`` - matrix dimension (default: ``300``)
- ``h`` - numerator and denominator bound (default: ``bnd``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
- ``times`` - number of experiments (default: ``1``)
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.MatrixVector_QQ(500)
sage: tm = b.MatrixVector_QQ(500, system='magma') # optional - magma
"""
if system == 'sage':
V = QQ**n
v = V.random_element(h)
M = random_matrix(QQ, n)
t = cputime()
for i in range(times):
w = M * v
return cputime(t)
elif system == 'magma':
code = """
n:=%s;
h:=%s;
times:=%s;
v:=VectorSpace(RationalField(),n)![Random(h)/(Random(h)+1) : i in [1..n]];
M:=MatrixAlgebra(RationalField(),n)![Random(h)/(Random(h)+1) : i in [1..n^2]];
t := Cputime();
for z in [1..times] do
W:=v*M;
end for;
s := Cputime(t);
""" % (n, h, times)
if verbose: print(code)
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError('unknown system "%s"' % system)
def matrix_multiply_GF(n=100, p=16411, system='sage', times=3):
"""
Given an n x n matrix A over GF(p) with random entries, compute
A * (A+1).
INPUT:
- ``n`` - matrix dimension (default: 100)
- ``p`` - prime number (default: ``16411``)
- ``system`` - either 'magma' or 'sage' (default: 'sage')
- ``times`` - number of experiments (default: ``3``)
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.matrix_multiply_GF(100, p=19)
sage: tm = b.matrix_multiply_GF(100, p=19, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(GF(p), n)
B = A + 1
t = cputime()
for n in range(times):
v = A * B
return cputime(t) / times
elif system == 'magma':
code = """
n := %s;
A := Random(MatrixAlgebra(GF(%s), n));
B := A + 1;
t := Cputime();
for z in [1..%s] do
K := A * B;
end for;
s := Cputime(t);
"""%(n,p,times)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))/times
else:
raise ValueError('unknown system "%s"'%system)
def matrix_multiply_GF(n=100, p=16411, system='sage', times=3):
"""
Given an n x n matrix A over GF(p) with random entries, compute
A * (A+1).
INPUT:
- ``n`` - matrix dimension (default: 100)
- ``p`` - prime number (default: ``16411``)
- ``system`` - either 'magma' or 'sage' (default: 'sage')
- ``times`` - number of experiments (default: ``3``)
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.matrix_multiply_GF(100, p=19)
sage: tm = b.matrix_multiply_GF(100, p=19, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(GF(p), n)
B = A + 1
t = cputime()
for n in range(times):
v = A * B
return cputime(t) / times
elif system == 'magma':
code = """
n := %s;
A := Random(MatrixAlgebra(GF(%s), n));
B := A + 1;
t := Cputime();
for z in [1..%s] do
K := A * B;
end for;
s := Cputime(t);
""" % (n, p, times)
if verbose: print code
magma.eval(code)
return float(magma.eval('s')) / times
else:
raise ValueError('unknown system "%s"' % system)
def det_QQ(n=300, num_bound=10, den_bound=10, system='sage'):
"""
Dense rational determinant over QQ.
Given an n x n matrix A over QQ with random entries
with numerator bound and denominator bound, compute det(A).
INPUT:
- ``n`` - matrix dimension (default: ``200``)
- ``num_bound`` - numerator bound, inclusive (default: ``10``)
- ``den_bound`` - denominator bound, inclusive (default: ``10``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.det_QQ(200)
sage: ts = b.det_QQ(10, num_bound=100000, den_bound=10000)
sage: tm = b.det_QQ(200, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(QQ, n, n, num_bound=num_bound, den_bound=den_bound)
t = cputime()
d = A.determinant()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := MatrixAlgebra(RationalField(), n)![Random(%s,%s)/Random(1,%s) : i in [1..n^2]];
t := Cputime();
d := Determinant(A);
s := Cputime(t);
""" % (n, -num_bound, num_bound, den_bound)
if verbose: print(code)
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError('unknown system "%s"' % system)
def det_QQ(n=300, num_bound=10, den_bound=10, system='sage'):
"""
Dense rational determinant over QQ.
Given an n x n matrix A over QQ with random entries
with numerator bound and denominator bound, compute det(A).
INPUT:
- ``n`` - matrix dimension (default: ``200``)
- ``num_bound`` - numerator bound, inclusive (default: ``10``)
- ``den_bound`` - denominator bound, inclusive (default: ``10``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.det_QQ(200)
sage: ts = b.det_QQ(10, num_bound=100000, den_bound=10000)
sage: tm = b.det_QQ(200, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(QQ, n, n, num_bound=num_bound, den_bound=den_bound)
t = cputime()
d = A.determinant()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := MatrixAlgebra(RationalField(), n)![Random(%s,%s)/Random(1,%s) : i in [1..n^2]];
t := Cputime();
d := Determinant(A);
s := Cputime(t);
"""%(n,-num_bound, num_bound, den_bound)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError, 'unknown system "%s"'%system
def nullspace_RDF(n=300, min=0, max=10, system='sage'):
"""
Nullspace over RDF:
Given a n+1 x n matrix over RDF with random entries
between min and max, compute the nullspace.
INPUT:
- ``n`` - matrix dimension (default: ``300``)
- ``min`` - minimal value for entries of matrix (default: ``0``)
- ``max`` - maximal value for entries of matrix (default: `10``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.nullspace_RDF(100) # long time
sage: tm = b.nullspace_RDF(100, system='magma') # optional - magma
"""
if system == 'sage':
from sage.rings.real_double import RDF
A = random_matrix(ZZ, n + 1, n, x=min, y=max + 1).change_ring(RDF)
t = cputime()
v = A.kernel()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := RMatrixSpace(RealField(16), n+1,n)![Random(%s,%s) : i in [1..n*(n+1)]];
t := Cputime();
K := Kernel(A);
s := Cputime(t);
""" % (n, min, max)
if verbose: print(code)
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError('unknown system "%s"' % system)
def nullspace_RDF(n=300, min=0, max=10, system='sage'):
"""
Nullspace over RDF:
Given a n+1 x n matrix over RDF with random entries
between min and max, compute the nullspace.
INPUT:
- ``n`` - matrix dimension (default: ``300``)
- ``min`` - minimal value for entries of matrix (default: ``0``)
- ``max`` - maximal value for entries of matrix (default: `10``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.nullspace_RDF(100) # long time
sage: tm = b.nullspace_RDF(100, system='magma') # optional - magma
"""
if system == 'sage':
from sage.rings.real_double import RDF
A = random_matrix(ZZ, n+1, n, x=min, y=max+1).change_ring(RDF)
t = cputime()
v = A.kernel()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := RMatrixSpace(RealField(16), n+1,n)![Random(%s,%s) : i in [1..n*(n+1)]];
t := Cputime();
K := Kernel(A);
s := Cputime(t);
"""%(n,min,max)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError, 'unknown system "%s"'%system
def smithform_ZZ(n=128, min=0, max=9, system='sage'):
"""
Smith Form over ZZ:
Given a n x n matrix over ZZ with random entries
between min and max, compute the Smith normal form.
INPUT:
- ``n`` - matrix dimension (default: ``128``)
- ``min`` - minimal value for entries of matrix (default: ``0``)
- ``max`` - maximal value for entries of matrix (default: ``9``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.smithform_ZZ(100)
sage: tm = b.smithform_ZZ(100, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n, n, x=min, y=max+1)
t = cputime()
v = A.elementary_divisors()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := MatrixAlgebra(IntegerRing(), n)![Random(%s,%s) : i in [1..n^2]];
t := Cputime();
K := ElementaryDivisors(A);
s := Cputime(t);
"""%(n,min,max)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError, 'unknown system "%s"'%system
def nullspace_ZZ(n=200, min=0, max=2**32, system='sage'):
"""
Nullspace over ZZ:
Given a n+1 x n matrix over ZZ with random entries
between min and max, compute the nullspace.
INPUT:
- ``n`` - matrix dimension (default: ``200``)
- ``min`` - minimal value for entries of matrix (default: ``0``)
- ``max`` - maximal value for entries of matrix (default: ``2**32``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.nullspace_ZZ(200)
sage: tm = b.nullspace_ZZ(200, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n+1, n, x=min, y=max+1).change_ring(QQ)
t = cputime()
v = A.kernel()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := RMatrixSpace(RationalField(), n+1,n)![Random(%s,%s) : i in [1..n*(n+1)]];
t := Cputime();
K := Kernel(A);
s := Cputime(t);
"""%(n,min,max)
if verbose: print(code)
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError('unknown system "%s"'%system)
def det_ZZ(n=200, min=1, max=100, system='sage'):
"""
Dense integer determinant over ZZ.
Given an n x n matrix A over ZZ with random entries
between min and max, inclusive, compute det(A).
INPUT:
- ``n`` - matrix dimension (default: ``200``)
- ``min`` - minimal value for entries of matrix (default: ``1``)
- ``max`` - maximal value for entries of matrix (default: ``100``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.det_ZZ(200)
sage: tm = b.det_ZZ(200, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n, n, x=min, y=max + 1)
t = cputime()
d = A.determinant()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := MatrixAlgebra(IntegerRing(), n)![Random(%s,%s) : i in [1..n^2]];
t := Cputime();
d := Determinant(A);
s := Cputime(t);
""" % (n, min, max)
if verbose: print(code)
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError('unknown system "%s"' % system)
def charpoly_ZZ(n=100, min=0, max=9, system='sage'):
"""
Characteristic polynomial over ZZ:
Given a n x n matrix over ZZ with random entries between min and
max, compute the charpoly.
INPUT:
- ``n`` - matrix dimension (default: ``100``)
- ``min`` - minimal value for entries of matrix (default: ``0``)
- ``max`` - maximal value for entries of matrix (default: ``9``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.charpoly_ZZ(100)
sage: tm = b.charpoly_ZZ(100, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n, n, x=min, y=max+1)
t = cputime()
v = A.charpoly()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := MatrixAlgebra(IntegerRing(), n)![Random(%s,%s) : i in [1..n^2]];
t := Cputime();
K := CharacteristicPolynomial(A);
s := Cputime(t);
"""%(n,min,max)
if verbose: print(code)
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError('unknown system "%s"'%system)
def smithform_ZZ(n=128, min=0, max=9, system='sage'):
"""
Smith Form over ZZ:
Given a n x n matrix over ZZ with random entries
between min and max, compute the Smith normal form.
INPUT:
- ``n`` - matrix dimension (default: ``128``)
- ``min`` - minimal value for entries of matrix (default: ``0``)
- ``max`` - maximal value for entries of matrix (default: ``9``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.smithform_ZZ(100)
sage: tm = b.smithform_ZZ(100, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n, n, x=min, y=max + 1)
t = cputime()
v = A.elementary_divisors()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := MatrixAlgebra(IntegerRing(), n)![Random(%s,%s) : i in [1..n^2]];
t := Cputime();
K := ElementaryDivisors(A);
s := Cputime(t);
""" % (n, min, max)
if verbose: print(code)
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError('unknown system "%s"' % system)
def rank2_ZZ(n=400, min=0, max=2**64, system='sage'):
"""
Rank 2 over ZZ:
Given a (n + 10) x n matrix over ZZ with random entries
between min and max, compute the rank.
INPUT:
- ``n`` - matrix dimension (default: ``400``)
- ``min`` - minimal value for entries of matrix (default: ``0``)
- ``max`` - maximal value for entries of matrix (default: ``2**64``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.rank2_ZZ(300)
sage: tm = b.rank2_ZZ(300, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n + 10, n, x=min, y=max + 1)
t = cputime()
v = A.rank()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := RMatrixSpace(IntegerRing(), n+10, n)![Random(%s,%s) : i in [1..n*(n+10)]];
t := Cputime();
K := Rank(A);
s := Cputime(t);
""" % (n, min, max)
if verbose: print(code)
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError('unknown system "%s"' % system)
def rank2_ZZ(n=400, min=0, max=2**64, system='sage'):
"""
Rank 2 over ZZ:
Given a (n + 10) x n matrix over ZZ with random entries
between min and max, compute the rank.
INPUT:
- ``n`` - matrix dimension (default: ``400``)
- ``min`` - minimal value for entries of matrix (default: ``0``)
- ``max`` - maximal value for entries of matrix (default: ``2**64``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.rank2_ZZ(300)
sage: tm = b.rank2_ZZ(300, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n+10, n, x=min, y=max+1)
t = cputime()
v = A.rank()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := RMatrixSpace(IntegerRing(), n+10, n)![Random(%s,%s) : i in [1..n*(n+10)]];
t := Cputime();
K := Rank(A);
s := Cputime(t);
"""%(n,min,max)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError, 'unknown system "%s"'%system
def det_ZZ(n=200, min=1, max=100, system='sage'):
"""
Dense integer determinant over ZZ.
Given an n x n matrix A over ZZ with random entries
between min and max, inclusive, compute det(A).
INPUT:
- ``n`` - matrix dimension (default: ``200``)
- ``min`` - minimal value for entries of matrix (default: ``1``)
- ``max`` - maximal value for entries of matrix (default: ``100``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.det_ZZ(200)
sage: tm = b.det_ZZ(200, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n, n, x=min, y=max+1)
t = cputime()
d = A.determinant()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := MatrixAlgebra(IntegerRing(), n)![Random(%s,%s) : i in [1..n^2]];
t := Cputime();
d := Determinant(A);
s := Cputime(t);
"""%(n,min,max)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError, 'unknown system "%s"'%system
def charpoly_ZZ(n=100, min=0, max=9, system='sage'):
"""
Characteristic polynomial over ZZ:
Given a n x n matrix over ZZ with random entries between min and
max, compute the charpoly.
INPUT:
- ``n`` - matrix dimension (default: ``100``)
- ``min`` - minimal value for entries of matrix (default: ``0``)
- ``max`` - maximal value for entries of matrix (default: ``9``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.charpoly_ZZ(100)
sage: tm = b.charpoly_ZZ(100, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n, n, x=min, y=max + 1)
t = cputime()
v = A.charpoly()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := MatrixAlgebra(IntegerRing(), n)![Random(%s,%s) : i in [1..n^2]];
t := Cputime();
K := CharacteristicPolynomial(A);
s := Cputime(t);
""" % (n, min, max)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError, 'unknown system "%s"' % system
def nullspace_ZZ(n=200, min=0, max=2**32, system='sage'):
"""
Nullspace over ZZ:
Given a n+1 x n matrix over ZZ with random entries
between min and max, compute the nullspace.
INPUT:
- ``n`` - matrix dimension (default: ``200``)
- ``min`` - minimal value for entries of matrix (default: ``0``)
- ``max`` - maximal value for entries of matrix (default: ``2**32``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.nullspace_ZZ(200)
sage: tm = b.nullspace_ZZ(200, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n + 1, n, x=min, y=max + 1).change_ring(QQ)
t = cputime()
v = A.kernel()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := RMatrixSpace(RationalField(), n+1,n)![Random(%s,%s) : i in [1..n*(n+1)]];
t := Cputime();
K := Kernel(A);
s := Cputime(t);
""" % (n, min, max)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError, 'unknown system "%s"' % system
def inverse_QQ(n=100, min=0, max=9, system='sage'):
"""
Given a n x n matrix over QQ with random integer entries
between min and max, compute the reduced row echelon form.
INPUT:
- ``n`` - matrix dimension (default: ``300``)
- ``min`` - minimal value for entries of matrix (default: ``-9``)
- ``max`` - maximal value for entries of matrix (default: ``9``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.inverse_QQ(100)
sage: tm = b.inverse_QQ(100, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n, n, x=min, y=max+1).change_ring(QQ)
t = cputime()
v = ~A
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := MatrixAlgebra(RationalField(), n)![Random(%s,%s) : i in [1..n*n]];
t := Cputime();
K := A^(-1);
s := Cputime(t);
"""%(n,min,max)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError, 'unknown system "%s"'%system
def det_GF(n=400, p=16411, system='sage'):
"""
Dense determinant over GF(p).
Given an n x n matrix A over GF with random entries compute
det(A).
INPUT:
- ``n`` - matrix dimension (default: 300)
- ``p`` - prime number (default: ``16411``)
- ``system`` - either 'magma' or 'sage' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.det_GF(1000)
sage: tm = b.det_GF(1000, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(GF(p), n, n)
t = cputime()
d = A.determinant()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := Random(MatrixAlgebra(GF(%s), n));
t := Cputime();
d := Determinant(A);
s := Cputime(t);
""" % (n, p)
if verbose: print(code)
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError('unknown system "%s"' % system)
def inverse_QQ(n=100, min=0, max=9, system='sage'):
"""
Given a n x n matrix over QQ with random integer entries
between min and max, compute the reduced row echelon form.
INPUT:
- ``n`` - matrix dimension (default: ``300``)
- ``min`` - minimal value for entries of matrix (default: ``-9``)
- ``max`` - maximal value for entries of matrix (default: ``9``)
- ``system`` - either 'sage' or 'magma' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.inverse_QQ(100)
sage: tm = b.inverse_QQ(100, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(ZZ, n, n, x=min, y=max + 1).change_ring(QQ)
t = cputime()
v = ~A
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := MatrixAlgebra(RationalField(), n)![Random(%s,%s) : i in [1..n*n]];
t := Cputime();
K := A^(-1);
s := Cputime(t);
""" % (n, min, max)
if verbose: print(code)
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError('unknown system "%s"' % system)
def det_GF(n=400, p=16411 , system='sage'):
"""
Dense determinant over GF(p).
Given an n x n matrix A over GF with random entries compute
det(A).
INPUT:
- ``n`` - matrix dimension (default: 300)
- ``p`` - prime number (default: ``16411``)
- ``system`` - either 'magma' or 'sage' (default: 'sage')
EXAMPLES::
sage: import sage.matrix.benchmark as b
sage: ts = b.det_GF(1000)
sage: tm = b.det_GF(1000, system='magma') # optional - magma
"""
if system == 'sage':
A = random_matrix(GF(p), n, n)
t = cputime()
d = A.determinant()
return cputime(t)
elif system == 'magma':
code = """
n := %s;
A := Random(MatrixAlgebra(GF(%s), n));
t := Cputime();
d := Determinant(A);
s := Cputime(t);
"""%(n,p)
if verbose: print code
magma.eval(code)
return float(magma.eval('s'))
else:
raise ValueError, 'unknown system "%s"'%system
