Changeset 39387 in project

Timestamp:

11/25/20 20:46:00 (7 weeks ago)

Author:

Kon Lovett

Message:

fix fp*-with-precision p argument type handling, type is iterface

Location:

release/5/fp-utils/trunk

Files:

• fp-inlines.scm (modified) (4 diffs)
• fp-utils.egg (modified) (1 diff)
• fp-utils.scm (modified) (7 diffs)

release/5/fp-utils/trunk/fp-inlines.scm

@@ -18 +18 @@
   fplog2 fplog10
   fpdegree->radian fpradian->degree
-  fpprecision-factor)
+  fpprecision-factor fpprecision-epsilon)
 
 (import scheme)
@@ -38 +38 @@
 
 (: fpzero? (float --> boolean))
-;
+(: fppositive? (float --> boolean))
+(: fpnatural? (float --> boolean))
+(: fpnegative? (float --> boolean))
+(: fpnon-positive? (float --> boolean))
+(: fpeven? (float --> boolean))
+(: fpodd? (float --> boolean))
+(: fpclosed-right? (float float float --> boolean))
+(: fpclosed? (float float float --> boolean))
+(: fpclosed-left? (float float float --> boolean))
+(: fpadd1 (float --> float))
+(: fpsub1 (float --> float))
+(: fplog2 (float --> float))
+(: fplog10 (float --> float))
+(: fpdegree->radian (float --> float))
+(: fpradian->degree (float --> float))
+(: fpprecision-factor ((or float fixnum) #!optional float --> float))
+(: fpprecision-epsilon ((or float fixnum) #!optional float --> float))
+(: fp% (float float --> float))
+
+;;
+
 (define (fpzero? n) (or (fp= 0.0 n) (fp= -0.0 n)))
 
-(: fppositive? (float --> boolean))
-;
 (define (fppositive? n) (fp< 0.0 n))
 
-(: fpnatural? (float --> boolean))
-;
 (define (fpnatural? n) (fp<= 0.0 n))
 
-(: fpnegative? (float --> boolean))
-;
 (define (fpnegative? n) (fp> 0.0 n))
 
-(: fpnon-positive? (float --> boolean))
-;
 (define (fpnon-positive? n) (fp>= 0.0 n))
 
 ;;
 
-(: fpeven? (float --> boolean))
-;
 (define (fpeven? n) (fpinteger? (fp/ n 2.0)))
 
-(: fpodd? (float --> boolean))
-;
 (define (fpodd? n) (not (fpeven? n)))
 
 ;;
 
-(: fpclosed-right? (float float float --> boolean))
-;
 (define (fpclosed-right? l x h) (and (fp< l x) (fp<= x h)))
 
-(: fpclosed? (float float float --> boolean))
-;
 (define (fpclosed? l x h) (and (fp<= l x) (fp<= x h)))
 
-(: fpclosed-left? (float float float --> boolean))
-;
 (define (fpclosed-left? l x h) (and (fp<= l x) (fp< x h)))
 
@@ -87 +89 @@
 ;;
 
-(: fpadd1 (float --> float))
-;
 (define (fpadd1 n) (fp+ n 1.0))
 
-(: fpsub1 (float --> float))
-;
 (define (fpsub1 n) (fp- n 1.0))
 
@@ -107 +105 @@
 ;;
 
-(: fplog2 (float --> float))
-;
 (define (fplog2 x) (fp/ (fplog x) 0.6931471805599453094172321214581765680755))
 
-(: fplog10 (float --> float))
-;
 (define (fplog10 x) (fp/ (fplog x) 2.3025850929940456840179914546843642076011))
 
 ;;
 
-(: fpdegree->radian (float --> float))
-;
 (define (fpdegree->radian deg) (fp* deg 0.0174532925199432957692369076848861271344))
 
-(: fpradian->degree (float --> float))
-;
 (define (fpradian->degree rad) (fp/ rad 0.0174532925199432957692369076848861271344))
 
 ;;
 
-(: fpprecision-factor ((or float fixnum) #!optional float --> float))
-;
 (define (fpprecision-factor p #!optional (base 10.0)) (fpexpt base (exact->inexact p)))
 
-#|
+(define (fpprecision-epsilon p #!optional (base 10.0))
+  (fp/ 1.0 (fpprecision-factor (fpadd1 (exact->inexact p)) base)) )
+
 ;;
 
-(: fp% (float float --> float))
-;
-(define (fp% n p) (fp/ (fp* 100.0 n) p))
-|#
+(define (fp% n p) (fp/ (fp* 100.0 n) (exact->inexact p)))
 
 ) ;fp-inlines

release/5/fp-utils/trunk/fp-utils.egg

@@ -3 +3 @@
 
 ((synopsis "fp utilities")
- (version "4.0.2")
+ (version "4.0.3")
  (category math)
  (author "[[kon lovett]]")

release/5/fp-utils/trunk/fp-utils.scm

@@ -39 +39 @@
 ;;;
 
-;;
-
 (: fpsum ((list-of float) --> float))
-;
+(: C_fmod (float float --> float))
+(: C_remainder (float float --> float))
+(: fpmodulo (float float --> float))
+(: fpquotient (float float --> float))
+(: fpremainder (float float --> float))
+(: fptruncate-with-precision (float #!optional float --> float))
+(: fpround-with-precision (float #!optional float --> float))
+(: fpceiling-with-precision (float #!optional float --> float))
+(: fpfloor-with-precision (float #!optional float --> float))
+(: fpdistance (float float float float --> float))
+(: fpdistance* (float float float float --> float))
+(: fpquo-and-rem (float float --> float float))
+(: fpmax-and-min (float #!rest float --> float float))
+(: fprandom (#!optional (or float fixnum) (or float fixnum) -> float))
+(: fp~= (float float #!optional float --> boolean))
+(: fp~<= (float float #!optional float --> boolean))
+(: fp~>= (float float #!optional float --> boolean))
+
+;;
+
 (define (fpsummation ls)
   (if (null? ls)
@@ -57 +74 @@
 ;;;
 
-(: C_fmod (float float --> float))
-;
 (define C_fmod (foreign-lambda double "fmod" double double))
 
-(: C_remainder (float float --> float))
-;
 (define C_remainder (foreign-lambda double "remainder" double double))
 
 ;;
 
-(: fpmodulo (float float --> float))
-;
 (define (fpmodulo x y) (fptruncate (C_fmod x y)))
 
-(: fpquotient (float float --> float))
-;
 (define (fpquotient x y) (fptruncate (fp/ x y)))
 
-(: fpremainder (float float --> float))
-;
 (define (fpremainder x y) (fptruncate (C_remainder x y)))
 
@@ -88 +95 @@
     ((make-unary-with-precision ?op)
       (lambda (n #!optional (p PRECISION-DEFAULT))
-        (if (fpzero? p)
+        (if (fpzero? (exact->inexact p))
           (?op n)
           (let ((pf (fpprecision-factor p)))
@@ -95 +102 @@
 ;;
 
-(: fptruncate-with-precision (float #!optional float --> float))
-;
 (define fptruncate-with-precision (make-unary-with-precision fptruncate))
 
-(: fpround-with-precision (float #!optional float --> float))
-;
 (define fpround-with-precision (make-unary-with-precision fpround))
 
-(: fpceiling-with-precision (float #!optional float --> float))
-;
 (define fpceiling-with-precision (make-unary-with-precision fpceiling))
 
-(: fpfloor-with-precision (float #!optional float --> float))
-;
 (define fpfloor-with-precision (make-unary-with-precision fpfloor))
 
 ;;
 
-(: fpdistance (float float float float --> float))
-;
 (define (fpdistance x1 y1 x2 y2) (fpsqrt (fpdistance* x1 y1 x2 y2)))
 
-(: fpdistance* (float float float float --> float))
-;
 (define (fpdistance* x1 y1 x2 y2) (fp+ (fpsqr (fp- x1 x2)) (fpsqr (fp- y1 y2))))
 
 ;;
 
-(: fpquo-and-rem (float float --> float float))
-;
 (define (fpquo-and-rem fpn fpd) (values (fpquotient fpn fpd) (fpremainder fpn fpd)))
 
 ;;
 
-(: fpmax-and-min (float #!rest float --> float float))
-;
 (define (fpmax-and-min fp . fps)
   (let loop ((fps fps) (mx fp) (mn fp))
@@ -140 +131 @@
 ;;
 
-(: fprandom (#!optional (or float fixnum) (or float fixnum) -> float))
-;
 (define-inline (*fpinv x) (if (fpzero? x) 0.0 (fp/ 1.0 x)))
 (define-inline (*fpinvfx x) (inexact->exact (*fpinv x)))
@@ -163 +152 @@
 ;;
 
-(: fp~= (float float #!optional float --> boolean))
-;
 (define (fp~= x y #!optional (eps flonum-epsilon))
   ;NOTE minimum/maximum-flonum is smallest/largest positive normal flonum
@@ -182 +169 @@
           (fp< (fpabs (fp/ d y)) eps) ) ) ) ) )
 
-(: fp~<= (float float #!optional float --> boolean))
-;
 (define (fp~<= x y #!optional (eps flonum-epsilon)) (or (fp< x y) (fp~= x y eps)))
 
-(: fp~>= (float float #!optional float --> boolean))
-;
 (define (fp~>= x y #!optional (eps flonum-epsilon)) (or (fp> x y) (fp~= x y eps)))
 
 #|
-;;
-
-(: fp% (float number --> float))
-;
-(define (fp% n p)
-  (fp* (fp* (exact->inexact p) 0.01) n) )
-
 ;;