Changeset 14575 in project


Ignore:
Timestamp:
05/10/09 08:06:41 (11 years ago)
Author:
Ivan Raikov
Message:

unitconv ported to Chicken 4.

Location:
release/4/unitconv
Files:
1 deleted
4 edited
1 copied

Legend:

Unmodified
Added
Removed
  • release/4/unitconv/trunk/unitconv-eggdoc.scm

    r7782 r14575  
    66     (name "unitconv")
    77     (description "Conversion of units of measurement")
    8      (author (url "http://chicken.wiki.br/ivan raikov" "Ivan Raikov"))
     8     (author (url "http://chicken.wiki.br/users/ivan-raikov" "Ivan Raikov"))
    99
    1010     (history
     11      (version "1.5" "Ported to Chicken 4")
     12      (version "1.4" "The predefined quantities have been put into unit-definitions.scm")
     13      (version "1.3" "Bug fix in unit-convert")
     14      (version "1.2" "Changed unit-convert to return a single numeric value given a single conversion argument")
     15      (version "1.1" "Added information units [patch by Joshua Griffith]")
    1116      (version "1.0" "Initial release"))
    1217
    1318     (requires)
    1419
    15      (usage "(require-extension unitconv)")
     20     (usage "(require-extension unitconv)"
     21            "(include \"unit-definitions\")")
    1622
    1723     (download "unitconv.egg")
     
    4046(define-base-quantity  Substance      dimvals[6])
    4147(define-base-quantity  Currency       dimvals[7])
     48(define-base-quantity  Information    dimvals[8])
    4249EOF
    4350)
     
    6976    (p "Now only conversion between units of the same dimensionality is permitted: ")
    7077    (pre #<<EOF
    71 (unit-convert meter inch 1) ->  (39.3700787401575)
     78(unit-convert meter inch 1) ->  39.3700787401575
    7279(unit-convert meter inch 2 3 4) ->  (78.740157480315 118.110236220472 157.48031496063)
    7380
     
    131138             (tr (td (tt "Luminosity")))
    132139             (tr (td (tt "Substance")))
    133              (tr (td (tt "Currency")))))
     140             (tr (td (tt "Currency")))
     141             (tr (td (tt "Information"))))))
    134142
    135143    (subsubsection "Derived Quantities"
     
    279287
    280288csi> (unit-convert pound-force-per-square-inch pascal 1850)
    281 (12755301.5646601)
     28912755301.5646601
    282290
    283291;; Unit prefix definition
     
    285293
    286294csi> (unit-convert inch millimeter 12)
    287 (304.8)
     295304.8
    288296EOF
    289297))
     
    291299
    292300     (license
    293       "Copyright 2007 Ivan Raikov.
     301"Copyright 2007-2009 Ivan Raikov.
    294302
    295303This program is free software: you can redistribute it and/or modify
     
    304312
    305313A full copy of the GPL license can be found at
    306 <http://www.gnu.org/licenses/>."))))
     314<http://www.gnu.org/licenses/>.")))
    307315
    308316(define (sexp->str x)
  • release/4/unitconv/trunk/unitconv.meta

    r9305 r14575  
     1;; -*- Hen -*-
     2
    13((egg "unitconv.egg") ; This should never change
    24
     
    1416 (category math)
    1517
    16  ; A list of eggs matrix-utils depends on.
     18 ; A list of eggs unitconv depends on.
    1719
    18  (needs syntax-case datatype eggdoc)
     20 (needs eggdoc datatype matchable)
    1921
    2022 (eggdoc "unitconv-eggdoc.scm")
  • release/4/unitconv/trunk/unitconv.scm

    r6904 r14575  
    55;;
    66
    7 (require-extension srfi-4)
    8 (require-extension datatype)
    9 
    10 (require-extension unit-support)
     7(module unitconv
     8
     9        (unit-factor-eval
     10         (define-quantity quantity-expr-eval)
     11         (define-unit unit-factor-eval)
     12         make-unit-prefix
     13
     14         unitconv:error
     15         make-quantity
     16         quantity?
     17         quantity-name
     18         quantity-int
     19         make-unit
     20         unit?
     21         unit-equal?
     22         unit-name
     23         unit-factor
     24         unit-prefix
     25         unit-convert
     26
     27         Unity       
     28         Length     
     29         Time       
     30         Temperature
     31         Mass       
     32         Current     
     33         Luminosity 
     34         Substance   
     35         Currency   
     36         Information
     37
     38         ;;
     39         ;; Geometry
     40         ;;
     41         Area
     42         Volume
     43
     44         ;;
     45         ;; Mechanics
     46         ;;
     47         Velocity
     48         Acceleration
     49         Force
     50         Pressure
     51         Energy
     52         Power
     53
     54         ;;
     55         ;; Electricity
     56         ;;
     57         Charge
     58         Potential
     59         Capacitance
     60         Resistance
     61         Conductance
     62         Inductance
     63
     64         ;;
     65         ;; Chemistry
     66         ;;
     67         Concentration
     68         Density
     69
     70         ;;
     71         ;; Optic
     72         ;;
     73         Luminance
     74
     75         ;;
     76         ;; Other
     77         ;;
     78         Frequency
     79
     80
     81         unitless
     82         
     83         ;; SI unit prefixes
     84         yocto
     85         zepto
     86         atto
     87         femto
     88         pico
     89         nano
     90         micro
     91         milli
     92         centi
     93         deci
     94         deca
     95         hecto
     96         kilo
     97         mega
     98         giga
     99         tera
     100         peta
     101         exa
     102         zetta
     103         yotta
     104
     105         ;; Time multiples
     106         twelve
     107         sixty
     108
     109         ;; Angles (dimensionless ratio)
     110         radian
     111         degree
     112
     113         ;; Units of length
     114         meter
     115         inch
     116         foot
     117         angstrom
     118         parsec
     119         millimeter
     120         micrometer
     121         micron
     122
     123         ;; Units of area and volume
     124         square-meter
     125         square-inch
     126         square-micron
     127         square-millimeter
     128         cubic-meter
     129         liter
     130
     131         ;; Units of mass
     132         kilogram
     133         gram
     134         milligram
     135         pound
     136         slug
     137         atomic-mass-unit
     138
     139         ;; Units of time
     140         second
     141         hour
     142
     143         ;; Units of acceleration
     144         meters-per-second-squared
     145
     146         ;; Units of frequency
     147         hertz
     148
     149         ;; Units of force
     150         newton
     151         pound-force
     152
     153         ;; Units of power
     154         watt
     155         horsepower
     156
     157         ;; Units of energy
     158         joule
     159         electron-volt
     160         kilowatt-hour
     161         calorie
     162         erg
     163         british-thermal-unit
     164
     165         ;; Units of current
     166         ampere
     167
     168         ;; Units of electric charge
     169         coulomb
     170
     171         ;; Units of electric potential
     172         volt
     173
     174         ;; Units of resistance
     175         ohm
     176
     177         ;; Units of capacitance
     178         farad
     179         microfarad
     180         picofarad
     181
     182         ;; Units of conductance
     183         siemens
     184
     185         ;; Units of inductance
     186         henry
     187         millihenry
     188         microhenry
     189
     190         ;; Units of substance
     191         mole
     192
     193         ;; Units of density
     194         rho
     195
     196         ;; Units of concentration
     197         molarity
     198         parts-per-million
     199
     200         ;; Units of temperature
     201         degK
     202
     203         ;; Units of information quantity, evidence, and information entropy
     204
     205         ;; bit = log_2(p)     (Shannon)
     206         bit
     207
     208         ;; byte = 8 bits
     209         byte
     210
     211         ;; nat = log_e(p)     (Boulton and Wallace)
     212         nat
     213
     214         ;; ban = log_10(p)    (Hartley, Turing, and Good)
     215         ban
     216
     217         ;; The deciban is the smallest weight of evidence discernible by a human
     218         ;; deciban = 10*log_10(p)
     219         deciban
     220
     221         ;; bits
     222         kilobit
     223         megabit
     224         gigabit
     225         terabit
     226         petabit
     227         exabit
     228         zettabit
     229         yottabit
     230         kibibit
     231         mebibit
     232         gibibit
     233         tebibit
     234         pebibit
     235         exbibit
     236         zebibit
     237         yobibit
     238
     239         ;; bytes
     240         kilobyte
     241         megabyte
     242         gigabyte
     243         terabyte
     244         petabyte
     245         exabyte
     246         zettabyte
     247         yottabyte
     248         kibibyte
     249         mebibyte
     250         gibibyte
     251         tebibyte
     252         pebibyte
     253         exbibyte
     254         zebibyte
     255         yobibyte
     256
     257         ;; bit rates
     258         bits-per-second
     259         kilobits-per-second
     260         megabits-per-second
     261         gigabits-per-second
     262         terabits-per-second
     263         petabits-per-second
     264         exabits-per-second
     265         zettabits-per-second
     266         yottabits-per-second
     267
     268         ;; byte rates
     269         bytes-per-second
     270         kilobytes-per-second
     271         megabytes-per-second
     272         gigabytes-per-second
     273         terabytes-per-second
     274         petabytes-per-second
     275         exabytes-per-second
     276         zettabytes-per-second
     277         yottabytes-per-second
     278         
     279         )
     280       
     281
     282   (import scheme chicken data-structures extras srfi-4)
     283
     284   (require-extension datatype matchable srfi-4)       
     285   (import-for-syntax matchable chicken)       
    11286
    12287(define pi 3.14159265358979)
    13288
    14289
    15 (define-macro (quantity-expr-eval expr left?)
    16   (match expr
    17          ((op x y)  `(let ((x1  (quantity-expr-eval ,x #t))
    18                            (y1  (quantity-expr-eval ,y ,left?)))
    19                            ,(case op
    20                               ((**)    `(* x1 y1))
    21                               ((*)     `(+ x1 y1))
    22                               ((/)     `(- x1 y1))
    23                               (else (unitconv:error 'quantity-expr-eval ": unknown quantity operation " op)))))
    24          
    25          (x         `(cond ((quantity? ,x)   
    26                             (quantity-int ,x))
    27                            ((and (not ,left?) (integer? ,x))
    28                             ,x)
    29                            ((and ,left? (integer? ,x))     
    30                             (unitconv:error 'quantity-expr-eval
    31                                          "integers are not allowed as the left operand of quantity expression"))
    32                            (else  (unitconv:error 'quantity-expr-eval ": unknown quantity " ,x))))))
     290(define (unitconv:error x . rest)
     291  (let ((port (open-output-string)))
     292    (let loop ((objs (cons x rest)))
     293      (if (null? objs)
     294          (begin
     295            (newline port)
     296            (error 'unitconv (get-output-string port)))
     297          (begin (display (car objs) port)
     298                 (display " " port)
     299                 (loop (cdr objs)))))))
     300
     301
     302(define-record quantity name int)
     303
     304(define-record-printer (quantity x out)
     305  (if (zero? (quantity-int x))
     306      (fprintf out "#(quantity Unity)")
     307      (fprintf out "#(quantity ~S ~S)"
     308               (quantity-name x)
     309               (quantity-int x))))
     310
     311
     312;; The number of base quantities defined
     313(define Q 9)
     314
     315(define dref s32vector-ref)
     316
     317;; The sizes of the field assigned to each base quantity; a field size
     318;; of 20 allows a value range of +-9 for the power of that quantity
     319(define dimsizes  (s32vector 20 20 20 10 10 10 10 10 20))
     320
     321;; Multipliers that can be used to move a vector value to its proper
     322;; field position; defined as follows:
     323;;
     324;;  dimvals_{0} = 1
     325;;  dimvals_{i} = dimvals_{i-1} * dimsizes_{i-1}   i > 0
     326;;
     327(define dimvals  (let loop ((i 1) (lst (list 1)))
     328                   (if (< i Q)
     329                       (let ((x  (* (car lst) (dref dimsizes (- i 1)))))
     330                         (loop (+ 1 i) (cons x lst)))
     331                       (list->s32vector (reverse lst)))))
     332
     333;; (s32vector 1 20 400 8000 80000 800000 8000000 80000000))
     334
     335;; A value that, when added to a dimension integer will make it
     336;; positive and will bias each vector component within its field by
     337;; half the size of the field; defined as:
     338;;
     339;;  dimbias = sum_{i=0}^{7}\frac{dimvals_{i} * dimsizes_{i}}{2}
     340;;
     341
     342(define dimbias  (let loop ((i 0)  (sum 0))
     343                   (if (< i Q)
     344                       (loop (+ i 1) (+ sum (/ (* (dref dimvals i) (dref dimsizes i)) 2)))
     345                       sum)))
     346                       
     347
     348;; 444444210
     349
     350;; Compute a dimension integer from a dimension vector
     351;;
     352;; For example, the dimension integer for force can be calculated as
     353;; follows:
     354;;
     355;; force = length * time^{-2} * mass
     356;;
     357;; (dimint (s32vector 1 -2 0 1 0 0 0 0))
     358;; => 7961
     359;;
     360(define (dimint v)
     361  (let loop ((i (- Q 1)) (sum 0))
     362    (if (fx<= 0 i)
     363        (loop (fx- i 1)  (+ sum (* (dref dimvals i) (dref v i))))
     364        sum)))
     365
     366
     367(define-syntax define-base-quantity
     368  (lambda (x r c)
     369    (let ((name   (cadr x))
     370          (value  (caddr x))
     371          (%define (r 'define)))
     372      `(,%define ,name (make-quantity ',name ,value)))))
     373
     374
     375(define-base-quantity  Unity          0)
     376(define-base-quantity  Length         (dref dimvals 0))
     377(define-base-quantity  Time           (dref dimvals 1))
     378(define-base-quantity  Temperature    (dref dimvals 2))
     379(define-base-quantity  Mass           (dref dimvals 3))
     380(define-base-quantity  Current        (dref dimvals 4))
     381(define-base-quantity  Luminosity     (dref dimvals 5))
     382(define-base-quantity  Substance      (dref dimvals 6))
     383(define-base-quantity  Currency       (dref dimvals 7))
     384(define-base-quantity  Information    (dref dimvals 8))
     385
     386
     387(define-record unit name dims factor abbrevs)
     388
     389(define (unit-equal? x y)
     390  (and (= (quantity-int (unit-dims x)) (quantity-int (unit-dims y)))
     391       (= (unit-factor x) (unit-factor y))))
     392 
     393(define-record-printer (unit x out)
     394  (let ((dims     (unit-dims x))
     395        (abbrevs  (unit-abbrevs x)))
     396    (if (null? abbrevs)
     397        (fprintf out "#(unit ~S " (unit-name x))
     398        (fprintf out "#(unit ~S ~S " (unit-name x) (unit-abbrevs x)))
     399    (fprintf out "[~S] ~S)"
     400           (quantity-name (unit-dims x))
     401           (unit-factor x))))
     402
     403(define (unit-prefix prefix u abbrevs)
     404  (or (and (unit? prefix) (unit? u))
     405      (unitconv:error 'unit-prefix ": invalid unit: " u))
     406  (if (not (= 0 (quantity-int (unit-dims prefix))))
     407      (unitconv:error 'unit-prefix ": prefix must be dimensionless: " prefix))
     408  (if (zero? (quantity-int (unit-dims u)))
     409      (unitconv:error 'unit-prefix ": unit must not be dimensionless: " u))
     410  (make-unit (string->symbol
     411              (string-append (symbol->string (unit-name prefix))
     412                             (symbol->string (unit-name u))))
     413             (unit-dims u)
     414             (* (unit-factor prefix) (unit-factor u))
     415             abbrevs))
     416     
     417
     418;;
     419;; Unit conversion
     420;;
     421(define (unit-convert src dest . vals)
     422  (or (and (unit? src) (unit? dest))
     423      (unitconv:error 'unit-convert ": invalid unit: " src dest))
     424  (if (= (quantity-int (unit-dims src)) (quantity-int (unit-dims dest)))
     425      (let ((f  (/ (unit-factor src) (unit-factor dest))))
     426        (if (null? vals)  f
     427            ((lambda (x) (if (null? (cdr x)) (car x) x)) (map (lambda (x) (* f x)) vals))))
     428      (unitconv:error 'unit-convert ": given units are of different dimensions: source=" src "; dest= " dest)))
     429
     430
     431(define-syntax quantity-expr-eval
     432  (lambda (x r c)
     433    (let ((expr       (cadr x))
     434          (left?      (caddr x))
     435          (%let       (r 'let))
     436          (%cond      (r 'cond))
     437          (%else      (r 'else))
     438          (integer?   (r 'integer?))
     439          (not        (r 'not))
     440          (and        (r 'and))
     441          (x1         (r 'x1))
     442          (y1         (r 'y1))
     443          (quantity-expr-eval    (r 'quantity-expr-eval))
     444          (quantity?       (r 'quantity?))
     445          (quantity-int    (r 'quantity-int)))
     446         
     447      (match expr
     448             ((op x y)
     449              `(,%let ((,x1  (,quantity-expr-eval ,x #t))
     450                       (,y1  (,quantity-expr-eval ,y ,left?)))
     451                 ,(case op
     452                    ((**)    `(* ,x1 ,y1))
     453                    ((*)     `(+ ,x1 ,y1))
     454                    ((/)     `(- ,x1 ,y1))
     455                    (else (unitconv:error 'quantity-expr-eval ": unknown quantity operation " op)))))
     456             
     457             (x
     458              `(,%cond ((,quantity? ,x)    (,quantity-int ,x))
     459                       ((,and (,not ,left?) (,integer? ,x)) ,x)
     460                       ((,and ,left? (,integer? ,x))     
     461                        (unitconv:error 'quantity-expr-eval
     462                                        "integers are not allowed as the left operand of quantity expression"))
     463                       (,%else  (unitconv:error 'quantity-expr-eval ": unknown quantity " ,x))))))))
    33464         
    34465 
    35466
    36 (define-macro (define-quantity name expr)
    37   `(define ,name (make-quantity ',name (quantity-expr-eval ,expr #f))))
    38 
    39 
    40 (define (binop-fold op lst)
     467(define-syntax define-quantity
     468  (lambda (x r c)
     469    (let ((name (cadr x))
     470          (expr (caddr x))
     471          (%define (r 'define))
     472          (make-quantity (r 'make-quantity))
     473          (quantity-expr-eval (r 'quantity-expr-eval)))
     474      `(,%define ,name (,make-quantity ',name (,quantity-expr-eval ,expr #f))))))
     475
     476
     477(define-for-syntax (binop-fold op lst)
    41478  (if (null? lst) lst
    42479      (match lst
     
    46483             ((x . rest) `(,op ,x ,(binop-fold op rest))))))
    47484
    48 (define-macro (unit-factor-eval expr)
    49   (match expr
    50          ((op x y)  `(let ((x1  (unit-factor-eval ,x))
    51                            (y1  (unit-factor-eval ,y)))
    52                            ,(case op
    53                               ((*)     `(* x1 y1))
    54                               ((/)     `(/ x1 y1))
    55                               (else (unitconv:error 'unit-factor-eval ": unknown unit factor operation " op)))))
    56 
    57          ((op x . y) `(unit-factor-eval ,(binop-fold op (cons x y))))
    58          
    59          (x         `(cond ((unit? ,x)   
    60                             (unit-factor ,x))
    61                            ((number? ,x)  ,x)
    62                            (else  (unitconv:error 'unit-factor-eval ": unknown unit " ,x))))))
     485
     486(define-syntax unit-factor-eval
     487  (lambda (x r c)
     488    (let ((expr (cadr x))
     489          (%let       (r 'let))
     490          (%cond      (r 'cond))
     491          (%else      (r 'else))
     492          (x1         (r 'x1))
     493          (y1         (r 'y1))
     494          (unit?        (r 'unit?))
     495          (unit-factor  (r 'unit-factor))
     496          (number?      (r 'number?)))
     497      (match expr
     498             ((op x y) 
     499              `(,%let ((,x1  (unit-factor-eval ,x))
     500                       (,y1  (unit-factor-eval ,y)))
     501                 ,(case op
     502                    ((*)     `(* ,x1 ,y1))
     503                    ((/)     `(/ ,x1 ,y1))
     504                    (else (unitconv:error 'unit-factor-eval ": unknown unit factor operation " op)))))
     505             
     506             ((op x . y)
     507              `(unit-factor-eval ,(binop-fold op (cons x y))))
     508             
     509             (x         `(cond ((,unit? ,x)   
     510                                (,unit-factor ,x))
     511                               ((,number? ,x)  ,x)
     512                               (else  (unitconv:error 'unit-factor-eval ": unknown unit " ,x))))))))
    63513         
    64514 
    65515
    66 (define-macro (define-unit name dims factor . abbrevs)
    67   `(define ,name (make-unit ',name ,dims (unit-factor-eval ,factor) ',abbrevs)))
    68 
    69 
    70 (define-macro (make-unit-prefix prefix unit . abbrevs)
    71   `(unit-prefix ,prefix ,unit ',abbrevs))
     516(define-syntax define-unit
     517  (lambda (x r c)
     518    (let ((name (cadr x))
     519          (dims (caddr x))
     520          (factor (cadddr x))
     521          (abbrevs (cddddr x))
     522          (%define (r 'define)))
     523      `(,%define ,name (make-unit ',name ,dims (unit-factor-eval ,factor) ',abbrevs)))))
     524
     525
     526(define-syntax make-unit-prefix
     527  (lambda (x r c)
     528    (let ((prefix (cadr x))
     529          (unit (caddr x))
     530          (abbrevs (cdddr x)))
     531      `(unit-prefix ,prefix ,unit ',abbrevs))))
    72532
    73533
     
    113573;;
    114574(define-quantity    Frequency     (/ Unity Time))
     575
     576;;
     577;; Information
     578;;
     579(define-quantity    Rate          (/ Information Time))
    115580
    116581
     
    139604(define-unit yotta  Unity  1.0e24)
    140605
     606;; IEC standard prefixes
     607(define-unit kibi   Unity  1024)
     608(define-unit mebi   Unity  1048576)
     609(define-unit gibi   Unity  1073741824)
     610(define-unit tebi   Unity  1099511627776)
     611(define-unit pebi   Unity  1125899906842624)
     612(define-unit exbi   Unity  1152921504606846976)
     613(define-unit zebi   Unity  1180591620717411303424)
     614(define-unit yobi   Unity  1208925819614629174706176)
     615
    141616;; Time multiples
    142617(define-unit twelve Unity 12)
     
    244719(define-unit degK       Temperature  1.0       K)
    245720
     721;; Units of information quantity, evidence, and information entropy
     722
     723;; bit = log_2(p)     (Shannon)
     724(define-unit bit      Information  1                 b bits
     725  shannon shannons Sh)
     726
     727;; byte = 8 bits
     728(define-unit byte     Information  8                 B bytes)
     729
     730;; nat = log_e(p)     (Boulton and Wallace)
     731(define-unit nat      Information  1.44269504088896  nats
     732  nit nits
     733  nepit nepits)
     734
     735;; ban = log_10(p)    (Hartley, Turing, and Good)
     736(define-unit ban      Information  3.32192809488736  bans
     737  hartley hartleys
     738  Hart Harts
     739  dit dits)
     740
     741;; The deciban is the smallest weight of evidence discernible by a human
     742;; deciban = 10*log_10(p)
     743(define-unit deciban  Information  (/ ban 10)        db decibans)
     744
     745;; bits
     746(define kilobit   (make-unit-prefix kilo  bit   kb kilobits))
     747(define megabit   (make-unit-prefix mega  bit   Mb megabits))
     748(define gigabit   (make-unit-prefix giga  bit   Gb gigabits))
     749(define terabit   (make-unit-prefix tera  bit   Tb terabits))
     750(define petabit   (make-unit-prefix peta  bit   Pb petabits))
     751(define exabit    (make-unit-prefix exa   bit   Eb exabits))
     752(define zettabit  (make-unit-prefix zetta bit   Zb zettabits))
     753(define yottabit  (make-unit-prefix yotta bit   Yb yottabits))
     754(define kibibit   (make-unit-prefix kibi  bit   Kib kibibits))
     755(define mebibit   (make-unit-prefix mebi  bit   Mib mebibits))
     756(define gibibit   (make-unit-prefix gibi  bit   Gib gibibits))
     757(define tebibit   (make-unit-prefix tebi  bit   Tib tebibits))
     758(define pebibit   (make-unit-prefix pebi  bit   Pib pebibits))
     759(define exbibit   (make-unit-prefix exbi  bit   Eib exbibits))
     760(define zebibit   (make-unit-prefix zebi  bit   Zib zebibits))
     761(define yobibit   (make-unit-prefix yobi  bit   Yib yobibits))
     762
     763;; bytes
     764(define kilobyte  (make-unit-prefix kilo  byte  kB kilobytes))
     765(define megabyte  (make-unit-prefix mega  byte  MB megabytes))
     766(define gigabyte  (make-unit-prefix giga  byte  GB gigabytes))
     767(define terabyte  (make-unit-prefix tera  byte  TB terabytes))
     768(define petabyte  (make-unit-prefix peta  byte  PB petabytes))
     769(define exabyte   (make-unit-prefix exa   byte  EB exabytes))
     770(define zettabyte (make-unit-prefix zetta byte  ZB zettabytes))
     771(define yottabyte (make-unit-prefix yotta byte  YB yottabytes))
     772(define kibibyte  (make-unit-prefix kibi  byte  KiB kibibytes))
     773(define mebibyte  (make-unit-prefix mebi  byte  MiB mebibytes))
     774(define gibibyte  (make-unit-prefix gibi  byte  GiB gibibytes))
     775(define tebibyte  (make-unit-prefix tebi  byte  TiB tebibytes))
     776(define pebibyte  (make-unit-prefix pebi  byte  PiB pebibytes))
     777(define exbibyte  (make-unit-prefix exbi  byte  EiB exbibytes))
     778(define zebibyte  (make-unit-prefix zebi  byte  ZiB zebibytes))
     779(define yobibyte  (make-unit-prefix yobi  byte  YiB yobibytes))
     780
     781;; bit rates
     782(define-unit       bits-per-second  Rate  (/ bit       second)  bps)
     783(define-unit   kilobits-per-second  Rate  (/ kilobit   second)  kbps)
     784(define-unit   megabits-per-second  Rate  (/ megabit   second)  Mbps)
     785(define-unit   gigabits-per-second  Rate  (/ gigabit   second)  Gbps)
     786(define-unit   terabits-per-second  Rate  (/ terabit   second)  Tbps)
     787(define-unit   petabits-per-second  Rate  (/ petabit   second)  Pbps)
     788(define-unit    exabits-per-second  Rate  (/ exabit    second)  Ebps)
     789(define-unit  zettabits-per-second  Rate  (/ zettabit  second)  Zbps)
     790(define-unit  yottabits-per-second  Rate  (/ yottabit  second)  Ybps)
     791
     792;; byte rates
     793(define-unit      bytes-per-second  Rate  (/ byte      second)  Bps)
     794(define-unit  kilobytes-per-second  Rate  (/ kilobyte  second)  kBps)
     795(define-unit  megabytes-per-second  Rate  (/ megabyte  second)  MBps)
     796(define-unit  gigabytes-per-second  Rate  (/ gigabyte  second)  GBps)
     797(define-unit  terabytes-per-second  Rate  (/ terabyte  second)  TBps)
     798(define-unit  petabytes-per-second  Rate  (/ petabyte  second)  PBps)
     799(define-unit   exabytes-per-second  Rate  (/ exabyte   second)  EBps)
     800(define-unit zettabytes-per-second  Rate  (/ zettabyte second)  ZBps)
     801(define-unit yottabytes-per-second  Rate  (/ yottabyte second)  YBps)
     802
     803)
  • release/4/unitconv/trunk/unitconv.setup

    r6904 r14575  
    1 
    2 (define has-exports? (string>=? (chicken-version) "2.310"))
     1;; -*- Hen -*-
    32
    43(define (dynld-name fn)         
    54  (make-pathname #f fn ##sys#load-dynamic-extension))   
    65
    7 (compile -O2 -d0 -o ,(dynld-name "unit-support") -s
    8          ,@(if has-exports? '(-check-imports -emit-exports unit-support.exports) '())
    9          unit-support.scm)
     6(compile -O2 -d0 -s unitconv -j unitconv)
     7(compile -O2 -d0 -s unitconv.import)
    108
    119(run (csi -qbs unitconv-eggdoc.scm > unitconv.html))
     
    1311(install-extension
    1412 'unitconv
    15  `( ,(dynld-name "unit-support") "unitconv.scm"  "unitconv.html"
    16    ,@(if has-exports? '("unit-support.exports") (list)) )
    17  `((version 1.0)
    18    (syntax)
    19    (require-at-runtime unit-support)
     13 `( ,(dynld-name "unitconv") ,(dynld-name "unitconv.import")  )   
     14 `((version 1.5)
    2015   (documentation "unitconv.html")))
Note: See TracChangeset for help on using the changeset viewer.