complex numbers
authorStefan Israelsson Tampe <stefan.itampe@gmail.com>
Mon, 2 Oct 2017 21:20:56 +0000 (23:20 +0200)
committerStefan Israelsson Tampe <stefan.itampe@gmail.com>
Mon, 2 Oct 2017 21:20:56 +0000 (23:20 +0200)
modules/language/python/compile.scm
modules/language/python/dir.scm
modules/language/python/number.scm

index a8fdeaccb10bcd331eec52d03b18379a5e97c4ce..5d9828bd1b33ba11e38d763714b7ff636957ef0f 100644 (file)
    ((__rrshift__)  (N 'py-rrshift))
    ((as_integer_ratio) (N 'py-as-integer-ratio))
    ((conjugate)    (N 'py-conjugate))
+   ((denominator)  (N 'py-denominator))
+   ((numerator)    (N 'py-numerator))
    ((fromhex)      (N 'py-fromhex))
    ((hex)          (N 'py-hex))
    ((imag)         (N 'py-imag))
                   (fast    (fastfkn tag))
                   (is-fkn? (aif it (and is-fkn? fast)
                                 `(#:call-obj (lambda (e)
-                                               `(lambda ,xs
-                                                  (apply ,it ,e ,xs))))
+                                               (lambda ,xs
+                                                 (apply ,it e ,xs))))
                                 #f)))
              (if is-fkn?
                  is-fkn?
index a1c77c96d853804dc5360a9ae183f3ebb2e662b9..1189673f897d8b9278b432331345749e20b5a639 100644 (file)
           (pylist-sort! l)
           l)
         l1)))
+
+(define-method (dir (o <py-complex>))
+  (let ((l1 (pycomplex-listing)))
+    (if (is-a? o <p>)
+        (let* ((l2 (next-method))
+               (l  (+ l1 l2)))
+          (pylist-sort! l)
+          l)
+        l1)))
           
     
 (define-method (dir (o <hashtable>   )) (pyhash-listing))
 (define-method (dir (o <string>      )) (pystring-listing))
-(define-method (dir (o <complex>     ))
-  (if (integer? o)
-      (pyint-listing)
-      (pyfloat-listing)))
+(define-method (dir (o <complex>     )) (pycomplex-listing))
+(define-method (dir (o <real>        )) (pyfloat-listing))
+(define-method (dir (o <integer>     )) (pyint-listing))
 
 (define-method (dir)
   (let ((l '()))
index 03b066cc4309db23678dd6c628ce7c764769803f..f2c0c6bc779f2952aa149fa2912658c5ec8a37b1 100644 (file)
@@ -5,18 +5,19 @@
   #:use-module (language python list)
   #:use-module (language python try)
   #:use-module (language python exceptions)
-  #:export (py-int py-float py-/ py-logand py-logior py-logxor py-abs
+  #:export (py-int py-float py-complex
+                   py-/ py-logand py-logior py-logxor py-abs
                    py-lshift py-rshift py-mod py-floordiv
-                   <py-int> <py-float>
-                   py-divmod pyfloat-listing pyint-listing
+                   <py-int> <py-float> <py-complex>
+                   py-divmod pyfloat-listing pyint-listing pycomplex-listing
                    py-as-integer-ratio py-conjugate py-fromhex py-hex py-imag
-                   py-is-integer py-real hex)))))
-    (p))
+                   py-is-integer py-real hex))
 
 (define-syntax-rule (aif it p x y) (let ((it p)) (if it x y)))
 
-(define-class <py-int>   () x)
-(define-class <py-float> () x)
+(define-class <py-int>     () x)
+(define-class <py-float>   () x)
+(define-class <py-complex> () x)
 
 (define-syntax-rule (b0 op)
   (begin
       (op (slot-ref o1 'x) o2))    
     (define-method (op (o1 <py-float>) o2)
       (op (slot-ref o1 'x) o2))
+    (define-method (op (o1 <py-complex>) o2)
+      (op (slot-ref o1 'x) o2))
     (define-method (op o2 (o1 <py-int>))
       (op (slot-ref o1 'x) o2))    
+    (define-method (op o2 (o1 <py-complex>))
+      (op (slot-ref o1 'x) o2))
     (define-method (op o2 (o1 <py-float>))
       (op (slot-ref o1 'x) o2))))
 
@@ -69,8 +74,8 @@
 (define-method (py-rshift (o1 <integer>) (o2 <integer>))
   (ash o1 (- o2)))
 
-(mk-biop i0 py-rlshift py-lshift __lshift__ __rlshift__)
-(mk-biop i0 py-rrshift py-rshift __rshift__ __rrshift__)
+(mk-biop2 i0 py-rlshift py-lshift __lshift__ __rlshift__)
+(mk-biop2 i0 py-rrshift py-rshift __rshift__ __rrshift__)
 
 (define-method (py-logand (o1 <integer>) (o2 <integer>))
   (logand o1 o2))
    (floor-quotient o1 o2)
    (floor-remainder o1 o2)))
 
-(define-method (py-flordiv (o1 <number>) (o2 <number>))
+(define-method (py-floordiv (o1 <number>) (o2 <number>))
   (floor-quotient o1 o2))
 
-(mk-biop2 b0 py-rflordiv py-flordiv __floordiv__ __rfloordiv__)
+(mk-biop2 b0 py-rfloordiv py-floordiv __floordiv__ __rfloordiv__)
 (mk-biop2 b0 py-rdivmod py-divmod __divmod__  __rdivmod__)
 (mk-biop2 b0 py-r/      py-/      __truediv__ __rtruediv__)
 
 (define-method (py-mod (o1 <real>)    (o2 <real>))
   (floor-remainder o1 o2))
 
-(mk-biop2 io py-rmod py-mod __mod__ __rmod__)
+(mk-biop2 i0 py-rmod py-mod __mod__ __rmod__)
 
 
 (define-method (py-abs (o <number>)) (abs o))
 
 (define-syntax-rule (u0 f)
   (begin
-    (define-method (f (o <py-int>  )) (f (slot-ref o 'x)))
-    (define-method (f (o <py-float>)) (f (slot-ref o 'x)))))
+    (define-method (f (o <py-int>  ))   (f (slot-ref o 'x)))
+    (define-method (f (o <py-float>))   (f (slot-ref o 'x)))
+    (define-method (f (o <py-complex>)) (f (slot-ref o 'x)))))
 
 (define-syntax-rule (i0 f)
   (begin
   (logcount i))
 
 (define-method (py-conjugate (i <complex>))
-  (make-rectangular (real-part i) (- (complex-part i))))
+  (make-rectangular (real-part i) (- (imag-part i))))
 (define-method (py-conjugate (i <number>)) i)
 
-(define-method (py-imag (i <complex>)) (complex-part i))
+(define-method (py-imag (i <complex>)) (imag-part i))
 (define-method (py-imag (i <number>)) i)
 
 (define-method (py-real (i <complex>)) (real-part i))
 (define-method (py-real (i <number>)) i)
 
-(define-method (py-denominator (<integer> o)) 0)
-(define-method (py-denominator (<real>    o))
+(define-method (py-denominator (o <integer>)) 0)
+(define-method (py-denominator (o <real>))
   (denominator (inexact->exact o)))
 
-(define-method (py-numerator (<integer> o)) o)
-(define-method (py-numerator (<real>    o))
+(define-method (py-numerator (o <integer>)) o)
+(define-method (py-numerator (o <real>   ))
   (numerator (inexact->exact o)))
 
-(define-method (py-as-integer-ratio (<integer> o))
+(define-method (py-as-integer-ratio (o <integer>))
   (list o 0))
-(define-method (py-as-integer-ratio (<real> o))
+(define-method (py-as-integer-ratio (o <real>))
   (let ((r (inexact->exact o)))
-    (list (numerator r) (denumerator r))))
+    (list (numerator r) (denominator r))))
 
-(define-method (py-fromhex     (<real> o))
+(define-method (py-fromhex     (o <real>))
   (error "1.2.fromhex('0x1.ap4') is not implemented"))
 
-(define-method (py-hex         (<real> o))
+(define-method (py-hex         (o <real>))
   (error "1.2.hex() is not implemented"))
                                
-(define-method (py-is-integer  (<real> o))
-  (= 0 (denominator (inexact->exact o))))
-(define-method (py-is-integer  (<integer> o)) #t)
+(define-method (py-is-integer  (o <real>))
+  (= 1 (denominator (inexact->exact o))))
+(define-method (py-is-integer  (o <integer>)) #t)
 
-(define-method (hex (<integer> o))
-  (+ "0x" (number->string i 16)))
+(define-method (hex (o <integer>))
+  (+ "0x" (number->string o 16)))
 
 (mk-unop u0 py-conjugate conjugate)
 (mk-unop u0 py-imag imag)
       ((self n k)
        (__init__ self (string->number n k))))))
 
+(define (proj? x)
+  (if (number? x)
+      x
+      (and
+       (or (is-a? x <py-complex>)
+           (is-a? x <py-int>)
+           (is-a? x <py-float>))
+       (slot-ref x 'x))))
+
+(define (projc? x)
+  (if (number? x)
+      (if (not (complex? x))
+          x
+          #f)
+      (and
+       (or (is-a? x <py-complex>)
+           (is-a? x <py-int>)
+           (is-a? x <py-float>))
+       (let ((ret (slot-ref x 'x)))
+         (if (not (complex? ret))
+             ret
+             #f)))))
+
 (define-python-class float (<py-float>)
   (define __init__
     (case-lambda
       ((self n)
        (let lp ((n n))
          (cond
-          ((number? n)
-           (slot-set! self 'x n))
+          ((projc? n) =>
+           (lambda (n)
+             (slot-set! self 'x n)))
           ((string? n)
            (lp (string->number n)))
           (else
            (aif it (slot-ref n '__float__)
                 (slot-set! self 'x it)
-                (raise ValueError "could not make int from " n)))))))))
+                (raise ValueError "could not make float from " n)))))))))
+
+  
+(define-python-class py-complex (<py-complex>)
+  (define __init__
+    (case-lambda
+      ((self n)
+       (cond
+        ((proj? n) =>
+         (lambda (n)
+           (slot-set! self 'x n)))
+        (else
+         (raise ValueError "could not make complex from " n))))
+      ((self n m)
+       (cond
+        ((projc? n) =>
+         (lambda (n)        
+           (cond
+            ((projc? m)
+             (lambda (m)
+               (slot-set! self 'x (make-rectangular n m))))
+            (else
+             (raise ValueError "could not make complex from " n m)))))
+        (else
+         (raise ValueError "could not make complex from " n m)))))))
 
 (define-method (py-class (o <integer>    )) int)
 (define-method (py-class (o <real>       )) float)
 
 (define (pyint-listing)
   (let ((l
-         (pk (to-pylist
-          (pk (map symbol->string
+         (to-pylist
+          (map symbol->string
                '(__abs__ __add__ __and__ __class__ __cmp__ __coerce__
                          __delattr__ __div__ __divmod__ __doc__ __float__
                          __floordiv__ __format__ __getattribute__
                          __rxor__ __setattr__ __sizeof__ __str__ __sub__
                          __subclasshook__ __truediv__ __trunc__ __xor__
                          bit_length conjugate denominator imag numerator
-                         real)))))))
+                         real)))))
     (pylist-sort! l)
     l))
 
                          is_integer real)))))
     (pylist-sort! l)
     l))
+
+(define (pycomplex-listing)
+  (let ((l
+         (to-pylist
+          (map symbol->string
+               '(__abs__ __add__ __class__ __coerce__ __delattr__ __div__
+                         __divmod__ __doc__ __eq__ __float__ __floordiv__
+                         __format__ __ge__ __getattribute__ __getnewargs__
+                         __gt__ __hash__ __init__ __int__ __le__ __long__
+                         __lt__ __mod__ __mul__ __ne__ __neg__ __new__
+                         __nonzero__ __pos__ __pow__ __radd__ __rdiv__
+                         __rdivmod__ __reduce__ __reduce_ex__ __repr__
+                         __rfloordiv__ __rmod__ __rmul__ __rpow__ __rsub__
+                         __rtruediv__ __setattr__ __sizeof__ __str__
+                         __sub__ __subclasshook__ __truediv__
+                         conjugate imag real)))))
+    (pylist-sort! l)
+    l))