Question

我有一个Numpy矩阵，例如numpy.matrix([[-1, 2],[1, -2]], dtype='int')。我想得到它的整数值的特征向量，如果有的话;例如，numpy.array([[-1], [1]])表示上述矩阵。 Numpy返回的是浮点数中的特征向量，缩放为单位长度。

可以在Sage中执行此操作，其中可以指定矩阵的字段（即数据类型），并且对矩阵执行的操作将遵循一个指定的字段。

如何在Python中很好地做到这一点？非常感谢提前。

Answer 1

我个人满意以下解决方案：我在Python中调用sage并让sage计算我想要的内容。 sage，以数学为导向，在涉及除实数以外的字段的计算中相当通用。

以下是我的脚本compute_intarrs.py，需要安装sage。请注意它有点慢。

import subprocess
import re
import numpy as np

# construct a numpy matrix
mat = np.matrix([[1,-1],[-1,1]])
# convert the matrix into a string recognizable by sage
matstr = re.sub('\s|[a-z]|\(|\)', '', mat.__repr__())

# write a (sage) python script "mat.py";
# for more info of the sage commands: 
# www.sagemath.org/doc/faq/faq-usage.html#how-do-i-import-sage-into-a-python-script
# www.sagemath.org/doc/tutorial/tour_linalg.html
f = open('mat.py', 'w')
f.write('from sage.all import *\n\n')
f.write('A = matrix(ZZ, %s)\n\n' % matstr)
f.write('print A.kernel()')  # this returns the left nullspace vectors
f.close()

# call sage and run mat.py
p = subprocess.Popen(['sage', '-python', 'mat.py'], stdout=subprocess.PIPE)

# process the output from sage
arrstrs = p.communicate()[0].split('\n')[2:-1]
arrs = [np.array(eval(re.sub('(?<=\d)\s*(?=\d|-)', ',', arrstr))) 
        for arrstr in arrstrs]
print arrs

结果：

In [1]: %run compute_intarrs.py

[array([1, 1])]

Answer 2

您可以使用dtype = object和fractions.Fraction类做一些非常酷的事情，例如

>>> A = np.array([fractions.Fraction(1, j) for j in xrange(1, 13)]).reshape(3, 4)
>>> A
array([[1, 1/2, 1/3, 1/4],
       [1/5, 1/6, 1/7, 1/8],
       [1/9, 1/10, 1/11, 1/12]], dtype=object)
>>> B = np.array([fractions.Fraction(1, j) for j in xrange(1, 13)]).reshape(4, 3)
>>> B
array([[1, 1/2, 1/3],
       [1/4, 1/5, 1/6],
       [1/7, 1/8, 1/9],
       [1/10, 1/11, 1/12]], dtype=object)
>>> np.dot(A, B)
array([[503/420, 877/1320, 205/432],
       [3229/11760, 751/4620, 1217/10080],
       [1091/6930, 1871/19800, 1681/23760]], dtype=object)

不幸的是，np.linalg模块在执行任何操作之前会将所有内容转换为float，因此您无法直接将解决方案作为整数或有理数获取。但是在计算之后你总是可以做以下事情：

def scale_to_int(x) :
    fracs = [fractions.Fraction(j) for j in x.ravel()]
    denominators = [j.denominator for j in fracs]
    lcm = reduce(lambda a, b: max(a, b) / fractions.gcd(a, b) * min(a, b),
                 denominators)
    fracs = map(lambda x : lcm * x, fracs)
    gcd = reduce(lambda a, b: fractions.gcd(a, b), fracs)
    fracs = map(lambda x: x / gcd, fracs)
    return np.array(fracs).reshape(x.shape)

它会很慢，对舍入误差非常敏感：

>>> scale_to_int(np.linspace(0, 1, 5)) # [0, 0.25, 0.5, 0.75, 1]
array([0, 1, 2, 3, 4], dtype=object)
>>> scale_to_int(np.linspace(0, 1, 4)) # [0, 0.33333333, 0.66666667, 1]
array([0, 6004799503160661, 12009599006321322, 18014398509481984], dtype=object)

您可以使用limit_denominator的{{1}}方法缓解部分内容，但可能不会那么强大。

如何获得Numpy矩阵的整数特征向量？

2 个答案: