- Join over
**1.5M+ people** - Join over
**100K+ communities** - Free
**without limits** - Create
**your own community**

- 16:59czgdp1807 review_requested #17881
- 16:59czgdp1807 labeled #17881
- 16:58sympy-bot commented #17844
- 16:58
asmeurer on master

copy edit functions/special/bes… copy edit functions/special/bet… copy edit functions/special/bsp… and 22 more (compare)

- 16:58asmeurer closed #17844
- 16:57asmeurer commented #17844
- 16:56sylee957 commented #17884
- 15:04asmeurer commented #17891
- 14:44smichr edited #17889
- 14:39smichr commented #17661
- 14:19
smichr on master

printing:Fix permutation repr t… Save state of print_cyclic Merge pull request #17891 from … (compare)

- 14:19smichr closed #17891
- 14:19smichr closed #17884
- 14:01serkin starred sympy/sympy
- 13:32
- 13:05codecov[bot] commented #17891
- 11:58sympy-bot commented #17891
- 11:58aditisingh2362 edited #17891
- 11:58sympy-bot commented #17891

Actually,

`solution = np.array(*[e for e in r_tmp]).astype(float)`

should flatten it as well

wow. :-( Given the matrix `PI`

```
array([[ -0.917, 0.042, 0. , 0. , -1. ],
[ 0.708, -1.125, 0.042, 0. , 5. ],
[ 0.375, 1.125, -1.125, 0.042, -10. ],
[ -0.208, -0.042, 1.125, -1.125, 10. ],
[ 0.042, 0. , -0.042, 1.125, -5. ],
[ 0. , 0. , 0. , -0.042, 1. ]])
```

and the vector `c`

`array([-1. , 0. , 0. , -0.042, 1.083, -0.042])`

the solution given by

`linsolve(Matrix(np.c_[PI,c]))`

returns an `EmptySet()`

while the same operation in Maple 16 returns non empty, and exactly

`np.array([649/576, 143/192, 75/64, 551/576, -25/13824])`

that in float is around

`array([ 1.127, 0.745, 1.172, 0.957, -0.002])`

Any ideas?

the example in maple is shown above

for sake of this test it was created using the ratios, as in

```
PI = np.array([
[-11/12, 1/24, 0, 0, -1],
[ 17/24, -9/8, 1/24, 0 ,5],
[3/8, 9/8, -9/8, 1/24, -10],
[-5/24, -1/24, 9/8, -9/8, 10],
[1/24, 0, -1/24, 9/8, -5],
[0, 0, 0, -1/24, 1]
])
```

Ideas, are very likely welcome.

It seems that your system is over-determined. It has 6 equations in 5 variables. It can have solutions only if the determinant of the extended system is 0.

```
>>> P = Matrix([[ -0.917, 0.042, 0. , 0. , -1. ],
... [ 0.708, -1.125, 0.042, 0. , 5. ],
... [ 0.375, 1.125, -1.125, 0.042, -10. ],
... [ -0.208, -0.042, 1.125, -1.125, 10. ],
... [ 0.042, 0. , -0.042, 1.125, -5. ],
... [ 0. , 0. , 0. , -0.042, 1. ]])
>>> c = Matrix([-1. , 0. , 0. , -0.042, 1.083, -0.042])
>>> Pc = P.row_join(c)
>>> Pc.det()
0.000998125750125132
```

In this example, the determinant not 0 because of the inaccuracy of floating point numbers. Hence there is no solution.

i am learning python megacourse on udemy and it is also teaching numpy, so i was wondering if it might be useful

A potential solution could be to define

`rationalize = lambda x: [nsimplify(e) for e in x]`

(this will turn numbers from a list into rationals). And then do

```
PI = Matrix(map(rationalize, [
[-11/12, 1/24, 0, 0, -1],
[ 17/24, -9/8, 1/24, 0 ,5],
[3/8, 9/8, -9/8, 1/24, -10],
[-5/24, -1/24, 9/8, -9/8, 10],
[1/24, 0, -1/24, 9/8, -5],
[0, 0, 0, -1/24, 1]
]))
```

and similarly for `c`

. I've just checked and this returns the right solutions

@valglad Amazing! I will test.

There are 6 rows and only 5 columns. One row could be omitted.

```
In [7]: linsolve(Pc[:5, :])
Out[7]:
{(1.12549831271091, 0.749071392102014, 1.16564957508439, 0.96140585029474, -0.
000620954287620833)}
```

I have created

`mrationalize = lambda x: [nsimplify(e) for e in [r for r in x]]`

that I do not like much the fell.
I have a problem with calculating eigenvectors for a simple 3x3 matrix in sympy. Trying to execute

```
q = symbols("q", positive=True)
m = Matrix([[-2, exp(-q), 1], [exp(q), -2, 1], [1, 1, -2]])
#m.eigenvects(simplify=True)
m.eigenvals()
```

results in very complicated expressions for the eigenvalues, trying to get the eigenvectors fails with a NotImplementedError. I expect the latter to be due to the former. However, when trying to do the same thing in Mathematica, I get much simpler expressions for everything. Is there some option / flag that I can set to have sympy compute these eigenvalues and eigenvectors? Is there currently some form of limitation within sympy that prevents me from doing this?

@adoa does Mathematica give a simpler expression for the eigenvalues?

Oh apparently they can be simplified if you call

`simplify`

@adoa it seems there is a

`simplify`

flag, but it doesn't work
This may help you

You should use whichever you feel more comfortable with

(sorry for these silly questions... I am trying my best ,i just need some guidance )