Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

from __future__ import print_function, division 

 

from sympy import Basic, Expr, S, sympify 

from .matexpr import ShapeError 

 

 

class Determinant(Expr): 

    """Matrix Determinant 

 

    Represents the determinant of a matrix expression. 

 

    >>> from sympy import MatrixSymbol, Determinant, eye 

    >>> A = MatrixSymbol('A', 3, 3) 

    >>> Determinant(A) 

    Determinant(A) 

 

    >>> Determinant(eye(3)).doit() 

    1 

    """ 

 

    def __new__(cls, mat): 

        mat = sympify(mat) 

        if not mat.is_Matrix: 

            raise TypeError("Input to Determinant, %s, not a matrix" % str(mat)) 

 

        if not mat.is_square: 

            raise ShapeError("Det of a non-square matrix") 

 

        return Basic.__new__(cls, mat) 

 

    @property 

    def arg(self): 

        return self.args[0] 

 

    def doit(self, expand=False): 

        try: 

            return self.arg._eval_determinant() 

        except (AttributeError, NotImplementedError): 

            return self 

 

def det(matexpr): 

    """ Matrix Determinant 

 

    >>> from sympy import MatrixSymbol, det, eye 

    >>> A = MatrixSymbol('A', 3, 3) 

    >>> det(A) 

    Determinant(A) 

 

    >>> det(eye(3)) 

    1 

    """ 

 

    return Determinant(matexpr).doit() 

 

 

from sympy.assumptions.ask import ask, Q 

from sympy.assumptions.refine import handlers_dict 

 

 

def refine_Determinant(expr, assumptions): 

    """ 

    >>> from sympy import MatrixSymbol, Q, assuming, refine, det 

    >>> X = MatrixSymbol('X', 2, 2) 

    >>> det(X) 

    Determinant(X) 

    >>> with assuming(Q.orthogonal(X)): 

    ...     print(refine(det(X))) 

    1 

    """ 

    if ask(Q.orthogonal(expr.arg), assumptions): 

        return S.One 

    elif ask(Q.singular(expr.arg), assumptions): 

        return S.Zero 

    elif ask(Q.unit_triangular(expr.arg), assumptions): 

        return S.One 

 

    return expr 

 

 

handlers_dict['Determinant'] = refine_Determinant