emacs-devel
[Top][All Lists]

## Re: Calc; Div by 0 in solving system

 From: Mattias Engdegård Subject: Re: Calc; Div by 0 in solving system Date: Mon, 22 Apr 2019 08:56:57 +0200

```21 apr. 2019 kl. 17.37 skrev Christopher Howard <address@hidden>:
>
> Place this on stack with algebriac mode:
>
> [2 * x - 3 * y + z = 5, x + y - 2 * z = 0, -x + 2 * y + 3 * z = -3]
>
> run command 'a S x,y,z'
>
> Receive error 'Division by zero: 1'
>
> I enabled Debug on Error but could not find the backtrace

This is the backtrace I get in Emacs 26.1:

* math-reject-arg((float 1 0) "*Division by zero")
math-div-by-zero((float 1 0) 0)
math-div((float 1 0) 0)
math-float((frac 1 0))
math-mul((frac 1 0) (float 138629436111989 -14))
math-mul-objects-fancy((frac 1 0) (cplx (float 138629436111989 -14) (float
314159265358979 -14)))
math-mul((frac 1 0) (cplx (float 138629436111989 -14) (float 314159265358979
-14)))
math-pow-fancy(-4 (frac 1 0))
math-pow(-4 (frac 1 0))
math-poly-laguerre-root((4) 0 t)
math-poly-any-root((4) 0 t)
math-try-solve-for((+ (+ (- (* 2 (- (var z var-z) (float 1 0))) (/ (- (+ 5 (*
3 (- (var z var-z) (float 1 0)))) (var z var-z)) 2)) (* 3 (var z var-z))) 3) 0
nil nil)
math-try-solve-for((calcFunc-eq (+ (- (* 2 (- (var z var-z) (float 1 0))) (/
(- (+ 5 (* 3 (- (var z var-z) (float 1 0)))) (var z var-z)) 2)) (* 3 (var z
var-z))) -3) 0 nil)
math-solve-for((calcFunc-eq (+ (- (* 2 (- (var z var-z) (float 1 0))) (/ (-
(+ 5 (* 3 (- (var z var-z) (float 1 0)))) (var z var-z)) 2)) (* 3 (var z
var-z))) -3) 0 (var z var-z) nil)
math-solve-system-rec((((calcFunc-eq (+ (- (* 2 (- (var z var-z) (float 1
0))) (/ (- (+ 5 (* 3 (- (var z var-z) (float 1 0)))) (var z var-z)) 2)) (* 3
(var z var-z))) -3))) ((var z var-z)) (((var y var-y) (- (var z var-z) (float 1
0))) ((var x var-x) (/ (- (+ 5 (* 3 (- (var z var-z) (float 1 0)))) (var z
var-z)) 2))))
math-solve-system-rec((((calcFunc-eq (- (+ (/ (- (+ 5 (* 3 (var y var-y)))
(var z var-z)) 2) (var y var-y)) (* 2 (var z var-z))) 0)) ((calcFunc-eq (+ (-
(* 2 (var y var-y)) (/ (- (+ 5 (* 3 (var y var-y))) (var z var-z)) 2)) (* 3
(var z var-z))) -3))) ((var y var-y) (var z var-z)) (((var x var-x) (/ (- (+ 5
(* 3 (var y var-y))) (var z var-z)) 2))))
math-solve-system-rec((((calcFunc-eq (+ (- (* 2 (var x var-x)) (* 3 (var y
var-y))) (var z var-z)) 5)) ((calcFunc-eq (- (+ (var x var-x) (var y var-y)) (*
2 (var z var-z))) 0)) ((calcFunc-eq (+ (- (* 2 (var y var-y)) (var x var-x)) (*
3 (var z var-z))) -3))) ((var x var-x) (var y var-y) (var z var-z)) nil)
math-solve-system((vec (calcFunc-eq (+ (- (* 2 (var x var-x)) (* 3 (var y
var-y))) (var z var-z)) 5) (calcFunc-eq (- (+ (var x var-x) (var y var-y)) (* 2
(var z var-z))) 0) (calcFunc-eq (+ (- (* 2 (var y var-y)) (var x var-x)) (* 3
(var z var-z))) -3)) (vec (var x var-x) (var y var-y) (var z var-z)) nil)
calcFunc-solve((vec (calcFunc-eq (+ (- (* 2 (var x var-x)) (* 3 (var y
var-y))) (var z var-z)) 5) (calcFunc-eq (- (+ (var x var-x) (var y var-y)) (* 2
(var z var-z))) 0) (calcFunc-eq (+ (- (* 2 (var y var-y)) (var x var-x)) (* 3
(var z var-z))) -3)) (vec (var x var-x) (var y var-y) (var z var-z)))
apply(calcFunc-solve ((vec (calcFunc-eq (+ (- (* 2 (var x var-x)) (* 3 (var y
var-y))) (var z var-z)) 5) (calcFunc-eq (- (+ (var x var-x) (var y var-y)) (* 2
(var z var-z))) 0) (calcFunc-eq (+ (- (* 2 (var y var-y)) (var x var-x)) (* 3
(var z var-z))) -3)) (vec (var x var-x) (var y var-y) (var z var-z))))
math-normalize((calcFunc-solve (vec (calcFunc-eq (+ (- (* 2 (var x var-x)) (*
3 (var y var-y))) (var z var-z)) 5) (calcFunc-eq (- (+ (var x var-x) (var y
var-y)) (* 2 (var z var-z))) 0) (calcFunc-eq (+ (- (* 2 (var y var-y)) (var x
var-x)) (* 3 (var z var-z))) -3)) (vec (var x var-x) (var y var-y) (var z
var-z))))
math-simplify((calcFunc-solve (vec (calcFunc-eq (+ (- (* 2 (var x var-x)) (*
3 (var y var-y))) (var z var-z)) 5) (calcFunc-eq (- (+ (var x var-x) (var y
var-y)) (* 2 (var z var-z))) 0) (calcFunc-eq (+ (- (* 2 (var y var-y)) (var x
var-x)) (* 3 (var z var-z))) -3)) (vec (var x var-x) (var y var-y) (var z
var-z))))
calc-normalize-fancy((calcFunc-solve (vec (calcFunc-eq (+ (- (* 2 (var x
var-x)) (* 3 (var y var-y))) (var z var-z)) 5) (calcFunc-eq (- (+ (var x var-x)
(var y var-y)) (* 2 (var z var-z))) 0) (calcFunc-eq (+ (- (* 2 (var y var-y))
(var x var-x)) (* 3 (var z var-z))) -3)) (vec (var x var-x) (var y var-y) (var
z var-z))))
calc-normalize((calcFunc-solve (vec (calcFunc-eq (+ (- (* 2 (var x var-x)) (*
3 (var y var-y))) (var z var-z)) 5) (calcFunc-eq (- (+ (var x var-x) (var y
var-y)) (* 2 (var z var-z))) 0) (calcFunc-eq (+ (- (* 2 (var y var-y)) (var x
var-x)) (* 3 (var z var-z))) -3)) (vec (var x var-x) (var y var-y) (var z
var-z))))
math-evaluate-expr((calcFunc-solve (vec (calcFunc-eq (+ (- (* 2 (var x
var-x)) (* 3 (var y var-y))) (var z var-z)) 5) (calcFunc-eq (- (+ (var x var-x)
(var y var-y)) (* 2 (var z var-z))) 0) (calcFunc-eq (+ (- (* 2 (var y var-y))
(var x var-x)) (* 3 (var z var-z))) -3)) (vec (var x var-x) (var y var-y) (var
z var-z))))
mapcar(math-evaluate-expr ((calcFunc-solve (vec (calcFunc-eq (+ (- (* 2 (var
x var-x)) (* 3 (var y var-y))) (var z var-z)) 5) (calcFunc-eq (- (+ (var x
var-x) (var y var-y)) (* 2 (var z var-z))) 0) (calcFunc-eq (+ (- (* 2 (var y
var-y)) (var x var-x)) (* 3 (var z var-z))) -3)) (vec (var x var-x) (var y
var-y) (var z var-z)))))
#f(compiled-function () #<bytecode 0x4a71afd9>)()
calc-do(#f(compiled-function () #<bytecode 0x4a71afd9>) 126)
calc-evaluate(1)
funcall-interactively(calc-evaluate 1)
call-interactively(calc-evaluate nil nil)
command-execute(calc-evaluate)

```