blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
171
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
8
| license_type
stringclasses 2
values | repo_name
stringlengths 6
82
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 13
values | visit_date
timestamp[ns] | revision_date
timestamp[ns] | committer_date
timestamp[ns] | github_id
int64 1.59k
594M
⌀ | star_events_count
int64 0
77.1k
| fork_events_count
int64 0
33.7k
| gha_license_id
stringclasses 12
values | gha_event_created_at
timestamp[ns] | gha_created_at
timestamp[ns] | gha_language
stringclasses 46
values | src_encoding
stringclasses 14
values | language
stringclasses 2
values | is_vendor
bool 2
classes | is_generated
bool 1
class | length_bytes
int64 4
7.87M
| extension
stringclasses 101
values | filename
stringlengths 2
149
| content
stringlengths 4
7.87M
| has_macro_def
bool 2
classes |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
6e29551692ca87e089836baa6ba286ebfb32a049 | 80c8c43dd7956bb78a0c586ea193e3114de31046 | /ex-1-35_40.scm | 4a64ed4b11638fe75a20cf3e9769f5edb2e7e14e | []
| no_license | UeharaYou/Learning-SICP | 78b9d29e6a84a0890ec9788073160c3f7fd8a231 | 3a6cf413a313d7249e121bdd1515e374d2a369ea | refs/heads/master | 2021-04-05T14:00:36.752016 | 2020-03-19T17:27:39 | 2020-03-19T17:27:39 | 248,564,129 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 528 | scm | ex-1-35_40.scm | ;; SICP Exercise: 1.35-1.40
;; Dependencies: txt-1-3.scm
(define (cout-frac-iter n d k)
(define (inner i result)
(cond ((< i 1) result)
(else (inner (- i 1) (/ (n i) (+ result (d i)))))))
(inner k 0))
(define (cout-frac-rec n d k)
(define (inner i)
(cond ((> i k) 0)
(else (/ (n i) (+ (d i) (inner (+ i 1)))))))
(inner 1))
(define (gen-tan iter);; -> (tan x)
(lambda (x) (cout-frac-iter (lambda (i) (if (= i 1) x (- (* x x)))) (lambda (i) (- (* i 2) 1)) iter))) | false |
444cb51110737432696beed0709642b0a8d31479 | 382770f6aec95f307497cc958d4a5f24439988e6 | /projecteuler/004/004.scm | 35eaa308bf2e90b82569e25be25a19dd8f0ed619 | [
"Unlicense"
]
| permissive | include-yy/awesome-scheme | 602a16bed2a1c94acbd4ade90729aecb04a8b656 | ebdf3786e54c5654166f841ba0248b3bc72a7c80 | refs/heads/master | 2023-07-12T19:04:48.879227 | 2021-08-24T04:31:46 | 2021-08-24T04:31:46 | 227,835,211 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 926 | scm | 004.scm | (define get-num
(lambda (a)
(reverse
(let f ([a a])
(cond
((zero? a)'())
(else
(cons (remainder a 10)
(f (/(- a(remainder a 10))10)))))))))
(define palind?
(lambda (num)
(let ([num-ls (get-num num)])
(equal? (reverse num-ls) num-ls))))
(let process ([i 100] [biggest 0])
(cond
((> i 999) biggest)
(else
(let f ([j 100] [big 0])
(cond
((> j 999)
(if (> big biggest)
(process (+ i 1) big)
(process (+ i 1) biggest)))
(else
(let ((now (* i j)))
(cond
((palind? now)
(if (> now big)
(f (+ j 1) now)
(f (+ j 1) big)))
(else
(f (+ j 1) big))))))))))
#|
(time (let process ...))
27 collections
0.218750000s elapsed cpu time, including 0.000000000s collecting
0.222798868s elapsed real time, including 0.000627372s collecting
113261800 bytes allocated, including 113700288 bytes reclaimed
906609
|#
| false |
b05b95c67f09880644007447b247ac69ff91445f | 710e486f87b70e57cc3c2a411d12c30644544b75 | /show/numeric.sld | aa8b725491f1194e06afcccd3434e56f846bb3cf | [
"BSD-3-Clause",
"MIT",
"LicenseRef-scancode-unknown-license-reference",
"BlueOak-1.0.0"
]
| permissive | ar-nelson/schemepunk | 6236a3200343257a9ce15a6e3f4bda1dd450c729 | 249bf057b256bbb9212f60345a84d84615c61893 | refs/heads/master | 2021-05-18T07:47:36.721609 | 2021-04-24T17:05:48 | 2021-04-24T17:05:48 | 251,185,680 | 92 | 7 | NOASSERTION | 2021-05-12T14:07:38 | 2020-03-30T02:53:33 | Scheme | UTF-8 | Scheme | false | false | 13,264 | sld | numeric.sld | (define-library (schemepunk show numeric)
(export numeric->string numeric->string/si)
(import (scheme base)
(scheme char)
(scheme complex)
(scheme inexact)
(scheme write)
(schemepunk syntax)
(schemepunk list)
(schemepunk string))
(begin
;; string utilities
(define (string-replace-all str ch1 ch2)
(with-output-to-string (λ()
(string-for-each
(λ ch (display (if (eqv? ch ch1) ch2 ch)))
str))))
(define (string-intersperse-right str sep rule)
(let lp ((i (string-length str))
(rule rule)
(res '()))
(let* ((offset (if (pair? rule) (car rule) rule))
(i2 (if offset (- i offset) 0)))
(if (is i2 <= 0)
(apply string-append (cons (string-copy str 0 i) res))
(lp i2
(if (and (pair? rule) (not (null? (cdr rule))))
(cdr rule)
rule)
(cons sep (cons (string-copy str i2 i) res)))))))
;; numeric formatting
(define (char-mirror c)
(case c ((#\() #\)) ((#\[) #\]) ((#\{) #\}) ((#\<) #\>) (else c)))
(define (integer-log a base)
(if (zero? a)
0
;; (exact (ceiling (/ (log (+ a 1)) (log base))))
(do ((ndigits 1 (+ ndigits 1))
(p base (* p base)))
((is p > a) ndigits))))
;; General formatting utilities.
(define (get-scale q radix)
(expt radix (- (integer-log q radix) 1)))
(define (char-digit d)
(cond ((char? d) d)
((is d < 10) (integer->char (+ d (char->integer #\0))))
(else (integer->char (+ (- d 10) (char->integer #\a))))))
(define (round-up ls radix)
(let lp ((ls ls) (res '()))
(cond
((null? ls)
(cons 1 res))
((not (number? (car ls)))
(lp (cdr ls) (cons (car ls) res)))
((= (car ls) (- radix 1))
(lp (cdr ls) (cons 0 res)))
(else
(append (reverse res) (cons (+ 1 (car ls)) (cdr ls)))))))
(define (maybe-round n d ls radix)
(let* ((q (quotient n d))
(digit (* 2 (if (is q >= radix)
(quotient q (get-scale q radix))
q))))
(if (or (is digit > radix)
(and (is digit = radix)
(let ((prev (find integer? ls)))
(and prev (odd? prev)))))
(round-up ls radix)
ls)))
(define (maybe-trim-zeros i res inexact? precision dec-ls)
(if (and (not precision) (positive? i))
(let lp ((res res))
(cond
((and (pair? res) (eqv? 0 (car res))) (lp (cdr res)))
((and (pair? res)
(eqv? (car dec-ls) (car res))
(null? (cdr dec-ls)))
(if inexact?
(cons 0 res) ; "1.0"
(cdr res))) ; "1"
(else res)))
res))
;; General slow loop to generate digits one at a time, for
;; non-standard radixes or writing rationals with a fixed
;; precision.
(define (display-general n-orig radix precision dec-sep)
(let* ((p (exact n-orig))
(n (numerator p))
(d (denominator p))
(dec-ls (if (char? dec-sep)
(list dec-sep)
(reverse (string->list dec-sep)))))
(let lp ((n n)
(i (if (zero? p) -1 (- (integer-log p radix))))
(res '()))
(cond
;; Use a fixed precision if specified, otherwise generate
;; 15 decimals.
((is i < (or precision 16))
(let ((res (if (zero? i)
(append dec-ls (if (null? res) (cons 0 res) res))
res))
(q (quotient n d)))
(cond
((is i < -1)
(let* ((scale (expt radix (- -1 i)))
(digit (quotient q scale))
(n2 (- n (* d digit scale))))
(lp n2 (+ i 1) (cons digit res))))
(else
(lp (* (remainder n d) radix)
(+ i 1)
(cons q res))))))
(else
(chain (maybe-round n d res radix)
(maybe-trim-zeros i _ (inexact? n-orig) precision dec-ls)
(reverse _)
(map char-digit _)
(list->string _)))))))
;; Generate a fixed precision decimal result by post-editing the
;; result of string->number.
(define (display-fixed n radix precision dec-sep)
(cond
((and (eqv? radix 10) (zero? precision) (inexact? n))
(number->string (exact (round n))))
((and (eqv? radix 10) (or (integer? n) (inexact? n)))
(let* ((s (number->string n))
(end (string-length s))
(dec (string-index s (is _ char=? #\.)))
(digits (and dec (- end dec))))
(cond
((string-index s (is _ char=? #\e))
(display-general n radix precision dec-sep))
((not digits)
(string-append s (if (char? dec-sep) (string dec-sep) dec-sep)
(make-string precision #\0)))
((is digits <= precision)
(string-append s (make-string (- precision digits -1) #\0)))
(else
(let* ((last (- end (- digits precision 1)))
(res (string-copy s 0 last)))
(if (and
(is last < end)
(let1 next (digit-value (string-ref s last))
(or (is next > 5)
(and (is next = 5)
(is last > 0)
(memv (digit-value (string-ref s (- last 1)))
'(1 3 5 7 9))))))
(chain (string->list res)
(map digit-value _)
(reverse _)
(round-up _ radix)
(map char-digit _)
(reverse _)
(list->string _))
res))))))
(else
(display-general n radix precision dec-sep))))
;; Generate any unsigned real number.
(define (display-positive-real n radix precision dec-sep)
(cond
(precision
(display-fixed n radix precision dec-sep))
((memv radix (if (exact? n) '(2 8 10 16) '(10)))
(number->string n radix))
(else
(display-general n radix precision dec-sep))))
;; Insert commas according to the current comma-rule.
(define (insert-commas str comma-rule comma-sep dec-sep)
(let* ((dec-pos (or (if (string? dec-sep)
(string-contains str dec-sep)
(string-index str (is _ char=? dec-sep)))
(string-length str)))
(left (string-copy str 0 dec-pos))
(right (string-copy str dec-pos))
(sep (cond ((char? comma-sep) (string comma-sep))
((string? comma-sep) comma-sep)
((eqv? #\, dec-sep) ".")
(else ","))))
(string-append
(string-intersperse-right left sep comma-rule)
right)))
(define-syntax is-neg-zero?
(syntax-rules ()
((_ n)
(is-neg-zero? (-0.0) n))
((_ (0.0) n) ; -0.0 is not distinguished?
#f)
((_ (-0.0) n)
(eqv? -0.0 n))))
(define (negative?* n)
(or (negative? n)
(is-neg-zero? n)))
(define+ (numeric->string n
:optional
(radix 10)
(precision #f)
(sign-rule #f)
(comma-rule #f)
(comma-sep #\,)
(decimal-sep #f)
(decimal-align #f))
(define dec-sep (or decimal-sep (if (eqv? comma-sep #\.) #\, #\.)))
;; Post-process a positive real number with decimal char fixup
;; and commas as needed.
(define (wrap-comma n)
(if (and (not precision) (exact? n) (not (integer? n)))
(string-append (wrap-comma (numerator n))
"/"
(wrap-comma (denominator n)))
(let* ((s0 (display-positive-real n radix precision dec-sep))
(s1 (if (or (eqv? #\. dec-sep)
(equal? "." dec-sep))
s0
(string-replace-all s0 #\. dec-sep))))
(if comma-rule
(insert-commas s1 comma-rule comma-sep dec-sep)
s1))))
;; Wrap the sign of a real number, forcing a + prefix or using
;; parentheses (n) for negatives according to sign-rule.
(define (wrap-sign n sign-rule)
(cond
((negative?* n)
(cond
((char? sign-rule)
(string-append (string sign-rule)
(wrap-comma (- n))
(string (char-mirror sign-rule))))
((pair? sign-rule)
(string-append (car sign-rule)
(wrap-comma (- n))
(cdr sign-rule)))
(else
(string-append "-" (wrap-comma (- n))))))
((eq? #t sign-rule)
(string-append "+" (wrap-comma n)))
(else
(wrap-comma n))))
;; Format a single real number with padding as necessary.
(define (display-real n sign-rule)
(cond
((finite? n)
(let* ((s (wrap-sign n sign-rule))
(dec-pos (if decimal-align
(or (if (string? dec-sep)
(string-contains s dec-sep)
(string-index s (is _ char=? dec-sep)))
(string-length s))
0))
(diff (- (or decimal-align 0) dec-pos 1)))
(if (positive? diff)
(string-append (make-string diff #\space) s)
s)))
(else
(number->string n))))
;; Write any number.
(cond
((and radix (not (and (integer? radix) (<= 2 radix 36))))
(error "invalid radix for numeric formatting" radix))
((zero? (imag-part n))
(display-real (real-part n) sign-rule))
(else
(string-append (display-real (real-part n) sign-rule)
(display-real (imag-part n) #t)
"i"))))
(define si-scale
(let* ((names10 #("" "k" "M" "G" "T" "E" "P" "Z" "Y"))
(names-10 #("" "m" "µ" "n" "p" "f" "a" "z" "y"))
(names2 (vector-map
(matchλ ("" "") ("k" "Ki") (s (string-append s "i")))
names10))
(names-2 (vector-map
(matchλ ("" "") (s (string-append s "i")))
names-10)))
(define (round-to n k)
(/ (round (* n k)) k))
(λ (n base)
(let* ((log-n (log n))
(names (if (negative? log-n)
(if (= base 1024) names-2 names-10)
(if (= base 1024) names2 names10)))
(k (min (exact ((if (negative? log-n) ceiling floor)
(/ (abs log-n) (log base))))
(- (vector-length names) 1)))
(n2 (round-to (/ n (expt base (if (negative? log-n) (- k) k)))
10)))
(values (if (integer? n2) (exact n2) (inexact n2))
(vector-ref names k))))))
(define+ (numeric->string/si n
:optional
(base 1000)
(separator "")
(radix 10)
(precision #f)
(sign-rule #f)
(comma-rule #f)
(comma-sep #\,)
(decimal-sep #f)
(decimal-align #f))
(let1-values (scaled suffix) (si-scale n base)
; TODO: Apply decimal-align after appending suffix
(string-append (numeric->string scaled
radix
precision
sign-rule
comma-rule
comma-sep
decimal-sep
decimal-align)
separator
suffix)))))
| true |
b79bfe098d77e01f843728cd0e3776fc9562afaa | a8216d80b80e4cb429086f0f9ac62f91e09498d3 | /lib/srfi/41.scm | 4392f97ad06068bdb6198754c764d9c7e74421ad | [
"BSD-3-Clause"
]
| permissive | ashinn/chibi-scheme | 3e03ee86c0af611f081a38edb12902e4245fb102 | 67fdb283b667c8f340a5dc7259eaf44825bc90bc | refs/heads/master | 2023-08-24T11:16:42.175821 | 2023-06-20T13:19:19 | 2023-06-20T13:19:19 | 32,322,244 | 1,290 | 223 | NOASSERTION | 2023-08-29T11:54:14 | 2015-03-16T12:05:57 | Scheme | UTF-8 | Scheme | false | false | 10,503 | scm | 41.scm |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; primitive layer adapted from SRFI 41 reference impl
(define-record-type Stream
(make-stream promise)
stream?
(promise stream-promise))
(define-record-type Stream-null
(make-stream-null)
%stream-null?)
(define-record-type Stream-pair
(make-stream-pair head tail)
%stream-pair?
(head %stream-car)
(tail %stream-cdr))
(define stream-null (make-stream (make-promise (make-stream-null))))
(define-syntax stream-cons
(syntax-rules ()
((stream-cons object stream)
(make-stream
(make-promise
(make-stream-pair
(delay object)
(delay-force (stream-promise stream))))))))
(define (stream-null? stream)
(and (stream? stream)
(%stream-null? (force (stream-promise stream)))))
(define (stream-pair? stream)
(and (stream? stream)
(%stream-pair? (force (stream-promise stream)))))
(define (stream-car stream)
(force (%stream-car (force (stream-promise stream)))))
(define (stream-cdr stream)
(let ((t (force (%stream-cdr (force (stream-promise stream))))))
(make-stream (make-promise t))))
(define-syntax stream-lambda
(syntax-rules ()
((stream-lambda formals body0 body1 ...)
(lambda formals
(make-stream
(delay-force (stream-promise (let () body0 body1 ...))))))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; derived
(define-syntax assert
(syntax-rules ()
((assert expr ...)
(begin (unless expr (error "assertion failed" 'expr)) ...))))
(define-syntax define-stream
(syntax-rules ()
((define-stream (name . args) e0 e1 ...)
(define name
(stream-lambda args e0 e1 ...)))))
(define-syntax stream-let
(syntax-rules ()
((stream-let lp ((name val) ...) e0 e1 ...)
((letrec ((lp (stream-lambda (name ...) e0 e1 ...))) lp)
val ...))))
(define-syntax stream
(syntax-rules ()
((stream) stream-null)
((stream x y ...) (stream-cons x (stream y ...)))))
(define (list->stream ls)
(assert (list? ls))
(let lp ((ls (reverse ls)) (res stream-null))
(if (null? ls)
res
(lp (cdr ls) (stream-cons (car ls) res)))))
(define (port->stream in)
(assert (input-port? in))
(let lp ()
(let ((ch (read-char in)))
(if (eof-object? ch)
stream-null
(stream-cons ch (lp))))))
(define (stream->list x . o)
(let ((n (if (pair? o) x +inf.0)))
(assert (not (negative? n)))
(let lp ((i 0)
(strm (if (pair? o) (car o) x))
(res '()))
(if (or (>= i n) (stream-null? strm))
(reverse res)
(lp (+ i 1)
(stream-cdr strm)
(cons (stream-car strm) res))))))
(define (stream-concat strms)
(assert (stream? strms))
(if (stream-null? strms)
stream-null
(let lp ((strm (stream-car strms))
(strms (stream-cdr strms)))
(assert (stream? strm))
(cond
((stream-null? strm)
(if (stream-null? strms)
stream-null
(lp (stream-car strms) (stream-cdr strms))))
(else
(stream-cons (stream-car strm)
(lp (stream-cdr strm) strms)))))))
(define (stream-append . strms)
(stream-concat (list->stream strms)))
(define (stream-from n . o)
(let ((step (if (pair? o) (car o) 1)))
(assert (number? n) (number? step))
(let lp ((n n))
(stream-cons n (lp (+ n step))))))
(define (stream-range first past . o)
(let ((step (if (pair? o) (car o) (if (< first past) 1 -1))))
(assert (number? first) (number? past) (number? step))
(if (positive? step)
(stream-let lp ((n first))
(if (< n past)
(stream-cons n (lp (+ n step)))
stream-null))
(stream-let lp ((n first))
(if (> n past)
(stream-cons n (lp (+ n step)))
stream-null)))))
(define (stream-constant . o)
(let lp ((ls o))
(if (null? ls)
(lp o)
(stream-cons (car ls) (lp (cdr ls))))))
(define (stream-ref strm k)
(assert (stream? strm) (integer? k) (not (negative? k)))
(if (positive? k)
(stream-ref (stream-cdr strm) (- k 1))
(stream-car strm)))
(define (stream-length strm)
(assert (stream? strm))
(let lp ((strm strm) (len 0))
(if (stream-null? strm)
len
(lp (stream-cdr strm) (+ len 1)))))
(define (stream-drop k strm)
(assert (integer? k) (not (negative? k)) (stream? strm))
(stream-let drop ((k k) (strm strm))
(if (or (zero? k) (stream-null? strm))
strm
(drop (- k 1) (stream-cdr strm)))))
(define (stream-drop-while pred? strm)
(assert (procedure? pred?) (stream? strm))
(stream-let drop-while ((strm strm))
(if (or (stream-null? strm) (not (pred? (stream-car strm))))
strm
(drop-while (stream-cdr strm)))))
(define (stream-filter pred? strm)
(assert (procedure? pred?) (stream? strm))
(stream-let filter ((strm strm))
(cond ((stream-null? strm) stream-null)
((pred? (stream-car strm))
(stream-cons (stream-car strm) (filter (stream-cdr strm))))
(else not (filter (stream-cdr strm))))))
(define (stream-for-each proc strm)
(assert (procedure? proc) (stream? strm))
(when (stream-pair? strm)
(proc (stream-car strm))
(stream-for-each proc (stream-cdr strm))))
(define (stream-fold kons knil strm)
(assert (procedure? kons) (stream? strm))
(let fold ((acc knil) (strm strm))
(if (stream-null? strm)
acc
(fold (kons (stream-car strm) acc) (stream-cdr strm)))))
(define (stream-scan proc base strm)
(assert (procedure? proc) (stream? strm))
(stream-let scan ((acc base) (strm strm))
(if (stream-null? strm)
(stream acc)
(stream-cons acc
(scan (proc acc (stream-car strm))
(stream-cdr strm))))))
(define (stream-map proc strm . o)
(assert (procedure? proc) (stream? strm))
(if (pair? o)
(stream-let lp ((strms (cons strm o)))
(if (any stream-null? strms)
stream-null
(stream-cons (apply proc (map stream-car strms))
(lp (map stream-cdr strms)))))
(stream-let lp ((strm strm))
(if (stream-null? strm)
stream-null
(stream-cons (proc (stream-car strm))
(lp (stream-cdr strm)))))))
(define (stream-iterate proc base)
(assert (procedure? proc))
(stream-let iterate ((base base))
(stream-cons base (iterate (proc base)))))
(define (stream-take k strm)
(assert (integer? k) (not (negative? k)) (stream? strm))
(stream-let take ((k k) (strm strm))
(if (and (positive? k) (stream-pair? strm))
(stream-cons (stream-car strm) (take (- k 1) (stream-cdr strm)))
stream-null)))
(define (stream-take-while pred strm)
(assert (procedure? pred) (stream? strm))
(stream-let take-while ((strm strm))
(if (and (stream-pair? strm) (pred (stream-car strm)))
(stream-cons (stream-car strm) (take-while (stream-cdr strm)))
stream-null)))
(define-syntax stream-of
(syntax-rules ()
((stream-of expr . clauses)
(stream-of/aux expr stream-null . clauses))))
(define-syntax stream-of/aux
(syntax-rules (in is)
((stream-of/aux expr tail)
(stream-cons expr tail))
((stream-of/aux expr tail (var in s) . rest)
(stream-let lp ((strm s))
(if (stream-null? strm)
tail
(let ((var (stream-car strm)))
(stream-of/aux expr (lp (stream-cdr strm)) . rest)))))
((stream-of/aux expr tail (var is e) . rest)
(let ((var e))
(stream-of/aux expr tail . rest)))
((stream-of/aux expr tail pred . rest)
(if pred (stream-of/aux expr tail . rest) tail))))
(define (stream-reverse strm)
(list->stream (reverse (stream->list strm))))
(define (stream-unfold mapper pred gen base)
(assert (procedure? mapper) (procedure? pred) (procedure? gen))
(stream-let unfold ((base base))
(if (pred base)
(stream-cons (mapper base) (unfold (gen base)))
stream-null)))
(define (stream-unfolds proc seed)
(assert (procedure? proc))
(let ((strm (stream-let lp ((seed seed))
(call-with-values
(lambda () (proc seed))
(lambda ls
(stream-cons (cdr ls)
(lp (car ls))))))))
(apply values
(map (lambda (i)
(stream-let lp ((strm strm))
(let ((x (list-ref (stream-car strm) i)))
(cond
((null? x) stream-null)
((pair? x) (stream-cons (car x) (lp (stream-cdr strm))))
(else (lp (stream-cdr strm)))))))
(iota (length (stream-car strm)))))))
(define (stream-zip strm . o)
(assert (stream? strm) (every stream? o))
(stream-let lp ((strms (cons strm o)))
(if (every stream-pair? strms)
(stream-cons (map stream-car strms)
(lp (map stream-cdr strms)))
stream-null)))
(define-syntax stream-match
(syntax-rules ()
((stream-match expr clause ...)
(let ((strm expr))
(assert (stream? strm))
(stream-match-next strm clause ...)))))
(define-syntax stream-match-next
(syntax-rules ()
((stream-match-next strm)
(error "no pattern matched"))
((stream-match-next strm clause . clauses)
(let ((fail (lambda () (stream-match-next strm . clauses))))
(stream-match-one strm clause (fail))))))
(define-syntax stream-match-one
(syntax-rules (_)
((stream-match-one strm (() . body) fail)
(if (stream-null? strm)
(stream-match-body fail . body)
fail))
((stream-match-one strm (_ . body) fail)
(stream-match-body fail . body))
((stream-match-one strm ((a . b) . body) fail)
(if (stream-pair? strm)
(stream-match-one
(stream-car strm)
(a
(stream-match-one (stream-cdr strm) (b . body) fail))
fail)
fail))
((stream-match-one strm (a . body) fail)
(let ((a strm))
(stream-match-body fail . body)))))
(define-syntax stream-match-body
(syntax-rules ()
((stream-match-body fail fender expr)
(if fender expr fail))
((stream-match-body fail expr)
expr)))
;; Local variables:
;; eval: (put 'stream-let 'scheme-indent-function 2)
;; End:
| true |
1ae66bd4363837fdfcbb99916e63f6fa05e846d5 | 2e4afc99b01124a1d69fa4f44126ef274f596777 | /apng/resources/dracula/lang/defun.ss | 99adc5d33ec1a48dd27497cc1bd688b7735f29ff | []
| no_license | directrix1/se2 | 8fb8204707098404179c9e024384053e82674ab8 | 931e2e55dbcc55089d9728eb4194ebc29b44991f | refs/heads/master | 2020-06-04T03:10:30.843691 | 2011-05-05T03:32:54 | 2011-05-05T03:32:54 | 1,293,430 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 2,591 | ss | defun.ss | #|
defun generates macros that check that the defined function is used only in
operator position (or acl2-provide/contract). Also does arity checking.
|#
#lang scheme
(require "constants.ss"
"declare.ss"
"../private/planet.ss"
"check.ss"
scheme/stxparam)
(require (for-syntax "t-or-nil.ss"
scheme/match
(cce function)
(cce syntax)))
(provide defun
defund
defstub
mutual-recursion)
(define-for-syntax (enforce-valid-name! stx v)
(unless (identifier? v)
(raise-syntax-error #f "expected an identifier" stx v))
(when (t-or-nil? v)
(raise-syntax-error #f "cannot bind reserved name" stx v)))
(define-for-syntax (expand-funs orig-stx funs-stx)
(match (syntax-local-context)
['expression
(raise-syntax-error #f
"may not be used as an expression" orig-stx)]
[_ (void)])
(syntax-case funs-stx ()
[((function args body) ...)
(andmap list? (syntax->datum #'(args ...)))
(begin
(for* ([ids (in-list (syntax->list #'((function ...) args ...)))]
[id (in-list (syntax->list ids))])
(enforce-valid-name! orig-stx id))
(with-syntax ([(checked ...) (generate-temporaries #'(function ...))]
[(arity ...) (map length (syntax->datum #'(args ...)))])
(quasisyntax/loc orig-stx
(begin
(define-below-marker-for HERE #,orig-stx)
(define-syntaxes (function ...)
(values (check-below-transformer #'HERE
(check-arity-transformer 'arity
(redirect-transformer #'checked)))
...))
(define-values (checked ...)
(let ([function (lambda args body)] ...)
(values function ...)))))))]))
(define-syntax (defstub stx)
(syntax-case stx ()
[(ds function (arg ...) dummy)
(expand-funs
stx
#'((function (arg ...)
(raise-user-error 'function "cannot execute a stub"))))]))
(define-syntax (defun stx)
(syntax-case stx ()
[(df function (arg ...) doc/declare ... body)
(expand-funs stx #'((function (arg ...) body)))]))
(define-syntax (defund stx)
(syntax-case stx ()
[(df function (arg ...) doc/declare ... body)
(expand-funs stx #'((function (arg ...) body)))]))
(define-syntax (mutual-recursion stx)
(syntax-case stx ()
[(mr (defun function (arg ...) doc/declare ... body) ...)
(expand-funs stx #'((function (arg ...) body) ...))]))
| true |
127ccbf303f5da588b8aa0b9a8160f78af4aeb01 | eef5f68873f7d5658c7c500846ce7752a6f45f69 | /spheres/algorithm/random/pick.sld | 08de91203eabe95188c540b3b97d1c2d9e00c448 | [
"MIT"
]
| permissive | alvatar/spheres | c0601a157ddce270c06b7b58473b20b7417a08d9 | 568836f234a469ef70c69f4a2d9b56d41c3fc5bd | refs/heads/master | 2021-06-01T15:59:32.277602 | 2021-03-18T21:21:43 | 2021-03-18T21:21:43 | 25,094,121 | 13 | 3 | null | null | null | null | UTF-8 | Scheme | false | false | 189 | sld | pick.sld | ;;!!! Reservoir sampling, random selection
;; .author Alvaro Castro-Castilla, 2012-2014
(define-library (spheres/algorithm/random pick)
(export random-pick)
(include "pick.scm"))
| false |
262f5fb9fd9a7e7531835d0007697d81e98eaea9 | defeada37d39bca09ef76f66f38683754c0a6aa0 | /UnityEngine.Networking/unity-engine/networking/network-writer.sls | 58231bdc816f599f5be25b2ffb6574d91960ed81 | []
| no_license | futsuki/ironscheme-port | 2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5 | 4e7a81b0fbeac9a47440464988e53fb118286c54 | refs/heads/master | 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,272 | sls | network-writer.sls | (library (unity-engine networking network-writer)
(export new
is?
network-writer?
finish-message
start-message
write
write-packed-uint32
write-bytes-and-size
as-array
write-packed-uint64
write-bytes-full
seek-zero
to-array
position)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new UnityEngine.Networking.NetworkWriter a ...)))))
(define (is? a) (clr-is UnityEngine.Networking.NetworkWriter a))
(define (network-writer? a)
(clr-is UnityEngine.Networking.NetworkWriter a))
(define-method-port
finish-message
UnityEngine.Networking.NetworkWriter
FinishMessage
(System.Void))
(define-method-port
start-message
UnityEngine.Networking.NetworkWriter
StartMessage
(System.Void System.Int16))
(define-method-port
write
UnityEngine.Networking.NetworkWriter
Write
(System.Void UnityEngine.Networking.MessageBase)
(System.Void UnityEngine.GameObject)
(System.Void UnityEngine.Transform)
(System.Void UnityEngine.Networking.NetworkIdentity)
(System.Void UnityEngine.Networking.NetworkHash128)
(System.Void UnityEngine.Matrix4x4)
(System.Void UnityEngine.Ray)
(System.Void UnityEngine.Plane)
(System.Void UnityEngine.Rect)
(System.Void UnityEngine.Quaternion)
(System.Void UnityEngine.Color32)
(System.Void UnityEngine.Color)
(System.Void UnityEngine.Vector4)
(System.Void UnityEngine.Vector3)
(System.Void UnityEngine.Vector2)
(System.Void System.Byte[] System.Int32 System.Int32)
(System.Void System.Boolean)
(System.Void System.String)
(System.Void System.Double)
(System.Void System.Single)
(System.Void System.UInt64)
(System.Void System.Int64)
(System.Void System.UInt32)
(System.Void System.Int32)
(System.Void System.UInt16)
(System.Void System.Int16)
(System.Void System.SByte)
(System.Void System.Byte)
(System.Void System.Char)
(System.Void UnityEngine.Networking.NetworkSceneId)
(System.Void UnityEngine.Networking.NetworkInstanceId))
(define-method-port
write-packed-uint32
UnityEngine.Networking.NetworkWriter
WritePackedUInt32
(System.Void System.UInt32))
(define-method-port
write-bytes-and-size
UnityEngine.Networking.NetworkWriter
WriteBytesAndSize
(System.Void System.Byte[] System.Int32))
(define-method-port
as-array
UnityEngine.Networking.NetworkWriter
AsArray
(System.Byte[]))
(define-method-port
write-packed-uint64
UnityEngine.Networking.NetworkWriter
WritePackedUInt64
(System.Void System.UInt64))
(define-method-port
write-bytes-full
UnityEngine.Networking.NetworkWriter
WriteBytesFull
(System.Void System.Byte[]))
(define-method-port
seek-zero
UnityEngine.Networking.NetworkWriter
SeekZero
(System.Void))
(define-method-port
to-array
UnityEngine.Networking.NetworkWriter
ToArray
(System.Byte[]))
(define-field-port
position
#f
#f
(property:)
UnityEngine.Networking.NetworkWriter
Position
System.Int16))
| true |
d7e6f312850e0588d31668e56d56c27d1ee6bddb | d3f9aa068d5ce8077b09fca99633d9e411f64af9 | /r6rs-lib/rnrs/records/syntactic-6.rkt | 62d86616cff9494807a2ccbaf6b84b9d17781959 | [
"Apache-2.0",
"MIT",
"SchemeReport",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/r6rs | 2ffcafa4bf70b51d568b3a7c1c1df36f5f557992 | f5e0ddb687c050fec6ecc9786155a40ac3d1cd8f | refs/heads/master | 2023-09-02T21:27:05.684364 | 2022-07-24T20:46:24 | 2022-07-24T20:46:24 | 27,413,096 | 10 | 6 | NOASSERTION | 2021-12-14T15:17:18 | 2014-12-02T03:24:44 | HTML | UTF-8 | Scheme | false | false | 15,089 | rkt | syntactic-6.rkt | #!r6rs
;; Implementation of implicit-naming layer for R6RS Records
;; Based on the SRFI implementation:
; Copyright (C) Michael Sperber (2005). All Rights Reserved.
;
; Permission is hereby granted, free of charge, to any person
; obtaining a copy of this software and associated documentation files
; (the "Software"), to deal in the Software without restriction,
; including without limitation the rights to use, copy, modify, merge,
; publish, distribute, sublicense, and/or sell copies of the Software,
; and to permit persons to whom the Software is furnished to do so,
; subject to the following conditions:
;
; The above copyright notice and this permission notice shall be
; included in all copies or substantial portions of the Software.
;
; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
; BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
; ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
; CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
; SOFTWARE.
(library (rnrs records syntactic (6))
(export define-record-type
record-type-descriptor
record-constructor-descriptor
fields mutable immutable parent parent-rtd protocol
sealed opaque nongenerative)
(import (for (rnrs base (6)) run expand)
(for (rnrs syntax-case (6)) expand)
(rename (r6rs private records-explicit)
(define-record-type define-record-type/explicit)))
(define-syntax define-record-type
;; Just check syntax, then send off to reference implementation
(lambda (stx)
(syntax-case stx ()
[(_ name-spec clause ...)
(with-syntax ([(name parts)
(syntax-case #'name-spec ()
[(name cname pname)
(begin
(if (not (identifier? #'name))
(syntax-violation #f
"expected an identifier for the record type name"
stx
#'name))
(if (not (identifier? #'cname))
(syntax-violation #f
"expected an identifier for the record type constructor name"
stx
#'cname))
(if (not (identifier? #'pname))
(syntax-violation #f
"expected an identifier for the record type predicate name"
stx
#'pname))
#'(name (name cname pname)))]
[name
(identifier? #'name)
#'(name name)]
[_
(syntax-violation #f
(string-append
"expected either an identifier for the record type name"
" or a form (<name-id> <constructor-id> <predicate-id>)")
stx
#'name-spec)])])
(let* ([clauses #'(clause ...)]
[extract (lambda (id)
(let loop ([clauses clauses][found #f])
(cond
[(null? clauses) found]
[(syntax-case (car clauses) ()
[(tag . body)
(free-identifier=? #'tag id)])
(if found
(syntax-violation #f
(string-append "duplicate "
(symbol->string (syntax->datum id))
" clause")
stx
(car clauses))
(loop (cdr clauses) (car clauses)))]
[else
(loop (cdr clauses) found)])))]
[kws (with-syntax ([(kw ...)
#'(fields mutable immutable parent
protocol sealed opaque nongenerative
parent-rtd)])
#'(kw ...))])
(for-each (lambda (clause)
(syntax-case clause ()
[(id . _)
(and (identifier? #'id)
(let loop ([kws kws])
(and (not (null? kws))
(or (free-identifier=? #'id (car kws))
(loop (cdr kws))))))
'ok]
[_
(syntax-violation #f
(string-append
"expected a `mutable', `immutable', `parent',"
" `protocol', `sealed', `opaque', `nongenerative',"
" or `parent-rtd' clause")
stx
clause)]))
clauses)
(if (and (extract #'parent) (extract #'parent-rtd))
(syntax-violation #f
"cannot specify both `parent' and `parent-rtd'"
stx))
(syntax-case (extract #'fields) ()
[#f 'ok]
[(_ spec ...)
(for-each (lambda (spec)
(syntax-case spec (immutable mutable)
[(immutable id acc-id)
(begin
(if (not (identifier? #'id))
(syntax-violation #f
"expected a field-name identifier"
spec
#'id))
(if (not (identifier? #'acc-id))
(syntax-violation #f
"expected a field-accessor identifier"
spec
#'acc-id)))]
[(immutable id)
(if (not (identifier? #'id))
(syntax-violation #f
"expected a field-name identifier"
spec
#'id))]
[(immutable . _)
(syntax-violation #f
"expected one or two identifiers"
spec)]
[(mutable id acc-id set-id)
(begin
(if (not (identifier? #'id))
(syntax-violation #f
"expected a field-name identifier"
spec
#'id))
(if (not (identifier? #'acc-id))
(syntax-violation #f
"expected a field-accessor identifier"
spec
#'acc-id))
(if (not (identifier? #'set-id))
(syntax-violation #f
"expected a field-mutator identifier"
spec
#'set-id)))]
[(mutable id)
(if (not (identifier? #'id))
(syntax-violation #f
"expected a field-name identifier"
spec
#'id))]
[(mutable . _)
(syntax-violation #f
"expected one or three identifiers"
spec)]
[id (identifier? #'id) 'ok]
[_ (syntax-violation #f
"expected an identifier, `immutable' form, or `mutable' form for field"
stx
spec)]))
#'(spec ...))])
(let ([p (extract #'parent)])
(syntax-case p ()
[#f 'ok]
[(_ id) (identifier? #'id) 'ok]
[_ (syntax-violation #f
"expected a single identifier for the parent record type"
p)]))
(let ([p (extract #'parent-rtd)])
(syntax-case p ()
[#f 'ok]
[(_ id cons-id) 'ok]
[_ (syntax-violation #f
"expected two expressions for the parent record type and constructor"
p)]))
(syntax-case (extract #'protocol) ()
[#f 'ok]
[(_ expr) 'ok])
(syntax-case (extract #'sealed) ()
[#f 'ok]
[(_ #f) 'ok]
[(_ #t) 'ok])
(syntax-case (extract #'opaque) ()
[#f 'ok]
[(_ #f) 'ok]
[(_ #t) 'ok])
(syntax-case (extract #'nongenerative) ()
[#f 'ok]
[(_) 'ok]
[(_ id) (identifier? #'id) 'ok])
#'(define-record-type-1 name parts
() clause ...)))])))
(define-syntax define-record-type-1
(syntax-rules (fields)
;; find FIELDS clause
((define-record-type-1 ?record-name ?record-name-spec
(?simple-clause ...)
(fields ?field-spec ...)
?clause ...)
(process-fields-clause (fields ?field-spec ...)
?record-name ?record-name-spec
(?simple-clause ...)
?clause ...))
;; collect all other clauses
((define-record-type-1 ?record-name ?record-name-spec
(?simple-clause ...)
?clause0
?clause ...)
(define-record-type-1 ?record-name ?record-name-spec
(?simple-clause ... ?clause0)
?clause ...))
;; pass it on
((define-record-type-1 ?record-name ?record-name-spec
(?simple-clause ...))
(define-record-type-2 ?record-name ?record-name-spec
(?simple-clause ...)))))
;; syntax-rules part
(define-syntax define-record-type-2
(lambda (form)
(syntax-case form ()
((_ ?record-name (?record-name-2 ?constructor-name ?predicate-name)
(?simple-clause ...))
(syntax
(begin
(define-record-type/explicit (?record-name ?constructor-name ?predicate-name)
?simple-clause ...))))
((_ ?record-name ?record-name-2
(?simple-clause ...))
(with-syntax ((?constructor-name
(datum->syntax (syntax ?record-name)
(string->symbol
(string-append "make-"
(symbol->string
(syntax->datum
(syntax ?record-name)))))))
(?predicate-name
(datum->syntax (syntax ?record-name)
(string->symbol
(string-append (symbol->string
(syntax->datum
(syntax ?record-name)))
"?")))))
(syntax
(define-record-type-2 ?record-name (?record-name ?constructor-name ?predicate-name)
(?simple-clause ...))))))))
(define-syntax process-fields-clause
(lambda (form)
(syntax-case form (fields mutable immutable)
((_ (fields ?field-clause ...)
?record-name ?record-name-spec
(?simple-clause ...)
?clause ...)
(let ((record-name (symbol->string (syntax->datum (syntax ?record-name)))))
(with-syntax
(((?simple-field ...)
(map (lambda (clause)
(syntax-case clause (mutable immutable)
((immutable ?field-name)
(with-syntax ((?accessor-name
(datum->syntax
(syntax ?field-name)
(string->symbol
(string-append record-name "-"
(symbol->string
(syntax->datum
(syntax ?field-name))))))))
(syntax
(immutable ?field-name ?accessor-name))))
((mutable ?field-name)
(with-syntax ((?accessor-name
(datum->syntax
(syntax ?field-name)
(string->symbol
(string-append record-name "-"
(symbol->string
(syntax->datum
(syntax ?field-name)))))))
(?mutator-name
(datum->syntax
(syntax ?field-name)
(string->symbol
(string-append record-name "-"
(symbol->string
(syntax->datum
(syntax ?field-name)))
"-set!")))))
(syntax
(mutable ?field-name ?accessor-name ?mutator-name))))
(?field-name
(identifier? (syntax ?field-name))
(with-syntax ((?accessor-name
(datum->syntax
(syntax ?field-name)
(string->symbol
(string-append record-name "-"
(symbol->string
(syntax->datum
(syntax ?field-name))))))))
(syntax
(immutable ?field-name ?accessor-name))))
(?clause
clause)))
(syntax (?field-clause ...)))))
(syntax
(define-record-type-1
?record-name ?record-name-spec
(?simple-clause ... (fields ?simple-field ...))
?clause ...)))))))))
| true |
f7f3ed3b93c33de12a3ab0b168e4fe2be8328121 | bf1c9803ae38f9aad027fbe4569ccc6f85ba63ab | /chapter_3/3.5.Streams/ex_3.74.scm | 4eeee6fc2c87489c7efaae5481a7f3f9f3eb1301 | []
| no_license | mehese/sicp | 7fec8750d3b971dd2383c240798dbed339d0345a | 611b09280ab2f09cceb2479be98ccc5403428c6c | refs/heads/master | 2021-06-12T04:43:27.049197 | 2021-04-04T22:22:47 | 2021-04-04T22:23:12 | 161,924,666 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,951 | scm | ex_3.74.scm | #lang sicp
;; Imports
(define (stream-car stream)
(car stream))
(define (stream-cdr stream)
(force (cdr stream)))
(define (stream-ref s n)
(if (= n 0)
(stream-car s)
(stream-ref (stream-cdr s) (- n 1))))
(define (stream-map proc . argstreams)
(if (stream-null? (car argstreams))
the-empty-stream
(cons-stream
(apply proc (map stream-car argstreams))
(apply stream-map
(cons proc
(map stream-cdr
argstreams))))))
(define (scale-stream stream factor)
(stream-map
(lambda (x) (* x factor))
stream))
(define (stream-for-each proc s)
(if (stream-null? s)
'done
(begin
(proc (stream-car s))
(stream-for-each proc (stream-cdr s)))))
(define (stream-filter pred stream)
(cond ((stream-null? stream)
the-empty-stream)
((pred (stream-car stream))
(cons-stream
(stream-car stream)
(stream-filter
pred
(stream-cdr stream))))
(else (stream-filter
pred
(stream-cdr stream)))))
(define (display-stream s)
(stream-for-each display-line s))
(define (display-line x)
(newline) (display x))
(define (display-first-n s n)
(define (display-iter substream i)
(if (>= i n)
(newline)
(begin
(newline)
(display (stream-car substream)) (display " ")
(display-iter (stream-cdr substream) (inc i)))))
(display-iter s 0))
(define (add-streams s1 s2) (stream-map + s1 s2))
(define (mul-streams s1 s2) (stream-map * s1 s2))
(define ones (cons-stream 1 ones))
(define integers (cons-stream 1 (add-streams ones integers)))
(define (interleave s1 s2)
(if (stream-null? s1)
s2
(cons-stream
(stream-car s1)
(interleave s2 (stream-cdr s1)))))
(define (pairs s t)
(cons-stream
(list (stream-car s) (stream-car t))
(interleave
(stream-map (lambda (x)
(list (stream-car s) x))
(stream-cdr t))
(pairs (stream-cdr s) (stream-cdr t)))))
(define (merge-weighed s1 s2 w-fun)
(cond ((stream-null? s1) s2)
((stream-null? s2) s1)
(else
(let ((s1car (stream-car s1))
(s2car (stream-car s2)))
(cond ((<= (apply w-fun s1car) (apply w-fun s2car))
(cons-stream
s1car
(merge-weighed (stream-cdr s1)
s2 w-fun)))
((> (apply w-fun s1car) (apply w-fun s2car))
(cons-stream
s2car
(merge-weighed s1
(stream-cdr s2) w-fun)))
(else
(error "Error: dunno what to do with" (list s1car s2car))))))))
(define (integral integrand initial-value dt)
(define int
(cons-stream
initial-value
(add-streams (scale-stream integrand dt)
int)))
int)
;; Problem
(define sense-data (stream-map sin integers))
(define (sign-change-detector a b)
(cond
((and (>= a 0) (>= b 0)) 0)
((and (< a 0) (< b 0)) 0)
((and (>= a 0) (< b 0)) 1)
((and (< a 0) (>= b 0)) -1)
(else (error "WTF"))))
(define (make-zero-crossings
input-stream last-value)
(cons-stream
(sign-change-detector
(stream-car input-stream)
last-value)
(make-zero-crossings
(stream-cdr input-stream)
(stream-car input-stream))))
(define zero-crossings-old
(make-zero-crossings sense-data 0))
;; Print helper
(define (zip-streams . streams)
(cons-stream
(map stream-car streams)
(apply zip-streams (map stream-cdr streams))))
(define zero-crossings
(stream-map sign-change-detector
sense-data
(cons-stream 0 sense-data)))
(display-first-n (zip-streams sense-data zero-crossings-old zero-crossings)
20); ✔ | false |
cfaa57f4bfd493dd538c677d64b828113856296a | 000dbfe5d1df2f18e29a76ea7e2a9556cff5e866 | /src/lib_core.stub | d5ec8a0ac1942b6130d7fd809432978f04a210fd | [
"BSD-3-Clause",
"LicenseRef-scancode-other-permissive",
"MIT",
"BSD-2-Clause"
]
| permissive | ktakashi/sagittarius-scheme | 0a6d23a9004e8775792ebe27a395366457daba81 | 285e84f7c48b65d6594ff4fbbe47a1b499c9fec0 | refs/heads/master | 2023-09-01T23:45:52.702741 | 2023-08-31T10:36:08 | 2023-08-31T10:36:08 | 41,153,733 | 48 | 7 | NOASSERTION | 2022-07-13T18:04:42 | 2015-08-21T12:07:54 | Scheme | UTF-8 | Scheme | false | false | 101,953 | stub | lib_core.stub | ;; -*- scheme -*-
(library (core)
(export :all)
(import :none)
(decl-code
(.define "LIBSAGITTARIUS_BODY")
(.include <sagittarius/private.h>
<sagittarius/private/instruction.h>
<sagittarius/private/builtin-symbols.h>
;; need this...
"shortnames.incl"
"gc-incl.inc"))
(define-cise-stmt assertion-violation
((_ who msg)
`(begin
(Sg_AssertionViolation ,who (SG_MAKE_STRING ,msg) SG_UNBOUND)))
((_ who msg irritants)
`(begin
(Sg_AssertionViolation ,who (SG_MAKE_STRING ,msg) ,irritants)
)))
(define-cise-stmt wrong-type-of-argument-violation
((_ who msg got)
`(begin
(Sg_WrongTypeOfArgumentViolation ,who (SG_MAKE_STRING ,msg) ,got SG_UNBOUND)))
((_ who msg got irritants)
`(begin
(Sg_WrongTypeOfArgumentViolation ,who (SG_MAKE_STRING ,msg) ,got ,irritants))))
(define-cise-stmt throw-i/o-error
((_ type who msg file)
`(throw-i/o-error ,type ,who ,msg ,file SG_UNDEF))
((_ type who msg file ret)
`(begin
(Sg_IOError ,type ,who (SG_MAKE_STRING ,msg) ,file SG_UNDEF)
(return ,ret))))
;; x=? macro
(define-cise-stmt x=?
((_ checker compare name first second rest)
`(begin
(,checker ,name ,first)
(,checker ,name ,second)
(cond ((SG_NULLP ,rest)
(result (,compare ,first ,second)))
((not (,compare ,first ,second))
(result FALSE))
(else
(let ((prev ,second))
(dolist (p ,rest)
(,checker ,name p)
(unless (,compare prev p)
(return #f))
(set! prev p))
(result TRUE)))))))
;; 11.1 base type
(define-c-proc boolean? (o) ::<boolean> :constant SG_BOOLP)
(define-c-proc pair? (o) ::<boolean> :constant (inline PAIRP) SG_PAIRP)
(define-c-proc symbol? (o) ::<boolean> :constant (inline SYMBOLP) SG_SYMBOLP)
(define-c-proc number? (o) ::<boolean> :constant SG_NUMBERP)
(define-c-proc char? (o) ::<boolean> :constant SG_CHARP)
(define-c-proc string? (o) ::<boolean> :constant SG_STRINGP)
(define-c-proc vector? (o) ::<boolean> :constant (inline VECTORP) SG_VECTORP)
(define-c-proc procedure? (o) ::<boolean> :constant SG_PROCEDUREP)
(define-c-proc null? (o) ::<boolean> :constant (inline NULLP) SG_NULLP)
;; 11.5 equivalence predicates
;; defined in compare.c
;;(define-c-proc eq? (a b) ::<boolean> :constant (inline EQ) SG_EQ)
;;(define-c-proc eqv? (a b) ::<boolean> :constant (inline EQV) Sg_EqvP)
;;(define-c-proc equal? (a b) ::<boolean> :constant Sg_EqualP)
;; 11.7.4.1 numerical type predicates
(define-c-proc complex? (o) ::<boolean> :constant SG_NUMBERP)
(define-c-proc real? (o) ::<boolean> :constant SG_REALP)
(define-c-proc rational? (o) ::<boolean> :constant Sg_RationalP)
(define-c-proc integer? (o) ::<boolean> :constant Sg_IntegerP)
(define-c-proc real-valued? (o) ::<boolean> :constant Sg_RealValuedP)
(define-c-proc rational-valued? (o) ::<boolean> :constant Sg_RationalValuedP)
(define-c-proc integer-valued? (o) ::<boolean> :constant Sg_IntegerValuedP)
(define-c-proc exact? (o) ::<boolean> :constant Sg_ExactP)
(define-c-proc inexact? (o) ::<boolean> :constant Sg_InexactP)
;; 11.7.4.2 generic conversions
(define-c-proc inexact (z::<number>) :constant Sg_Inexact)
(define-c-proc exact (z::<number>) :constant Sg_Exact)
;; 11.7.4.3 arithmetic operations
(define-cise-stmt check-real
((_ name o)
`(unless (SG_REALP ,o)
(wrong-type-of-argument-violation ',name "real number" ,o))))
(define-cise-stmt numcmp
((_ op compar)
`(loop (cond ((not (,op (,compar arg0 arg1) 0)) (break))
((SG_NULLP rest) (result TRUE) (break))
(else (set! arg0 arg1)
(set! arg1 (SG_CAR rest))
(set! rest (SG_CDR rest)))))))
;; = < > <= >=
(define-c-proc = (arg0 arg1 :rest rest) ::<boolean> :constant
(result FALSE)
(loop (cond ((not (Sg_NumEq arg0 arg1)) (break))
((SG_NULLP rest) (result TRUE) (break))
(else (set! arg0 arg1)
(set! arg1 (SG_CAR rest))
(set! rest (SG_CDR rest))))))
(define-c-proc < (arg0 arg1 :rest rest) ::<boolean> :constant
(result FALSE)
(numcmp < Sg_NumCmp))
(define-c-proc <= (arg0 arg1 :rest rest) ::<boolean> :constant
(result FALSE)
(numcmp <= Sg_NumCmp))
(define-c-proc > (arg0 arg1 :rest rest) ::<boolean> :constant
(result FALSE)
(numcmp > Sg_NumCmp))
(define-c-proc >= (arg0 arg1 :rest rest) ::<boolean> :constant
(result FALSE)
(numcmp >= Sg_NumCmp))
(define-c-proc zero? (n::<number>) ::<boolean> :constant Sg_ZeroP)
(define-c-proc positive? (x::<number>) ::<boolean> :constant Sg_PositiveP)
(define-c-proc negative? (x::<number>) ::<boolean> :constant Sg_NegativeP)
(define-c-proc odd? (x::<number>) ::<boolean> :constant Sg_OddP)
(define-c-proc even? (x::<number>) ::<boolean> :constant
(result (not (Sg_OddP x))))
(define-c-proc finite? (x::<number>) ::<boolean> Sg_FiniteP)
(define-c-proc infinite? (x::<number>) ::<boolean> Sg_InfiniteP)
(define-c-proc nan? (x::<number>) ::<boolean> Sg_NanP)
(define-c-proc max (arg0 :rest rest) :constant
(Sg_MinMax arg0 rest NULL (& SG_RESULT)))
(define-c-proc min (arg0 :rest rest) :constant
(Sg_MinMax arg0 rest (& SG_RESULT) NULL))
;; arithmetic
(define-cise-stmt check-number
((_ name v)
`(unless (SG_NUMBERP ,v)
(wrong-type-of-argument-violation ',name "number" ,v))))
;; are these arithmetic operation constant?
(define-c-proc + (:rest rest) :constant
(cond ((not (SG_PAIRP rest)) (result (SG_MAKE_INT 0)))
((not (SG_NUMBERP (SG_CAR rest)))
(wrong-type-of-argument-violation '+ "number" (SG_CAR rest) rest)
(result SG_UNDEF)) ; dummy
(else
(let ((r (SG_CAR rest)))
(dolist (v (SG_CDR rest))
(check-number + v)
(set! r (Sg_Add r v)))
(result r)))))
(define-c-proc * (:rest rest) :constant
(cond ((not (SG_PAIRP rest)) (result (SG_MAKE_INT 1)))
((not (SG_NUMBERP (SG_CAR rest)))
(wrong-type-of-argument-violation '+ "number" (SG_CAR rest) rest)
(result SG_UNDEF)) ; dummy
(else
(let ((r (SG_CAR rest)))
(dolist (v (SG_CDR rest))
(check-number * v)
(set! r (Sg_Mul r v)))
(result r)))))
(define-c-proc - (arg1::<number> :rest rest) :constant
(if (SG_NULLP rest)
(result (Sg_Negate arg1))
(begin
(dolist (v rest)
(check-number - v)
(set! arg1 (Sg_Sub arg1 v)))
(result arg1))))
(define-c-proc / (arg1::<number> :rest rest) :constant
(if (SG_NULLP rest)
(result (Sg_Inverse arg1))
(let ((exact::int (Sg_ExactP arg1)))
(dolist (v rest)
(check-number / v)
;; if inexact numbers have already appeared,
;; we can skip checking
(when exact (set! exact (Sg_ExactP v)))
(when (and exact (Sg_ZeroP v))
(assertion-violation '/ "undefined for 0" (Sg_Cons arg1 rest)))
(set! arg1 (Sg_Div arg1 v)))
(result arg1))))
;; base arithmetic
(define-c-proc abs (x::<number>) :constant Sg_Abs)
(define-c-proc numerator (x::<number>) :constant Sg_Numerator)
(define-c-proc denominator (x::<number>) :constant Sg_Denominator)
(define-cise-stmt check-real-valued
((_ name n)
`(unless (Sg_RealValuedP ,n)
(wrong-type-of-argument-violation ',name "real number" ,n))))
(define-c-proc floor (x::<number>) :constant
(check-real-valued floor x)
(result (Sg_Round x SG_ROUND_FLOOR)))
(define-c-proc ceiling (x::<number>) :constant
(check-real-valued ceiling x)
(result (Sg_Round x SG_ROUND_CEIL)))
(define-c-proc truncate (x::<number>) :constant
(check-real-valued truncate x)
(result (Sg_Round x SG_ROUND_TRUNC)))
(define-c-proc round (x::<number>) :constant
(check-real-valued round x)
(result (Sg_Round x SG_ROUND_ROUND)))
(define-cise-stmt check-finite
((_ name n)
`(unless (Sg_FiniteP ,n)
(wrong-type-of-argument-violation ',name "finite" ,n))))
(define-cise-stmt check-not-nan
((_ name n)
`(when (Sg_NanP ,n)
(wrong-type-of-argument-violation ',name "non nan" ,n))))
(define-cise-stmt check-not-zero
((_ name n)
`(when (Sg_ZeroP ,n)
(wrong-type-of-argument-violation ',name "not zero" ,n))))
(define-cise-stmt check-integer-arith-argument
((_ name x y)
`(begin
(check-finite ,name ,x)
(check-not-nan ,name ,x)
(check-not-zero ,name ,y))))
(define-c-proc div (x::<number> y::<number>) :constant
(check-integer-arith-argument div x y)
(result (Sg_IntegerDiv x y)))
(define-c-proc mod (x::<number> y::<number>) :constant
(check-integer-arith-argument mod x y)
(result (Sg_IntegerMod x y)))
(define-c-proc div0 (x::<number> y::<number>) :constant
(check-integer-arith-argument div0 x y)
(result (Sg_IntegerDiv0 x y)))
(define-c-proc mod0 (x::<number> y::<number>) :constant
(check-integer-arith-argument mod0 x y)
(result (Sg_IntegerMod0 x y)))
;; takes 2. r6rs implementation is in scmlib.scm
(define-c-proc %gcd (x::<number> y::<number>) :constant Sg_Gcd)
(define-c-proc exp (x::<number>) :constant Sg_Exp)
(define-c-proc expt (x::<number> y::<number>) :constant Sg_Expt)
(define-c-proc log (x::<number> :optional base::<number>) :constant
(if (SG_UNBOUNDP base)
(if (== x (SG_MAKE_INT 0))
(assertion-violation 'log "undefined for 0" x)
(result (Sg_Log x)))
(result (Sg_Div (Sg_Log x) (Sg_Log base)))))
(define-c-proc make-rectangular (a::<number> b::<number>) :constant
(unless (SG_REALP a)
(wrong-type-of-argument-violation 'make-rectangular "real number required"
a (SG_LIST2 a b)))
(unless (SG_REALP b)
(wrong-type-of-argument-violation 'make-rectangular "real number required"
b (SG_LIST2 a b)))
(result (Sg_MakeComplex a b)))
(define-c-proc make-polar (r::<number> t::<number>) :constant
(unless (SG_REALP r)
(wrong-type-of-argument-violation 'make-polar "real number required"
r (SG_LIST2 r t)))
(unless (SG_REALP t)
(wrong-type-of-argument-violation 'make-polar "real number required"
t (SG_LIST2 r t)))
(result (Sg_MakeComplexPolar r t)))
(define-c-proc real-part (r::<number>) :constant
(cond ((SG_COMPLEXP r)
(result (-> (SG_COMPLEX r) real)))
((SG_REALP r) (result r))
(else
;; never happen
(wrong-type-of-argument-violation 'real-part "number required" r))))
(define-c-proc imag-part (r::<number>) :constant
(cond ((SG_COMPLEXP r)
(result (-> (SG_COMPLEX r) imag)))
((SG_REALP r)
(result (SG_MAKE_INT 0)))
(else
(wrong-type-of-argument-violation 'imag-part "number required" r))))
(define-c-proc magnitude (n::<number>) :constant Sg_Magnitude)
(define-c-proc angle (n::<number>) :constant Sg_Angle)
(define-c-proc sin (n::<number>) :constant Sg_Sin)
(define-c-proc cos (n::<number>) :constant Sg_Cos)
(define-c-proc tan (n::<number>) :constant Sg_Tan)
(define-c-proc asin (n::<number>) :constant Sg_Asin)
(define-c-proc acos (n::<number>) :constant Sg_Acos)
(define-c-proc atan (n::<number> :optional n2::<number>) :constant
(cond ((SG_UNBOUNDP n2) (result (Sg_Atan n)))
(else
(check-real-valued atan n)
(check-real-valued atan n2)
(result (Sg_Atan2 n n2)))))
(define-c-proc sqrt (n::<number>) :constant Sg_Sqrt)
(define-c-proc exact-integer-sqrt (n::<number>) :constant
(when (or (Sg_NegativeP n) (not (SG_EXACT_INTP n)))
(wrong-type-of-argument-violation 'exact-integer-sqrt
"non-negative exact integer required"
n))
(result (Sg_ExactIntegerSqrt n)))
(define-c-proc rationalize (x::<number> e::<number>) :constant
(check-real rationalize x)
(check-real rationalize e)
(result (Sg_Rationalize x e)))
;; r5rs compatible
(define-c-proc quotient (n1::<number> n2::<number>) :constant
(when (SG_EQ n2 (SG_MAKE_INT 0))
(assertion-violation 'quotient "attempt to calculate a quotient by zero"
(SG_LIST2 n1 n2)))
(result (Sg_Quotient n1 n2 NULL)))
(define-c-proc remainder (n1::<number> n2::<number>) :constant
(result (Sg_Modulo n1 n2 TRUE)))
(define-c-proc modulo (n1::<number> n2::<number>) :constant
(result (Sg_Modulo n1 n2 FALSE)))
(define-c-proc integer-length (n::<number>) ::<fixnum> :constant
Sg_IntegerLength)
;; 11.7.4.4 numerical input and output
(define-c-proc number->string (z::<number>
:optional (radix::<fixnum> 10)
precision) :constant
;; ignore precision
(result (Sg_NumberToString z (cast int radix) FALSE)))
(define-c-proc string->number (s::<string> :optional (radix::<fixnum> 10))
:constant
(result (Sg_StringToNumber s (cast int radix) FALSE)))
;; 11.8 booleans
(define-c-proc not (arg0) ::<boolean> :constant (inline NOT) SG_FALSEP)
(define-cise-stmt check-boolean
((_ name b)
`(unless (SG_BOOLP ,b)
(wrong-type-of-argument-violation ',name "boolean" ,b))))
(define-c-proc boolean=? (b1 b2 :rest rest) ::<boolean> :constant
(x=? check-boolean SG_EQ boolean=? b1 b2 rest))
;; 11.9 pairs and lists
(define-c-proc cons (o1 o2) :no-side-effect (inline CONS) Sg_Cons)
(define-c-proc car (o::<pair>) :constant
(inline CAR) (setter set-car!) SG_CAR)
(define-c-proc cdr (o::<pair>) :constant
(inline CDR) (setter set-cdr!) SG_CDR)
"#define CXR_SETTER(PRE, pre, tail) \
SgObject cell = Sg_C##tail##r(obj); \
if (!SG_PAIRP(cell)) \
Sg_Error(UC(\"can't set c\" #pre #tail \"r of %S\"), obj); \
SG_SET_C##PRE##R(cell, value);"
(define-c-proc caar (o::<pair>) :constant (inline CAAR)
(setter (obj value) ::<void> (CXR_SETTER A a a)) Sg_Caar)
(define-c-proc cadr (o::<pair>) :constant (inline CADR)
(setter (obj value) ::<void> (CXR_SETTER A a d)) Sg_Cadr)
(define-c-proc cdar (o::<pair>) :constant (inline CDAR)
(setter (obj value) ::<void> (CXR_SETTER D d a)) Sg_Cdar)
(define-c-proc cddr (o::<pair>) :constant (inline CDDR)
(setter (obj value) ::<void> (CXR_SETTER D d d)) Sg_Cddr)
;; moved from (core base)
;; Why did I do this...
"#define CXXR_SETTER(PRE, pre, tail) \
SgObject cell = Sg_C##pre##r(Sg_C##tail##r(obj)); \
if (!SG_PAIRP(cell)) \
Sg_Error(UC(\"can't set c\" #pre #tail \"r of %S\"), obj); \
SG_SET_C##PRE##R(cell, value);"
(define-c-proc caaar (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER A a a))
(result (Sg_Car (Sg_Caar o))))
(define-c-proc caadr (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER A a d))
(result (Sg_Car (Sg_Cadr o))))
(define-c-proc cadar (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER A d a))
(result (Sg_Car (Sg_Cdar o))))
(define-c-proc caddr (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER A d d))
(result (Sg_Car (Sg_Cddr o))))
(define-c-proc cdaar (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER D a a))
(result (Sg_Cdr (Sg_Caar o))))
(define-c-proc cdadr (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER D a d))
(result (Sg_Cdr (Sg_Cadr o))))
(define-c-proc cddar (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER D d a))
(result (Sg_Cdr (Sg_Cdar o))))
(define-c-proc cdddr (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER D d d))
(result (Sg_Cdr (Sg_Cddr o))))
(define-c-proc caaaar (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER A a aa))
(result (Sg_Caar (Sg_Caar o))))
(define-c-proc caaadr (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER A a ad))
(result (Sg_Caar (Sg_Cadr o))))
(define-c-proc caadar (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER A a da))
(result (Sg_Caar (Sg_Cdar o))))
(define-c-proc caaddr (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER A a dd))
(result (Sg_Caar (Sg_Cddr o))))
(define-c-proc cadaar (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER A d aa))
(result (Sg_Cadr (Sg_Caar o))))
(define-c-proc cadadr (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER A d ad))
(result (Sg_Cadr (Sg_Cadr o))))
(define-c-proc caddar (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER A d da))
(result (Sg_Cadr (Sg_Cdar o))))
(define-c-proc cadddr (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER A d dd))
(result (Sg_Cadr (Sg_Cddr o))))
(define-c-proc cdaaar (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER D a aa))
(result (Sg_Cdar (Sg_Caar o))))
(define-c-proc cdaadr (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER D a ad))
(result (Sg_Cdar (Sg_Cadr o))))
(define-c-proc cdadar (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER D a da))
(result (Sg_Cdar (Sg_Cdar o))))
(define-c-proc cdaddr (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER D a dd))
(result (Sg_Cdar (Sg_Cddr o))))
(define-c-proc cddaar (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER D d aa))
(result (Sg_Cddr (Sg_Caar o))))
(define-c-proc cddadr (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER D d ad))
(result (Sg_Cddr (Sg_Cadr o))))
(define-c-proc cdddar (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER D d da))
(result (Sg_Cddr (Sg_Cdar o))))
(define-c-proc cddddr (o) :constant
(setter (obj value) ::<void> (CXXR_SETTER D d dd))
(result (Sg_Cddr (Sg_Cddr o))))
(define-c-proc list? (arg0) ::<boolean> :constant SG_PROPER_LISTP)
(define-c-proc list (:rest rest) :no-side-effect (inline LIST) (result rest))
(define-c-proc length (lst) ::<fixnum> :constant Sg_Length)
;; are these transparent?
(define-c-proc append (:rest lst) :no-side-effect (inline APPEND) Sg_Append)
(define-c-proc reverse (lst) :no-side-effect Sg_Reverse)
(define-c-proc list-tail (lst k::<fixnum> :optional fallback) :constant
Sg_ListTail)
;; from where should we expose this?
(define-c-proc list-set! (lst k::<fixnum> v)
(let ((p (Sg_ListTail lst k SG_FALSE)))
(if (SG_PAIRP p)
(SG_SET_CAR p v)
(assertion-violation 'list-set! "index out of bound"
(SG_LIST2 lst (SG_MAKE_INT k))))))
(define-c-proc list-ref (lst k::<fixnum> :optional fallback) :constant
(setter list-set!)
Sg_ListRef)
;; list miscs
(define-c-proc last-pair (lst) :constant Sg_LastPair)
;; 11.10 symbols
(define-c-proc symbol->string (z::<symbol>) :constant SG_SYMBOL_NAME)
(define-cise-stmt check-symbol
((_ name s)
`(unless (SG_SYMBOLP ,s)
(wrong-type-of-argument-violation ',name "symbol" ,s))))
(define-c-proc symbol=? (s1::<symbol> s2::<symbol> :rest rest)
::<boolean> :constant
(x=? check-symbol SG_EQ symbol=? s1 s2 rest))
(define-c-proc string->symbol (z::<string>) :constant Sg_Intern)
;; 11.11 characters
(define-cise-stmt check-char
((_ name c)
`(unless (SG_CHARP ,c)
(wrong-type-of-argument-violation ',name "char" ,c))))
(define-c-proc char->integer (c::<char>) :constant SG_MAKE_INT)
(define-c-proc integer->char (ch::<fixnum>) :constant
(unless (or (and (<= 0 ch) (<= ch #xD7FF))
(and (<= #xE000 ch) (<= ch #x10FFFF)))
(assertion-violation 'integer->char "code point out of range"
(SG_MAKE_INT ch)))
(result (SG_MAKE_CHAR ch)))
(define-c-proc char=? (c1 c2 :rest rest) ::<boolean> :constant
(x=? check-char SG_EQ char=? c1 c2 rest))
(define-cise-stmt char<>=?
((_ compare name first second rest)
`(begin
(check-char ,name ,first)
(check-char ,name ,second)
(cond ((SG_NULLP ,rest)
(result (,compare ,first ,second)))
((not (,compare ,first ,second))
(result FALSE))
(else
(let ((prev ,second))
(dolist (p ,rest)
(check-char ,name p)
(unless (,compare prev p)
(return #f))
(set! prev p))
(result TRUE)))))))
(define-c-proc char<? (c1 c2 :rest rest) ::<boolean> :constant
(char<>=? < char<? c1 c2 rest))
(define-c-proc char>? (c1 c2 :rest rest) ::<boolean> :constant
(char<>=? > char>? c1 c2 rest))
(define-c-proc char<=? (c1 c2 :rest rest) ::<boolean> :constant
(char<>=? <= char<=? c1 c2 rest))
(define-c-proc char>=? (c1 c2 :rest rest) ::<boolean> :constant
(char<>=? >= char>=? c1 c2 rest))
;; 11.12 strings
(define-cise-stmt check-string
((_ name s)
`(unless (SG_STRINGP ,s)
(wrong-type-of-argument-violation ',name "string" ,s))))
(define-c-proc make-string (k::<fixnum> :optional (c::<char> #\space))
Sg_ReserveString)
(define-c-proc string (:rest rest) :no-side-effect
(result (Sg_ListToString rest 0 -1)))
(define-c-proc string-length (s::<string>) ::<fixnum> :constant
SG_STRING_SIZE)
(define-c-proc string-ref (s::<string> k::<fixnum> :optional fallback)
:constant
(setter string-set!)
(cond ((SG_UNBOUNDP fallback)
(result (SG_MAKE_CHAR (Sg_StringRef s k))))
((and (<= 0 k) (< k (SG_STRING_SIZE s)))
(result (SG_MAKE_CHAR (Sg_StringRef s k))))
(else (result fallback))))
;; string compares
(define-c-proc string=? (s1::<string> s2::<string> :rest rest)
::<boolean> :constant
(x=? check-string Sg_StringEqual string=? s1 s2 rest))
(define-cise-stmt string-compare
((_ compare value name first second rest)
`(begin
(cond ((SG_NULLP ,rest)
(result (,compare (Sg_StringCompare ,first ,second) ,value)))
((not (,compare (Sg_StringCompare ,first ,second) ,value))
(result FALSE))
(else
(let ((prev ,second))
(dolist (p ,rest)
(check-string ,name p)
(unless (,compare (Sg_StringCompare prev p) ,value)
(return #f))
(set! prev p))
(result TRUE)))))))
(define-c-proc string<? (s1::<string> s2::<string> :rest rest)
::<boolean> :constant
(string-compare == -1 string<? s1 s2 rest))
(define-c-proc string>? (s1::<string> s2::<string> :rest rest)
::<boolean> :constant
(string-compare == 1 string>? s1 s2 rest))
(define-c-proc string<=? (s1::<string> s2::<string> :rest rest)
::<boolean> :constant
(string-compare <= 0 string<=? s1 s2 rest))
(define-c-proc string>=? (s1::<string> s2::<string> :rest rest)
::<boolean> :constant
(string-compare >= 0 string>=? s1 s2 rest))
(define-c-proc substring (s::<string> start::<fixnum> end::<fixnum>)
:no-side-effect
(when (< start 0)
(wrong-type-of-argument-violation 'substring "non negative exact integer"
(SG_MAKE_INT start)
(SG_LIST3 s (SG_MAKE_INT start)
(SG_MAKE_INT end))))
(when (< end 0)
(wrong-type-of-argument-violation 'substring "non negative exact integer"
(SG_MAKE_INT end)
(SG_LIST3 s (SG_MAKE_INT start)
(SG_MAKE_INT end))))
(when (< end start)
(assertion-violation 'substring "end index is smaller than start index"
(SG_LIST3 s (SG_MAKE_INT start) (SG_MAKE_INT end))))
(when (< (SG_STRING_SIZE s) end)
(assertion-violation 'substring "end index out of bounds"
(SG_LIST3 s (SG_MAKE_INT start) (SG_MAKE_INT end))))
(result (Sg_Substring s start end)))
(define-c-proc string-append (:rest rest) :no-side-effect Sg_StringAppend)
;; we take start+end as optional arguments for srfi-13
(define-c-proc string->list
(s::<string> :optional (start::<fixnum> 0) (end::<fixnum> -1))
:no-side-effect
Sg_StringToList)
(define-c-proc list->string
(o::<list> :optional (start::<fixnum> 0) (end::<fixnum> -1))
:no-side-effect
Sg_ListToString)
;; we take start+end as optional arguments for srfi-13
(define-c-proc string-copy
(s::<string> :optional (start::<fixnum> 0) (end::<fixnum> -1))
:no-side-effect
Sg_Substring)
;; 11.13 vectors
(define-c-proc make-vector (size::<fixnum> :optional fill) :no-side-effect
(when (SG_UNBOUNDP fill) (set! fill SG_UNDEF))
(result (Sg_MakeVector size fill)))
(define-c-proc vector (:rest rest) :no-side-effect (inline VECTOR)
(result (Sg_ListToVector rest 0 -1)))
(define-c-proc vector-length (vec::<vector>) ::<fixnum> :constant
(inline VEC_LEN)
(result (SG_VECTOR_SIZE vec)))
(define-c-proc vector-ref (vec::<vector> i::<fixnum> :optional fallback)
:constant (setter vector-set!)
(cond ((or (< i 0)
(>= i (SG_VECTOR_SIZE vec)))
(when (SG_UNBOUNDP fallback)
(assertion-violation 'vector-ref "index out of range"
(SG_MAKE_INT i)))
(result fallback))
(else (result (SG_VECTOR_ELEMENT vec i)))))
(define-c-proc vector-set! (vec::<vector> i::<fixnum> obj) ::<void>
(when (SG_LITERAL_VECTORP vec)
(assertion-violation 'vector-set "attempt to modify immutable vector"
(SG_LIST1 vec)))
(cond ((or (< i 0) (>= i (SG_VECTOR_SIZE vec)))
(assertion-violation 'vector-ref "index out of range"
(SG_MAKE_INT i)))
(else (set! (SG_VECTOR_ELEMENT vec i) obj))))
(define-c-proc vector->list
(vec::<vector> :optional (start::<fixnum> 0) (end::<fixnum> -1))
:no-side-effect
Sg_VectorToList)
(define-c-proc list->vector
(lst :optional (start::<fixnum> 0) (end::<fixnum> -1)) :no-side-effect
(unless (SG_LISTP lst)
(wrong-type-of-argument-violation 'list->vector "propert list" lst))
(result (Sg_ListToVector lst start end)))
(define-c-proc vector-fill!
(vec::<vector> fill :optional (start::<fixnum> 0) (end::<fixnum> -1))
::<void>
Sg_VectorFill)
;; 11.14 errors and violations
(define-c-proc assertion-violation (who message :rest irritants) ::<void>
Sg_AssertionViolation)
(define-c-proc error (who message :rest irritants) ::<void>
(let ((condi SG_FALSE))
(if (SG_FALSEP who)
(set! condi
(Sg_Condition
(SG_LIST2 (Sg_MakeError message)
(Sg_MakeIrritantsCondition irritants))))
(set! condi
(Sg_Condition
(SG_LIST3 (Sg_MakeError message)
(Sg_MakeWhoCondition who)
(Sg_MakeIrritantsCondition irritants)))))
(Sg_Raise condi FALSE)))
;; we might remove this
(define-c-proc scheme-error (who msg :rest irritant) ::<void>
(Sg_Error (UC "%S %A %S") who msg irritant))
(define-c-proc syntax-error (form :rest irritant) ::<void>
Sg_SyntaxError)
;; 11.15 control features
;; is apply constant? I think it's depending on the given procedure...
(define-c-proc apply (proc::<procedure> arg1 :rest rest) :no-side-effect
(inline APPLY)
;; can we consider this no-side-effect?
(let ((head::SgObject '()) (tail::SgObject '()))
(cond ((SG_NULLP rest) (result (Sg_VMApply proc arg1)))
(else
(set! head (Sg_Cons arg1 '()))
(set! tail head)
(dopairs (cp rest)
(when (SG_NULLP (SG_CDR cp))
(SG_APPEND head tail (SG_CAR cp))
(break))
(unless (SG_PAIRP (SG_CDR cp))
(assertion-violation 'apply "improper list not allowed"
rest))
(SG_APPEND1 head tail (SG_CAR cp)))
(result (Sg_VMApply proc head))))))
;; call/cc
(define-c-proc call/cc (proc::<procedure>) Sg_VMCallCC)
(define-c-proc call-with-current-continuation (proc::<procedure>) Sg_VMCallCC)
(define-c-proc values (:rest rest) :constant (inline VALUES) Sg_Values)
(define-c-proc dynamic-wind (before thunk after) Sg_VMDynamicWind)
;; standard libraries
;; 1 Unicode
;; 1.1 characters
(define-cise-stmt check-char
((_ name c)
`(unless (SG_CHARP ,c)
(wrong-type-of-argument-violation ',name "character" ,c))))
;; these can be constant since we always return the same value
;; however no guarantee that unicode spec itself gets changed
;; so just as it is for now.
;; remember unicode 1.1 to unicode 2.0, this may happen in future...
(define-c-proc char-upcase (c::<char>) ::<char> :no-side-effect Sg_CharUpCase)
(define-c-proc char-downcase (c::<char>) ::<char> :no-side-effect
Sg_CharDownCase)
(define-c-proc char-titlecase (c::<char>) ::<char> :no-side-effect
Sg_CharTitleCase)
(define-c-proc char-foldcase (c::<char>) ::<char> :no-side-effect
Sg_CharFoldCase)
(define-c-proc char-general-category (c::<char>) :no-side-effect
(result (Sg_CategroyToSymbol (Sg_CharGeneralCategory c))))
(define-c-proc char-alphabetic? (c::<char>) ::<boolean> :no-side-effect
Sg_CharAlphabeticP)
(define-c-proc char-numeric? (c::<char>) ::<boolean> :no-side-effect
Sg_CharNumericP)
(define-c-proc char-whitespace? (c::<char>) ::<boolean> :no-side-effect
Sg_Ucs4WhiteSpaceP)
(define-c-proc char-upper-case? (c::<char>) ::<boolean> :no-side-effect
Sg_CharUpperCaseP)
(define-c-proc char-lower-case? (c::<char>) ::<boolean> :no-side-effect
Sg_CharLowerCaseP)
(define-c-proc char-title-case? (c::<char>) ::<boolean> :no-side-effect
Sg_CharTitleCaseP)
;; 1.2 strings
;; for SRFI-13
;; these will allocate new string so not constant
(define-c-proc string-upcase
(s::<string> :optional (start::<fixnum> 0) (end::<fixnum> -1))
:no-side-effect
(result (Sg_StringUpCase (Sg_MaybeSubstring s start end))))
(define-c-proc string-downcase
(s::<string> :optional (start::<fixnum> 0) (end::<fixnum> -1))
:no-side-effect
(result (Sg_StringDownCase (Sg_MaybeSubstring s start end))))
(define-c-proc string-titlecase
(s::<string> :optional (start::<fixnum> 0) (end::<fixnum> -1))
:no-side-effect
(result (Sg_StringTitleCase (Sg_MaybeSubstring s start end) FALSE)))
(define-c-proc string-foldcase
(s::<string> :optional (start::<fixnum> 0) (end::<fixnum> -1))
:no-side-effect
(result (Sg_StringFoldCase (Sg_MaybeSubstring s start end))))
;; TODO Should we also add start end to these?
(define-c-proc string-normalize-nfd (s::<string>) :no-side-effect
Sg_StringNormalizeNfd)
(define-c-proc string-normalize-nfkd (s::<string>) :no-side-effect
Sg_StringNormalizeNfkd)
(define-c-proc string-normalize-nfc (s::<string>) :no-side-effect
Sg_StringNormalizeNfc)
(define-c-proc string-normalize-nfkc (s::<string>) :no-side-effect
Sg_StringNormalizeNfkc)
;; 2 Bytevectors
;; 2.2 general operations
(define-c-proc native-endianness () :no-side-effect Sg_NativeEndianness)
(define-c-proc bytevector=? (bv1::<bytevector> bv2::<bytevector>)
::<boolean> :constant
Sg_ByteVectorEqP)
(define-c-proc bytevector-copy
(src::<bytevector> :optional (start::<fixnum> 0) (end::<fixnum> -1))
:no-side-effect
Sg_ByteVectorCopy)
(define-cise-stmt check-non-negative-fixnum
((_ name n)
`(when (< ,n 0)
(wrong-type-of-argument-violation ',name
"non negative exact integer"
(SG_MAKE_INT ,n)))))
(define-c-proc bytevector-copy! (src::<bytevector> sstart::<fixnum>
dst::<bytevector> dstart::<fixnum>
k::<fixnum>)
::<void>
(check-non-negative-fixnum bytevector-copy! sstart)
(check-non-negative-fixnum bytevector-copy! dstart)
(Sg_ByteVectorCopyX src sstart dst dstart k))
(define-c-proc make-bytevector (len::<fixnum> :optional (fill::<fixnum> 0))
:no-side-effect
(check-non-negative-fixnum make-bytevector len)
(result (Sg_MakeByteVector len (cast int fill))))
(define-c-proc bytevector? (o) ::<boolean> :constant SG_BVECTORP)
(define-c-proc bytevector-length (bv::<bytevector>) ::<fixnum> :constant
SG_BVECTOR_SIZE)
(define-c-proc bytevector-fill!
(bv::<bytevector> fill::<fixnum> :optional (start::<fixnum> 0) (end::<fixnum> -1)) ::<void>
(Sg_ByteVectorFill bv (cast int fill) start end))
;; 2.3 operations on bytes and octets
(define-c-proc u8-list->bytevector (lst) :no-side-effect
(result (Sg_ListToByteVector lst 8 FALSE)))
(define-c-proc bytevector->u8-list (bv::<bytevector>) :no-side-effect
(result (Sg_ByteVectorToList bv 8 FALSE)))
(define-cise-stmt bv-check-index
((_ name bv index)
`(unless (and (> (SG_BVECTOR_SIZE ,bv) ,index) (>= ,index 0))
(assertion-violation ',name "index out of range"
(SG_LIST2 ,bv (SG_MAKE_INT ,index)))))
((_ name bv index offset)
`(let ((len::long (SG_BVECTOR_SIZE ,bv)))
(unless (and (> len ,offset)
(< ,index (- len ,offset)))
(assertion-violation ',name "index out of range"
(SG_LIST2 ,bv (SG_MAKE_INT ,index)))))))
(define-cise-stmt bv-check-literal
((_ name bv)
`(when (SG_LITERAL_BVECTORP ,bv)
(assertion-violation ',name "attempt to modify literal bytevector"
,bv))))
(define-c-proc bytevector-u8-ref (bv::<bytevector> index::<fixnum>)
::<fixnum> :constant
(setter bytevector-u8-set!)
(bv-check-index bytevector-u8-ref bv index)
(result (SG_BVECTOR_ELEMENT bv index)))
(define-c-proc bytevector-u8-set!
(bv::<bytevector> index::<fixnum> value::<fixnum>) ::<void>
(bv-check-literal bytevector-u8-set! bv)
(bv-check-index bytevector-u8-set! bv index)
(unless (SG_IS_OCTET value)
(assertion-violation 'bytevector-u8-set!
"value out of range. must be 0 <= value <= 255"
(SG_MAKE_INT value)))
(set! (SG_BVECTOR_ELEMENT bv index) (cast uint8_t value)))
(define-c-proc bytevector-s8-ref (bv::<bytevector> index::<fixnum>)
::<fixnum> :constant
(setter bytevector-s8-set!)
(bv-check-index bytevector-s8-ref bv index)
(result (cast int8_t (SG_BVECTOR_ELEMENT bv index))))
(define-c-proc bytevector-s8-set!
(bv::<bytevector> index::<fixnum> value::<fixnum>) ::<void>
(bv-check-literal bytevector-s8-set! bv)
(bv-check-index bytevector-s8-set! bv index)
(unless (SG_IS_BYTE value)
(assertion-violation 'bytevector-s8-set!
"value out of range. must be -128 <= value <= 127"
(SG_MAKE_INT value)))
(set! (SG_BVECTOR_ELEMENT bv index) (cast uint8_t value)))
(define-cise-stmt bv-check-align
((_ name index align)
`(unless (== (% ,index ,align) 0)
(assertion-violation ',name "index not aligned"
(SG_MAKE_INT ,index)))))
(define-cise-stmt bv-check-value
((_ name value min max)
(let ((v (gensym "cise__")))
`(let ((,v :: long ,value))
(unless (and (<= ,min ,v)
(<= ,v ,max))
(assertion-violation ',name "value out of range"
(SG_MAKE_INT ,v)))))))
;; 2.5 operations on 16-bit integers
;; u16
(define-c-proc bytevector-u16-native-ref
(bv::<bytevector> index::<fixnum>) ::<fixnum> :constant
(setter bytevector-u16-native-set!)
(bv-check-index bytevector-u16-native-ref bv index 1)
(bv-check-align bytevector-u16-native-ref index 2)
(result (Sg_ByteVectorU16NativeRef bv index)))
(define-c-proc bytevector-u16-native-set!
(bv::<bytevector> index::<fixnum> value::<fixnum>) ::<void>
(bv-check-literal bytevector-u16-native-set! bv)
(bv-check-index bytevector-u16-native-set! bv index 1)
(bv-check-value bytevector-u16-native-set! value 0 #xFFFF)
(Sg_ByteVectorU16NativeSet bv index value))
(define-c-proc bytevector-u16-ref
(bv::<bytevector> index::<fixnum> endian::<symbol>) ::<fixnum> :constant
;;(setter bytevector-u16-set!)
(bv-check-index bytevector-u16-ref bv index 1)
(cond ((SG_EQ endian 'big)
(result (Sg_ByteVectorU16BigRef bv index)))
((SG_EQ endian 'little)
(result (Sg_ByteVectorU16LittleRef bv index)))
(else
(assertion-violation 'bytevector-u16-ref "unsupported endianness"
endian))))
(define-c-proc bytevector-u16-set!
(bv::<bytevector> index::<fixnum> value::<fixnum> endian::<symbol>) ::<void>
(bv-check-literal bytevector-u16-set! bv)
(bv-check-index bytevector-u16-set! bv index 1)
(bv-check-value bytevector-u16-set! value 0 #xFFFF)
(cond ((SG_EQ endian 'big)
(Sg_ByteVectorU16BigSet bv index value))
((SG_EQ endian 'little)
(Sg_ByteVectorU16LittleSet bv index value))
(else
(assertion-violation 'bytevector-u16-set!
"unsupported endianness" endian))))
;; s16
(define-c-proc bytevector-s16-native-ref
(bv::<bytevector> index::<fixnum>) ::<fixnum> :constant
(setter bytevector-s16-native-set!)
(bv-check-index bytevector-s16-native-ref bv index 1)
(bv-check-align bytevector-s16-native-ref index 2)
(result (Sg_ByteVectorS16NativeRef bv index)))
(define-c-proc bytevector-s16-native-set!
(bv::<bytevector> index::<fixnum> value::<fixnum>) ::<void>
(bv-check-literal bytevector-s16-native-set! bv)
(bv-check-index bytevector-s16-native-set! bv index 1)
(bv-check-value bytevector-s16-native-set! value #x-8000 #x7FFF)
(Sg_ByteVectorS16NativeSet bv index value))
(define-c-proc bytevector-s16-ref
(bv::<bytevector> index::<fixnum> endian::<symbol>) ::<fixnum> :constant
;;(setter bytevector-s16-set!)
(bv-check-index bytevector-s16-ref bv index 1)
(cond ((SG_EQ endian 'big)
(result (Sg_ByteVectorS16BigRef bv index)))
((SG_EQ endian 'little)
(result (Sg_ByteVectorS16LittleRef bv index)))
(else
(assertion-violation 'bytevector-s16-ref "unsupported endianness"
endian))))
(define-c-proc bytevector-s16-set!
(bv::<bytevector> index::<fixnum> value::<fixnum> endian::<symbol>) ::<void>
(bv-check-literal bytevector-s16-set! bv)
(bv-check-index bytevector-s16-set! bv index 1)
(bv-check-value bytevector-s16-set! value #x-8000 #x7FFF)
(cond ((SG_EQ endian 'big)
(Sg_ByteVectorS16BigSet bv index value))
((SG_EQ endian 'little)
(Sg_ByteVectorS16LittleSet bv index value))
(else
(assertion-violation 'bytevector-s16-set! "unsupported endianness"
endian))))
;; 2.6 operations on 32-bit integers
;; u32
(define-c-proc bytevector-u32-native-ref (bv::<bytevector> index::<fixnum>)
:constant
(setter bytevector-u32-native-set!)
(bv-check-index bytevector-u32-native-ref bv index 3)
(bv-check-align bytevector-u32-native-ref index 4)
(result (Sg_MakeIntegerFromU32 (Sg_ByteVectorU32NativeRef bv index))))
(define-c-proc bytevector-u32-native-set!
(bv::<bytevector> index::<fixnum> v::<number>) ::<void>
(bv-check-literal bytevector-u32-native-set! bv)
(bv-check-index bytevector-u32-native-set! bv index 3)
(let ((value::uint32_t 0))
(cond ((SG_INTP v)
(bv-check-value bytevector-u32-native-set! (SG_INT_VALUE v)
0 UINT32_MAX)
(set! value (cast uint32_t (SG_INT_VALUE v))))
((SG_BIGNUMP v)
(set! value (Sg_BignumToU32 v SG_CLAMP_NONE NULL)))
(else
(wrong-type-of-argument-violation 'bytevector-u32-native-set!
"exact integer" v)))
(Sg_ByteVectorU32NativeSet bv index value)))
(define-c-proc bytevector-u32-ref
(bv::<bytevector> index::<fixnum> endian::<symbol>) :constant
;;(setter bytevector-u32-set!)
(bv-check-index bytevector-u32-ref bv index 3)
(cond ((SG_EQ endian 'big)
(result (Sg_MakeIntegerFromU32 (Sg_ByteVectorU32BigRef bv index))))
((SG_EQ endian 'little)
(result (Sg_MakeIntegerFromU32
(Sg_ByteVectorU32LittleRef bv index))))
(else
(assertion-violation 'bytevector-u32-ref
"unsupported endianness" endian))))
(define-c-proc bytevector-u32-set!
(bv::<bytevector> index::<fixnum> v::<number> endian::<symbol>) ::<void>
(bv-check-literal bytevector-u32-set! bv)
(bv-check-index bytevector-u32-set! bv index 3)
(let ((value::uint32_t 0))
(cond ((SG_INTP v)
;; for 64 bit environment fixnum can be more than 32 bits
(bv-check-value bytevector-u32-set! (SG_INT_VALUE v)
0 UINT32_MAX)
(set! value (cast uint32_t (SG_INT_VALUE v))))
((SG_BIGNUMP v)
(set! value (Sg_BignumToU32 v SG_CLAMP_NONE NULL)))
(else
(wrong-type-of-argument-violation 'bytevector-u32-set!
"exact integer" v)))
(cond ((SG_EQ endian 'big)
(Sg_ByteVectorU32BigSet bv index value))
((SG_EQ endian 'little)
(Sg_ByteVectorU32LittleSet bv index value))
(else
(assertion-violation 'bytevector-u32-set!
"unsupported endianness" endian)))))
;; s32
(define-c-proc bytevector-s32-native-ref (bv::<bytevector> index::<fixnum>)
:constant
(setter bytevector-s32-native-set!)
(bv-check-index bytevector-s32-native-ref bv index 3)
(bv-check-align bytevector-s32-native-ref index 4)
(result (Sg_MakeIntegerFromS32 (Sg_ByteVectorS32NativeRef bv index))))
(define-c-proc bytevector-s32-native-set!
(bv::<bytevector> index::<fixnum> v::<number>) ::<void>
(bv-check-literal bytevector-s32-native-set! bv)
(bv-check-index bytevector-s32-native-set! bv index 3)
(let ((value::int32_t 0))
(cond ((SG_INTP v)
(bv-check-value bytevector-s32-native-set! (SG_INT_VALUE v)
INT32_MIN INT32_MAX)
(set! value (cast int32_t (SG_INT_VALUE v))))
((SG_BIGNUMP v)
(set! value (Sg_BignumToS32 v SG_CLAMP_NONE NULL)))
(else
(wrong-type-of-argument-violation 'bytevector-s32-native-set!
"exact integer" v)))
(Sg_ByteVectorS32NativeSet bv index value)))
(define-c-proc bytevector-s32-ref
(bv::<bytevector> index::<fixnum> endian::<symbol>) :constant
;;(setter bytevector-s32-set!)
(bv-check-index bytevector-s32-ref bv index 3)
(cond ((SG_EQ endian 'big)
(result (Sg_MakeIntegerFromS32 (Sg_ByteVectorS32BigRef bv index))))
((SG_EQ endian 'little)
(result (Sg_MakeIntegerFromS32
(Sg_ByteVectorS32LittleRef bv index))))
(else
(assertion-violation 'bytevector-s32-ref
"unsupported endianness" endian))))
(define-c-proc bytevector-s32-set!
(bv::<bytevector> index::<fixnum> v::<number> endian::<symbol>) ::<void>
(bv-check-literal bytevector-s32-set! bv)
(bv-check-index bytevector-s32-set! bv index 3)
(let ((value::int32_t 0))
(cond ((SG_INTP v)
(bv-check-value bytevector-s32-set! (SG_INT_VALUE v)
INT32_MIN INT32_MAX)
(set! value (cast int32_t (SG_INT_VALUE v))))
((SG_BIGNUMP v)
(set! value (Sg_BignumToS32 v SG_CLAMP_NONE NULL)))
(else
(wrong-type-of-argument-violation 'bytevector-s32-set!
"exact integer" v)))
(cond ((SG_EQ endian 'big)
(Sg_ByteVectorS32BigSet bv index value))
((SG_EQ endian 'little)
(Sg_ByteVectorS32LittleSet bv index value))
(else
(assertion-violation 'bytevector-s32-set!
"unsupported endianness" endian)))))
;; 2.7 operations on 64-bit integers
;; u64
(define-c-proc bytevector-u64-native-ref (bv::<bytevector> index::<fixnum>)
:constant
(setter bytevector-u64-native-set!)
(bv-check-index bytevector-u64-native-ref bv index 7)
(bv-check-align bytevector-u64-native-ref index 8)
(result (Sg_MakeIntegerFromU64 (Sg_ByteVectorU64NativeRef bv index))))
(define-c-proc bytevector-u64-native-set!
(bv::<bytevector> index::<fixnum> v::<number>) ::<void>
(bv-check-literal bytevector-u64-native-set! bv)
(bv-check-index bytevector-u64-native-set! bv index 7)
(let ((value::uint64_t 0))
(cond ((SG_INTP v)
;; we don't have to check the limit value
;; unless we would get 128 bit environment...
(when (< (SG_INT_VALUE v) 0)
(assertion-violation 'bytevector-u64-native-set!
"value out of range" v))
(set! value (cast uint64_t (SG_INT_VALUE v))))
((SG_BIGNUMP v)
(set! value (Sg_BignumToU64 v SG_CLAMP_NONE NULL)))
(else
(wrong-type-of-argument-violation 'bytevector-u64-native-set!
"exact integer" v)))
(Sg_ByteVectorU64NativeSet bv index value)))
(define-c-proc bytevector-u64-ref
(bv::<bytevector> index::<fixnum> endian::<symbol>) :constant
;;(setter bytevector-u64-set!)
(bv-check-index bytevector-u64-ref bv index 7)
(cond ((SG_EQ endian 'big)
(result (Sg_MakeIntegerFromU64
(Sg_ByteVectorU64BigRef bv index))))
((SG_EQ endian 'little)
(result (Sg_MakeIntegerFromU64
(Sg_ByteVectorU64LittleRef bv index))))
(else
(assertion-violation 'bytevector-u64-ref
"unsupported endianness" endian))))
(define-c-proc bytevector-u64-set!
(bv::<bytevector> index::<fixnum> v::<number> endian::<symbol>) ::<void>
(bv-check-literal bytevector-u64-set! bv)
(bv-check-index bytevector-u64-set! bv index 7)
(let ((value::uint64_t 0))
(cond ((SG_INTP v)
(when (< (SG_INT_VALUE v) 0)
(assertion-violation 'bytevector-u64-set!
"value out of range" v))
(set! value (cast uint64_t (SG_INT_VALUE v))))
((SG_BIGNUMP v)
(set! value (Sg_BignumToU64 v SG_CLAMP_NONE NULL)))
(else
(wrong-type-of-argument-violation 'bytevector-u64-set!
"exact integer" v)))
(cond ((SG_EQ endian 'big)
(Sg_ByteVectorU64BigSet bv index value))
((SG_EQ endian 'little)
(Sg_ByteVectorU64LittleSet bv index value))
(else
(assertion-violation 'bytevector-u64-set!
"unsupported endianness" endian)))))
;; s64
(define-c-proc bytevector-s64-native-ref (bv::<bytevector> index::<fixnum>)
:constant
(setter bytevector-s64-native-set!)
(bv-check-index bytevector-s64-native-ref bv index 7)
(bv-check-align bytevector-s64-native-ref index 8)
(result (Sg_MakeIntegerFromS64 (Sg_ByteVectorS64NativeRef bv index))))
(define-c-proc bytevector-s64-native-set!
(bv::<bytevector> index::<fixnum> v::<number>) ::<void>
(bv-check-literal bytevector-s64-native-set! bv)
(bv-check-index bytevector-s64-native-set! bv index 7)
(let ((value::int64_t 0))
(cond ((SG_INTP v)
(when (or (< (SG_INT_VALUE v) SG_INT_MIN)
(> (SG_INT_VALUE v) SG_INT_MAX))
(assertion-violation 'bytevector-s64-native-set!
"value out of range" v))
(set! value (cast int64_t (SG_INT_VALUE v))))
((SG_BIGNUMP v)
(set! value (Sg_BignumToS64 v SG_CLAMP_NONE NULL)))
(else
(wrong-type-of-argument-violation 'bytevector-s64-native-set!
"exact integer" v)))
(Sg_ByteVectorS64NativeSet bv index value)))
(define-c-proc bytevector-s64-ref
(bv::<bytevector> index::<fixnum> endian::<symbol>) :constant
;;(setter bytevector-s64-set!)
(bv-check-index bytevector-s64-ref bv index 7)
(cond ((SG_EQ endian 'big)
(result (Sg_MakeIntegerFromS64 (Sg_ByteVectorS64BigRef bv index))))
((SG_EQ endian 'little)
(result (Sg_MakeIntegerFromS64
(Sg_ByteVectorS64LittleRef bv index))))
(else
(assertion-violation 'bytevector-s64-ref
"unsupported endianness" endian))))
(define-c-proc bytevector-s64-set!
(bv::<bytevector> index::<fixnum> v::<number> endian::<symbol>) ::<void>
(bv-check-literal bytevector-s64-set! bv)
(bv-check-index bytevector-s64-set! bv index 7)
(let ((value::int64_t 0))
(cond ((SG_INTP v)
(when (or (< (SG_INT_VALUE v) SG_INT_MIN)
(> (SG_INT_VALUE v) SG_INT_MAX))
(assertion-violation 'bytevector-s64-set!
"value out of range" v))
(set! value (cast int64_t (SG_INT_VALUE v))))
((SG_BIGNUMP v)
(set! value (Sg_BignumToS64 v SG_CLAMP_NONE NULL)))
(else
(wrong-type-of-argument-violation 'bytevector-s64-set!
"exact integer" v)))
(cond ((SG_EQ endian 'big)
(Sg_ByteVectorS64BigSet bv index value))
((SG_EQ endian 'little)
(Sg_ByteVectorS64LittleSet bv index value))
(else
(assertion-violation 'bytevector-s64-set!
"unsupported endianness" endian)))))
;; 2.8 operations on ieee-754 representations
;; ieee-single
(define-c-proc bytevector-ieee-single-native-ref
(bv::<bytevector> index::<fixnum>) :constant
(setter bytevector-ieee-single-native-set!)
(bv-check-index bytevector-ieee-single-native-ref bv index 3)
(bv-check-align bytevector-ieee-single-native-ref index 4)
(result (Sg_MakeFlonum (Sg_ByteVectorIEEESingleNativeRef bv index))))
(define-c-proc bytevector-ieee-single-ref
(bv::<bytevector> index::<fixnum> endian::<symbol>) :constant
;;(setter bytevector-ieee-single-set!)
(bv-check-index bytevector-ieee-single-ref bv index 3)
(cond ((SG_EQ endian 'big)
(result (Sg_MakeFlonum (Sg_ByteVectorIEEESingleBigRef bv index))))
((SG_EQ endian 'little)
(result (Sg_MakeFlonum (Sg_ByteVectorIEEESingleLittleRef bv index))))
(else
(assertion-violation 'bytevector-ieee-single-ref
"unsupported endianness" endian))))
(define-c-proc bytevector-ieee-single-native-set!
(bv::<bytevector> index::<fixnum> v::<number>) ::<void>
(bv-check-literal bytevector-ieee-single-native-set! bv)
(bv-check-index bytevector-ieee-single-native-set! bv index 3)
(bv-check-align bytevector-ieee-single-native-set! index 4)
(check-real bytevector-ieee-single-native-set! v)
(let ((value::double (Sg_GetDouble v)))
(Sg_ByteVectorIEEESingleNativeSet bv index (cast float value))))
(define-c-proc bytevector-ieee-single-set!
(bv::<bytevector> index::<fixnum> v::<number> endian::<symbol>) ::<void>
(bv-check-literal bytevector-ieee-single-set! bv)
(bv-check-index bytevector-ieee-single-set! bv index 3)
(check-real bytevector-ieee-single-set! v)
(let ((value::double (Sg_GetDouble v)))
(cond ((SG_EQ endian 'big)
(Sg_ByteVectorIEEESingleBigSet bv index (cast float value)))
((SG_EQ endian 'little)
(Sg_ByteVectorIEEESingleLittleSet bv index (cast float value)))
(else
(assertion-violation 'bytevector-ieee-single-set!
"unsupported endianness" endian)))))
;; ieee-double
(define-c-proc bytevector-ieee-double-native-ref
(bv::<bytevector> index::<fixnum>) :constant
(setter bytevector-ieee-double-native-set!)
(bv-check-index bytevector-ieee-double-native-ref bv index 7)
(bv-check-align bytevector-ieee-double-native-ref index 8)
(result (Sg_MakeFlonum (Sg_ByteVectorIEEEDoubleNativeRef bv index))))
(define-c-proc bytevector-ieee-double-ref
(bv::<bytevector> index::<fixnum> endian::<symbol>) :constant
;;(setter bytevector-ieee-double-set!)
(bv-check-index bytevector-ieee-double-ref bv index 7)
(cond ((SG_EQ endian 'big)
(result (Sg_MakeFlonum (Sg_ByteVectorIEEEDoubleBigRef bv index))))
((SG_EQ endian 'little)
(result (Sg_MakeFlonum (Sg_ByteVectorIEEEDoubleLittleRef bv index))))
(else
(assertion-violation 'bytevector-ieee-double-ref
"unsupported endianness" endian))))
(define-c-proc bytevector-ieee-double-native-set!
(bv::<bytevector> index::<fixnum> v::<number>) ::<void>
(bv-check-literal bytevector-ieee-double-native-set! bv)
(bv-check-index bytevector-ieee-double-native-set! bv index 7)
(bv-check-align bytevector-ieee-double-native-set! index 8)
(check-real bytevector-ieee-double-native-set! v)
(let ((value::double (Sg_GetDouble v)))
(Sg_ByteVectorIEEEDoubleNativeSet bv index value)))
(define-c-proc bytevector-ieee-double-set!
(bv::<bytevector> index::<fixnum> v::<number> endian::<symbol>) ::<void>
(bv-check-literal bytevector-ieee-double-set! bv)
(bv-check-index bytevector-ieee-double-set! bv index 7)
(check-real bytevector-ieee-double-set! v)
(let ((value::double (Sg_GetDouble v)))
(cond ((SG_EQ endian 'big)
(Sg_ByteVectorIEEEDoubleBigSet bv index value))
((SG_EQ endian 'little)
(Sg_ByteVectorIEEEDoubleLittleSet bv index value))
(else
(assertion-violation 'bytevector-ieee-double-set!
"unsupported endianness" endian)))))
;; 2.9 operations on strings
;; converter
;; utf8 <-> string
(define-cise-expr utf8-tail?
((_ b)
`(and (<= #x80 ,b) (<= ,b #xbf))))
(define-cfn check-utf8-3bytes (bv i::long)
::int :static
(let ((first::int (SG_BVECTOR_ELEMENT bv i))
(second::int (SG_BVECTOR_ELEMENT bv (+ i 1)))
(third::int (SG_BVECTOR_ELEMENT bv (+ i 2))))
(cond ((not (utf8-tail? third)) (return FALSE))
((not (or (and (== #xe0 first) (<= #xa0 second) (<= second #xbf))
(and (== #xed first) (<= #x80 second) (<= second #x9f))
(and (<= #xe1 first) (<= first #xec) (utf8-tail? second))
(and (or (== #xee first) (== #xef first))
(utf8-tail? second))))
(return FALSE))
(else (return TRUE)))))
(define-cfn check-utf8-4bytes (bv i::long)
::int :static
(let ((first::int (SG_BVECTOR_ELEMENT bv i))
(second::int (SG_BVECTOR_ELEMENT bv (+ i 1)))
(third::int (SG_BVECTOR_ELEMENT bv (+ i 2)))
(forth::int (SG_BVECTOR_ELEMENT bv (+ i 3))))
(cond ((or (not (utf8-tail? third)) (not (utf8-tail? forth)))
(return FALSE))
((not (or (and (== #xf0 first) (<= #x90 second) (<= second #xbf))
(and (== #xf4 first) (<= #x80 second) (<= second #x8f))
(and (<= #xf1 first) (<= first #xf3)
(utf8-tail? second))))
(return FALSE))
(else (return TRUE)))))
(define-c-proc utf8->string (bv::<bytevector> :optional (start::<fixnum> 0)
(end::<fixnum> -1))
:no-side-effect
(let ((s)
(count::long 0)
(size::long (SG_BVECTOR_SIZE bv))
(i::long start))
(SG_CHECK_START_END start end size)
(while (< i end)
(post++ count)
(let ((f::uint8_t (SG_BVECTOR_ELEMENT bv i)))
(+= i (?: (< f #x80) 1
(?: (and (<= #xc2 f) (<= f #xdf)
(utf8-tail? (SG_BVECTOR_ELEMENT bv (+ i 1)))) 2
(?: (and (<= #xe0 f) (<= f #xef)
(check-utf8-3bytes bv i)) 3
;; the last one is error replacing so 1
(?: (and (<= #xf0 f) (<= f #xf4)
(check-utf8-4bytes bv i)) 4 1)))))))
(set! s (Sg_ReserveString count 0))
(Sg_ConvertUtf8BufferToUcs4 (Sg_MakeUtf8Codec)
(+ (SG_BVECTOR_ELEMENTS bv) start) size
(SG_STRING_VALUE s) count NULL
SG_REPLACE_ERROR FALSE)
(result s)))
(define-c-proc string->utf8 (s::<string> :optional (start::<fixnum> 0)
(end::<fixnum> -1))
:no-side-effect
(let ((bv)
(count::long 0)
(size::long (SG_STRING_SIZE s)))
(SG_CHECK_START_END start end size)
(dotimes (i (- end start) long)
(let ((ucs4::SgChar (SG_STRING_VALUE_AT s (+ i start))))
(+= count (?: (< ucs4 #x80) 1
(?: (< ucs4 #x800) 2
(?: (< ucs4 #x10000) 3
;; the last one is error replacing so 2
(?: (< ucs4 #x200000) 4 2)))))))
(set! bv (Sg_MakeByteVector count 0))
(set! count 0)
(dotimes (i (- end start) long)
(+= count (Sg_ConvertUcs4ToUtf8
(SG_STRING_VALUE_AT s (+ i start))
(+ (SG_BVECTOR_ELEMENTS bv) count)
SG_REPLACE_ERROR)))
(result bv)))
;; utf16 <-> string
(define-c-proc utf16->string (bv::<bytevector> endian::<symbol>
:optional mandatory)
:no-side-effect
(let ((endianness::SgEndianness NO_BOM)
(skipBOM::int FALSE))
(when (SG_UNBOUNDP mandatory)
(set! endianness (Sg_Utf16CheckBOM bv))
(when (not (== endianness NO_BOM)) (set! skipBOM TRUE)))
(when (or (and (not (SG_UNBOUNDP mandatory))
(not (SG_FALSEP mandatory)))
(== endianness NO_BOM))
(cond ((SG_EQ endian 'little)
(set! endianness UTF_16LE))
((SG_EQ endian 'big)
(set! endianness UTF_16BE))
(else
(assertion-violation
'utf16->string "endianness should be little or big" endian))))
(let ((skipSize::int 0)
(codec SG_UNDEF)
(trans::SgTranscoder))
(when skipBOM (set! skipSize 2))
(set! codec (Sg_MakeUtf16Codec endianness))
(Sg_InitTranscoder (& trans) codec E_NONE SG_REPLACE_ERROR)
;; TODO guard
(result (Sg_ByteVectorToString bv (& trans) skipSize -1)))))
(define-c-proc string->utf16 (s::<string> :optional endian::<symbol>)
:no-side-effect
(let ((endianness::SgEndianness UTF_16BE)
(trans::SgTranscoder))
(if (not (SG_UNBOUNDP endian))
(cond ((SG_EQ endian 'little)
(set! endianness UTF_16LE))
((SG_EQ endian 'big)
(set! endianness UTF_16BE))
(else
(assertion-violation
'string->utf16 "endianness should be little or big" endian))))
(Sg_InitTranscoder (& trans) (Sg_MakeUtf16Codec endianness)
E_NONE SG_REPLACE_ERROR)
(result (Sg_StringToByteVector s (& trans) 0 -1))))
(define-c-proc string->utf32 (s::<string> :optional endian::<symbol>)
:no-side-effect
(let ((endianness::SgEndianness UTF_32BE)
(trans::SgTranscoder))
(if (not (SG_UNBOUNDP endian))
(cond ((SG_EQ endian 'little)
(set! endianness UTF_32LE))
((SG_EQ endian 'big)
(set! endianness UTF_32BE))
(else
(assertion-violation
'string->utf32 "endianness should be little or big" endian))))
(Sg_InitTranscoder (& trans) (Sg_MakeUtf32Codec endianness)
E_NONE SG_REPLACE_ERROR)
(result (Sg_StringToByteVector s (& trans) 0 -1))))
(define-c-proc utf32->string (bv::<bytevector> endian::<symbol>
:optional mandatory)
:no-side-effect
(let ((endianness::SgEndianness NO_BOM)
(skipBOM::int FALSE))
(when (SG_UNBOUNDP mandatory)
(set! endianness (Sg_Utf32CheckBOM bv))
(if (not (== endianness NO_BOM))
(set! skipBOM TRUE)))
(when (or (and (not (SG_UNBOUNDP mandatory))
(not (SG_FALSEP mandatory)))
(== endianness NO_BOM))
(cond ((SG_EQ endian 'little)
(set! endianness UTF_32LE))
((SG_EQ endian 'big)
(set! endianness UTF_32BE))
(else
(assertion-violation
'utf32->string "endianness should be little or big" endian))))
(let ((skipSize::int 0)
(codec SG_UNDEF)
(trans::SgTranscoder))
(if skipBOM
(set! skipSize 4))
(set! codec (Sg_MakeUtf32Codec endianness))
(Sg_InitTranscoder (& trans) codec E_NONE SG_REPLACE_ERROR)
;; TODO guard
(result (Sg_ByteVectorToString bv (& trans) skipSize -1)))))
;; 3 List utilities
(define-c-proc memq (arg0 arg1) :constant Sg_Memq)
(define-c-proc memv (arg0 arg1) :constant Sg_Memv)
(define-c-proc assq (obj alist) :constant Sg_Assq)
(define-c-proc assv (obj alist) :constant Sg_Assv)
(define-c-proc cons* (:rest rest) :no-side-effect
(let ((h '()) (t '()))
(when (SG_PAIRP rest)
(dopairs (cp rest)
(unless (SG_PAIRP (SG_CDR cp))
(if (SG_NULLP h)
(set! h (SG_CAR cp))
(SG_SET_CDR t (SG_CAR cp)))
(break))
(SG_APPEND1 h t (SG_CAR cp))))
(result h)))
;; 7 Exceptions and conditions
;; 7.1 exceptions
;; these are moved to Scheme
;; (define-c-proc with-exception-handler (handler thunk)
;; Sg_VMWithExceptionHandler)
;;
;; (define-c-proc raise (c)
;; (result (Sg_Raise c FALSE)))
;;
;; (define-c-proc raise-continuable (c)
;; (result (Sg_Raise c TRUE)))
;; 8 I/O
;; 8.2 port i/o
;; 8.2.3 buffer modes
(define-c-proc buffer-mode? (o) ::<boolean> :constant
(result (or (SG_EQ o 'none)
(SG_EQ o 'line)
(SG_EQ o 'block))))
;; 8.2.4 transcoders
(define-c-proc latin-1-codec () :no-side-effect Sg_MakeLatin1Codec)
(define-c-proc utf-8-codec () :no-side-effect Sg_MakeUtf8Codec)
(define-c-proc utf-16-codec () :no-side-effect
(result (Sg_MakeUtf16Codec UTF_16CHECK_BOM)))
(define-c-proc native-eol-style () :no-side-effect
(let ((style::SgEolStyle (Sg_NativeEol)))
(cond ((== style LF)
(result 'lf))
((== style CR)
(result 'cr))
((== style LS)
(result 'ls))
((== style NEL)
(result 'nel))
((== style CRNEL)
(result 'crnel))
((== style CRLF)
(result 'crlf))
((== style E_NONE)
(result 'none))
(else
;; all plat form should return eol style by Sg_NativeEol.
;; so this never happen. just dummy
(assertion-violation 'native-eol-style
"platform native eol style not found"
'())))))
(define-c-proc make-transcoder (c::<codec> :optional eol mode::<symbol>)
:no-side-effect
(unless (or (SG_UNBOUNDP eol)
(SG_SYMBOLP eol))
(wrong-type-of-argument-violation 'make-transcoder
"symbol" eol))
(let ((style::SgEolStyle (Sg_NativeEol))
(handling::SgErrorHandlingMode SG_REPLACE_ERROR))
(cond ((SG_UNBOUNDP eol)) ;; do nothing
((SG_EQ eol 'lf)
(set! style LF))
((SG_EQ eol 'cr)
(set! style CR))
((SG_EQ eol 'ls)
(set! style LS))
((SG_EQ eol 'nel)
(set! style NEL))
((SG_EQ eol 'crnel)
(set! style CRNEL))
((SG_EQ eol 'crlf)
(set! style CRLF))
((SG_EQ eol 'none)
(set! style E_NONE))
(else
(assertion-violation 'make-transcoder
"invalid eol-style"
eol)))
(cond ((or (SG_UNBOUNDP mode)
(SG_EQ mode 'replace))) ;; do nothing
((SG_EQ mode 'raise)
(set! handling SG_RAISE_ERROR))
((SG_EQ mode 'ignore)
(set! handling SG_IGNORE_ERROR))
(else
(assertion-violation 'make-transcoder
"invalid error-handling-mode"
mode)))
(result (Sg_MakeTranscoder c style handling))))
(define-c-proc native-transcoder () :no-side-effect Sg_MakeNativeTranscoder)
(define-c-proc transcoder-codec (t::<transcoder>) :no-side-effect
SG_TRANSCODER_CODEC)
(define-c-proc transcoder-eol-style (t::<transcoder>) :no-side-effect
(let ((style::SgEolStyle (SG_TRANSCODER_EOL_STYLE t)))
(cond ((== style LF)
(result 'lf))
((== style CR)
(result 'cr))
((== style LS)
(result 'ls))
((== style NEL)
(result 'nel))
((== style CRNEL)
(result 'crnel))
((== style CRLF)
(result 'crlf))
((== style E_NONE)
(result 'none))
(else
;; never happen
(assertion-violation 'transcoder-eol-style
"transcoder had unknown eol-style. this must be a bug, please report it"
'())))))
(define-c-proc transcoder-error-handling-mode (t::<transcoder>)
:no-side-effect
(let ((mode::SgErrorHandlingMode (SG_TRANSCODER_MODE t)))
(cond ((SG_EQ mode SG_REPLACE_ERROR)
(result SG_SYMBOL_REPLACE))
((SG_EQ mode SG_IGNORE_ERROR)
(result SG_SYMBOL_IGNORE))
((SG_EQ mode SG_RAISE_ERROR)
(result SG_SYMBOL_RAISE))
(else
(assertion-violation 'transcoder-error-handling-mode
"transcoder had unknown error-handling-mode. this must be a bug, please report it"
'())))))
(define-c-proc bytevector->string
(b::<bytevector> t::<transcoder>
:optional (start::<fixnum> 0) (end::<fixnum> -1))
:no-side-effect
Sg_ByteVectorToString)
(define-c-proc string->bytevector
(s::<string> t::<transcoder>
:optional (start::<fixnum> 0) (end::<fixnum> -1))
:no-side-effect
Sg_StringToByteVector)
;; 8.2.5 end-of-file object
(define-c-proc eof-object () :no-side-effect (result SG_EOF))
(define-c-proc eof-object? (o) ::<boolean> :constant SG_EOFP)
;; 8.2.6 input port and output port
;; check utility for opened port
(define-cise-stmt check-port-open
((_ name p)
`(when (Sg_PortClosedP ,p)
(wrong-type-of-argument-violation ',name "opened port" ,p))))
(define-cise-stmt check-binary-port
((_ name p)
`(unless (SG_BINARY_PORTP ,p)
(wrong-type-of-argument-violation ',name "binary-port" ,p))))
(define-c-proc port? (obj) ::<boolean> :constant SG_PORTP)
(define-c-proc port-transcoder (p::<port>) :no-side-effect
Sg_PortTranscoder)
(define-c-proc textual-port? (p) ::<boolean> :constant SG_TEXTUAL_PORTP)
(define-c-proc binary-port? (p) ::<boolean> :constant SG_BINARY_PORTP)
(define-c-proc transcoded-port (p::<port> t::<transcoder>)
(check-binary-port transcoded-port p)
(check-port-open transcoded-port p)
(Sg_PseudoClosePort p)
(result (Sg_MakeTranscodedPort p t)))
(define-c-proc port-has-port-position? (p::<port>) ::<boolean> :no-side-effect
Sg_HasPortPosition)
(define-c-proc port-has-set-port-position!? (p::<port>) ::<boolean>
:no-side-effect
Sg_HasSetPortPosition)
(define-c-proc port-position (p::<port>) :no-side-effect
(check-port-open port-position p)
(result (Sg_MakeIntegerFromS64 (Sg_PortPosition p))))
(define-c-proc set-port-position!
(p::<port> off::<number> :optional (whence::<symbol> 'begin))
::<void>
(check-port-open set-port-position! p)
(let ((w::SgWhence SG_BEGIN))
(cond ((SG_EQ whence 'begin)
(when (Sg_NegativeP off)
(wrong-type-of-argument-violation 'set-port-position!
"non negative number"
off
(SG_LIST3 p off whence)))
(set! w SG_BEGIN))
((SG_EQ whence 'current) (set! w SG_CURRENT))
((SG_EQ whence 'end) (set! w SG_END))
(else (assertion-violation 'set-port-position!
"unknown whence" whence)))
(Sg_SetPortPosition p (Sg_GetIntegerS64Clamp off SG_CLAMP_NONE NULL) w)))
(define-c-proc close-port (p::<port>) ::<void>
(Sg_ClosePort p))
;; 8.2.7 input port
(define-cise-stmt check-input-port
((_ name p)
`(unless (SG_INPUT_PORTP ,p)
(wrong-type-of-argument-violation ',name "input port" ,p))))
(define-c-proc input-port? (obj) ::<boolean> :constant SG_INPUT_PORTP)
(define-c-proc port-eof? (p::<port>) ::<boolean> :no-side-effect
(if (SG_BINARY_PORTP p)
(let ((ch::int (Sg_Peekb p)))
(result (== ch EOF)))
(let ((ch::SgChar (Sg_Peekc p)))
(result (== ch EOF)))))
(define-c-proc open-file-input-port (file::<string>
:optional (option #f)
mode::<symbol>
(transcoder::<transcoder> #f))
;; we can ignore option
(when (SG_UNBOUNDP mode)
(set! mode 'block))
(let ((fo (Sg_OpenFile file SG_READ))
(bufferMode::int SG_BUFFER_MODE_BLOCK))
(unless (SG_FILEP fo)
(Sg_IOError SG_IO_FILE_NOT_EXIST_ERROR
'open-file-input-port fo file SG_UNDEF))
;; we only support 'block or none for now.
(if (SG_EQ mode 'none)
(set! bufferMode SG_BUFFER_MODE_NONE))
(if (SG_FALSEP transcoder)
(result (Sg_MakeFileBinaryInputPort fo bufferMode))
(let ((in (Sg_MakeFileBinaryInputPort fo bufferMode)))
(result (Sg_MakeTranscodedPort in transcoder))))))
(define-c-proc open-bytevector-input-port
(bv::<bytevector> :optional (t::<transcoder> #f)
(start::<fixnum> 0) (end::<fixnum> -1))
(let ((bp (Sg_MakeByteVectorInputPort bv start end)))
(if (SG_FALSEP t)
(result bp)
(result (Sg_MakeTranscodedPort bp t)))))
(define-c-proc open-string-input-port
(s::<string> :optional (start::<fixnum> 0) (end::<fixnum> -1))
(result (Sg_MakeStringInputPort s start end)))
(define-c-proc standard-input-port () Sg_StandardInputPort)
(define-c-proc current-input-port (:optional p::<port>)
(let ((vm::SgVM* (Sg_VM)))
(if (SG_UNBOUNDP p)
(result (-> vm currentInputPort))
(begin
(check-input-port current-input-port p)
(set! (-> vm currentInputPort) p)
(result SG_UNDEF)))))
(define-cise-stmt check-procedure-or-false
((_ name proc)
`(unless (or (SG_FALSEP ,proc)
(SG_PROCEDUREP ,proc))
(wrong-type-of-argument-violation ',name
"procedure or #f"
,proc))))
(define-c-proc make-custom-binary-input-port
(id::<string> read::<procedure> getter setter close
:optional (ready #f))
(check-procedure-or-false make-custom-binary-input-port getter)
(check-procedure-or-false make-custom-binary-input-port setter)
(check-procedure-or-false make-custom-binary-input-port close)
(check-procedure-or-false make-custom-binary-input-port ready)
(result (Sg_MakeCustomBinaryPort id SG_INPUT_PORT read SG_FALSE
getter setter close ready)))
(define-c-proc make-custom-textual-input-port
(id::<string> read::<procedure> getter setter close
:optional (ready #f))
(check-procedure-or-false make-custom-textual-input-port getter)
(check-procedure-or-false make-custom-textual-input-port setter)
(check-procedure-or-false make-custom-textual-input-port close)
(check-procedure-or-false make-custom-textual-input-port ready)
(result (Sg_MakeCustomTextualPort id SG_INPUT_PORT read SG_FALSE
getter setter close ready)))
;; 8.2.8 binary input
(decl-code (.include <string.h>))
;; we don't know what would happen in custom port
;; so if it's custom port we lock it.
(define-cise-stmt binary-port-read-u8-op
((_ p safe)
(let ((unsafe (string->symbol (format "~aUnsafe" safe))))
`(let ((b::int))
(if (SG_CUSTOM_PORTP ,p)
(set! b (,safe ,p))
(set! b (,unsafe ,p)))
(if (== EOF b)
(result SG_EOF)
(result (SG_MAKE_INT b)))))))
(define-cise-stmt binary-port-write-u8-op
((_ p b safe)
(let ((unsafe (string->symbol (format "~aUnsafe" safe))))
`(if (SG_CUSTOM_PORTP ,p)
(,safe ,p ,b)
(,unsafe ,p ,b)))))
(define-c-proc get-u8 (p::<port> :optional (reckless #f))
(check-port-open get-u8 p)
(when (SG_FALSEP reckless) (check-binary-port get-u8 p))
(check-input-port get-u8 p)
(binary-port-read-u8-op p Sg_Getb))
(define-c-proc lookahead-u8 (p::<port> :optional (reckless #f))
(check-port-open lookahead-u8 p)
(when (SG_FALSEP reckless) (check-binary-port lookahead-u8 p))
(check-input-port lookahead-u8 p)
(binary-port-read-u8-op p Sg_Peekb))
(define-cise-stmt check-fixnum-range
((_ name t start end start-op end-op)
`(unless (and (,start-op ,start ,t)
(,end-op ,t ,end))
(assertion-violation ',name "out of range" (SG_MAKE_INT ,t))))
((_ name t range op)
`(unless (,op ,t ,range)
(assertion-violation ',name "out of range" (SG_MAKE_INT ,t)))))
(define-cise-stmt read-to-buffer
((_ port result buf start count read)
(let ((i (gensym))
(r (gensym))
(c (gensym))
(t (gensym)))
`(let ((,(string->symbol (format "~a::int64_t" i)) ,start)
(,(string->symbol (format "~a::int64_t" r)) 0)
(,(string->symbol (format "~a::int64_t" c)) ,count)
(,(string->symbol (format "~a::int" t)) (Sg_ReadOncePortP ,port)))
(for (() (not (== ,c 0)) ())
(set! ,r (,read ,port (+ ,buf ,i) ,c))
(set! ,result (+ ,r ,result))
;; (when (< ,r ,c) (break))
(when (== ,r 0) (break))
(when ,t (break))
(set! ,c (- ,c ,r))
(set! ,i (+ ,i ,r)))))))
(define-c-proc get-bytevector-n
(p::<port> count::<fixnum> :optional (reckless #f))
(check-port-open get-bytevector-n p)
(when (SG_FALSEP reckless) (check-binary-port get-bytevector-n p))
(check-input-port get-bytevector-n p)
(check-non-negative-fixnum get-bytevector-n count)
(if (== count 0)
(result (Sg_MakeByteVector 0 0))
(let ((bp::SgBytePort)
(bufsiz::int)
(buf::uint8_t* NULL)
(c::int64_t count)
(res::int64_t 0)
(s::int64_t)
(t::int (Sg_ReadOncePortP p)))
(set! bufsiz (?: (< count 1024) count 1024))
(set! buf (SG_NEW_ATOMIC2 (uint8_t*) bufsiz))
(Sg_InitByteArrayOutputPort (& bp) count)
(SG_PORT_LOCK_READ p)
(for (() (not (== c 0)) ())
(set! res 0)
(set! s (?: (< c bufsiz) c bufsiz))
(read-to-buffer p res buf 0 s Sg_ReadbUnsafe)
(Sg_WritebUnsafe (SG_PORT (& bp)) buf 0 res)
(when (== res 0) (break))
(when t (break))
(set! c (- c res)))
(SG_PORT_UNLOCK_READ p)
(let ((bv (Sg_GetByteVectorFromBinaryPort (& bp))))
(SG_CLEAN_BYTE_PORT (& bp))
(if (== (SG_BVECTOR_SIZE bv) 0)
(result SG_EOF)
(result bv))))
#;(let ((buf (Sg_MakeByteVector count 0))
(res::int64_t 0))
;; (Sg_Readb p (SG_BVECTOR_ELEMENTS buf) count)
(SG_PORT_LOCK_READ p)
(read-to-buffer p res (SG_BVECTOR_ELEMENTS buf)
0 count Sg_ReadbUnsafe)
(SG_PORT_UNLOCK_READ p)
(cond ((== res 0) (result SG_EOF))
(else
(unless (== count res)
(set! (SG_BVECTOR_SIZE buf) res))
(result buf))))))
(define-c-proc get-bytevector-n!
(p::<port> bv::<bytevector> start::<fixnum> count::<fixnum>
:optional (reckless #f))
(check-port-open get-bytevector-n! p)
(when (SG_FALSEP reckless) (check-binary-port get-bytevector-n p))
(check-input-port get-bytevector-n! p)
(check-non-negative-fixnum get-bytevector-n! start)
(check-non-negative-fixnum get-bytevector-n! count)
(check-fixnum-range get-bytevector-n! (SG_BVECTOR_SIZE bv)(+ start count)>=)
(if (== count 0)
(result (SG_MAKE_INT 0))
(let ((res::int64_t 0))
;; (Sg_Readb p (+ (SG_BVECTOR_ELEMENTS bv) start) count)
(SG_PORT_LOCK_READ p)
(read-to-buffer p res (SG_BVECTOR_ELEMENTS bv)
start count Sg_ReadbUnsafe)
(SG_PORT_UNLOCK_READ p)
(if (== res 0)
(result SG_EOF)
(result (SG_MAKE_INT res))))))
;; TODO this allocates memory twice.
(define-c-proc get-bytevector-some (p::<port> :optional (reckless #f))
(check-port-open get-bytevector-some p)
(when (SG_FALSEP reckless)
(check-binary-port get-bytevector-n p))
(check-input-port get-bytevector-some p)
(let ((buf (Sg_MakeByteVector 512 0)) ;; some
(res::int64_t 0))
;; (Sg_Readb p (SG_BVECTOR_ELEMENTS buf) 512)
(SG_PORT_LOCK_READ p)
(read-to-buffer p res (SG_BVECTOR_ELEMENTS buf) 0 512 Sg_ReadbUnsafe)
(SG_PORT_UNLOCK_READ p)
(cond ((== res 0)
(result SG_EOF))
(else
(unless (== res 512)
(set! (SG_BVECTOR_SIZE buf) res))
(result buf)))))
(define-c-proc get-bytevector-all (p::<port> :optional (reckless #f))
(check-port-open get-bytevector-all p)
(when (SG_FALSEP reckless)
(check-binary-port get-bytevector-n p))
(check-input-port get-bytevector-all p)
;; TODO we need to get the rest size to reduce memory allocation.
;; but for now I implement like this
(let ((buf::uint8_t* NULL)
(res::int64_t (Sg_ReadbAll p (& buf))))
(if (== res 0)
(result SG_EOF)
(let ((r (Sg_MakeByteVectorFromU8Array buf res)))
(set! buf NULL) ; gc friendliness
(result r)))))
;; 8.2.9 textual port
(define-cise-stmt check-textual-port
((_ name p)
`(unless (SG_TEXTUAL_PORTP ,p)
(wrong-type-of-argument-violation ',name
"textual-port"
,p))))
(define-cise-expr string-port?
((_ p)
`(SG_STRING_PORTP ,p)))
;; If it's transcoded port there is always a chance to read more then
;; one byte and if that happens in multi thread script it would not
;; read a char properly. in case of the we need lock
;; custom port is the same reason as binary port.
;; so only string port which is buffering and it always put one char
;; in one operation.
(define-cise-stmt string-port-read-char-op
((_ p safe)
(let ((unsafe (string->symbol (format "~aUnsafe" safe))))
`(let ((c::SgChar))
(if (string-port? ,p)
(set! c (,unsafe ,p))
(set! c (,safe ,p)))
(if (== c EOF)
(result SG_EOF)
(result (SG_MAKE_CHAR c)))))))
(define-cise-stmt string-port-write-char-op
((_ p c safe)
(let ((unsafe (string->symbol (format "~aUnsafe" safe))))
`(if (string-port? ,p)
(,unsafe ,p ,c)
(,safe ,p ,c)))))
(define-c-proc get-char (p::<port>)
(check-port-open get-char p)
(check-textual-port get-char p)
(check-input-port get-char p)
(string-port-read-char-op p Sg_Getc))
(define-c-proc lookahead-char (p::<port>)
(check-port-open lookahead-char p)
(check-textual-port lookahead-char p)
(check-input-port lookahead-char p)
(string-port-read-char-op p Sg_Peekc))
(define-c-proc get-string-n (p::<port> count::<fixnum>)
(check-port-open get-string-n p)
(check-textual-port get-string-n p)
(check-input-port get-string-n p)
(check-non-negative-fixnum get-string-n count)
(if (== count 0)
(result (Sg_MakeEmptyString))
(let ((ch::SgChar (Sg_Peekc p)))
(if (== ch EOF)
(result SG_EOF)
(let* ((buf::SgString* (Sg_ReserveString count 0))
(len::int64_t 0))
;; (Sg_Reads p (SG_STRING_VALUE buf) count)
(SG_PORT_LOCK_READ p)
(read-to-buffer p len (SG_STRING_VALUE buf) 0 count
Sg_ReadsUnsafe)
(SG_PORT_UNLOCK_READ p)
(if (== len count)
(result buf)
(result (Sg_Substring buf 0 len))))))))
(define-c-proc get-string-n!
(p::<port> s::<string> start::<fixnum> count::<fixnum>)
(check-port-open get-string-n! p)
(check-textual-port get-string-n! p)
(check-input-port get-string-n! p)
(check-non-negative-fixnum get-string-n! start)
(check-non-negative-fixnum get-string-n! count)
(check-fixnum-range get-string-n! (SG_STRING_SIZE s) (+ start count) >=)
;; string must not be literal
(when (SG_IMMUTABLE_STRINGP s)
(assertion-violation 'get-string-n!
"attempt to modify an immutable string" s))
(if (== count 0)
(result (SG_MAKE_INT 0))
(let ((ch::SgChar (Sg_Peekc p)))
(if (== ch EOF)
(result SG_EOF)
(let ((len::int64_t 0))
;; (Sg_Reads p (+ (SG_STRING_VALUE s) start) count)
(SG_PORT_LOCK_READ p)
(read-to-buffer p len (SG_STRING_VALUE s) start count
Sg_ReadsUnsafe)
(SG_PORT_UNLOCK_READ p)
(result (SG_MAKE_INT len)))))))
(define-c-proc get-string-all (p::<port>)
(check-port-open get-string-all p)
(check-textual-port get-string-all p)
(check-input-port get-string-all p)
(let ((ch::SgChar (Sg_Peekc p)))
(cond ((== ch EOF)
(result SG_EOF))
(else
(SG_PORT_LOCK_READ p)
;; TODO how much should we allocate as default size?
(let ((buf (Sg_ReserveString 1024 0))
(out SG_FALSE)
(firstP::int TRUE)) ;; to avoid unnecessary allocation
(loop
(let ((len::int64_t
(Sg_ReadsUnsafe p (SG_STRING_VALUE buf) 1024)))
;; ok if len is less, then read everything
(cond ((== len 0)
(when firstP
(SG_PORT_UNLOCK_READ p)
(return SG_EOF))
(break))
((< len 1024)
(when firstP
(SG_PORT_UNLOCK_READ p)
(return (Sg_Substring buf 0 len)))
(Sg_Writes out (SG_STRING_VALUE buf) len)
(break))
(else
(if firstP (set! out (Sg_MakeStringOutputPort -1)))
(Sg_PutsUnsafe out buf)))
(set! firstP FALSE)))
(SG_PORT_UNLOCK_READ p)
(result (Sg_GetStringFromStringPort out)))))))
(define-c-proc get-line (p::<port>)
(check-port-open get-line p)
(check-textual-port get-line p)
(check-input-port get-line p)
(result (Sg_ReadLine p LF)))
(define-c-proc get-datum (p::<port>)
(check-port-open get-dutum p)
(check-textual-port get-datum p)
(check-input-port get-dutum p)
;; TODO should get-datum read shared-object too?
(let ((ctx::SgReadContext SG_STATIC_READ_CONTEXT))
(result (Sg_ReadWithContext p (& ctx)))))
;; 8.2.10 output port
(define-cise-stmt check-output-port
((_ name p)
`(unless (SG_OUTPUT_PORTP ,p)
(wrong-type-of-argument-violation ',name "output port" ,p))))
(define-c-proc output-port? (obj) ::<boolean> :constant SG_OUTPUT_PORTP)
(define-c-proc flush-output-port
(:optional (p::<port> (Sg_CurrentOutputPort))) ::<void>
Sg_FlushPort)
(define-c-proc output-port-buffer-mode (p::<port>)
(if (SG_BUFFERED_PORTP p)
(cond ((SG_EQ (-> (SG_BUFFERED_PORT p) mode) SG_BUFFER_MODE_NONE)
(result 'none))
((SG_EQ (-> (SG_BUFFERED_PORT p) mode) SG_BUFFER_MODE_LINE)
(result 'line))
((SG_EQ (-> (SG_BUFFERED_PORT p) mode) SG_BUFFER_MODE_BLOCK)
(result 'block))
(else
(assertion-violation 'output-port-buffer-mode
"port has invalid buffer mode. may be bug?"
p)))
(result 'none)))
(define-cfn get-open-flags
(option oflags::int file exists?::int rappend::int*)
::int :static
(let ((opt (Sg_SlotRefUsingClass (Sg_ClassOf option) option 'members)))
(if (and exists? (SG_NULLP opt))
(throw-i/o-error SG_IO_FILE_ALREADY_EXIST_ERROR
'open-file-output-port
"file already exists" file 0)
(let ((no-create?::int (not (SG_FALSEP (Sg_Memq 'no-create opt))))
(no-truncate?::int (not (SG_FALSEP (Sg_Memq 'no-truncate opt))))
(no-fail?::int (not (SG_FALSEP (Sg_Memq 'no-fail opt))))
(append?::int (not (SG_FALSEP (Sg_Memq 'append opt))))
(open-flags::int oflags))
(cond ((and no-create? no-truncate?)
(when (not exists?)
(throw-i/o-error SG_IO_FILE_NOT_EXIST_ERROR
'open-file-output-port
"file-options no-create: file not exist"
file 0)))
(no-create?
(if exists?
(set! open-flags (logior SG_TRUNCATE open-flags))
(throw-i/o-error SG_IO_FILE_NOT_EXIST_ERROR
'open-file-output-port
"file-options no-create: file not exist"
file 0)))
((and no-fail? no-truncate?)
(when (not exists?)
(set! open-flags (logior SG_TRUNCATE open-flags))))
(no-fail?
;; no-truncate
(set! open-flags (logior SG_TRUNCATE open-flags)))
(no-truncate?
(cond ((and exists? (not append?))
(throw-i/o-error SG_IO_FILE_ALREADY_EXIST_ERROR
'open-file-output-port
"file-options no-truncate: file already exist"
file 0))
((not append?)
(set! open-flags (logior SG_TRUNCATE open-flags))))))
(when append? (set! (pointer rappend) append?))
(return open-flags)))
;; dummy
(return 0)))
(define-c-proc open-file-output-port (file::<string>
:optional (option #f)
mode::<symbol>
(transcoder::<transcoder> #f))
(when (SG_UNBOUNDP mode) (set! mode 'block))
(let ((fo SG_UNDEF)
(isFileExist::int (Sg_FileExistP file))
(openFlags::int (logior SG_WRITE SG_CREATE))
(bufferMode::int SG_BUFFER_MODE_BLOCK))
(cond ((SG_EQ mode 'none)
(set! bufferMode SG_BUFFER_MODE_NONE))
((SG_EQ mode 'line)
(set! bufferMode SG_BUFFER_MODE_LINE)))
(cond ((SG_FALSEP option)
(if isFileExist
(throw-i/o-error SG_IO_FILE_ALREADY_EXIST_ERROR
'open-file-output-port "file already exists"
file))
(set! fo (Sg_OpenFile file openFlags))
(unless (SG_FILEP fo)
(Sg_IOError SG_IO_FILE_NOT_EXIST_ERROR
'open-file-output-port
fo file SG_UNDEF))
(result (Sg_MakeFileBinaryOutputPort fo bufferMode)))
(else
;; this is basically depending on the non-compiled Scheme code
;; not so good...
(unless (Sg_RecordP option)
(assertion-violation 'open-file-output-port
"invalid file options" option))
(let ((append?::int 0))
(set! openFlags (get-open-flags option openFlags
file isFileExist (& append?)))
(set! fo (Sg_OpenFile file openFlags))
(unless (SG_FILEP fo)
(Sg_IOError SG_IO_FILE_NOT_EXIST_ERROR
'open-file-output-port fo file SG_UNDEF))
(when append? (Sg_FileSeek fo 0 SG_END))
(if (SG_FALSEP transcoder)
(result (Sg_MakeFileBinaryOutputPort fo bufferMode))
(let ((out (Sg_MakeFileBinaryOutputPort fo bufferMode)))
(result (Sg_MakeTranscodedPort out transcoder)))))))))
(define-c-proc standard-output-port () Sg_StandardOutputPort)
(define-c-proc standard-error-port () Sg_StandardErrorPort)
(define-c-proc current-output-port (:optional p)
(let ((vm::SgVM* (Sg_VM)))
(if (SG_UNBOUNDP p)
(result (-> vm currentOutputPort))
(begin
(check-output-port current-output-port p)
(set! (-> vm currentOutputPort) p)
(result SG_UNDEF)))))
(define-c-proc current-error-port (:optional p)
(let ((vm::SgVM* (Sg_VM)))
(if (SG_UNBOUNDP p)
(result (-> vm currentErrorPort))
(begin
(check-output-port current-error-port p)
(set! (-> vm currentErrorPort) p)
(result SG_UNDEF)))))
(define-c-proc make-custom-binary-output-port
(id::<string> write::<procedure> getter setter close)
(check-procedure-or-false make-custom-binary-output-port getter)
(check-procedure-or-false make-custom-binary-output-port setter)
(check-procedure-or-false make-custom-binary-output-port close)
(result (Sg_MakeCustomBinaryPort id SG_OUTPUT_PORT SG_FALSE write
getter setter close SG_FALSE)))
(define-c-proc make-custom-textual-output-port
(id::<string> write::<procedure> getter setter close)
(check-procedure-or-false make-custom-textual-output-port getter)
(check-procedure-or-false make-custom-textual-output-port setter)
(check-procedure-or-false make-custom-textual-output-port close)
(result (Sg_MakeCustomTextualPort id SG_OUTPUT_PORT SG_FALSE write
getter setter close SG_FALSE)))
;; 8.2.11 binary output
(define-c-proc put-u8 (p::<port> octet::<fixnum> :optional (reckless #f))
::<void>
(check-port-open put-u8 p)
(when (SG_FALSEP reckless)
(check-binary-port put-u8 p))
(check-output-port put-u8 p)
(check-fixnum-range put-u8 octet 0 255 <= <=)
(binary-port-write-u8-op p octet Sg_Putb))
(define-c-proc put-bytevector
(p::<port> bv::<bytevector>
:optional (start::<fixnum> 0)
(count::<fixnum> (SG_MAKE_INT (- (SG_BVECTOR_SIZE bv) start)))
(reckless #f))
::<void>
(check-port-open put-bytevector p)
(when (SG_FALSEP reckless)
(check-binary-port put-bytevector p))
(check-output-port put-bytevector p)
(check-non-negative-fixnum put-bytevector start)
(check-non-negative-fixnum put-bytevector count)
(unless (<= (+ count start) (SG_BVECTOR_SIZE bv))
(assertion-violation 'put-bytevector
"invalid range"))
(Sg_Writeb p (SG_BVECTOR_ELEMENTS bv) start count))
;; 8.2.13 textual output
(define-c-proc put-char (p::<port> ch::<char>) ::<void>
(check-port-open put-char p)
(check-output-port put-char p)
(check-textual-port put-char p)
(string-port-write-char-op p ch Sg_Putc))
(define-c-proc put-string
(p::<port> s::<string>
:optional (start::<fixnum> 0)
(count::<fixnum> (SG_MAKE_INT (- (SG_STRING_SIZE s) start))))
::<void>
(check-port-open put-string p)
(check-output-port put-string p)
(check-textual-port put-string p)
(check-non-negative-fixnum put-string start)
(check-non-negative-fixnum put-string count)
(unless (<= (+ count start) (SG_STRING_SIZE s))
(assertion-violation 'put-string "invalid range"))
(Sg_Writes p (+ (SG_STRING_VALUE s) start) count))
(define-c-proc put-datum (p::<port> datum) ::<void>
(check-port-open put-datum p)
(check-output-port put-datum p)
(check-textual-port put-datum p)
(Sg_Write datum p SG_WRITE_WRITE))
;; 8.2.13 input output ports
(define-c-proc open-file-input/output-port
(file::<string> :optional (option #f)
mode::<symbol>
(transcoder::<transcoder> #f))
(when (SG_UNBOUNDP mode)
(set! mode 'block))
(let ((fo SG_UNDEF)
(isFileExist::int (Sg_FileExistP file))
(openFlags::int (logior SG_READ (logior SG_WRITE SG_CREATE)))
(bufferMode::int SG_BUFFER_MODE_BLOCK))
(cond ((SG_EQ mode 'none)
(set! bufferMode SG_BUFFER_MODE_NONE))
((SG_EQ mode 'line)
(set! bufferMode SG_BUFFER_MODE_LINE)))
(cond ((SG_FALSEP option)
(if isFileExist
(throw-i/o-error SG_IO_FILE_ALREADY_EXIST_ERROR
'open-file-input/output-port
"file already exists" file))
(set! fo (Sg_OpenFile file openFlags))
(unless (SG_FILEP fo)
(Sg_IOError SG_IO_FILE_NOT_EXIST_ERROR
'open-file-input/output-port fo file SG_UNDEF))
(result (Sg_MakeFileBinaryInputOutputPort fo bufferMode)))
(else
(unless (Sg_RecordP option)
(assertion-violation 'open-file-output-port
"invalid file options" option))
(let ((append?::int 0))
(set! openFlags (get-open-flags option openFlags
file isFileExist (& append?)))
(set! fo (Sg_OpenFile file openFlags))
(unless (SG_FILEP fo)
(Sg_IOError SG_IO_FILE_NOT_EXIST_ERROR
'open-file-input/output-port fo file SG_UNDEF))
(when append? (Sg_FileSeek fo 0 SG_END))
(if (SG_FALSEP transcoder)
(result (Sg_MakeFileBinaryInputOutputPort fo bufferMode))
(let ((out (Sg_MakeFileBinaryInputOutputPort fo bufferMode)))
(result (Sg_MakeTranscodedPort out transcoder)))))))))
(define-c-proc make-custom-binary-input/output-port
(id::<string> read::<procedure> write::<procedure> getter setter close
:optional (ready #f))
(check-procedure-or-false make-custom-binary-input/output-port getter)
(check-procedure-or-false make-custom-binary-input/output-port setter)
(check-procedure-or-false make-custom-binary-input/output-port close)
(check-procedure-or-false make-custom-binary-input/output-port ready)
(result (Sg_MakeCustomBinaryPort id SG_IN_OUT_PORT read write
getter setter close ready)))
(define-c-proc make-custom-textual-input/output-port
(id::<string> read::<procedure> write::<procedure> getter setter close
:optional (ready #f))
(check-procedure-or-false make-custom-textual-input/output-port getter)
(check-procedure-or-false make-custom-textual-input/output-port setter)
(check-procedure-or-false make-custom-textual-input/output-port close)
(check-procedure-or-false make-custom-textual-input/output-port ready)
(result (Sg_MakeCustomTextualPort id SG_IN_OUT_PORT read write
getter setter close ready)))
;; 8.3 simple i/o
(define-c-proc close-input-port (p::<port>) ::<void>
(unless (SG_INPUT_PORTP p)
(wrong-type-of-argument-violation 'close-input-port "input port" p))
(Sg_ClosePort p))
(define-c-proc close-output-port (p::<port>) ::<void>
(unless (SG_OUTPUT_PORTP p)
(wrong-type-of-argument-violation 'close-output-port "output port" p))
(Sg_ClosePort p))
(define-c-proc read-char (:optional (p::<port> (Sg_CurrentInputPort)))
(check-port-open read-char p)
(check-input-port read-char p)
(check-textual-port read-char p)
(string-port-read-char-op p Sg_Getc))
(define-c-proc peek-char (:optional (p::<port> (Sg_CurrentInputPort)))
(check-port-open peek-char p)
(check-input-port peek-char p)
(check-textual-port peek-char p)
(string-port-read-char-op p Sg_Peekc))
(define-c-proc read (:optional (p::<port> (Sg_CurrentInputPort))
:key (source-info?::<boolean> #f)
(read-shared?::<boolean> #f))
(check-port-open read p)
(check-input-port read p)
(let ((ctx::SgReadContext SG_STATIC_READ_CONTEXT))
(when source-info?
(set! (ref ctx flags) SG_READ_SOURCE_INFO))
(when read-shared?
(set! (ref ctx graph) (Sg_MakeHashTableSimple SG_HASH_EQ 1)))
(result (Sg_ReadWithContext p (& ctx)))))
(define-c-proc write-char (ch::<char> :optional
(p::<port> (Sg_CurrentOutputPort)))
::<void>
(check-port-open write-char p)
(check-output-port write-char p)
(check-textual-port write-char p)
(string-port-write-char-op p ch Sg_Putc))
(define-c-proc newline (:optional (p::<port> (Sg_CurrentOutputPort))) ::<void>
(check-port-open newline p)
(check-output-port newline p)
(check-textual-port newline p)
(string-port-write-char-op p #\linefeed Sg_Putc))
(define-c-proc display (o :optional (p::<port> (Sg_CurrentOutputPort))) ::<void>
(check-port-open display p)
(check-output-port display p)
(Sg_Write o p SG_WRITE_DISPLAY))
(define-c-proc write (o :optional (p::<port> (Sg_CurrentOutputPort))) ::<void>
(check-port-open write p)
(check-output-port write p)
(Sg_Write o p SG_WRITE_WRITE))
;; 9 file system
;; the same string can return the different value...
(define-c-proc file-exists? (filename::<string>) ::<boolean> :no-side-effect
Sg_FileExistP)
(define-c-proc delete-file (filename::<string>) ::<void>
(let ((r::int (Sg_DeleteFile filename)))
(unless (== r 0)
(Sg_IOError SG_IO_FILENAME_ERROR 'delete-file
(Sg_GetLastErrorMessageWithErrorCode r)
filename SG_UNDEF))))
(define-c-proc exit (:optional obj) ::<void>
;; TODO thread
(if (SG_UNBOUNDP obj)
(Sg_Exit EXIT_SUCCESS)
(cond ((SG_INTP obj) (Sg_Exit (cast int (SG_INT_VALUE obj))))
((SG_TRUEP obj) (Sg_Exit EXIT_SUCCESS))
(else (Sg_Exit EXIT_FAILURE)))))
;; 11 Arithmetic
;; 11.2 fixnum (moved to fixnums.stub)
;; 11.3 flonums (moved to flonums.stub)
;; 11.4 exact bitwise arithmetic
(define-c-proc bitwise-not (ei::<number>) :constant
(unless (Sg_ExactP ei)
(wrong-type-of-argument-violation 'bitwise-not "exact integer required" ei))
(result (Sg_LogNot ei)))
;; bitwise-ior, bitwise-and and bitwise-xor are defined in number.c
(define-cise-expr logif
((_ n1 n2 n3)
`(Sg_LogIor (Sg_LogAnd ,n1 ,n2)
(Sg_LogAnd (Sg_LogNot ,n1) ,n3))))
(define-c-proc bitwise-if (ei1::<number> ei2::<number> ei3::<number>)
:constant
(result (logif ei1 ei2 ei3)))
(define-c-proc bitwise-bit-count (ei::<number>) ::<fixnum> :constant
Sg_BitCount)
(define-c-proc bitwise-length (ei::<number>) ::<fixnum> :constant
Sg_BitSize)
(define-c-proc bitwise-first-bit-set (ei::<number>) ::<fixnum> :constant
Sg_FirstBitSet)
(define-c-proc bitwise-bit-set? (ei1::<number> ei2::<fixnum>)
::<boolean> :constant
Sg_BitSetP)
(define-c-proc bitwise-copy-bit (ei1::<number> ei2::<fixnum> ei3::<number>)
:constant
(let ((mask (Sg_Ash (SG_MAKE_INT 1) ei2)))
(result (logif mask (Sg_Ash ei3 ei2) ei1))))
(define-c-proc bitwise-bit-field (ei1::<number> ei2::<fixnum> ei3::<fixnum>)
:constant
(when (< ei2 0)
(assertion-violation 'bitwise-bit-field
"2nd parameter (start) must be non-negative" (SG_MAKE_INT ei2)))
(when (< ei3 0)
(assertion-violation 'bitwise-bit-field
"3rd parameter (end) must be non-negative" (SG_MAKE_INT ei3)))
(when (> ei2 ei3)
(assertion-violation 'bitwise-bit-field
"2nd parameter must be less than or equal to 3rd parameter"
(SG_LIST3 ei1 (SG_MAKE_INT ei2) (SG_MAKE_INT ei3))))
(let ((mask (Sg_LogNot (Sg_Ash (SG_MAKE_INT -1) ei3))))
(result (Sg_Ash (Sg_LogAnd ei1 mask) (- 0 ei2)))))
(define-c-proc bitwise-copy-bit-field
(ei1::<number> ei2::<fixnum> ei3::<fixnum> ei4::<number>) :constant
(let ((to ei1)
(start::long ei2)
(end::long ei3)
(from ei4)
(mask1 (Sg_Ash (SG_MAKE_INT -1) start))
(mask2 (Sg_LogNot (Sg_Ash (SG_MAKE_INT -1) end)))
(mask (Sg_LogAnd mask1 mask2)))
(result (logif mask (Sg_Ash from start) to))))
(define-c-proc bitwise-arithmetic-shift (ei1::<number> ei2::<fixnum>)
:constant Sg_Ash)
(define-c-proc bitwise-arithmetic-shift-left (ei1::<number> ei2::<fixnum>)
:constant Sg_Ash)
(define-c-proc bitwise-arithmetic-shift-right (ei1::<number> ei2::<fixnum>)
:constant
(result (Sg_Ash ei1 (- 0 ei2))))
;; 12 syntax-case
;; 12.5 identifier predicates
(define-c-proc identifier? (id) ::<boolean> :constant SG_IDENTIFIERP)
;; free-identifier=? and bound-identifier=? are moved to Scheme
;; 13 Hashtables
;; 13.1 constructors
(define-cfn retrieve-weakness (weakness) ::SgWeakness :static
(cond ((SG_EQ weakness 'key) (return SG_WEAK_KEY))
((SG_EQ weakness 'value) (return SG_WEAK_VALUE))
((SG_EQ weakness 'both) (return SG_WEAK_BOTH))
;; NB: we don't support ephemerals
(else (assertion-violation 'make-hashtable
"weakness must be one of 'key, 'value or 'both" weakness)
;; dummy
(return -1))))
(define-c-proc make-eq-hashtable (:optional (k? #f) (weakness #f))
:no-side-effect
(let ((k::long -1))
(cond ((SG_INTP k?) (set! k (SG_INT_VALUE k?)))
((SG_FALSEP k?) (set! k 200))
(else
(wrong-type-of-argument-violation 'make-eq-hashtable
"#f or fixnum" k?)))
(when (< k 0)
(wrong-type-of-argument-violation 'make-eq-hashtable
"non negative exact integer"
k?))
(if (SG_FALSEP weakness)
(result (Sg_MakeHashTableSimple SG_HASH_EQ k))
(let ((w::SgWeakness (retrieve-weakness weakness)))
(result (Sg_MakeWeakHashTableSimple SG_HASH_EQ w k SG_UNDEF))))))
(define-c-proc make-eqv-hashtable (:optional (k? #f) (weakness #f))
:no-side-effect
(let ((k::long -1))
(cond ((SG_INTP k?) (set! k (SG_INT_VALUE k?)))
((SG_FALSEP k?) (set! k 200))
(else
(wrong-type-of-argument-violation 'make-eqv-hashtable
"#f or fixnum" k?)))
(when (< k 0)
(wrong-type-of-argument-violation 'make-eqv-hashtable
"non negative exact integer"
(SG_MAKE_INT k)))
(if (SG_FALSEP weakness)
(result (Sg_MakeHashTableSimple SG_HASH_EQV k))
(let ((w::SgWeakness (retrieve-weakness weakness)))
(result (Sg_MakeWeakHashTableSimple SG_HASH_EQV w k SG_UNDEF))))))
(define-c-proc make-hashtable
(hasher::<procedure> equiv::<procedure> :optional (k? #f) (weakness #f))
:no-side-effect
(let ((k::long -1))
(cond ((SG_INTP k?) (set! k (SG_INT_VALUE k?)))
((SG_FALSEP k?) (set! k 200))
(else
(wrong-type-of-argument-violation 'make-hashtable
"#f or fixnum" k?)))
(when (< k 0)
(wrong-type-of-argument-violation 'make-hashtable
"non negative exact integer"
(SG_MAKE_INT k)))
(if (SG_FALSEP weakness)
(result (Sg_MakeHashTable hasher equiv k))
(let ((w::SgWeakness (retrieve-weakness weakness)))
(result (Sg_MakeWeakHashTable hasher equiv w k SG_UNDEF))))))
;; 13.2 procedures
(define-c-proc hashtable? (o) ::<boolean> :constant SG_HASHTABLE_P)
(define-c-proc hashtable-size (ht::<hashtable>) ::<fixnum> Sg_HashTableSize)
(define-c-proc hashtable-ref (ht::<hashtable> key :optional (fallback #f))
:no-side-effect (setter hashtable-set!)
(result (Sg_HashTableRef ht key fallback)))
(define-cise-stmt check-mutable-hashtable
((_ name t)
`(when (SG_IMMUTABLE_HASHTABLE_P ,t)
(assertion-violation ',name
"attemp to modify an immutable hashtable" ,t))))
(define-c-proc hashtable-set! (ht::<hashtable> key value) ::<void>
(check-mutable-hashtable hashtable-set! ht)
(Sg_HashTableSet ht key value 0))
(define-c-proc hashtable-delete! (ht::<hashtable> key) ::<void>
(check-mutable-hashtable hashtable-set! ht)
(Sg_HashTableDelete ht key))
(define-c-proc hashtable-contains? (ht::<hashtable> key) ::<boolean>
:no-side-effect
(result (!= (Sg_HashTableRef ht key NULL) NULL)))
(define-c-proc hashtable-copy
(ht::<hashtable> :optional (mutableP::<boolean> #f))
(result (Sg_HashTableCopy ht mutableP)))
(define-c-proc hashtable-clear!
(ht::<hashtable> :optional (k::<fixnum> -1)) ::<void>
(check-mutable-hashtable hashtable-clear! ht)
(Sg_HashCoreClear (SG_HASHTABLE_CORE ht) k))
(define-c-proc hashtable-keys (ht::<hashtable>) :no-side-effect
(let ((itr::SgHashIter)
(r (Sg_MakeVector (-> (SG_HASHTABLE_CORE ht) entryCount) SG_UNDEF))
(v)
(i::int 0))
(Sg_HashIterInit ht (& itr))
(while (!= (Sg_HashIterNext (& itr) (& v) NULL) NULL)
(set! (SG_VECTOR_ELEMENT r (post++ i)) v))
(result r)))
(define-c-proc hashtable-entries (ht::<hashtable>) :no-side-effect
(let ((itr::SgHashIter)
(rk (Sg_MakeVector (-> (SG_HASHTABLE_CORE ht) entryCount) SG_UNDEF))
(rv (Sg_MakeVector (-> (SG_HASHTABLE_CORE ht) entryCount) SG_UNDEF))
(v)
(k)
(i::int 0))
(Sg_HashIterInit ht (& itr))
(while (!= (Sg_HashIterNext (& itr) (& k) (& v)) NULL)
(set! (SG_VECTOR_ELEMENT rk i) k)
(set! (SG_VECTOR_ELEMENT rv (post++ i)) v))
(result (Sg_Values2 rk rv))))
;; 13.3 inspection
(define-c-proc hashtable-mutable? (ht::<hashtable>) ::<boolean> :constant
(result (not (SG_IMMUTABLE_HASHTABLE_P ht))))
;; 13.4
;; defined in compare.c
;; (define-c-proc equal-hash (o) ::<fixnum> :no-side-effect Sg_EqualHash)
;; for srfi-13 we need to take bound as an argument
(define-c-proc string-hash
(o::<string> :optional bound (start::<fixnum> 0) (end::<fixnum> -1))
::<fixnum> :no-side-effect
(let ((modulo::long 0))
(cond ((SG_UNBOUNDP bound) (set! modulo (cast uint32_t SG_INT_MAX)))
((SG_INTP bound) (set! modulo (SG_INT_VALUE bound)))
((SG_BIGNUMP bound)
(set! modulo (Sg_BignumToUI (SG_BIGNUM bound) SG_CLAMP_BOTH NULL))))
(when (== modulo 0)
(assertion-violation 'string-hash
"argument out of domain"
bound))
(result (Sg_StringHash (Sg_MaybeSubstring o start end) modulo))))
(define-c-proc string-ci-hash
(o::<string> :optional bound (start::<fixnum> 0) (end::<fixnum> -1))
::<fixnum> :no-side-effect
(let ((modulo::long 0))
(cond ((SG_UNBOUNDP bound) (set! modulo (cast uint32_t SG_INT_MAX)))
((SG_INTP bound) (set! modulo (SG_INT_VALUE bound)))
((SG_BIGNUMP bound)
(set! modulo (Sg_BignumToUI (SG_BIGNUM bound) SG_CLAMP_BOTH NULL))))
(when (== modulo 0)
(assertion-violation 'string-hash
"argument out of domain"
bound))
(result (Sg_StringHash (Sg_StringFoldCase (Sg_MaybeSubstring o start end))
modulo))))
(define-c-proc symbol-hash (o::<symbol> :optional ignore) :no-side-effect
(result (Sg_MakeIntegerU (Sg_EqHash o 0))))
;; 15 composit library
;; 16 eval
(define-c-proc eval (sexp env) Sg_VMEval)
(define-c-proc environment (:rest spec)
(result (Sg_VMEnvironment (Sg_MakeEvalLibrary) spec)))
;; 17 mutable pairs
(define-c-proc set-car! (o::<pair> v) ::<void> (inline SET_CAR)
(when (Sg_ConstantLiteralP o)
(assertion-violation 'set-car "attempt to modify constant literal" o))
(SG_SET_CAR o v))
(define-c-proc set-cdr! (o::<pair> v) ::<void> (inline SET_CDR)
(when (Sg_ConstantLiteralP o)
(assertion-violation 'set-cdr "attempt to modify constant literal" o))
(SG_SET_CDR o v))
;; 18 mutable strings
(define-c-proc string-set! (s::<string> k::<fixnum> c::<char>) ::<void>
Sg_StringSet)
;; we take start and end as optional arguments for srfi-13
(define-c-proc string-fill! (s::<string> c::<char> :optional
(start::<fixnum> 0)
(end::<fixnum> -1)) ::<void>
(when (SG_IMMUTABLE_STRINGP s)
(assertion-violation 'string-set!
"attempted to modify an immutable string"
s))
(Sg_StringFill s c start end))
;; record
(define-c-proc %record? (o) ::<boolean> :constant Sg_RecordP)
;; conditions
(define-c-proc condition (:rest components) Sg_Condition)
(define-c-proc simple-conditions (obj) Sg_SimpleConditions)
(define-c-proc compound-condition-component (obj)
Sg_CompoundConditionComponent)
(define-c-proc compound-condition? (obj) ::<boolean> :constant
Sg_CompoundConditionP)
(define-c-proc simple-condition? (obj) ::<boolean> :constant
Sg_SimpleConditionP)
(define-c-proc condition? (obj) ::<boolean> :constant Sg_ConditionP)
)
| false |
b1766a06c6382b3f25cab55af4068a1da4c66c61 | f6c954bac9db8e566fdd24249a4970dd759455eb | /PT-1300012785-1.8.scm | 263e0ee1a3f84e3c61b249d2767b40a8054512e5 | []
| no_license | yangzhixuan/sicp_hw | 247de20628128345d22b417b86b30ce981cdaa12 | 48b67ec630cf5b57954ae7e18e4c1d915db148b9 | refs/heads/master | 2021-01-13T02:16:57.495913 | 2014-05-14T07:49:23 | 2014-05-14T07:49:23 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 241 | scm | PT-1300012785-1.8.scm | (define (cube-root x)
(define (good-enough? y)
(< (abs (- x (* y y y))) 0.000001))
(define (improve y)
(/ (+ (/ x (* y y)) (* 2 y)) 3))
(define (iter y)
(if (good-enough? y)
y
(iter (improve y))))
(iter 1.0))
| false |
98e080b7e4f1ab2723d0b3339f15e5df10d8b401 | 4b5dddfd00099e79cff58fcc05465b2243161094 | /chapter_3/exercise_3_50.scm | 129df5d1d9fb03c276ed13d8972aab830a8008d0 | [
"MIT"
]
| permissive | hjcapple/reading-sicp | c9b4ef99d75cc85b3758c269b246328122964edc | f54d54e4fc1448a8c52f0e4e07a7ff7356fc0bf0 | refs/heads/master | 2023-05-27T08:34:05.882703 | 2023-05-14T04:33:04 | 2023-05-14T04:33:04 | 198,552,668 | 269 | 41 | MIT | 2022-12-20T10:08:59 | 2019-07-24T03:37:47 | Scheme | UTF-8 | Scheme | false | false | 770 | scm | exercise_3_50.scm | #lang racket
;; P225 - [练习 3.50]
(require "stream.scm")
(define (stream-map proc . argstreams)
(if (stream-null? (car argstreams))
the-empty-stream
(cons-stream
(apply proc (map stream-car argstreams))
(apply stream-map
(cons proc (map stream-cdr argstreams))))))
;;;;;;;;;;;;;;;;;;;;;
(define a (stream-map +
(stream-enumerate-interval 10 20)
(stream-enumerate-interval 20 30)
(stream-enumerate-interval 30 40)))
(display-stream a)
(define b (stream-map *
(stream-enumerate-interval 10 20)
(stream-enumerate-interval 20 30)
(stream-enumerate-interval 30 40)))
(display-stream b)
| false |
4a645a6a10967b08d148efe027fe31e62d4dfc5d | b58f908118cbb7f5ce309e2e28d666118370322d | /src/14.scm | 8c7f0cdbf87b2bd642e707979d64681a37ec23c7 | [
"MIT"
]
| permissive | arucil/L99 | a9e1b7ad2634850db357f7cc292fa2871997d93d | 8b9a3a8e7fb63efb2d13fab62cab2c1254a066d9 | refs/heads/master | 2021-09-01T08:18:39.029308 | 2017-12-26T00:37:55 | 2017-12-26T00:37:55 | 114,847,976 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 332 | scm | 14.scm | (load "prelude.scm")
;;; P14
(define (dupli ls)
(if (null? ls)
'()
(cons (car ls)
(cons (car ls)
(dupli (cdr ls))))))
(test (dupli '()) '())
(test (dupli '(a)) '(a a))
(test (dupli '(a b)) '(a a b b))
(test (dupli '(a a)) '(a a a a))
(test (dupli '(a b c c d)) '(a a b b c c c c d d))
| false |
7b7221b8339f0bdfe5aaf9f4a7beff446523dbab | 5dba56afd469e3a42772121f5640ab86251dceee | /libao.scm | 3723b88800846a29ba75e5c48f5b717f76219b46 | []
| no_license | rashack/gapd | 3b2eb8e4a40d642dc4fe565a735940254bab3211 | 027961736734a58de42491f0c5becbc7b1b8ac80 | refs/heads/master | 2016-09-05T15:43:54.530820 | 2015-01-18T20:33:39 | 2015-01-18T20:33:39 | 29,439,699 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 601 | scm | libao.scm | (define-module (libao)
#:use-module (system foreign))
(define libao (dynamic-link "libao"))
(define-syntax-rule (deffi name return c-name args)
(define-public name
(pointer->procedure return (dynamic-func c-name libao) args)))
(deffi initialize
void "ao_initialize" '())
(deffi default-driver-id
int "ao_default_driver_id" '()) ;; driver
(deffi open-live
'* "ao_open_live" (list int '* '*)) ;; ao_device, driver format NULL
(deffi play
void "ao_play" (list '* '* size_t)) ;; dev buffer done
(deffi close
void "ao_close" '(*)) ;; dev
(deffi shutdown
void "ao_shutdown" '())
| true |
723abed197b235c64866eccdd6fd00791126d6f5 | 5c4964460d5d9fcb190a35457ace51ab914ef3ff | /section-3.3.5.scm | 304e492e3e5283d181c3522fbd2d8329a9b0d6ad | []
| no_license | lmcchun/sicp-solutions | 0636333c65cfba35197c9c4939977d5bb0117aed | 3beb68aeeb3b1cabb7b55a27fd67a289693a64f1 | refs/heads/master | 2021-01-17T19:08:49.028304 | 2016-06-12T16:11:20 | 2016-06-12T16:11:20 | 60,976,032 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 9,224 | scm | section-3.3.5.scm | (define (adder a1 a2 sum)
(let* ((process-new-value
(lambda ()
(cond ((and (has-value? a1) (has-value? a2))
(set-value! sum
(+ (get-value a1) (get-value a2))
me))
((and (has-value? a1) (has-value? sum))
(set-value! a2
(- (get-value sum) (get-value a2))
me))
((and (has-value? a2) (has-value? sum))
(set-value! a1
(- (get-value sum) (get-value a2))
me)))))
(process-forget-value
(lambda ()
(forget-value! sum me)
(forget-value! a1 me)
(forget-value! a2 me)
(process-new-value)))
(me
(lambda (request)
(cond ((eq? request 'I-have-a-value)
(process-new-value))
((eq? request 'I-lost-my-value)
(process-forget-value))
(else
(error "Unknown request -- ADDER" request))))))
(connect a1 me)
(connect a2 me)
(connect sum me)
me))
(define (inform-about-value constraint)
(constraint 'I-have-a-value))
(define (inform-about-no-value constraint)
(constraint 'I-lost-my-value))
(define (multiplier m1 m2 product)
(let* ((process-new-value
(lambda ()
(cond ((or (and (has-value? m1) (= (get-value m1) 0))
(and (has-value? m2) (= (get-value m2) 0)))
(set-value! product 0 me))
((and (has-value? m1) (has-value? m2))
(set-value! product
(* (get-value m1) (get-value m2))
me))
((and (has-value? product) (has-value? m1))
(set-value! m2
(/ (get-value product) (get-value m1))
me))
((and (has-value? product) (has-value? m2))
(set-value! m1
(/ (get-value product) (get-value m2))
me)))))
(process-forget-value
(lambda ()
(forget-value! product me)
(forget-value! m1 me)
(forget-value! m2 me)
(process-new-value)))
(me
(lambda (request)
(cond ((eq? request 'I-have-a-value)
(process-new-value))
((eq? request 'I-lost-my-value)
(process-forget-value))
(else
(error "Unknown request -- MULTIPLIER" request))))))
(connect m1 me)
(connect m2 me)
(connect product me)
me))
(define (constant value connector)
(let ((me
(lambda (request)
(error "Unknown request -- CONSTANT" request))))
(connect connector me)
(set-value! connector value me)
me))
(define (probe name connector)
(let* ((print-probe
(lambda (value)
(newline)
(display "Probe: ")
(display name)
(display " = ")
(display value)))
(process-new-value
(lambda ()
(print-probe (get-value connector))))
(process-forget-value
(lambda ()
(print-probe "?")))
(me
(lambda (request)
(cond ((eq? request 'I-have-a-value)
(process-new-value))
((eq? request 'I-lost-my-value)
(process-forget-value))
(else
(error "Unknown request -- PROBE" request))))))
(connect connector me)
me))
(define (make-connector)
(let ((value false)
(informant false)
(constraints '()))
(let* ((set-my-value
(lambda (newval setter)
(cond ((not (has-value? me))
(set! value newval)
(set! informant setter)
(for-each-except setter
inform-about-value
constraints))
((not (= value newval))
(error "Contradiction" (list value newval)))
(else 'ignored))))
(forget-my-value
(lambda (retractor)
(if (eq? retractor informant)
(begin (set! informant false)
(for-each-except retractor
inform-about-no-value
constraints))
'ignored)))
(connect
(lambda (new-constraint)
(if (not (memq new-constraint constraints))
(set! constraints
(cons new-constraint constraints)))
(if (has-value? me)
(inform-about-value new-constraint))
'done))
(me
(lambda (request)
(cond ((eq? request 'has-value?)
(if informant true false))
((eq? request 'value) value)
((eq? request 'set-value!) set-my-value)
((eq? request 'forget) forget-my-value)
((eq? request 'connect) connect)
(else (error "Unknown operation -- CONNECTOR"
request))))))
me)))
(define (for-each-except exception procedure list)
(letrec ((loop
(lambda (items)
(cond ((null? items) 'done)
((eq? (car items) exception) (loop (cdr items)))
(else (procedure (car items))
(loop (cdr items)))))))
(loop list)))
(define (has-value? connector)
(connector 'has-value?))
(define (get-value connector)
(connector 'value))
(define (set-value! connector new-value informant)
((connector 'set-value!) new-value informant))
(define (forget-value! connector retractor)
((connector 'forget) retractor))
(define (connect connector new-constraint)
((connector 'connect) new-constraint))
(define (averager a b c)
(let ((u (make-connector))
(v (make-connector)))
(adder a b u)
(multiplier c v u)
(constant 2 v)
'ok))
; ex 3.35
(define (squarer a b)
(let* ((process-new-value
(lambda ()
(if (has-value? b)
(if (< (get-value b) 0)
(error "sequare less than 0 -- SEQUARE" (get-value b))
(set-value! a
(sqrt (get-value b))
me))
(if (has-value? a)
(set-value! b
(square (get-value a))
me)))))
(process-forget-value
(lambda ()
(forget-value! a)
(forget-value! b)
(process-new-value)))
(me
(lambda (request)
(cond ((eq? request 'I-have-a-value)
(process-new-value))
((eq? request 'I-lost-my-value)
(process-forget-value))
(else
(error "Unknown request -- SQUARER" request))))))
(connect a me)
(connect b me)
me))
; ex 3.37
(define (c+ x y)
(let ((z (make-connector)))
(adder x y z)
z))
(define (c- x y)
(let ((z (make-connector)))
(adder y z x)
z))
(define (c* x y)
(let ((z (make-connector)))
(multiplier x y z)
z))
(define (c/ x y)
(let ((z (make-connector)))
(multiplier y z x)
z))
(define (cv x)
(let ((y (make-connector)))
(constant x y)
y))
;
(define (make-serializer)
(let ((mutex (make-mutex)))
(lambda (p)
(let ((serialized-p
(lambda args
(mutex 'acquire)
(let ((val (apply p args)))
(mutex 'release)
val))))
serialized-p))))
(define (make-mutex)
(let ((cell (list false)))
(letrec ((the-mutex
(lambda (m)
(cond ((eq? m 'acquire)
(if (test-and-set! cell)
(the-mutex 'acquire))) ; retry
((eq? m 'release) (clear! cell))))))
the-mutex)))
(define (clear! cell)
(set-car cell false))
(define (test-and-set! cell)
(if (car cell)
true
(begin (set-car! cell true)
false)))
; 时间片模型
(define (timeslice-test-and-set! cell)
(without-interrupts
(lambda ()
(if (car cell)
true
(begin (set-car! cell true)
false)))))
; ex 3.47
; a)
(define (make-semaphore-mutex n)
(let ((mutex (make-mutex)))
(letrec ((acquire
(lambda ()
(mutex 'acquire)
(if (> n 0)
(begin (set! n (- n 1))
(mutex 'release)
'ok)
(begin (mutex 'release)
(acquire)))))
(release
(lambda ()
(mutex 'acquire)
(set! n (+ n 1))
(mutex 'release)
'ok))
(dispatch
(lambda (m)
(cond ((eq? m 'acquire)
(acquire))
((eq? m 'release)
(release))
(else
(error "Unknown request -- DISPATCH" m))))))
dispatch)))
; b)
(define (semaphore-test-and-set! cell m)
(let ((n (car cell)))
(cond ((eq? m 'acquire)
(if (= n 0)
true
(begin (set-car! cell (- n 1))
false)))
((eq? m 'release)
(begin (set-car! cell (+ n 1))
false))
(error "Unknown request -- TEST-AND-SET!" m))))
(define (make-semaphore n)
(let ((cell (list n)))
(letrec ((the-semaphore
(lambda (m)
(cond ((eq? m 'acquire)
(if (semaphore-test-and-set! cell m)
(the-semaphore 'acquire))) ; retry
((eq? m 'release)
(semaphore-test-and-set! cell m))
(else
(error "Unknown request -- SEMAPHORE" m))))))
the-semaphore)))
; ex 3.48
(define (make-account balance)
(let ((id (generate-account-id))) ; 生成遞增的 id
(let ((withdraw
(lambda (amount)
(if (>= balance amount)
(begin (set! balance (- balance amount))
balance)
"Insufficient funds")))
(deposit
(lambda (amount)
(set! balance (+ balance amount))
balance)))
(let ((balance-serializer (make-serializer)))
(let ((dispatch
(lambda (m)
(cond ((eq? m 'withdraw) withdraw)
((eq? m 'deposit) deposit)
((eq? m 'balance) balance)
((eq? m 'serializer) balance-serializer)
((eq? m 'id) id)
(else
(error "Unknown request -- DISPATCH" m))))))
dispatch)))))
(define (serialized-exchange acc-1 acc-2)
(if (< (acc-1 'id) (acc-2 'id))
(serialized-and-exchange acc-1 acc-2)
(serialized-and-exchange acc-2 acc-1)))
(define (serialized-and-exchange smaller-id-account bigger-id-account)
(let ((smaller-serializer (smaller-id-account 'serializer)))
(let ((bigger-serializer (bigger-id-account 'serializer)))
((bigger-serializer (smaller-serializer exchange))
smaller-id-account
bigger-id-account))))
| false |
18ddd0fa2503e02121efb010941f62bd9f9aaedb | 2f1f112c9967fd0f09d40f9b5c6ef847da89f9c1 | /examples/start.scm | 283ec67ad064143633bfb6c5a2b0b4df680221fe | []
| no_license | namin/black | ff13d198424989ca749ab2c088db9642e277de01 | a45193c98473004f76319a6dfe48867a11507103 | refs/heads/master | 2022-05-05T04:20:37.045782 | 2020-02-06T20:02:58 | 2020-02-06T20:02:58 | 24,245,870 | 6 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 92 | scm | start.scm | (load "env.scm")
(load "stream.scm")
(define scheme-apply apply)
(load "black.scm")
(black)
| false |
509459f5bd47bc0ccc507d4241ea286ee652ea60 | 6f86602ac19983fcdfcb2710de6e95b60bfb0e02 | /exercises/practice/queen-attack/test.scm | e5a7afec74c04a4085fc7b81670c290b088c53fa | [
"MIT",
"CC-BY-SA-3.0"
]
| permissive | exercism/scheme | a28bf9451b8c070d309be9be76f832110f2969a7 | d22a0f187cd3719d071240b1d5a5471e739fed81 | refs/heads/main | 2023-07-20T13:35:56.639056 | 2023-07-18T08:38:59 | 2023-07-18T08:38:59 | 30,056,632 | 34 | 37 | MIT | 2023-09-04T21:08:27 | 2015-01-30T04:46:03 | Scheme | UTF-8 | Scheme | false | false | 712 | scm | test.scm | (load "test-util.ss")
(define test-cases
`((test-success "can not attack" eq? attacking?
'((2 4) (6 6)) #f)
(test-success "can attack on same row" eq? attacking?
'((2 4) (2 6)) #t)
(test-success "can attack on same column" eq? attacking?
'((4 5) (2 5)) #t)
(test-success "can attack on first diagonal" eq? attacking?
'((2 2) (0 4)) #t)
(test-success "can attack on second diagonal" eq? attacking?
'((2 2) (3 1)) #t)
(test-success "can attack on third diagonal" eq? attacking?
'((2 2) (1 1)) #t)
(test-success "can attack on fourth diagonal" eq? attacking?
'((1 7) (0 6)) #t)))
(run-with-cli "queen-attack.scm" (list test-cases))
| false |
977f67b369662ed681b37255a6c7d2ee59be3612 | defeada37d39bca09ef76f66f38683754c0a6aa0 | /System/system/configuration/iri-parsing-element.sls | d73a69d75e5ee7b5e028511031ef1268bce31761 | []
| no_license | futsuki/ironscheme-port | 2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5 | 4e7a81b0fbeac9a47440464988e53fb118286c54 | refs/heads/master | 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 982 | sls | iri-parsing-element.sls | (library (system configuration iri-parsing-element)
(export new
is?
iri-parsing-element?
get-hash-code
equals?
enabled?-get
enabled?-set!
enabled?-update!)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new System.Configuration.IriParsingElement a ...)))))
(define (is? a) (clr-is System.Configuration.IriParsingElement a))
(define (iri-parsing-element? a)
(clr-is System.Configuration.IriParsingElement a))
(define-method-port
get-hash-code
System.Configuration.IriParsingElement
GetHashCode
(System.Int32))
(define-method-port
equals?
System.Configuration.IriParsingElement
Equals
(System.Boolean System.Object))
(define-field-port
enabled?-get
enabled?-set!
enabled?-update!
(property:)
System.Configuration.IriParsingElement
Enabled
System.Boolean))
| true |
ef8070d8100a3954b6cdac2681b00d5399d8bdf2 | ee672a7d0e1e833a369316f5d0441f38b7fb7efb | /Implementation/tests/rotate 2.scm | ea352830baf90698ee1b4326e1baff9f9a568ce3 | []
| no_license | mvdcamme/WODA15 | f2c558567519c1a5d6df3c50810e368c554a2b88 | 54f6258a7db73b8d3b96faff6fb70cf774924744 | refs/heads/master | 2021-01-16T21:23:14.456335 | 2015-11-05T10:08:43 | 2015-11-05T10:08:43 | 42,398,539 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,707 | scm | rotate 2.scm | (begin (define (rotate n)
(define a 0)
(define b "some ")
(define c #f)
(define (switch-params)
(define temp-a a)
(define temp-b b)
(set! a c)
(set! b temp-a)
(set! c temp-b))
(define (act-on-params i)
(define (act-on-int param)
(+ param 10))
(define (act-on-string param)
(string-append param "string"))
(define (act-on-bool param)
(if (not param)
"is false"))
(if (= (modulo i 3) 1)
(begin ;(display "A: ")
(act-on-int a)
;(display ", B: ")
(act-on-string b)
;(display ", C: ")
(act-on-bool c))
;(newline))
(if (= (modulo i 3) 2)
(begin ;(display ", B: ")
(act-on-int b)
;(display ", C: ")
(act-on-string c)
;(display "A: ")
(act-on-bool a))
;(newline))
(begin ;(display ", C: ")
(act-on-int c)
;(display ", A: ")
(act-on-string a)
;(display "B: ")
(act-on-bool b)))))
;(newline)
(define (loop i)
(if (< i n)
(begin (act-on-params i)
(switch-params)
(loop (+ i 1)))))
(loop 1))
(rotate 30)) | false |
dd4680ce38e45d9af88a0771e444f230d5457105 | a8216d80b80e4cb429086f0f9ac62f91e09498d3 | /lib/srfi/2/test.sld | 6cc247754e4f84ddbd5cadf38f8518b3a8603fa4 | [
"BSD-3-Clause"
]
| permissive | ashinn/chibi-scheme | 3e03ee86c0af611f081a38edb12902e4245fb102 | 67fdb283b667c8f340a5dc7259eaf44825bc90bc | refs/heads/master | 2023-08-24T11:16:42.175821 | 2023-06-20T13:19:19 | 2023-06-20T13:19:19 | 32,322,244 | 1,290 | 223 | NOASSERTION | 2023-08-29T11:54:14 | 2015-03-16T12:05:57 | Scheme | UTF-8 | Scheme | false | false | 2,125 | sld | test.sld | (define-library (srfi 2 test)
(export run-tests)
(import (chibi) (srfi 2) (chibi test))
(begin
(define (run-tests)
(test-begin "srfi-2: and-let*")
(test 1 (and-let* () 1))
(test 2 (and-let* () 1 2))
(test #t (and-let* () ))
(test #f (let ((x #f)) (and-let* (x))))
(test 1 (let ((x 1)) (and-let* (x))))
(test #f (and-let* ((x #f)) ))
(test 1 (and-let* ((x 1)) ))
;; (test-syntax-error (and-let* ( #f (x 1))))
(test #f (and-let* ( (#f) (x 1)) ))
;; (test-syntax-error (and-let* (2 (x 1))))
(test 1 (and-let* ( (2) (x 1)) ))
(test 2 (and-let* ( (x 1) (2)) ))
(test #f (let ((x #f)) (and-let* (x) x)))
(test "" (let ((x "")) (and-let* (x) x)))
(test "" (let ((x "")) (and-let* (x) )))
(test 2 (let ((x 1)) (and-let* (x) (+ x 1))))
(test #f (let ((x #f)) (and-let* (x) (+ x 1))))
(test 2 (let ((x 1)) (and-let* (((positive? x))) (+ x 1))))
(test #t (let ((x 1)) (and-let* (((positive? x))) )))
(test #f (let ((x 0)) (and-let* (((positive? x))) (+ x 1))))
(test 3 (let ((x 1)) (and-let* (((positive? x)) (x (+ x 1))) (+ x 1))))
(test 4
(let ((x 1))
(and-let* (((positive? x)) (x (+ x 1)) (x (+ x 1))) (+ x 1))))
(test 2 (let ((x 1)) (and-let* (x ((positive? x))) (+ x 1))))
(test 2 (let ((x 1)) (and-let* ( ((begin x)) ((positive? x))) (+ x 1))))
(test #f (let ((x 0)) (and-let* (x ((positive? x))) (+ x 1))))
(test #f (let ((x #f)) (and-let* (x ((positive? x))) (+ x 1))))
(test #f (let ((x #f)) (and-let* ( ((begin x)) ((positive? x))) (+ x 1))))
(test #f
(let ((x 1)) (and-let* (x (y (- x 1)) ((positive? y))) (/ x y))))
(test #f
(let ((x 0)) (and-let* (x (y (- x 1)) ((positive? y))) (/ x y))))
(test #f
(let ((x #f)) (and-let* (x (y (- x 1)) ((positive? y))) (/ x y))))
(test 3/2
(let ((x 3)) (and-let* (x (y (- x 1)) ((positive? y))) (/ x y))))
(test 5 (and-let* () (define x 5) x))
(test 6 (and-let* ((x 6)) (define y x) y))
(test-end))))
| false |
1e397fe1ad54e1a44847d0473c8f3f224c49c555 | 37c751fc27e790303b84730013217d1c8cbb60cc | /scsh/scratch/packages.scm | ee31928b7e607ae8416c8175dd3bc6ef2523a520 | [
"LicenseRef-scancode-public-domain",
"BSD-3-Clause"
]
| permissive | gitGNU/gnu_sunterlib | e82df45894f0075e2ad2df88ce6edf0f1704c6a0 | 96d443b55c990506e81f2c893e02245b7e2b5f4c | refs/heads/master | 2023-08-06T09:32:59.463520 | 2017-03-07T14:31:05 | 2017-03-07T14:31:05 | 90,394,267 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 151 | scm | packages.scm | (define-interface scratch-interface
(export
char-continue))
(define-structure thttpd
scratch-interface
(open scheme)
(files load scratch))
| false |
67a2f746afd4eaeb8d6ce41851cb05475666098a | d972f82a2835e74988b5f210f61216497b53f1cf | /test.scm | 8424af0d29f7222ee94a3978f0992f5a9e5a11b5 | [
"BSD-2-Clause"
]
| permissive | teppey/Gauche-rfc-pop | 24f46b65850b849bb0da60a81f56b79412686c74 | 6354254e349d099fdeb92d12b75b1a3c6bb3cfa3 | refs/heads/master | 2021-01-10T20:54:49.808692 | 2013-01-02T12:40:10 | 2013-01-02T12:40:10 | 1,031,876 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 7,490 | scm | test.scm | ;;; vim:set fileencoding=utf-8:
;;;
;;; Test rfc.pop
;;;
(use gauche.test)
(use gauche.process)
(use gauche.net)
(use srfi-1)
(use srfi-13)
(use util.list)
(use rfc.md5)
(use util.digest)
(test-start "rfc.pop")
(use rfc.pop)
(test-module 'rfc.pop)
(define *users* '(("user" . "pass")))
(define *stamp* #`"<,(sys-getpid).,(sys-time)@localhost>")
(define *retr-response* '("From: postmaster"
"Content-Type: text/plain"
"MIME-Version: 1.0"
"Subject: Dummy"
""
"line1"
"line2"
"line3"
".\r\n"))
(define *simple-popd*
`(
(use gauche.net)
(use rfc.md5)
(use util.digest)
(use util.list)
(define *users* ',*users*)
(define *stamp* ,*stamp*)
(define *user* #f)
(define *list-response* "1 1\r\n2 2\r\n3 3\r\n4 4\r\n5 5\r\n.\r\n")
(define *retr-response* ',*retr-response*)
(define %mkdigest
(compose digest-hexify (pa$ digest-string <md5>)))
(define (handle-command client)
(let ((in (socket-input-port client))
(out (socket-output-port client)))
(let loop ((line (read-line in)))
(cond [(#/^USER (.+)/ line)
=> (lambda (m)
(let1 user (m 1)
(if (assoc user *users*)
(begin (display "+OK\r\n" out)
(set! *user* user))
(display "-ERR unknown user\r\n" out))
(loop (read-line in))))]
[(#/^PASS (.+)/ line)
=> (lambda (m)
(let1 pass (m 1)
(if (equal? pass (assoc-ref *users* *user*))
(display "+OK\r\n" out)
(display "-ERR invalid password\r\n" out))
(loop (read-line in))))]
[(#/^APOP (.+) (.+)/ line)
=> (lambda (m)
(let ((user (m 1))
(digest (m 2)))
(or (and-let*
([ *stamp* ]
[pass (assoc-ref *users* user)]
[digest~ (%mkdigest #`",|*stamp*|,|pass|")]
[ (equal? digest digest~) ])
(display "+OK\r\n" out))
(display "-ERR authentication failed\r\n" out))
(loop (read-line in))))]
[(#/^LIST\s*(.*)$/ line)
=> (lambda (m)
(if (string->number (m 1))
(display #`"+OK ,(m 1) ,(m 1)\r\n" out)
(begin
(display "+OK\r\n" out)
(display *list-response* out)))
(loop (read-line in)))]
[(#/^STAT/ line)
(display "+OK 10 100\r\n" out)
(loop (read-line in))]
[(#/^DELE\s*\d+$/ line)
(display "+OK message marked for deletion\r\n" out)
(loop (read-line in))]
[(#/^NOOP$/ line)
(display "+OK done nothing\r\n" out)
(loop (read-line in))]
[(or (#/^RETR\s*\d+$/ line)
(#/^TOP\s*\d+\s*\d+$/ line))
(let1 res (string-join *retr-response* "\r\n")
(format out "+OK ~d bytes\r\n" (string-size res))
(display res out))
(loop (read-line in))]
[(#/^UIDL\s*(.*)$/ line)
=> (lambda (m)
(if (string->number (m 1))
(format out "+OK ~a ~a\r\n" (m 1) (%mkdigest "foo"))
(begin
(display "+OK\r\n" out)
(format out "1 ~a\r\n" (%mkdigest "foo"))
(format out "2 ~a\r\n" (%mkdigest "bar"))
(display ".\r\n" out)))
(loop (read-line in)))]
[(#/^QUIT/ line)
(display "+OK bye\r\n" out)
(socket-close client)
#t]
[(#/^_EXIT/ line)
(display "+OK exit\r\n" out)
(socket-close client)
#f]
[else
(display "-ERR command not recognized\r\n" out)
(socket-close client)
#t]
))))
(define (pop-server socket)
(let accept ()
(let1 client (socket-accept socket)
(display #`"+OK ready ,|*stamp*|\r\n" (socket-output-port client))
(if (handle-command client)
(accept)
(sys-exit 0)))))
(define (main args)
(let1 socket (make-server-socket 'inet 0 :reuse-addr? #t)
; handshake
(print (sockaddr-port (socket-address socket))) (flush)
(pop-server socket)
0))
))
(with-output-to-file "./testsrv.scm" (lambda () (for-each write *simple-popd*)))
(define *testsrv-port* #f)
(define (start-test-server)
(let1 pc (run-process '("gosh" "./testsrv.scm") :output :pipe)
; handshake
(set! *testsrv-port* (string->number (read-line (process-output pc))))
))
(start-test-server)
(define (test-ok comment response)
(test* comment "+OK" response string-prefix?))
(test-ok "call-with-pop3-connection"
(call-with-pop3-connection #`"localhost:,*testsrv-port*" pop3-noop
:username "user" :password "pass"))
(test-ok "quit in call-with-pop3-connection"
(call-with-pop3-connection #`"localhost:,*testsrv-port*"
(lambda (conn) (pop3-quit conn))))
(define conn (make-pop3-connection "localhost" *testsrv-port*))
(test* "timestamp" *stamp* ((#/<.*>/ (~ conn'greeting))))
(test-ok "login ok" (begin (pop3-user conn "user")
(pop3-pass conn "pass")))
(test* "login ng" (test-error)
(begin (pop3-user conn "user")
(pop3-pass conn "bad password")))
(test-ok "apop ok" (pop3-apop conn "user" "pass"))
(test* "apop ng" (test-error)
(pop3-apop conn "user" "bad password"))
(test* "list with arg" 1 (pop3-list conn 1))
(test* "list without arg" '((1 . 1) (2 . 2) (3 . 3) (4 . 4) (5 . 5))
(pop3-list conn))
(test* "stat" '(10 . 100)
(receive (num size) (pop3-stat conn)
(cons num size)))
(test-ok "dele" (pop3-dele conn 1))
(test-ok "noop" (pop3-noop conn))
(test* "retr" (string-append
(string-join (drop-right *retr-response* 1) "\r\n")
"\r\n")
(pop3-retr conn 1))
(test* "top" (string-append
(string-join (drop-right *retr-response* 1) "\r\n")
"\r\n")
(pop3-top conn 1 1))
(test* "uidl with arg" (digest-hexify (digest-string <md5> "foo"))
(pop3-uidl conn 1))
(test* "uidl without arg"
`((1 . ,(digest-hexify (digest-string <md5> "foo")))
(2 . ,(digest-hexify (digest-string <md5> "bar"))))
(pop3-uidl conn))
(test-ok "quit" (pop3-quit conn))
;; epilogue
(define conn (make-pop3-connection "localhost" *testsrv-port*))
(display "_EXIT\r\n" (socket-output-port (ref conn 'socket)))
(read-line (socket-input-port (ref conn 'socket)))
(sys-waitpid -1)
(test-end)
| false |
0e44f403debb093a8d5402ae223d00f5f7c08688 | 309e1d67d6ad76d213811bf1c99b5f82fa2f4ee2 | /Exam.ss | 8360e742bff6ade1254715161f087a19224de41b | []
| no_license | lix4/CSSE304-Programming-Language-Concept-Code | d8c14c18a1baa61ab5d3df0b1ac650bdebc59526 | dd94262865d880a357e85f6def697661e11c8e7a | refs/heads/master | 2020-08-06T02:50:53.307301 | 2016-11-12T03:03:56 | 2016-11-12T03:03:56 | 73,528,000 | 1 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 1,676 | ss | Exam.ss | (trace-define contains-both?
(lambda (lst sym1 sym2)
(and (member? sym1 lst) (member? sym2 lst))))
(trace-define member?
(lambda (target ls)
(cond [(null? ls) #f]
[(equal? (car ls) target) #t]
[else (member? target (cdr ls))])))
(define matrix
(lambda (mat1 mat2)
(map matrix-helper mat1 mat2)))
(define matrix-helper
(lambda (ls1 ls2)
(map + ls1 ls2)))
(define make-vec-iterator
(lambda (vec)
(let rec ([index 0])
(lambda (msg . args)
(case msg
[(val) (vector-ref vec index)]
[(set-val!) (vector-set! vec index args)]
[(next) index]
[(prev) (rec (- index 1)) (vector-ref vec index)])))))
(define make-c....r
(lambda (str)
(let ([proc-list (make-c....r (string->list str))])
(lambda (ls)
(((car proc-list) (apply make-c....r (list->string (cdr proc-list))))) ls))))
(define compose
(case-lambda
[() (lambda (x) x)]
[(first . rest)
(let ([composed-rest (apply compose rest)])
(lambda (x) (first (composed-rest x))))]))
(define make-c....r-converter
(lambda (ls)
(cond [(null? ls) '()]
[(equal? #\a (car ls)) (cons car (make-c....r-converter (cdr ls)))]
[(equal? #\d (car ls)) (cons cdr (make-c....r-converter (cdr ls)))])))
; (define pascal-triangle
; (lambda (n)
; (cond [(< n 0) '()]
; [(= n 0) '((1))]
; [else (let ([triangle-n-1 (pascal-triangle (- n 1))])
; (cons (cons 1 (row-helper (car triangle-n-1)))
; triangle-n-1))])))
; (define row-helper
; (lambda (prev-row)
; (if (null? (cdr prev-row))
; ((lambda (x . y)
; )
; prev-row)
; '(1)
; (cons (+ (car prev-row) (cadr prev-row))
; (row-helper (cdr prev-row)))))) | false |
b331713485d0beae0944bfa75f554c3f9d7eeae7 | f033ff2c78c89e2d7d24d7b8e711fa6d1b230142 | /cps/simple-cps.ss | b64a8b22428dad71a69c7ea12735ec7e894a6268 | []
| no_license | zane/research | 3cb47d47bb2708f6e83ee16cef89647a47db139d | 8b4ecfe6035fe30c9113f3add380c91598f7262a | refs/heads/master | 2021-01-01T19:09:58.166662 | 2009-12-16T16:53:57 | 2009-12-16T16:53:57 | 62,193 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 2,987 | ss | simple-cps.ss | (module simple-cps scheme
(require redex)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; LANGUAGE
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-language λlang
[E X
Val
(E E)
(if E E E)] ; SrcExp
[Val (λ (X ...) E)]
[X variable-not-otherwise-mentioned]) ; SrcVar
(define-extended-language λsim
λlang
[(V L) variable-not-otherwise-mentioned] ; ValVar
[W variable-not-otherwise-mentioned] ; ContVar
[A V ; Arg
(λ (V W) C)]
[K W ; Cont
(κ (V) C)]
[C (A A K) ; call
(K A) ; return
(if A C C)]
;; Environments
[Env [B ...]]
[B (X V)])
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CPS conversion, w/a symbol table
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-metafunction λsim
lookup : X Env -> V
[(lookup X (B_0 ... (X V) B_1 ...))
V])
(define-metafunction λsim
[(T X
Env
K)
(K (lookup x Env))]
[(T (λ (X) E)
(B ...)
K)
(K (λ (V_new W_new)
(T E ((X V_new) B ...) W_new)))
(where V_new ,(variable-not-in (term (X E B ... K))
(term v)))
(where W_new ,(variable-not-in (term (X E B ... K V_new))
(term w)))]
[(T (E_1 E_2)
Env
K)
(T E_1 Env (κ (V_new)
(T E_2 Env (κ (L_new)
(V_new L_new K)))))
(where V_new ,(variable-not-in (term (E_1 E_2 Env K))
(term v)))
(where L_new ,(variable-not-in (term (E_1 E_2 Env K V_new))
(term l)))])
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Introduce app, ret & bind funs
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-metafunction λsim
ret : K A -> C
[(ret K A) (K A)])
(define-metafunction λsim
app : A A W -> C
[(app A_1 A_2 K) (A_1 A_2 K)])
(define-metafunction λsim
T_1 : E Env K -> any
[(T_1 X Env K) (ret K (lookup X Env))]
[(T_1 (λ (X) E)
(B ...)
K)
(ret K (λ (V W) (T_1 E ((X V) B ...) W)))
(where V ,(variable-not-in (term (X E B ... K))
(term v)))
(where W ,(variable-not-in (term (X E B ... K V))
(term w)))]
[(T_1 (E_1 E_2) Env K)
(T_1 E_1 Env (κ (V_1)
(T_1 E_2 Env (κ (V_2)
(app V_1 V_2 K)))))
(where V_1 ,(variable-not-in (term (E_1 E_2 Env K))
(term v)))
(where V_2 ,(variable-not-in (term (E_1 E_2 Env K V_1))
(term v)))])
) | false |
1ee47ce49484c764efd76acea0d5dcb681b20fb8 | 1d042bcd7bbc6bd323424f9302810f91c27e36d5 | /l6.scm | 81a841ffc39b5c6cf861a3b5a3ee848fc6a42d04 | []
| no_license | haoxianhan/yast-exercise | 4940c85ef305b6237d7006c06dc4ce37875d2e4d | 40288c2e15d8661b072d8291dd75cc42c2d1086d | refs/heads/main | 2023-01-03T13:09:58.778556 | 2020-10-29T02:08:15 | 2020-10-29T02:08:15 | 303,937,893 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 2,915 | scm | l6.scm | ; 练习1
; 用map编写下面的函数：
; 一个将表中所有元素翻倍的函数；
(define (map-double ls)
(map (lambda (x) (* x 2)) ls))
(map-double '(1 2 3 4))
; 一个将两个表中对应位置元素相减的函数
(define (map-reduce ls1 ls2)
(map - ls1 ls2))
(map-reduce '(2 2 3) '(4 5 6))
; 练习2
; 编写下列函数：
; 滤取（Filtering Out）出一个表中的偶数；
(define (filter-out-even ls)
(keep-matching-items ls even?))
(define (filter-out-even1 ls)
(delete-matching-items ls odd?))
(filter-out-even '(1 2 3 4 5 6 6))
(filter-out-even1 '(1 2 3 4 5 6 6))
; 滤取出不满足10 ≤ x ≤ 100的数；
(define (filter-out-10-100 ls)
(delete-matching-items ls (lambda (x) (<= 10 x 100) )))
(filter-out-10-100 '(1 2 3 4 11 15 99 100 101 102))
; 练习3
; 编写一个将表中所有元素平方的函数，然后求取它们的和，最后求和的平方根。
(define (reduce-squ-sum-sqrt ls)
(sqrt (reduce + 0 (map (lambda (x) (* x x)) ls))))
(reduce-squ-sum-sqrt '(1 2 3))
; 练习4
; 编写下列函数
; 以sin(x)的大小升序排序；
(define (sort-sin ls)
(sort ls (lambda (x y) (< (sin x) (sin y)))))
(sort-sin '(1 2 3 4 5 6))
; 以表长度降序排序；
(define (sort-len ls)
(sort ls (lambda (x y) (> (length x) (length y)))))
(sort-len '((1 2 3) (1) (2 3)))
; 练习5
; 用apply编写练习3中的函数。
; 练习3
; 编写一个将表中所有元素平方的函数，然后求取它们的和，最后求和的平方根。
(define (apply-squ-sum-sqrt ls)
(sqrt (apply + (map (lambda (x) (* x x)) ls))))
(apply-squ-sum-sqrt '(1 2 3))
; 练习 6
; 自己实现keep-matching-items。
(define (my-keep-matching-items ls proc)
(cond
((null? ls) '())
((proc (car ls)) (cons (car ls) (my-keep-matching-items (cdr ls) proc)))
(else (my-keep-matching-items (cdr ls) proc))))
(my-keep-matching-items '(1 2 3 4) even?)
; 自己实现map。接受不止一个表作为参数可能有点困难。剩余的参数是通过带点得序对(.)来定义的。其cdr部分以表的形式传递给函数。 例: my-list
; (define (my-list . x) x)
; 多说一句，你需要apply函数。
(define (my-map fun . lss)
(letrec ((iter (lambda (fun lss)
(if (null? lss)
'()
(cons (fun (car lss))
(iter fun (cdr lss))))))
(map-rec (lambda (fun lss)
(if (memq '() lss)
'()
(cons (apply fun (iter car lss))
(map-rec fun (iter cdr lss)))))))
(map-rec fun lss)))
; 这题自己没想到
; 这里操作是每次都将lss的每个列表第一个取出来，(iter car lss)便是做这事
; (if (memq '() lss)) 此处可以忽略列表长度不一的问题
(my-map + '(1 2 3 4) '(10 20 30 40) '(100 200 300 400))
; (load "l6.scm")
| false |
2bfe1d56516743ebdff89faa2b39c89ae4b327f6 | ca39b0bad8cf2fb9bc5699720c1ef86a34ab096a | /libskiwi/scm/packages.scm | d3a374b4013875877c662b5012f366e4e2c8f255 | [
"MIT"
]
| permissive | janm31415/skiwi | 9f40c2120f14dd895cd875087ee941ec6a155b2d | 8234d18fd95a971e947f28477b6173c3c7ef30da | refs/heads/master | 2022-09-23T23:52:09.637174 | 2022-08-31T21:34:50 | 2022-08-31T21:34:50 | 252,686,866 | 4 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 626 | scm | packages.scm |
;; misc
(define-module csv (misc csv))
(define-module list-common (misc list-common))
(define-module mbe (misc mbe))
(define-module oldscheme (misc oldscheme))
(define-module substring (misc substring))
;; r5rs
(define-module values (r5rs values))
(define-module dynamic-wind (r5rs dynamic-wind))
(define-module io (r5rs input-output))
(define-module eval (r5rs eval))
;; srfi
(define-module srfi-1 (srfi srfi1))
(define-module srfi-6 (srfi srfi6))
(define-module srfi-27 (srfi srfi27))
(define-module srfi-28 (srfi srfi28))
;; slib
(define-module slib (slib skiwi-slib))
;; test
(define-module test-r4rs (test r4rstest)) | false |
decdbfc572141fd89aa6110f93508b4ad55221e8 | ec5b4a92882f80b3f62eac8cbd059fb1f000cfd9 | /functional/scheme/get-averages.ss | 846a8b3b2bb749c70193ecb3dbe2d029c2b31b45 | []
| no_license | ggem/alpa | ee35ffc91d9f4b1d540ce8b2207595813e488e5f | 4f53b888b5a5b4ffebd220c6e0458442325fbff2 | refs/heads/master | 2019-01-02T03:12:17.899768 | 2005-01-04T03:43:12 | 2005-01-04T03:43:12 | 42,612,681 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,869 | ss | get-averages.ss | ;;;
;;;
;;;
(define costs '(cost_addition
cost_binding
cost_booleanop
cost_car
cost_cdr
cost_cond
cost_cons
cost_constant
cost_division
cost_funcall
cost_multiplication
cost_negation
cost_null
cost_varref))
(define average
(lambda (times % filter)
(letrec ([nth-cdr
(lambda (n ls)
(if (zero? n)
ls
(nth-cdr (- n 1) (cdr ls))))]
[middle
(lambda (lst)
(let* ([len (length lst)]
[cut (quotient (* len (- 100 %)) 200)])
(if (= % 0)
(if (null? lst)
lst
(list (list-ref lst (quotient len 2))))
(reverse (nth-cdr cut (reverse (nth-cdr cut lst)))))))]
[average-hlp
(lambda (ls n acc)
(cond
[(null? ls) (if (> n 0) (/ acc n) 0.0)]
[(filter (car ls))
(average-hlp (cdr ls) (+ n 1)
(+ acc (car ls)))]
[else
(average-hlp (cdr ls) n acc)]))]
[average
(lambda (ls)
(if (null? ls)
0.0
(average-hlp ls 0 0.0)))])
(average (middle (sort < times))))))
(define get-times
(lambda (name)
(eval (string->symbol (string-append (symbol->string name) "s")))))
(define (get-averages)
(do ([filters (list (lambda (x) #t) (lambda (x) (>= x 0))) (cdr filters)]
[filstrs '("all" "non-negative") (cdr filstrs)])
[(null? filters)]
(do ([procs (list car cdr) (cdr procs)]
[strs '("without" "with") (cdr strs)])
[(null? procs)]
(do ([% 100 (- % 10)])
[(negative? %)]
(printf "~n~n;;; ~a garbage collection~n" (car strs))
(printf ";;; using ~a% of the data~n" %)
(printf ";;; average of ~a numbers~n~n" (car filstrs))
(do ([costs costs (cdr costs)])
[(null? costs)]
(let ([runtimes (map (car procs) (get-times (car costs)))])
(printf "(define ~a ~a)~n" (car costs)
(average runtimes % (car filters)))))))))
(get-averages)
(exit)
| false |
ec5220984f73a491985fb21f3c8966bdcf56a3c2 | 2e4afc99b01124a1d69fa4f44126ef274f596777 | /apng/resources/dracula/lang/declare.ss | 71df719e8d0fd40a379844162b3d20482344b422 | []
| no_license | directrix1/se2 | 8fb8204707098404179c9e024384053e82674ab8 | 931e2e55dbcc55089d9728eb4194ebc29b44991f | refs/heads/master | 2020-06-04T03:10:30.843691 | 2011-05-05T03:32:54 | 2011-05-05T03:32:54 | 1,293,430 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 165 | ss | declare.ss | (module declare mzscheme
(provide declare)
(define-syntax (declare stx)
(raise-syntax-error #f
"declare may not be used as an expression" stx))
)
| true |
f802fffd8563348a6963cac0a5fa5f904cda0226 | 92b8d8f6274941543cf41c19bc40d0a41be44fe6 | /testsuite/command3.scm | a3f7f7ea72c5ba91c681bb8109464892628272cd | [
"MIT"
]
| permissive | spurious/kawa-mirror | 02a869242ae6a4379a3298f10a7a8e610cf78529 | 6abc1995da0a01f724b823a64c846088059cd82a | refs/heads/master | 2020-04-04T06:23:40.471010 | 2017-01-16T16:54:58 | 2017-01-16T16:54:58 | 51,633,398 | 6 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 349 | scm | command3.scm | #!/usr/bin/env kawa
;; Kawa-options: %F "a b" c
(format #t "~w~%" (command-line))
;; The reason for the '[^ ]*' in the pattern is to make sur we
;; only have the fielname in (car (command-line)) - because of the #! above.
;; Assumed filename (and specifically $srcdir) does not contain spaces.
;; Output-pattern: [(]"[^ ]*command3.scm" "a b" "c"[)]
| false |
2d855df30a49fb8fec8f1b3e19f32770dfeb83f9 | bf1c9803ae38f9aad027fbe4569ccc6f85ba63ab | /chapter_3/3.5.Streams/ex_3.66.scm | 360d40be74104b6b7e33ae259af2716ead9b7c86 | []
| no_license | mehese/sicp | 7fec8750d3b971dd2383c240798dbed339d0345a | 611b09280ab2f09cceb2479be98ccc5403428c6c | refs/heads/master | 2021-06-12T04:43:27.049197 | 2021-04-04T22:22:47 | 2021-04-04T22:23:12 | 161,924,666 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,568 | scm | ex_3.66.scm | #lang sicp
;; Imports
(define (stream-car stream)
(car stream))
(define (stream-cdr stream)
(force (cdr stream)))
(define (stream-ref s n)
(if (= n 0)
(stream-car s)
(stream-ref (stream-cdr s) (- n 1))))
(define (stream-map proc . argstreams)
(if (stream-null? (car argstreams))
the-empty-stream
(cons-stream
(apply proc (map stream-car argstreams))
(apply stream-map
(cons proc
(map stream-cdr
argstreams))))))
(define (scale-stream stream factor)
(stream-map
(lambda (x) (* x factor))
stream))
(define (stream-for-each proc s)
(if (stream-null? s)
'done
(begin
(proc (stream-car s))
(stream-for-each proc (stream-cdr s)))))
(define (stream-filter pred stream)
(cond ((stream-null? stream)
the-empty-stream)
((pred (stream-car stream))
(cons-stream
(stream-car stream)
(stream-filter
pred
(stream-cdr stream))))
(else (stream-filter
pred
(stream-cdr stream)))))
(define (display-stream s)
(stream-for-each display-line s))
(define (display-line x)
(newline) (display x))
(define (display-first-n s n)
(define (display-iter substream i)
(if (> i n)
(newline)
(begin
(newline)
(display (stream-car substream)) (display " ")
(display-iter (stream-cdr substream) (inc i)))))
(display-iter s 0))
(define (add-streams s1 s2) (stream-map + s1 s2))
(define (mul-streams s1 s2) (stream-map * s1 s2))
(define ones (cons-stream 1 ones))
(define integers (cons-stream 1 (add-streams ones integers)))
(define (interleave s1 s2)
(if (stream-null? s1)
s2
(cons-stream
(stream-car s1)
(interleave s2 (stream-cdr s1)))))
(define (pairs s t)
(cons-stream
(list (stream-car s) (stream-car t))
(interleave
(stream-map (lambda (x)
(list (stream-car s) x))
(stream-cdr t))
(pairs (stream-cdr s) (stream-cdr t)))))
;; Problem
(define int-pairs (pairs integers integers))
(define (count-pairs-before s target-pair)
(define (found-pair? test-pair)
(and (= (car target-pair) (car test-pair))
(= (cadr target-pair) (cadr test-pair))))
(define (iter-pairs substream count)
(if (found-pair? (stream-car substream))
count
(begin
;(display (stream-car substream))
(iter-pairs (stream-cdr substream) (inc count)))))
(iter-pairs s 0))
;(count-pairs-before int-pairs (list 4 4))
;; Every second element is a (1 x) pair, but there's nothing that
;; follows (1 1). Also we don't count the current pair. The formula
;; for any (1 n) pair is 2n - 3
(count-pairs-before int-pairs (list 1 100)) ;; 197 as expected
;; n cnt
;; 1 0
;; 2 2
;; 3 6
;; 4 14
;; 5 30
;; 6 62
;; 7 126
;; 2(2^(n-1) - 1) for an (n n) pair
(count-pairs-before int-pairs (list 16 16)) ;; checks out
;(list 100 100)
;; 2(2^99 - 1) is way too big for my laptop
;; ~ 1.267650600228229401496703205374 × 10^30
;; n cnt
;; 1 1
;; 2 4 2x2
;; 3 10 2x5 3 ( 5- 2)
;; 4 22 2x11 6 (11- 5)
;; 5 46 2x23 12 (12- 6)
;; 6 94 2x47 24 (24-12)
;; 7 190 2x95 48 ...
;; 8 382 2x191 96 ...
;; 9 766 2x383 192
;; 2*(3*2^(n-2) - 1) pairs that precede (n n+1 pair)
(count-pairs-before int-pairs (list 13 14)) ; 12286 as expected
;; again 2(3*2^97 - 1) too big to calculate in scheme for (99 100)
;; is 950737950171172051122527404030
| false |
aa9e11520378ebfd81e302d7d5f1ece96eee2b9a | 9cb1626e30c6ea40b11cd3715c03d0d5b88722de | /src/sake/filesets.scm | aab755e6002a6a5e0541be61d4770fcd4585b60c | [
"Zlib"
]
| permissive | alvatar/sphere-core | fbc2a76ed6743cbe7be99ff0abf50a79e331bb55 | 09e07d8b881f6b0292a4292b8b9a30a4ab5798f7 | refs/heads/master | 2020-05-18T13:32:08.074184 | 2015-03-21T12:17:50 | 2015-03-21T12:17:50 | 976,512 | 9 | 0 | null | 2014-04-26T12:30:09 | 2010-10-10T15:43:10 | Scheme | UTF-8 | Scheme | false | false | 6,396 | scm | filesets.scm | ;-------------------------------------------------------------------------------
; Filesets and combinators
;-------------------------------------------------------------------------------
(define (extension=? ext)
(ends-with? ext))
(define (ends-with? end)
(lambda (name)
(and (>= (string-length name) (string-length end))
(string=? (substring name (- (string-length name) (string-length end)) (string-length name))
end))))
(define (newer-than? filename1 #!key
(dir (current-build-directory)))
(lambda (filename2)
(or (not (file-exists? filename1))
(> (time->seconds (file-last-modification-time filename2))
(time->seconds (file-last-modification-time filename1))))))
(define (newer-than/extension? ext #!key
(dir (current-build-directory)))
(lambda (filename2)
(let ((filename1 (string-append
dir
(path-strip-extension (path-strip-directory filename2))
ext)))
(or (not (file-exists? filename1))
(>= (time->seconds (file-last-modification-time filename2))
(time->seconds (file-last-modification-time filename1)))))))
(define (f-and . ts)
(lambda (name)
(let f-and ((ts ts))
(or (null? ts)
(and ((car ts) name)
(f-and (cdr ts)))))))
(define (f-or . ts)
(lambda (name)
(let f-or ((ts ts))
(and (pair? ts)
(or ((car ts) name)
(f-or (cdr ts)))))))
(define (shift fn)
(lambda (t)
(lambda (name)
(fn (t name)))))
(define f-not (shift not))
(define (any? name) #t)
(define (none? name) #f)
(##define (fileset #!key
(dir (current-directory))
(test any?)
(recursive #f))
(let ((dir (path-add-trailing-directory-separator dir)))
(reduce append '()
(map (lambda (name)
(let* ((f (string-append dir name))
(childs (if (and recursive (directory? f))
(fileset dir: (path-add-trailing-directory-separator f)
test: test
recursive: recursive)
'())))
(if (test f)
(cons f childs)
childs)))
(directory-files `(path: ,dir ignore-hidden: dot-and-dot-dot))))))
;-------------------------------------------------------------------------------
; File handling
;-------------------------------------------------------------------------------
(define (path-add-trailing-directory-separator dir)
(string-append (path-strip-trailing-directory-separator dir) "/"))
(define (path-relative dir)
(path-normalize dir 'shortest (current-directory)))
(define (directory? name)
(eq? (file-type name) 'directory))
(define (regular? name)
(eq? (file-type name) 'regular))
;;; Make directory
(define (sake#make-directory dir)
(let ((dir0 (path-strip-trailing-directory-separator dir)))
(if (file-exists? dir0) #t
(begin
(sake#make-directory (path-directory dir0))
(create-directory dir0)))))
;;; Improved delete-file
(define (sake#delete-file file #!key (recursive #f) (force #t))
(let ((file (path-expand file)))
(info "deleting " file)
(cond
((not (file-exists? file)) 'ok)
((directory? file)
(sake#delete-directory file recursive: recursive force: force))
(else
(##delete-file file)))))
;;; Improved delete-directory
(define (sake#delete-directory dir #!key (recursive #t) (force #t))
(if force (for-each ##delete-file (fileset dir: dir recursive: #f test: regular?)))
(if recursive (for-each (lambda (dir) (sake#delete-file
(path-add-trailing-directory-separator dir)
recursive: recursive
force: force))
(fileset dir: dir recursive: #t test: directory?)))
(if (null? (fileset dir: dir recursive: #t test: any?))
(##delete-directory dir)
(warn dir " is not empty")))
;;; Delete a list of files
(define (sake#delete-files files)
(for-each (lambda (f) (sake#delete-file f recursive: #t)) files))
;;; Improved copy-file
(define (sake#copy-file file dest #!key (force #t))
(let ((file (path-expand file)))
(cond
((directory? file)
(info "copying " file " to " dest)
(sake#copy-directory file dest force: force))
((and force (file-exists? dest))
(sake#delete-file dest recursive: #t)
(sake#copy-file file dest force: #f))
((not (file-exists? dest))
(info "copying " file " to " dest)
(##copy-file file dest))
(else
(warn dest " already exists")))))
;;; Copy a directory
(define (sake#copy-directory file dest #!key (force #t))
(cond
((and force (file-exists? dest))
(sake#delete-file dest recursive: #t force: #t)
(sake#copy-directory file dest force: force))
((not (file-exists? dest))
(create-directory dest)
(for-each
(lambda (filename)
(sake#copy-file filename
(string-append
(path-strip-trailing-directory-separator dest)
"/" (path-strip-directory filename))))
(fileset dir: file recursive: #f)))
(else
(warn dest " already exists"))))
;;; Copy a list of files and directories
(define (sake#copy-files files dest #!key (force #t))
(for-each
(lambda (file)
(sake#copy-file file
(string-append (path-strip-trailing-directory-separator dest)
"/"
(path-strip-directory file))
force: force))
files))
(define (sake#read-file file)
(call-with-input-file (path-expand file)
(lambda (in) (read-line in #f))))
(define (sake#read-files files)
(call-with-output-string
""
(lambda (out)
(for-each (lambda (file) (display (sake#read-file file) out))
files))))
(define (sake#append-files files dest)
(call-with-output-file dest
(lambda (out)
(for-each (lambda (file) (display (sake#read-file file) out))
files))))
| false |
be7fdbe9f608938e163d020799bf52c4bb150e39 | 185024f40e1ceed452781a1f3f57e6d16f57d799 | /util-test.ss | 27b24b2c1efcc03972dce5172047e277b83d8f4a | []
| no_license | noelwelsh/numeric | b82cd4ca9e4afb18df0129ec2231fc03f9b66450 | ac4488cf8cc6f0558f74ca9b8faad0f198e76a84 | refs/heads/master | 2021-01-18T21:32:27.393991 | 2010-02-22T14:05:19 | 2010-02-22T14:05:19 | 275,898 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 759 | ss | util-test.ss | #lang scheme/base
(require
(planet schematics/schemeunit:3)
"util.ss")
(define/provide-test-suite util-tests
(test-case
"in-2d-range"
(check-equal?
(for/list ([(i j) (in-2d-range (5 5))])
(list i j))
'((0 0) (0 1) (0 2) (0 3) (0 4)
(1 0) (1 1) (1 2) (1 3) (1 4)
(2 0) (2 1) (2 2) (2 3) (2 4)
(3 0) (3 1) (3 2) (3 3) (3 4)
(4 0) (4 1) (4 2) (4 3) (4 4)))
(check-equal?
(for/list ([(i j) (in-2d-range (1 1) (5 5))])
(list i j))
'((1 1) (1 2) (1 3) (1 4)
(2 1) (2 2) (2 3) (2 4)
(3 1) (3 2) (3 3) (3 4)
(4 1) (4 2) (4 3) (4 4)))
(check-equal?
(for/list ([(i j) (in-2d-range (1 1) (5 5) (2 2))])
(list i j))
'((1 1) (1 3)
(2 1) (2 3)
(3 1) (3 3))))) | false |
15af56a9442a0003a4d000fd996fbca7879700c4 | 320a615ef54449a39e2ca9e59847106e30cc8d7a | /test-qm/nist-molecules/gp/carboxylate acids/pentanoic acid/pentanoic acid.scm | 649224e89c44a877fd364b02569f75684ff0473f | []
| no_license | alexei-matveev/bgy3d | 5cf08ea24a5c0f7b0d6e1d572effdeef8232f173 | 0facadd04c6143679033202d18017ae2a533b453 | refs/heads/master | 2021-01-01T17:47:22.766959 | 2015-07-10T09:21:49 | 2015-07-10T09:21:49 | 38,872,299 | 2 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 2,938 | scm | pentanoic acid.scm | ;;
;; pentanoic acid ECP, RKS.
;;
((operations
(operations_symm #t)
(operations_integral #t)
(operations_scf #t)
(operations_dipole #t)
(operations_properties #t))
(main_options
(integrals_on_file #f) ; This is faster
(relativistic "false") ; This is an ECP calculation
(spin_restricted #t)) ; pentanoic acid is closed shell
(geo
(units angstrom)
("CT3" (0.9690 0.9499 1.0698) (z 6))
("CT2" (2.1126 1.8447 1.4909) (z 6))
("CT2" (3.4564 1.1801 1.2350) (z 6))
("CT2" (4.6009 2.1010 1.6329) (z 6))
("C" (5.9285 1.4318 1.3841) (z 6))
("OH" (6.4076 0.6912 2.4116) (z 8))
("O" (6.6289 1.4680 0.3886) (z 8))
("HC" (0.0000 1.4309 1.2543) (z 1))
("HC" (1.0152 0.7058 0.0000) (z 1))
("HC" (0.9735 0.0000 1.6208) (z 1))
("HC" (2.0574 2.8087 0.9469) (z 1))
("HC" (2.0170 2.1022 2.5646) (z 1))
("HC" (3.5191 0.2279 1.7986) (z 1))
("HC" (3.5430 0.9031 0.1652) (z 1))
("HC" (4.5558 3.0450 1.0542) (z 1))
("HC" (4.5113 2.3890 2.6998) (z 1))
("HO" (7.2417 0.3008 2.1695) (z 1)))
(mixing (chmix 0.5) (start_after_cycle 5))
(grid (sym_reduce #t) (weight_grads #t))
(rep 17 (gridatom (nrad 30) (nang 131)))
(xc_control (xc "pbe"))
(ecp "nwchem" "C" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(ecp "nwchem" "C" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(ecp "nwchem" "C" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(ecp "nwchem" "C" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(ecp "nwchem" "C" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(ecp "nwchem" "O" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(ecp "nwchem" "O" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(bas "nwchem" "H" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(bas "nwchem" "H" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(bas "nwchem" "H" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(bas "nwchem" "H" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(bas "nwchem" "H" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(bas "nwchem" "H" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(bas "nwchem" "H" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(bas "nwchem" "H" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(bas "nwchem" "H" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(bas "nwchem" "H" "crenbl_ecp" "ahlrichs_coulomb_fitting")
(properties
(plot_orbitals #t))
(orbital_plot
(n_input_lines 0)
(density_plot #t)
(density_tot #t)))
;;;
;;; BGY3d input follows. The parameter solute specifies the table to
;;; take the site-specific force field parameters. The names of the
;;; sites are those specified in PG input above:
;;;
((solute "pentanoic acid, nist")
(solvent "water")
(L 10.0) ; box size, A
(N 128) ; grid dimension
;; (rho 0.033427745) ; solvent number density, A^-3
;; (beta 1.6889) ; inverse temperature, kcal^-1
(norm-tol 1.0e-12)
(closure KH))
| false |
c81f07b6c2ff23fbfea8356a83946ee4b1d5f404 | b0c1935baa1e3a0b29d1ff52a4676cda482d790e | /examples/scripts/sum.scm | fc772ed48f2fff54756aee5a9bd2439cc93acb0b | [
"MIT"
]
| permissive | justinethier/husk-scheme | 35ceb8f763a10fbf986340cb9b641cfb7c110509 | 1bf5880b2686731e0870e82eb60529a8dadfead1 | refs/heads/master | 2023-08-23T14:45:42.338605 | 2023-05-17T00:30:56 | 2023-05-17T00:30:56 | 687,620 | 239 | 28 | MIT | 2023-05-17T00:30:07 | 2010-05-26T17:02:56 | Haskell | UTF-8 | Scheme | false | false | 241 | scm | sum.scm | #!/usr/bin/env huski
#|
An example shell script using huski, that sums up numbers entered on
the command line. EG:
./sum.scm 0 1 1 2 3 5 8 13 21 34 55 89 144
|#
(define (main args)
(write (apply + (map string->number (cdr args)))))
| false |
8a427a71f810aa73a190a076a94a3e572a5b0de9 | 0011048749c119b688ec878ec47dad7cd8dd00ec | /src/spoilers/745/solution.scm | 2990684a51ab31035412d9ab9a50e396171f74f5 | [
"0BSD"
]
| permissive | turquoise-hexagon/euler | e1fb355a44d9d5f9aef168afdf6d7cd72bd5bfa5 | 852ae494770d1c70cd2621d51d6f1b8bd249413c | refs/heads/master | 2023-08-08T21:01:01.408876 | 2023-07-28T21:30:54 | 2023-07-28T21:30:54 | 240,263,031 | 8 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 673 | scm | solution.scm | (import
(chicken fixnum)
(euler))
(define (solve n m)
(let ((lim (fxsqrt n)))
(let ((mem (make-vector (+ lim 1) 1)))
(vector-set! mem 0 0)
(let loop ((i lim))
(unless (fx= i 0)
(let loop ((t 2) (acc 0))
(if (fx> t (fx/ lim i))
(vector-set! mem i (fx- (fx/ n (fx* i i)) acc))
(loop (fx+ t 1) (fx+ acc (vector-ref mem (fx* i t))))))
(loop (fx- i 1))))
(let loop ((i 0) (acc 0))
(if (fx> i lim)
acc
(loop (fx+ i 1) (fxmod (fx+ acc (fx* (vector-ref mem i) (fx* i i))) m)))))))
(let ((_ (solve #e1e14 1000000007)))
(print _) (assert (= _ 94586478)))
| false |
179affade31e260dbd5a5d4dd19ddbc96277143b | acc632afe0d8d8b94b781beb1442bbf3b1488d22 | /deps/sdl2/lib/sdl2-internals/helpers/sdl-failure.scm | 5d4b1526586a9b651dce45fbce0a3b7cc9d5f049 | [
"BSD-2-Clause",
"BSD-3-Clause"
]
| permissive | kdltr/life-is-so-pretty | 6cc6e6c6e590dda30c40fdbfd42a5a3a23644794 | 5edccf86702a543d78f8c7e0f6ae544a1b9870cd | refs/heads/master | 2021-01-20T21:12:00.963219 | 2016-05-13T12:19:02 | 2016-05-13T12:19:02 | 61,128,206 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,111 | scm | sdl-failure.scm | ;;
;; chicken-sdl2: CHICKEN Scheme bindings to Simple DirectMedia Layer 2
;;
;; Copyright © 2013, 2015-2016 John Croisant.
;; All rights reserved.
;;
;; Redistribution and use in source and binary forms, with or without
;; modification, are permitted provided that the following conditions
;; are met:
;;
;; - Redistributions of source code must retain the above copyright
;; notice, this list of conditions and the following disclaimer.
;;
;; - Redistributions in binary form must reproduce the above copyright
;; notice, this list of conditions and the following disclaimer in
;; the documentation and/or other materials provided with the
;; distribution.
;;
;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
;; FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
;; COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
;; INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
;; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
;; SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
;; HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
;; STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
;; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
;; OF THE POSSIBILITY OF SUCH DAMAGE.
(export sdl-failure)
;;; Returns an exception condition of kind (exn sdl2) indicating that
;;; an SDL function failed. Use abort to signal the exception.
;;;
;;; fn-name should be a string giving the name of the SDL function
;;; that failed. ret-code should be the integer error code that was
;;; returned by the failing function (usually -1), or #f if the
;;; function failed without an integer return code (e.g. it returned a
;;; NULL pointer instead).
;;;
;;; The error message is constructed automatically based on the
;;; function name, return code, and the error string from get-error.
;;;
;;; Examples:
;;;
;;; ;; With return code
;;; (let ((ret-code (SDL_Init ...)))
;;; (unless (zero? ret-code)
;;; (abort (sdl-failure "SDL_Init" ret-code))))
;;;
;;; ;; Without return code
;;; (let ((surface (SDL_CreateRGBSurface ...)))
;;; (if (and (surface? surface) (not (struct-null? surface)))
;;; surface
;;; (abort (sdl-failure "SDL_CreateRGBSurface" #f))))
;;;
(: sdl-failure (string (or fixnum boolean) -> condition))
(define (sdl-failure fn-name ret-code)
(let ((sdl-err-msg (SDL_GetError)))
(make-composite-condition
(make-property-condition
'exn 'message
(sprintf "~A failed~A.~A"
fn-name
(if ret-code
(sprintf " (return code ~S)" ret-code)
"")
(if (zero? (string-length sdl-err-msg))
""
(sprintf "~NDetails: ~A" sdl-err-msg))))
(make-property-condition
'sdl2
'function fn-name
'return-code ret-code
'sdl-error sdl-err-msg))))
| false |
b9fcfa0f6c5803f744a8afd5021db6ce14e97db5 | 665da87f9fefd8678b0635e31df3f3ff28a1d48c | /srfi/test-1.scm | d36b9c651c39262ebf657b2b22da654371e5f280 | [
"MIT"
]
| permissive | justinethier/cyclone | eeb782c20a38f916138ac9a988dc53817eb56e79 | cc24c6be6d2b7cc16d5e0ee91f0823d7a90a3273 | refs/heads/master | 2023-08-30T15:30:09.209833 | 2023-08-22T02:11:59 | 2023-08-22T02:11:59 | 31,150,535 | 862 | 64 | MIT | 2023-03-04T15:15:37 | 2015-02-22T03:08:21 | Scheme | UTF-8 | Scheme | false | false | 164 | scm | test-1.scm | (import (scheme base)
(scheme write)
(scheme cyclone pretty-print)
(1))
(pretty-print `(
,(iota 10)
,(iota 10 5)
,(iota 10 5 10)
))
| false |
c9d46aba0a739896431d3209d1bc89a4857094cc | 9d7417f187812a477793ca23da844b34ab2a139d | /Graphikos/GraphikosTests/lib/ironscheme/syntax/symbolic-case.sls | 6bb3aaf81ca4ef2ade19f75b43b9b99c52d6b3a3 | [
"MIT",
"BSD-3-Clause"
]
| permissive | simonmoriat/PLP | 5ae19daba4925919b593b4a21dc91dec9de9a6ce | 3d130acaa45239cdb289462a242a8c15836a39ca | refs/heads/master | 2023-05-11T23:36:28.347462 | 2016-06-08T07:07:50 | 2016-06-08T07:07:50 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,035 | sls | symbolic-case.sls | #| License
Copyright (c) 2007-2015 Llewellyn Pritchard
All rights reserved.
This source code is subject to terms and conditions of the BSD License.
See docs/license.txt. |#
(library (ironscheme syntax symbolic-case)
(export
syntax-casep
symbolic=?
symbolic-case)
(import (ironscheme))
(define (symbolic=? x y)
(eq? (syntax->datum x) y))
(define-syntax symbolic-case
(lambda (x)
(syntax-case x ()
[(_ e ...)
#'(syntax-casep symbolic=? e ...)])))
(define-syntax syntax-casep
(lambda (x)
(define (parse-clause c)
(syntax-case c ()
[(p e)
#'(p #t e)]
[(p f e)
#'(p f e)]))
(syntax-case x ()
[(ctx =? expr (lit ...) e ...)
(and (identifier? #'=?) (for-all identifier? #'(lit ...)))
(with-syntax [(((p f e) ...) (map parse-clause #'(e ...)))]
#'(syntax-case expr ()
[p
(and (=? #'lit 'lit) ... f)
e] ...))])))) | true |
fc52007918fcf7019d48d6c7b46f2fcd2da5e175 | defeada37d39bca09ef76f66f38683754c0a6aa0 | /UnityEngine.UI/unity-engine/ui/canvas-list-pool.sls | e5336710c7d853160979d1b04ff8016de2368fc6 | []
| no_license | futsuki/ironscheme-port | 2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5 | 4e7a81b0fbeac9a47440464988e53fb118286c54 | refs/heads/master | 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 549 | sls | canvas-list-pool.sls | (library (unity-engine ui canvas-list-pool)
(export is? canvas-list-pool? get release)
(import (ironscheme-clr-port))
(define (is? a) (clr-is UnityEngine.UI.CanvasListPool a))
(define (canvas-list-pool? a)
(clr-is UnityEngine.UI.CanvasListPool a))
(define-method-port
get
UnityEngine.UI.CanvasListPool
Get
(static:
"System.Collections.Generic.List`1[[UnityEngine.Canvas, UnityEngine, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null]]"))
(define-method-port release UnityEngine.UI.CanvasListPool Release))
| false |
09b1b48e575a52713e13b503753b6b71934746c1 | 8ac3afd282844107d15635d7b959a302a371c0e0 | /c/4.ss | f8bb27947c4faea96657f7751924b60755dd567a | []
| no_license | noelwelsh/opencl | f0de13a1a2767661f960816b5723cdc6e56620d2 | 7c18657df9681ce9a2ff1d74ca5fbad4705b86ca | refs/heads/master | 2020-04-02T17:24:59.759065 | 2010-05-18T15:54:58 | 2010-05-18T15:54:58 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 112 | ss | 4.ss | #lang scheme
(require
"4-1.ss"
"4-2.ss"
"4-3.ss")
(provide
(all-from-out
"4-1.ss"
"4-2.ss"
"4-3.ss")) | false |
7735226d61397b664efdc2e5229f5a377f134d14 | f40f97c37847103138c82d3f1b3956d9c2592b76 | /mvp/synthesis-task-compiler.scm | e573d48b83142eb976913dd667689bc7d1e79bb5 | [
"MIT"
]
| permissive | k-tsushima/Shin-Barliman | 34df6868aafcd2d36dbbc57ef56eab555da05a5c | abea8511d18273196ac806dcf14b88d4098e18f8 | refs/heads/master | 2021-06-25T13:47:22.721816 | 2020-01-24T04:11:24 | 2020-01-24T04:11:24 | 182,607,716 | 16 | 1 | MIT | 2020-12-02T00:12:39 | 2019-04-22T02:18:17 | Scheme | UTF-8 | Scheme | false | false | 2,862 | scm | synthesis-task-compiler.scm | ;; Scheme subprocess started by MCP for generating code to be sent to SCP for synthesis
(load "pmatch.scm")
(load "common-chez.scm")
;; Loading will occur at first use if not explicitly forced like this.
(load-config #f)
(define PROGRAM-NAME "synthesis-task-compiler")
#| begin logging infrastructure definitions (how to abstract this?) |#
(define ENABLE-LOGGING (config-ref 'enable-synthesis-task-compiler-logging))
(define LOG-FILE-NAME (format "~a.log" PROGRAM-NAME))
(define LOG-FILE-OUTPUT-PORT-BOX (box #f))
(define (logf format-str . args)
(when ENABLE-LOGGING
(unless (unbox LOG-FILE-OUTPUT-PORT-BOX)
(let ((output-port (open-output-file LOG-FILE-NAME 'replace)))
(set-box! LOG-FILE-OUTPUT-PORT-BOX output-port)))
(apply fprintf (unbox LOG-FILE-OUTPUT-PORT-BOX) format-str args)
(flush-output-port (unbox LOG-FILE-OUTPUT-PORT-BOX))))
#| end logging infrastructure definitions |#
(define-syntax write/flush
(syntax-rules ()
[(_ msg out-port)
(begin
(write msg out-port)
(flush-output-port out-port)
(logf "wrote msg to ~s:\n\n~s\n\n\n" 'out-port msg))]))
(logf "started ~a\n" PROGRAM-NAME)
(define (handle-mcp-messages)
(define mcp-in-port (current-input-port))
(define mcp-out-port (current-output-port))
(when (input-port-ready? mcp-in-port)
(let ((msg (read mcp-in-port)))
(cond
((eof-object? msg)
(void))
(else
(logf "read message from mcp:\n\n~s\n\n\n" msg)
(pmatch msg
[(compile ,synthesis-id (,definitions ,inputs ,outputs))
;; TODO
;;
;; This is where the template compilation smarts and
;; optimizations will go!
;;
;; For now, do the boring thing as just echo back the
;; synthesis problem to the MCP.
(let (
;; Most boring version--echo back single, original synthesis "template"
(definitions/inputs/outputs* (list `(,definitions ,inputs ,outputs)))
;; Use this version instead to test multiple (identical) synthesis "templates"
;; (definitions/inputs/outputs* (make-list 10 `(,definitions ,inputs ,outputs)))
)
(let ((msg `(synthesize* ,synthesis-id ,definitions/inputs/outputs*)))
(write/flush msg mcp-out-port)
(logf "wrote message to mcp:\n\n~s\n\n\n" msg)))]
[,else
(logf "** unknown message type from mcp: ~s\n\n" msg)]))))))
(let main-compiler-loop ()
(handle-mcp-messages)
;; Sleep for 10 ms (10 million nanoseconds) to avoid using 100% of
;; the CPU time checking if a new message has arrived.
(let ((millisecond (expt 10 6)))
(sleep (make-time 'time-duration (* 10 millisecond) 0)))
(main-compiler-loop))
| true |
71d80feb6ee8ef447b0ce79d046d5efaf3e58971 | 5eb631d9a0885a550b709c6e9f905066f6af531b | /ex/chap2/38.scm | cf84f45fb8d67a11174d4cb43ff698579afdff78 | []
| no_license | hanpum/sicp | 344cb6456daf2c2f6b002aa20dc3e177c34b18bd | 454efaf28ee0f0487e372ede28f452eb762de404 | refs/heads/master | 2023-06-09T08:11:55.080048 | 2021-06-29T00:01:49 | 2021-06-29T00:01:49 | 381,190,193 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 453 | scm | 38.scm | (load "utils")
;; function defined in utils.scm
(println "~%begin testing of 38")
(define data '(1 2 3))
(define (test op init opname)
(println "(fold-left ~S ~S ~S): ~S" opname init data (fold-left op init data))
(println "(fold-right ~S ~S ~S): ~S" opname init data (fold-right op init data))
(newline))
(test / 1 "/")
(test list '() "list")
;; op should get same result while evalue from left to right and right to left
(test + 0 "+")
| false |
4c2343e6292f2a9608c10c44097eeab6fd039b55 | 15b3f9425594407e43dd57411a458daae76d56f6 | /bin/compiler/test/list.scm | b928267e4ae3e079aba3fd25011d6fd95ebc98a7 | []
| no_license | aa10000/scheme | ecc2d50b9d5500257ace9ebbbae44dfcc0a16917 | 47633d7fc4d82d739a62ceec75c111f6549b1650 | refs/heads/master | 2021-05-30T06:06:32.004446 | 2015-02-12T23:42:25 | 2015-02-12T23:42:25 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 56 | scm | list.scm | (define (make-binding name value)
(cons name value))
| false |
6a43794e9d8426f4445864911b09c22aa3e48cbc | ece1c4300b543df96cd22f63f55c09143989549c | /Chapter4/zzamb.scm | f63b3afdc88f595d722c9ec46109af29a31027c1 | []
| no_license | candlc/SICP | e23a38359bdb9f43d30715345fca4cb83a545267 | 1c6cbf5ecf6397eaeb990738a938d48c193af1bb | refs/heads/master | 2022-03-04T02:55:33.594888 | 2019-11-04T09:11:34 | 2019-11-04T09:11:34 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 5,247 | scm | zzamb.scm | (define (amb? exp) (tagged-list? exp 'amb))
(define (amb-choices exp) (cdr exp))
(define (ambeval exp env succeed fail)
((analyze exp) env succeed fail))
(define (analyze-self-evaluating exp)
(lambda (env succeed fail)
(succeed exp fail)))
(define (analyze-quoted exp)
(let ((qval (text-of-quotation exp)))
(lambda (env succeed fail)
(succeed qval fail))))
(define (analyze-variable exp)
(lambda (env succeed fail)
(succeed (lookup-variable-value exp env)
fail)))
(define (analyze-lambda exp)
(let ((vars (lambda-parameters exp))
(bproc (analyze-sequence
(lambda-body exp))))
(lambda (env succeed fail)
(succeed (make-procedure vars bproc env)
fail))))
(define (analyze-definition exp)
(let ((var (definition-variable exp))
(vproc (analyze
(definition-value exp))))
(lambda (env succeed fail)
(vproc env
(lambda (val fail2)
(define-variable! var val env)
(succeed 'ok fail2))
fail))))
(define (analyze-assignment exp)
(let ((var (assignment-variable exp))
(vproc (analyze
(assignment-value exp))))
(lambda (env succeed fail)
(vproc env
(lambda (val fail2) ; *1*
(let ((old-value
(lookup-variable-value
var
env)))
(set-variable-value!
var
val
env)
(succeed
'ok
(lambda () ; *2*
(set-variable-value!
var
old-value
env)
(fail2)))))
fail))))
(define (analyze-if exp)
(let ((pproc (analyze (if-predicate exp)))
(cproc (analyze (if-consequent exp)))
(aproc (analyze (if-alternative exp))))
(lambda (env succeed fail)
(pproc env
;; success continuation for evaluating
;; the predicate to obtain pred-value
(lambda (pred-value fail2)
(if (true? pred-value)
(cproc env succeed fail2)
(aproc env succeed fail2)))
;; failure continuation for
;; evaluating the predicate
fail))))
(define (analyze-application exp)
(let ((fproc (analyze (operator exp)))
(aprocs (map analyze (operands exp))))
(lambda (env succeed fail)
(fproc env
(lambda (proc fail2)
(get-args
aprocs
env
(lambda (args fail3)
(execute-application
proc args succeed fail3))
fail2))
fail))))
(define (get-args aprocs env succeed fail)
(if (null? aprocs)
(succeed '() fail)
((car aprocs)
env
;; success continuation for this aproc
(lambda (arg fail2)
(get-args
(cdr aprocs)
env
;; success continuation for
;; recursive call to get-args
(lambda (args fail3)
(succeed (cons arg args)
fail3))
fail2))
fail)))
(define (execute-application
proc args succeed fail)
(cond ((primitive-procedure? proc)
(succeed
(apply-primitive-procedure
proc args)
fail))
((compound-procedure? proc)
((procedure-body proc)
(extend-environment
(procedure-parameters proc)
args
(procedure-environment proc))
succeed
fail))
(else (error "Unknown procedure type:
EXECUTE-APPLICATION"
proc))))
(define (analyze-amb exp)
(let ((cprocs
(map analyze (amb-choices exp))))
(lambda (env succeed fail)
(define (try-next choices)
(if (null? choices)
(fail)
((car choices)
env
succeed
(lambda ()
(try-next (cdr choices))))))
(try-next cprocs))))
(define input-prompt ";;; Amb-Eval input:")
(define output-prompt ";;; Amb-Eval value:")
(define (driver-loop)
(define (internal-loop try-again)
(prompt-for-input input-prompt)
(let ((input (read)))
(if (eq? input 'try-again)
(try-again)
(begin
(newline)
(display
";;; Starting a new problem ")
(ambeval
input
the-global-environment
;; ambeval success
(lambda (val next-alternative)
(announce-output
output-prompt)
(user-print val)
(internal-loop
next-alternative))
;; ambeval failure
(lambda ()
(announce-output
";;; There are no
more values of")
(user-print input)
(driver-loop)))))))
(internal-loop
(lambda ()
(newline)
(display
";;; There is no current problem")
(driver-loop)))) | false |
d46b6e49c3460adb7c18871652b31b8035b72dc4 | 15b3f9425594407e43dd57411a458daae76d56f6 | /bin/init.scm | 06de3eee935ea1578aa0f8df8ce268253b7212eb | []
| no_license | aa10000/scheme | ecc2d50b9d5500257ace9ebbbae44dfcc0a16917 | 47633d7fc4d82d739a62ceec75c111f6549b1650 | refs/heads/master | 2021-05-30T06:06:32.004446 | 2015-02-12T23:42:25 | 2015-02-12T23:42:25 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 91 | scm | init.scm | ; This file is loaded on startup of my scheme implementation
(load "interpreter/init.scm")
| false |
53ab652f8d9e0f3a1bb2cf6494e1b1d68fd2312e | 6fe3cf1c6fabcf6020aae0df8154b1d3ffb334b1 | /cogen-boxops.scm | 561ab42e66905f0be955bc444ee37f4a147735f0 | []
| no_license | tonyg/pgg | bd4eae9196abcca94f316e0198408b9bd90a7820 | 1625eba59e529b92572cb51b3749015e793d3563 | refs/heads/master | 2020-06-04T04:30:57.758708 | 2012-04-11T01:11:50 | 2012-04-11T01:11:50 | 3,988,925 | 5 | 0 | null | null | null | null | WINDOWS-1252 | Scheme | false | false | 273 | scm | cogen-boxops.scm | ;;; cogen-boxops.scm
;;; copyright © 1996, 1997, 1998 by Peter Thiemann
;;; non-commercial use is free as long as the original copright notice
;;; remains intact
(define (make-cell v)
(list v))
(define (cell-ref r)
(car r))
(define (cell-set! r v)
(set-car! r v))
| false |
8b74a3e8d94a214358013f5b8999af951dfccdf4 | 9b0c653f79bc8d0dc87526f05bdc7c9482a2e277 | /2/2-31.ss | 41aaf5f780c636f0bf3d899a24b39f4c447d7ece | []
| no_license | ndNovaDev/sicp-magic | 798b0df3e1426feb24333658f2313730ae49fb11 | 9715a0d0bb1cc2215d3b0bb87c076e8cb30c4286 | refs/heads/master | 2021-05-18T00:36:57.434247 | 2020-06-04T13:19:34 | 2020-06-04T13:19:34 | 251,026,570 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 412 | ss | 2-31.ss | (define (dn x)
(display x)
(newline))
(define (square n)
(* n n))
(define (tree-map proc tree)
(cond ((null? tree) '())
((pair? tree) (cons (tree-map proc (car tree))
(tree-map proc (cdr tree))))
(else (proc tree))))
(define (square-tree tree)
(tree-map square tree))
(dn (square-tree
(list 1
(list 2 (list 3 4) 5)
(list 6 7))))
(exit)
| false |
18c2818a966c8694812c5623050e752d02b5cb11 | 648776d3a0d9a8ca036acaf6f2f7a60dcdb45877 | /queries/sql/indents.scm | b09f9b5bda8c9aced9f747141fa935cfc4c5c8ce | [
"Apache-2.0"
]
| permissive | nvim-treesitter/nvim-treesitter | 4c3c55cbe6ff73debcfaecb9b7a0d42d984be3e6 | f8c2825220bff70919b527ee68fe44e7b1dae4b2 | refs/heads/master | 2023-08-31T20:04:23.790698 | 2023-08-31T09:28:16 | 2023-08-31T18:19:23 | 256,786,531 | 7,890 | 980 | Apache-2.0 | 2023-09-14T18:07:03 | 2020-04-18T15:24:10 | Scheme | UTF-8 | Scheme | false | false | 338 | scm | indents.scm | [
(select)
(cte)
(column_definitions)
(case)
(subquery)
(insert)
(when_clause)
] @indent.begin
(block
(keyword_begin)
) @indent.begin
(column_definitions ")" @indent.branch)
(subquery ")" @indent.branch)
(cte ")" @indent.branch)
[
(keyword_end)
(keyword_values)
(keyword_into)
] @indent.branch
(keyword_end) @indent.end
| false |
e9a7a219d705a646d81aad5c301793f0162c0255 | d074b9a2169d667227f0642c76d332c6d517f1ba | /sicp/ch_2/exercise.2.56.scm | 1408567509b1b61b93cb9c314b2811f285b338d3 | []
| no_license | zenspider/schemers | 4d0390553dda5f46bd486d146ad5eac0ba74cbb4 | 2939ca553ac79013a4c3aaaec812c1bad3933b16 | refs/heads/master | 2020-12-02T18:27:37.261206 | 2019-07-14T15:27:42 | 2019-07-14T15:27:42 | 26,163,837 | 7 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,177 | scm | exercise.2.56.scm | #lang racket/base
(require "../lib/test.rkt")
(require "../lib/myutils.scm")
;;; Exercise 2.56:
;; Show how to extend the basic differentiator to handle more kinds of
;; expressions. For instance, implement the differentiation rule
;;
;; d(u^n) du
;; ---- = nu^(n-1) * --
;; dx dx
;;
;; by adding a new clause to the `deriv' program and defining
;; appropriate procedures `exponentiation?', `base', `exponent', and
;; `make-exponentiation'. (You may use the symbol `**' to denote
;; exponentiation.) Build in the rules that anything raised to the
;; power 0 is 1 and anything raised to the power 1 is the thing
;; itself.
(define (variable? x) (symbol? x))
(define (same-variable? v1 v2)
(and (variable? v1) (variable? v2) (eq? v1 v2)))
(define (=number? exp num)
(and (number? exp) (= exp num)))
(define (operator? x op)
(and (pair? x) (eq? (car x) op)))
;; +
(define (sum? x) (operator? x '+))
(define addend cadr)
(define augend caddr)
(define (make-sum a1 a2)
(cond ((=number? a1 0) a2)
((=number? a2 0) a1)
((and (number? a1) (number? a2)) (+ a1 a2))
(else (list '+ a1 a2))))
;; *
(define (product? x) (operator? x '*))
(define multiplier cadr)
(define multiplicand caddr)
(define (make-product m1 m2)
(cond ((or (=number? m1 0) (=number? m2 0)) 0)
((=number? m1 1) m2)
((=number? m2 1) m1)
((and (number? m1) (number? m2)) (* m1 m2))
(else (list '* m1 m2))))
;; **
(define (exponentiation? x) (operator? x '**))
(define base cadr)
(define exponent caddr)
(define (make-exponentiation base exponent)
(cond ((=number? exponent 0) 1)
((=number? exponent 1) base)
((and (number? base) (number? exponent)) (expt base exponent))
(else (list '** base exponent))))
;; meat
(define (deriv exp var)
(cond ((number? exp) 0)
((variable? exp)
(if (same-variable? exp var) 1 0))
((sum? exp)
(make-sum (deriv (addend exp) var)
(deriv (augend exp) var)))
((product? exp)
(make-sum
(make-product (multiplier exp)
(deriv (multiplicand exp) var))
(make-product (deriv (multiplier exp) var)
(multiplicand exp))))
((exponentiation? exp)
(make-product
(make-product
(exponent exp)
(make-exponentiation (base exp) (make-sum (exponent exp) -1)))
(deriv (base exp) var)))
(else
(error "unknown expression type -- DERIV" exp))))
;; tests
(assert-equal 1 (deriv '(+ x 3) 'x))
(assert-equal 'y (deriv '(* x y) 'x))
(assert-equal '(+ (* x y) (* y (+ x 3))) (deriv '(* (* x y) (+ x 3)) 'x))
(assert-equal #t (exponentiation? '(** x 1)))
(assert-equal 'x (base '(** x 1)))
(assert-equal 1 (exponent '(** x 1)))
(assert-equal 1 (deriv '(** x 1) 'x))
(assert-equal 0 (deriv '(** x 0) 'x))
(assert-equal 0 (deriv '(** y 1) 'x))
(assert-equal 0 (deriv '(** y 0) 'x))
(assert-equal '(* 3 (** x 2)) (deriv '(** x 3) 'x))
(done)
| false |
fa7a80b47bb3b0b3b9969746753c7077dd095bdc | ab05b79ab17619f548d9762a46199dc9eed6b3e9 | /sitelib/ypsilon/pango/renderer.scm | 0c6fc8573dd9d6454ec6fa22d6afe9f0bf7d20c6 | [
"BSD-2-Clause"
]
| permissive | lambdaconservatory/ypsilon | 2dce9ff4b5a50453937340bc757697b9b4839dee | f154436db2b3c0629623eb2a53154ad3c50270a1 | refs/heads/master | 2021-02-28T17:44:05.571304 | 2017-12-17T12:29:00 | 2020-03-08T12:57:52 | 245,719,032 | 1 | 0 | NOASSERTION | 2020-03-07T23:08:26 | 2020-03-07T23:08:25 | null | UTF-8 | Scheme | false | false | 4,548 | scm | renderer.scm | #!nobacktrace
;;; Ypsilon Scheme System
;;; Copyright (c) 2004-2009 Y.FUJITA / LittleWing Company Limited.
;;; See license.txt for terms and conditions of use.
(library (ypsilon pango renderer)
(export pango_renderer_activate
pango_renderer_deactivate
pango_renderer_draw_error_underline
pango_renderer_draw_glyph
pango_renderer_draw_glyph_item
pango_renderer_draw_glyphs
pango_renderer_draw_layout
pango_renderer_draw_layout_line
pango_renderer_draw_rectangle
pango_renderer_draw_trapezoid
pango_renderer_get_color
pango_renderer_get_layout
pango_renderer_get_layout_line
pango_renderer_get_matrix
pango_renderer_get_type
pango_renderer_part_changed
pango_renderer_set_color
pango_renderer_set_matrix)
(import (rnrs) (ypsilon ffi))
(define lib-name
(cond (on-linux "libpango-1.0.so.0")
(on-sunos "libpango-1.0.so.0")
(on-freebsd "libpango-1.0.so.0")
(on-openbsd "libpango-1.0.so.0")
(on-darwin "Gtk.framework/Gtk")
(on-windows "libpango-1.0-0.dll")
(else
(assertion-violation #f "can not locate Pango library, unknown operating system"))))
(define lib (load-shared-object lib-name))
(define-syntax define-function
(syntax-rules ()
((_ ret name args)
(define name (c-function lib lib-name ret name args)))))
;; void pango_renderer_activate (PangoRenderer* renderer)
(define-function void pango_renderer_activate (void*))
;; void pango_renderer_deactivate (PangoRenderer* renderer)
(define-function void pango_renderer_deactivate (void*))
;; void pango_renderer_draw_error_underline (PangoRenderer* renderer, int x, int y, int width, int height)
(define-function void pango_renderer_draw_error_underline (void* int int int int))
;; void pango_renderer_draw_glyph (PangoRenderer* renderer, PangoFont* font, PangoGlyph glyph, double x, double y)
(define-function void pango_renderer_draw_glyph (void* void* uint32_t double double))
;; void pango_renderer_draw_glyph_item (PangoRenderer* renderer, const char* text, PangoGlyphItem* glyph_item, int x, int y)
(define-function void pango_renderer_draw_glyph_item (void* char* void* int int))
;; void pango_renderer_draw_glyphs (PangoRenderer* renderer, PangoFont* font, PangoGlyphString* glyphs, int x, int y)
(define-function void pango_renderer_draw_glyphs (void* void* void* int int))
;; void pango_renderer_draw_layout (PangoRenderer* renderer, PangoLayout* layout, int x, int y)
(define-function void pango_renderer_draw_layout (void* void* int int))
;; void pango_renderer_draw_layout_line (PangoRenderer* renderer, PangoLayoutLine* line, int x, int y)
(define-function void pango_renderer_draw_layout_line (void* void* int int))
;; void pango_renderer_draw_rectangle (PangoRenderer* renderer, PangoRenderPart part, int x, int y, int width, int height)
(define-function void pango_renderer_draw_rectangle (void* int int int int int))
;; void pango_renderer_draw_trapezoid (PangoRenderer* renderer, PangoRenderPart part, double y1_, double x11, double x21, double y2, double x12, double x22)
(define-function void pango_renderer_draw_trapezoid (void* int double double double double double double))
;; PangoColor* pango_renderer_get_color (PangoRenderer* renderer, PangoRenderPart part)
(define-function void* pango_renderer_get_color (void* int))
;; PangoLayout* pango_renderer_get_layout (PangoRenderer* renderer)
(define-function void* pango_renderer_get_layout (void*))
;; PangoLayoutLine* pango_renderer_get_layout_line (PangoRenderer* renderer)
(define-function void* pango_renderer_get_layout_line (void*))
;; const PangoMatrix* pango_renderer_get_matrix (PangoRenderer* renderer)
(define-function void* pango_renderer_get_matrix (void*))
;; GType pango_renderer_get_type (void)
(define-function unsigned-long pango_renderer_get_type ())
;; void pango_renderer_part_changed (PangoRenderer* renderer, PangoRenderPart part)
(define-function void pango_renderer_part_changed (void* int))
;; void pango_renderer_set_color (PangoRenderer* renderer, PangoRenderPart part, const PangoColor* color)
(define-function void pango_renderer_set_color (void* int void*))
;; void pango_renderer_set_matrix (PangoRenderer* renderer, const PangoMatrix* matrix)
(define-function void pango_renderer_set_matrix (void* void*))
) ;[end]
| true |
5201ffabcb2018ea67963b425ed6a91b81abee8e | e75694971a8d65a860e49d099aba868e1b7ec664 | /a4.scm | 5a489e18c0dfa14a1f0b68e24be0f93dd6a68e0a | []
| no_license | telnet23/sicp | d29088e1bdef7ede3cf5805559e0edb3b0ef54fe | a85fa7f17c7485163c9484ed5709d6ec64e87aaa | refs/heads/master | 2023-02-20T09:20:38.216645 | 2019-04-30T20:15:12 | 2019-04-30T20:15:12 | 331,790,140 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,608 | scm | a4.scm | "problem 1. (a)"
(define (lucas n) (cond ((= n 0) 2)
((= n 1) 1)
((> n 1) (+ (lucas (- n 1))
(lucas (- n 2))))))
;(lucas 30)
;(lucas 35)
;(lucas 40)
"problem 1. (b)"
(define (fast-Lucas-help n k lucas-a lucas-b)
(if (= n k)
lucas-a
(fast-Lucas-help n (+ k 1) (+ lucas-a lucas-b) lucas-a )))
(define (fast-Lucas n) (fast-Lucas-help n 1 1 2))
" Recursive calls Recursive calls made by"
" made by (Lucas k) (fast-Lucas-help k 1 1 2)"
"k=1 0 0"
"k=2 2 1"
"k=3 4 2"
"k=4 8 3"
"k=5 16 4"
"k=6 24 5"
"problem 2. (a)"
(define (sum term a next b)
(if (> a b)
0
(+ (term a)
(sum term (next a) next b))))
(define (harmonic n) (sum (lambda (x) (/ 1 x)) 1 (lambda (x) (+ x 1)) n))
"problem 2. (b)"
(define (sum-i term a next b accumulator)
(if (> a b)
accumulator
(sum-i term (next a) next b (+ accumulator (term a)))))
(define (harmonic-i n) (sum-i (lambda (x) (/ 1 x)) 1 (lambda (x) (+ x 1)) n 0))
"problem 2. (c)"
(harmonic 1)
(harmonic-i 1)
(harmonic 50)
(harmonic-i 50)
(harmonic 100)
(harmonic-i 100)
"problem 3."
(define (compose f g) (lambda (x) (f (g x))))
((compose (lambda (x) (* x x)) (lambda (x) (+ x 1))) 6)
"problem 4."
(define (repeated f n)
(if (= n 0)
(lambda (x) x)
(compose (repeated f (- n 1)) f)))
"problem 5."
(define (m91 x)
(if (> x 100)
(- x 10)
((repeated m91 91) (+ x 901))))
| false |
27e26e00ee1ca8ee67fed20c9ed90be3c79a2635 | 98fd12cbf428dda4c673987ff64ace5e558874c4 | /sicp/v1/chapter-2.3/ndpar-2.3.scm | 6d5f102dd24e1446a0d456dd96b2bb3ddaadeb4a | [
"Unlicense"
]
| permissive | CompSciCabal/SMRTYPRTY | 397645d909ff1c3d1517b44a1bb0173195b0616e | a8e2c5049199635fecce7b7f70a2225cda6558d8 | refs/heads/master | 2021-12-30T04:50:30.599471 | 2021-12-27T23:50:16 | 2021-12-27T23:50:16 | 13,666,108 | 66 | 11 | Unlicense | 2019-05-13T03:45:42 | 2013-10-18T01:26:44 | Racket | UTF-8 | Scheme | false | false | 15,047 | scm | ndpar-2.3.scm | #lang racket
;; -------------------------------------------------------------------
;; Symbolic Data
;; -------------------------------------------------------------------
;; Exercise 2.53, p.144
(list 'a 'b 'c) ;=> '(a b c)
(list (list 'george)) ;=> '((george))
(cdr '((x1 x2) (y1 y2))) ;=> '((y1 y2))
(cadr '((x1 x2) (y1 y2))) ;=> '(y1 y2)
(pair? (car '(a short list))) ;=> #f
(memq 'red '((red shoes) (blue socks))) ;=> #f
(memq 'red '(red shoes blue socks)) ;=> '(red shoes blue socks)
;; Exercise 2.54, p.145
;; Symbol equality (same as built-in equal?)
(define (my-equal? x y)
(cond ((and (null? x) (null? y)) #t)
((and (pair? x) (pair? y))
(and (my-equal? (car x) (car y))
(my-equal? (cdr x) (cdr y))))
((and (symbol? x) (symbol? y))
(eq? x y)) (else false)))
;; Tests
(my-equal? '(this is a list) '(this is a list))
(not (my-equal? '(this is a list) '(this (is a) list)))
;; Exercise 2.55, p.145
;; Double quotation
(eq? (car ''abracadabra)
(car (quote (quote abracadabra))))
;; -------------------------------------------------------------------
;; Symbolic Differentiation, p.147
;; -------------------------------------------------------------------
(define (deriv sexp var)
(cond ((number? sexp) 0)
((variable? sexp)
(if (same-variable? sexp var) 1 0))
((sum? sexp)
(make-sum (deriv (addend sexp) var)
(deriv (augend sexp) var)))
((product? sexp)
(make-sum (make-product (multiplier sexp)
(deriv (multiplicand sexp) var))
(make-product (deriv (multiplier sexp) var)
(multiplicand sexp))))
((exponentiation? sexp)
(let ((u (base sexp))
(n (exponent sexp)))
(make-product (make-product n (deriv u var))
(make-exponentiation u (- n 1)))))
(else (error "unknown s-expression type -- DERIV" sexp))))
(define variable? symbol?)
(define (same-variable? v1 v2)
(and (variable? v1) (variable? v2) (eq? v1 v2)))
(define (make-sum a1 a2)
(cond ((=number? a1 0) a2)
((=number? a2 0) a1)
((and (number? a1) (number? a2)) (+ a1 a2))
(else (list '+ a1 a2))))
(define (sum? x)
(and (pair? x) (eq? (car x) '+)))
(define addend cadr)
(define (augend s) (combine-rest s '+))
(define (combine-rest sexp op)
(let ((rest (cddr sexp)))
(if (= (length rest) 1)
(car rest)
(cons op rest))))
(define (make-product m1 m2)
(cond ((or (=number? m1 0) (=number? m2 0)) 0)
((=number? m1 1) m2)
((=number? m2 1) m1)
((and (number? m1) (number? m2)) (* m1 m2))
(else (list '* m1 m2))))
(define (product? x)
(and (pair? x) (eq? (car x) '*)))
(define multiplier cadr)
(define (multiplicand p) (combine-rest p '*))
(define (=number? sexp num)
(and (number? sexp) (= sexp num)))
;; Tests
(eq? 1 (deriv '(+ x 3) 'x))
(eq? 'y (deriv '(* x y) 'x))
;; Exercise 2.56, p.150
;; Derivative of polynomial
(define (make-exponentiation b e)
(cond ((=number? e 0) 1)
((=number? e 1) b)
(else (list '** b e))))
(define (exponentiation? x)
(and (pair? x) (eq? (car x) '**)))
(define base cadr)
(define exponent caddr)
;; Tests
(equal? '(* 5 (** x 4))
(deriv '(** x 5) 'x))
(equal? '(* 2 x)
(deriv '(** x 2) 'x))
(= 1 (deriv '(** x 1) 'x))
;; Exercise 2.57, p.151
(equal? '(+ (* 2 x) 2)
(deriv '(+ (** x 2) (* 2 x) 1) 'x))
(equal? '(+ (* x y) (* y (+ x 3)))
(deriv '(* x y (+ x 3)) 'x))
(= 2 (deriv '(+ x y (+ x 3)) 'x))
;; Exercise 2.58, p.151
;; Algebraic infix notation
#|
;; Parenthesized version
(define (make-sum a1 a2)
(cond ((=number? a1 0) a2)
((=number? a2 0) a1)
((and (number? a1) (number? a2)) (+ a1 a2))
(else (list a1 '+ a2)))) ; swap the addend and +
(define (sum? x)
(and (pair? x) (eq? (cadr x) '+))) ; car -> cadr
(define addend car) ; cadr -> car
(define augend caddr)
(define (make-product m1 m2)
(cond ((or (=number? m1 0) (=number? m2 0)) 0)
((=number? m1 1) m2)
((=number? m2 1) m1)
((and (number? m1) (number? m2)) (* m1 m2))
(else (list m1 '* m2)))) ; swap the multiplier and *
(define (product? x)
(and (pair? x) (eq? (cadr x) '*))) ; car -> cadr
(define multiplier car) ; cadr -> car
(define multiplicand caddr)
;; Tests
(= 4 (deriv '(x + (3 * (x + (y + 2)))) 'x))
;; Standard algebraic version
(define (make-sum a1 a2)
(cond ((=number? a1 0) a2)
((=number? a2 0) a1)
((and (number? a1) (number? a2)) (+ a1 a2))
((and (pair? a1) (pair? a2)) (append a1 '(+) a2))
((pair? a1) (append a1 `(+ ,a2)))
((pair? a2) (append `(,a1 +) a2))
(else (list a1 '+ a2))))
(define (sum? x)
(and (pair? x) (member '+ x)))
(define (addend x)
(let-values (((left _) (split-by x '+)))
(if (= (length left) 1)
(car left)
left)))
(define (augend x)
(let-values (((_ right) (split-by x '+)))
(if (= (length right) 1)
(car right)
right)))
(define (make-product m1 m2)
(cond ((or (=number? m1 0) (=number? m2 0)) 0)
((=number? m1 1) m2)
((=number? m2 1) m1)
((and (number? m1) (number? m2)) (* m1 m2))
(else (list m1 '* m2))))
(define (product? x)
(and (pair? x) (eq? (cadr x) '*)))
(define multiplier car)
(define (multiplicand x)
(let-values (((left _) (split-by x '+)))
(let ((m (cddr left)))
(if (= (length m) 1)
(car m)
m))))
(define (split-by li op)
(let-values (((left right)
(splitf-at li (lambda (x) (not (eq? '+ x))))))
(if (null? right)
(values left right)
(values left (cdr right)))))
;; Tests
(= 4 (deriv '(x + 3 * (x + y + 2)) 'x))
(deriv '(x * y * z + x * (x + y) + 2 * x * (x + z) + y * z) 'x)
|#
;; -------------------------------------------------------------------
;; Sets as unordered lists
;; -------------------------------------------------------------------
#|
;; Membership, Θ(n)
(define (element-of-set? x set)
(cond ((null? set) false)
((equal? x (car set)) true)
(else (element-of-set? x (cdr set)))))
;; Adjoin, Θ(n)
(define (adjoin-set x set)
(if (element-of-set? x set)
set
(cons x set)))
;; Intersection, Θ(n^2)
(define (intersection-set set1 set2)
(cond ((or (null? set1) (null? set2)) '())
((element-of-set? (car set1) set2)
(cons (car set1)
(intersection-set (cdr set1) set2)))
(else (intersection-set (cdr set1) set2))))
;; Union, Θ(n^2)
;; Exercise 2.59, p.153
(define (union-set set1 set2)
(if (null? set1)
set2
(union-set (cdr set1)
(adjoin-set (car set1) set2))))
;; -------------------------------------------------------------------
;; Exercise 2.60, p.153
;; Sets as unordered lists with duplicates
;; -------------------------------------------------------------------
;; Adjoin, Θ(1)
(define adjoin-set cons)
;; element-of-set? is the same, Θ(n)
;; intersection-set is the same, Θ(n^2)
;; union-set is the same, Θ(n)
;; This representation is better if the majority of
;; operations are adjoin and union.
;; -------------------------------------------------------------------
;; (Numeric) sets as ordered lists
;; -------------------------------------------------------------------
;; Membership, Θ(n)
(define (element-of-set? x set)
(cond ((null? set) false)
((= x (car set)) true)
((< x (car set)) false)
(else (element-of-set? x (cdr set)))))
;; Adjoin, Θ(n)
;; Exercise 2.61, p.155
(define (adjoin-set x set)
(cond ((null? set) (list x))
((= x (car set)) set)
((< x (car set)) (cons x set))
(else (cons (car set)
(adjoin-set x (cdr set))))))
;; Intersection, Θ(n)
(define (intersection-set set1 set2)
(if (or (null? set1) (null? set2))
'()
(let ((x1 (car set1))
(x2 (car set2)))
(cond ((= x1 x2)
(cons x1 (intersection-set (cdr set1)
(cdr set2))))
((< x1 x2)
(intersection-set (cdr set1) set2))
((< x2 x1)
(intersection-set set1 (cdr set2)))))))
;; Union, Θ(n)
;; Exercise 2.62, p.155
(define (union-set set1 set2)
(cond ((null? set1) set2)
((null? set2) set1)
(else (let ((x1 (car set1))
(x2 (car set2)))
(cond ((= x1 x2)
(cons x1 (union-set (cdr set1)
(cdr set2))))
((< x1 x2)
(cons x1 (union-set (cdr set1)
set2)))
((< x2 x1)
(cons x2 (union-set set1
(cdr set2)))))))))
;; Tests
(equal? '(1 2 4 6 8) (adjoin-set 1 '(2 4 6 8)))
(equal? '(2 4 5 6 8) (adjoin-set 5 '(2 4 6 8)))
(equal? '(2 4 6 8 9) (adjoin-set 9 '(2 4 6 8)))
(equal? '(2 4 6) (union-set '() '(2 4 6)))
(equal? '(1 3 5) (union-set '(1 3 5) '()))
(equal? '(1 2 3 4 5 6) (union-set '(1 3 5) '(2 4 6)))
|#
;; -------------------------------------------------------------------
;; (Numeric) sets as binary trees
;; -------------------------------------------------------------------
;; Tree abstraction
(define entry car)
(define left-branch cadr)
(define right-branch caddr)
;; You can do it as (define make-tree list),
;; but it does not enforce correct number of params
(define (make-tree entry left right)
(list entry left right))
;; Exercise 2.63, p.158
;; Depth-first traversal. Order of growth?
;; 1) No left trees:
;; result = (append '() (cons x y))
;; = (cons x y),
;; which gives Θ(n) complexity.
;; 2) No right trees:
;; result = (append z (cons a '())
;; = (append z '(a))
;; = (append (append y (cons b '())) '(a))
;; = (append (append y '(b)) '(a))
;; = (append (append (append x '(c)) '(b)) '(a)),
;; and we have triangular matrix of cons in the end,
;; which gives Θ(n^2) complexity.
;; 3) Balanced tree: Θ(n log n) complexity.
(define (tree->list-1 tree)
(if (null? tree)
'()
(append (tree->list-1 (left-branch tree))
(cons (entry tree)
(tree->list-1 (right-branch tree))))))
;; Depth-first traversal, Θ(n).
;; Every element of the tree is cons'ed only once.
(define (tree->list-2 tree)
(define (copy-to-list tree result)
(if (null? tree)
result
(copy-to-list (left-branch tree)
(cons (entry tree)
(copy-to-list (right-branch tree)
result)))))
(copy-to-list tree '()))
(define tree-1 '(7 (3 (1 () ())
(5 () ()))
(9 ()
(11 () ()))))
(define tree-2 '(3 (1 () ())
(7 (5 () ())
(9 ()
(11 () ())))))
(define tree-3 '(5 (3 (1 () ())
())
(9 (7 () ())
(11 () ()))))
;; tree->list-1 and tree->list-2 produce the same results
(equal? '(1 3 5 7 9 11) (tree->list-1 tree-1))
(equal? '(1 3 5 7 9 11) (tree->list-1 tree-2))
(equal? '(1 3 5 7 9 11) (tree->list-1 tree-3))
(equal? '(1 3 5 7 9 11) (tree->list-2 tree-1))
(equal? '(1 3 5 7 9 11) (tree->list-2 tree-2))
(equal? '(1 3 5 7 9 11) (tree->list-2 tree-3))
;; Exercise 2.64, p.159
;; Ordered list -> balanced BST
;; Θ(n) order of growth
(define (list->tree elements)
(car (partial-tree elements (length elements))))
(define (partial-tree elts n)
(if (= n 0)
(cons '() elts)
(let* ((left-size (quotient (- n 1) 2))
(left-result (partial-tree elts left-size))
(left-tree (car left-result))
(non-left-elts (cdr left-result))
(right-size (- n (+ left-size 1)))
(this-entry (car non-left-elts))
(right-result (partial-tree (cdr non-left-elts) right-size))
(right-tree (car right-result))
(remaining-elts (cdr right-result)))
(cons (make-tree this-entry left-tree right-tree)
remaining-elts))))
;; Tests
(define tree-4 '(5 (1 ()
(3 () ()))
(9 (7 () ())
(11 () ()))))
(equal? tree-4 (list->tree '(1 3 5 7 9 11)))
;; Set operations
;; Membership, Θ(log n) on balanced tree
(define (element-of-set? x set)
(lookup x set identity))
;; Adjoin, Θ(log n) on balanced tree
(define (adjoin-set x set)
(cond ((null? set) (make-tree x '() '()))
((= x (entry set)) set)
((< x (entry set))
(make-tree (entry set)
(adjoin-set x (left-branch set))
(right-branch set)))
((> x (entry set))
(make-tree (entry set)
(left-branch set)
(adjoin-set x (right-branch set))))))
;; Exercise 2.65, p.160
(define (union-set set1 set2)
(let ((ol1 (tree->list-2 set1))
(ol2 (tree->list-2 set2)))
(list->tree (union-list ol1 ol2))))
(define (intersection-set set1 set2)
(let ((ol1 (tree->list-2 set1))
(ol2 (tree->list-2 set2)))
(list->tree (intersection-list ol1 ol2))))
;; These two procedures are the same
;; as above for odered lists
(define (intersection-list ol1 ol2)
(if (or (null? ol1) (null? ol2))
'()
(let ((x1 (car ol1)) (x2 (car ol2)))
(cond ((= x1 x2)
(cons x1 (intersection-list (cdr ol1) (cdr ol2))))
((< x1 x2)
(intersection-list (cdr ol1) ol2))
((< x2 x1)
(intersection-list ol1 (cdr ol2)))))))
(define (union-list ol1 ol2)
(cond ((null? ol1) ol2)
((null? ol2) ol1)
(else (let ((x1 (car ol1)) (x2 (car ol2)))
(cond ((= x1 x2)
(cons x1 (union-list (cdr ol1) (cdr ol2))))
((< x1 x2)
(cons x1 (union-list (cdr ol1) ol2)))
((< x2 x1)
(cons x2 (union-list ol1 (cdr ol2)))))))))
;; Exercise 2.66, p.161
(define (lookup key records keyf)
(cond ((null? records) false)
((= key (keyf (entry set))) true)
((< key (keyf (entry set)))
(lookup key (left-branch set) keyf))
((> key (keyf (entry set)))
(lookup key (right-branch set) keyf))))
;; Tests
(define tree-5 '(6 (2 ()
(4 () ()))
(10 (8 () ())
())))
(equal? '(6 (3 (1 ()
(2 () ()))
(4 ()
(5 () ())))
(9 (7 ()
(8 () ()))
(10 ()
(11 () ()))))
(union-set tree-1 tree-5))
(equal? tree-4 (intersection-set tree-1 tree-2))
| false |
14f8990f6927072b054c794699aec07b1327aead | c5de45adc74a609415f9318fda24479561a5728b | /Day05-fact-examples.ss | 6287879043c7738f02a889a021a971f2191104d1 | []
| no_license | rhit-zhuz9/CSSE304 | 8b7498336cf9573b18b3cd0f5654ddfb1b1dfc69 | f3a10bf17ca1daa532f277a0cf4f7c9746ea89e7 | refs/heads/master | 2023-03-15T11:54:52.913169 | 2018-05-30T03:00:43 | 2018-05-30T03:00:43 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,819 | ss | Day05-fact-examples.ss | ;; Original version of factorial function:
(define fact ; standard factorial function.
(lambda (n)
(if (zero? n)
1
(* n (fact (- n 1))))))
(define fact-tail ; tail-recursive version with accumulator
(lambda (n accum)
(if (zero? n)
accum
(fact-tail (- n 1) (* n accum)))))
(define factorial
(lambda (n)
(fact-tail n 1))
;; Now an Experiment. For each expression, try to predict what will happen.
;; Then execute it to see what really happens. Can you explain what you see?
(define f fact)
(f 5)
(define fact
(lambda (n)
"Abe Lincoln elected President"))
(fact 1860)
(f 1860)
; We'd like to write fact so that we can rename it safely:
; (defnie g fact)
; (define fact whatever) and still have g work.
; It would also be nice to add the efficiency-enhancing acccumulator
; How about this?
(define fact
(let ([fact-real (lambda (n accum)
(if (zero? n)
accum
(fact-real (- n 1) (* n accum))))])
(lambda (n) (fact-real n 1))))
; Solution?
(define fact
(letrec ([fact-tail
(lambda (n prod)
(if (zero? n)
prod
(fact-tail (sub1 n)
(* n prod))))])
(lambda (n) (fact-tail n 1))))
; another letrec example
(define odd?
(letrec ([odd? (lambda (n)
(if (zero? n)
#f
(even? (sub1 n))))]
[even? (lambda (n)
(if (zero? n)
#t
(odd? (sub1 n))))])
(lambda (n)
(odd? n))))
;; Named let version of fact
(define fact
(lambda (n)
(let loop ([x n] [prod 1])
(if (zero? x)
prod
(loop (sub1 x) (* prod x))))))
| false |
8645dba7ce0995e49a4cdaaadac6b1cfaa181445 | ec0f122fdcf4ceaf5e9e183575a460006c19ebe0 | /tests/test-misc-utils.scm | 1fa984f7f2da7fcc9c0d8dc541e214cbfca64d47 | []
| no_license | ThomasHintz/keep-the-records | d96e6253ebc3d2e11ee37277a6293c7365b25f9b | c20e648e831bed2ced3f2f74bfc590dc06b5f076 | refs/heads/master | 2021-01-13T02:37:41.053488 | 2013-07-19T04:18:44 | 2013-07-19T04:18:44 | 1,272,038 | 2 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 966 | scm | test-misc-utils.scm | (import misc-utils)
(test-begin "misc-utils")
(test-group
"fold-sep"
(test "xa*/b*/c*" (fold-sep (lambda (e) (string-append e "*")) "/" "x" '("a" "b" "c"))))
(test-group
"range"
(test '() (range 0))
(test '(0) (range 1))
(test '(0) (range 0 1))
(test '(0 1) (range 2))
(test '(0 1) (range 0 2))
(test '(1 2) (range 1 3))
(test '(-2 -1) (range -2 0))
(test-error (range -10))
(test-error (range 0 -10)))
(test-group
"dash->space"
(test "a b c" (dash->space "a-b-c")))
(test-group
"space->dash"
(test "a-b-c" (space->dash "a b c")))
(test-group
"id->name"
(test "Eat Good" (id->name "eat-good")))
(test-group
"name->id"
(test "eat-good" (name->id "Eat Good")))
(test-group
"list->path"
(test "/a/b/c" (list->path '("a" "b" "c") "/")))
(test-group
"html-escape"
(test "eat'stuff' food" (html-escape "eat'stuff' food")))
(test-group
"js-filter"
(test "eatstuff food" (js-filter "eat'stuff' food")))
(test-end "misc-utils")
| false |
aaf9e4cb29de52599f47fe3d36b514f19a7e061c | a67405c70ba9f3d826990e03a05c77800f368630 | /benchmarks/salsa.fpcore | aa6dc44f1b352c0fd8e6dfece2b0417a271706f4 | []
| no_license | billzorn/FPBench | b1da7f25f65c77ce2d78f78aea012a15a224be86 | 46f4f76ae617154b1dd5fece2f10a0be97fdd747 | refs/heads/master | 2021-06-29T18:42:06.178372 | 2019-06-11T06:25:26 | 2019-06-11T06:25:26 | 141,492,672 | 0 | 0 | null | 2018-07-18T21:35:29 | 2018-07-18T21:35:29 | null | UTF-8 | Scheme | false | false | 4,221 | fpcore | salsa.fpcore | ;; -*- mode: scheme -*-
(FPCore (sr* sl*)
:name "Odometry"
:description "Compute the position of a robot from the speed of the wheels.
Inputs: Speed `sl`, `sr` of the left and right wheel, in rad/s."
:cite (damouche-martel-chapoutot-fmics15)
:fpbench-domain controls
:precision binary32
:pre (and (< 0.05 sl* (* 2 PI)) (< 0.05 sr* (* 2 PI)))
:example ([sr* 0.0785398163397] [sl* 0.0525398163397])
(let ([inv_l 0.1] [c 12.34])
(while* (< t 1000)
([delta_dl 0.0 (* c sl)]
[delta_dr 0.0 (* c sr)]
[delta_d 0.0 (* (+ delta_dl delta_dr) 0.5)]
[delta_theta 0.0 (* (- delta_dr delta_dl) inv_l)]
[arg 0.0 (+ theta (* delta_theta 0.5))]
;; cos
[cosi 0.0 (+ (- 1 (* (* arg arg) 0.5)) (* (* (* (* arg arg) arg) arg) 0.0416666666))]
[x 0.0 (+ x (* delta_d cosi))]
;; sin
[sini 0.0 (+ (- arg (* (* (* arg arg) arg) 0.1666666666))
(* (* (* (* (* arg arg) arg) arg) arg) 0.008333333))]
[y 0.0 (+ y (* delta_d sini))]
[theta -.985 (+ theta delta_theta)]
[t 0 (+ t 1)]
[tmp sl* sl]
[sl sl* (if (== j 50) sr sl)]
[sr sr* (if (== j 50) tmp sr)]
[j 0 (if (== j 50) 0 (+ j 1))])
x))) ;; `y` is also an output but is skipped for now
(FPCore (m kp ki kd c)
:name "PID"
:description "Keep a measure at its setpoint using a PID controller.
Inputs: Measure `m`; gains `kp`, `ki`, `kd`; setpoint `c`"
:cite (damouche-martel-chapoutot-nsv14 damouche-martel-chapoutot-fmics15)
:fpbench-domain controls
:precision binary64
:pre (and (< -10.0 m 10.0) (< -10.0 c 10.0))
:example ([m -5.0] [kp 9.4514] [ki 0.69006] [kd 2.8454])
(let* ([dt 0.5] [invdt (/ 1 dt)])
(while* (< t 100.0)
([e 0.0 (- c m)]
[p 0.0 (* kp e)]
[i 0.0 (+ i (* (* ki dt) e))]
[d 0.0 (* (* kd invdt) (- e eold))]
[r 0.0 (+ (+ p i) d)]
[m m (+ m (* 0.01 r))]
[eold 0.0 e]
[t 0.0 (+ t dt)])
m)))
(FPCore (h y_n* c)
:name "Runge-Kutta 4"
:description "Solve the differential equation `y' = (c - y)^2
Inputs: Step size `h`; initial condition `y_n*`; paramter `c`"
:cite (damouche-martel-chapoutot-fmics15)
:fpbench-domain mathematics
:precision binary32
:pre (and (< 0 y_n* 100) (< 10e-6 h 0.1) (< 50 c 200))
:example ([h 0.1] [y_n* 10.1] [c 100.1])
(let ([sixieme (/ 1 6)] [eps 0.005] [k 1.2])
(while (> e eps)
([y_n
y_n*
(let* ([k1 (let ([v (- c y_n)]) (* (* k v) v))]
[k2 (let ([v (- c (+ y_n (* (* 0.5 h) k1)))]) (* (* k v) v))]
[k3 (let ([v (- c (+ y_n (* (* 0.5 h) k2)))]) (* (* k v) v))]
[k4 (let ([v (- c (+ y_n (* h k3)))]) (* (* k v) v))])
(+ y_n (* (* sixieme h) (+ (+ (+ k1 (* 2.0 k2)) (* 2.0 k3)) k4))))]
[i 0.0 (+ i 1.0)]
[e 1.0 (- e eps)])
(fabs e)))) ;; `i` is also an output but is skipped for now
(FPCore (y yd)
:name "Lead-lag System"
:description "Move a mass from an initial position to a desired position.
Inputs: Initial position `y`; desired position `yd`"
:cite (feron-ieee10 damouche-martel-chapoutot-fmics15)
:fpbench-domain controls
:precision binary32
:pre (and (< 0 yd 50) (< 0 y 50))
:example ([y 2.5] [yd 5.0])
(let ([eps 0.01] [Dc -1280.0]
[Ac00 .499] [Ac01 -.05] [Ac10 .010] [Ac11 1.00]
[Bc0 1.0] [Bc1 0.0] [Cc0 564.48] [Cc1 0.0])
(while* (> e eps)
([yc 0.0 (let ([v (- y yd)]) (if (< v -1.0) -1.0 (if (< 1.0 v) 1.0 v)))]
[u 0.0 (+ (* Cc0 xc0) (+ (* Cc1 xc1) (* Dc yc)))]
[xc0 0.0 (+ (* Ac00 xc0) (+ (* Ac01 xc1) (* Bc0 yc)))]
[xc1 0.0 (+ (* Ac10 xc0) (+ (* Ac11 xc1) (* Bc1 yc)))]
[i 0.0 (+ i 1.0)]
[e 1.0 (fabs (- yc xc1))])
xc1)))
(FPCore (u)
:name "Trapeze"
:cite (damouche-martel-chapoutot-fmics15)
:fpbench-domain mathematics
:pre (<= 1.11 u 2.22)
(let* ([a 0.25] [b 5000] [n 25] [h (/ (- b a) n)])
(while* (< xa 5000)
([xb 0 (let ([v (+ xa h)]) (if (> v 5000) 5000 v))]
[r
0
(let ([gxa (/ u (- (+ (- (* (* (* 0.7 xa) xa) xa) (* (* 0.6 xa) xa)) (* 0.9 xa)) 0.2))]
[gxb (/ u (- (+ (- (* (* (* 0.7 xb) xb) xb) (* (* 0.6 xb) xb)) (* 0.9 xb)) 0.2))])
(+ r (* (* (+ gxa gxb) 0.5) h)))]
[xa 0.25 (+ xa h)])
r)))
| false |
8e3f944af65cb95dd9f6e862d2d977b83f375b40 | 5355071004ad420028a218457c14cb8f7aa52fe4 | /2.2/e-2.23.scm | c69ee7da3262c9353871fc3558f3403301f42f98 | []
| no_license | ivanjovanovic/sicp | edc8f114f9269a13298a76a544219d0188e3ad43 | 2694f5666c6a47300dadece631a9a21e6bc57496 | refs/heads/master | 2022-02-13T22:38:38.595205 | 2022-02-11T22:11:18 | 2022-02-11T22:11:18 | 2,471,121 | 376 | 90 | null | 2022-02-11T22:11:19 | 2011-09-27T22:11:25 | Scheme | UTF-8 | Scheme | false | false | 1,031 | scm | e-2.23.scm | ; Exercise 2.23.
; The procedure for-each is similar to map. It takes as arguments a procedure and a list of
; elements. However, rather than forming a list of the results, for-each just applies the
; procedure to each of the elements in turn, from left to right. The values returned by applying
; the procedure to the elements are not used at all -- for-each is used with
; procedures that perform an action, such as printing. For example,
; (for-each (lambda (x) (newline) (display x))
; (list 57 321 88))
; 57
; 321
; 88
; The value returned by the call to for-each (not illustrated above) can
; be something arbitrary, such as true. Give an implementation of for-each.
; --------------------------------------------------------------------
(load "../common.scm")
; One implementation of for-each can be this
(define (for-each proc items)
(if (null? items)
nil
(begin
(proc (car items))
(for-each proc (cdr items)))))
(for-each (lambda (x) (newline) (display x))
(list 57 321 88))
| false |
43efd53c65d9c0ecfc4fbc090a3ae4a18083600e | b14c18fa7a4067706bd19df10f846fce5a24c169 | /Chapter3/3.1.scm | c47391f27f7af30a5a7d96258bdc161569b8996f | []
| no_license | silvesthu/LearningSICP | eceed6267c349ff143506b28cf27c8be07e28ee9 | b5738f7a22c9e7967a1c8f0b1b9a180210051397 | refs/heads/master | 2021-01-17T00:30:29.035210 | 2016-11-29T17:57:16 | 2016-11-29T17:57:16 | 19,287,764 | 3 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 271 | scm | 3.1.scm | #lang scheme
; use begin to combine multiple statements, and get return value from last one
;(display (begin 1 2))
(define (make-accumulator init)
(define sum init)
(lambda (addition) (set! sum (+ sum addition)) sum)
)
(define A (make-accumulator 5))
(A 10)
(A 10) | false |
41ff9e4e38a8afc2a65b49994ba2d11f1cb8f3c3 | 910c7561d77364436e75caacd9140b62ad606c00 | /libchicken/mini-srfi-1.scm | de4a64ef196aefcb1c0d794088ca9e51026c0fa0 | []
| no_license | SnellerInc/distill | 567039bd436d1d1f78f01bf2e86064d33224c1fc | cec7234f46eede218d3c4d04e9e0c8dc53785a5a | refs/heads/master | 2023-08-30T10:24:54.839538 | 2021-10-31T01:04:29 | 2021-10-31T01:05:45 | 416,853,839 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 7,117 | scm | mini-srfi-1.scm | ;;;; minimal implementation of SRFI-1 primitives
;
;
; Copyright (c) 2015-2020, The CHICKEN Team
; All rights reserved.
;
; Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
; conditions are met:
;
; Redistributions of source code must retain the above copyright notice, this list of conditions and the following
; disclaimer.
; Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
; disclaimer in the documentation and/or other materials provided with the distribution.
; Neither the name of the author nor the names of its contributors may be used to endorse or promote
; products derived from this software without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
; AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
; CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
; SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
; OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
; POSSIBILITY OF SUCH DAMAGE.
(declare
(unused take span drop partition split-at append-map every any cons* concatenate
first second third fourth alist-cons fifth remove
filter filter-map unzip1 last list-index lset-adjoin/eq? lset-difference/eq?
lset-union/eq? lset-intersection/eq? list-tabulate lset<=/eq? lset=/eq? length+
find find-tail iota make-list posq posv)
(hide take span drop partition split-at append-map every any cons* concatenate delete
first second third fourth alist-cons delete-duplicates fifth remove
filter filter-map unzip1 last list-index lset-adjoin/eq? lset-difference/eq?
lset-union/eq? lset-intersection/eq? list-tabulate lset<=/eq? lset=/eq? length+
find find-tail iota make-list posq posv))
(define (partition pred lst)
(let loop ((yes '()) (no '()) (lst lst))
(cond ((null? lst) (values (reverse yes) (reverse no)))
((pred (car lst)) (loop (cons (car lst) yes) no (cdr lst)))
(else (loop yes (cons (car lst) no) (cdr lst))))))
(define (span pred lst)
(let loop ((lst lst) (head '()))
(cond ((null? lst) (values (reverse head) lst))
((pred (car lst)) (loop (cdr lst) (cons (car lst) head)))
(else (values (reverse head) lst)))))
(define (take lst n)
(if (fx<= n 0)
'()
(cons (car lst) (take (cdr lst) (fx- n 1)))))
(define (drop lst n)
(let loop ((lst lst) (n n))
(if (fx<= n 0)
lst
(loop (cdr lst) (fx- n 1)))))
(define (split-at lst n)
(let loop ((n n) (prev '()) (node lst))
(if (fx<= n 0)
(values (reverse prev) node)
(loop (fx- n 1) (cons (car node) prev) (cdr node)))))
(define (append-map proc lst1 . lsts)
(if (null? lsts)
(foldr (lambda (x r) (append (proc x) r)) '() lst1)
(let loop ((lsts (cons lst1 lsts)))
(if (any null? lsts)
'()
(append (apply proc (map (lambda (x) (car x)) lsts))
(loop (map (lambda (x) (cdr x)) lsts)))))))
(define (every pred lst)
(let loop ((lst lst))
(cond ((null? lst))
((not (pred (car lst))) #f)
(else (loop (cdr lst))))))
(define (any pred lst)
(let loop ((lst lst))
(cond ((null? lst) #f)
((pred (car lst)))
(else (loop (cdr lst))))))
(define (cons* x1 . xs)
(let loop ((x x1) (rest xs))
(if (null? rest)
x
(cons x (loop (car rest) (cdr rest))))))
(define (concatenate lst)
(let loop ((lst lst))
(if (null? lst)
'()
(append (car lst) (loop (cdr lst))))))
(define (delete x lst test)
(let loop ((lst lst))
(cond ((null? lst) lst)
((test x (car lst))
(loop (cdr lst)))
(else
(cons (car lst) (loop (cdr lst)))))))
(define (first x) (car x))
(define (second x) (cadr x))
(define (third x) (caddr x))
(define (fourth x) (cadddr x))
(define (fifth x) (car (cddddr x)))
(define (delete-duplicates lst test)
(let loop ((lst lst))
(if (null? lst)
lst
(let* ((x (car lst))
(tail (cdr lst))
(new-tail (loop (delete x tail test))))
(if (equal? tail new-tail)
lst
(cons x new-tail))))))
(define (alist-cons x y z) (cons (cons x y) z))
(define (filter pred lst)
(foldr (lambda (x r) (if (pred x) (cons x r) r)) '() lst))
(define (filter-map pred lst)
(foldr (lambda (x r)
(cond ((pred x) => (lambda (y) (cons y r)))
(else r)))
'()
lst))
(define (remove pred lst)
(filter (lambda (x) (not (pred x))) lst))
(define (unzip1 lst) (map (lambda (x) (car x)) lst))
(define (last lst)
(let loop ((lst lst))
(if (null? (cdr lst))
(car lst)
(loop (cdr lst)))))
(define (list-index pred lst)
(let loop ((i 0) (lst lst))
(cond ((null? lst) #f)
((pred (car lst)) i)
(else (loop (fx+ i 1) (cdr lst))))))
(define (lset-adjoin/eq? lst . vals)
(let loop ((vals vals) (lst lst))
(cond ((null? vals) lst)
((memq (car vals) lst) (loop (cdr vals) lst))
(else (loop (cdr vals) (cons (car vals) lst))))))
(define (lset-difference/eq? ls . lss)
(foldl
(lambda (ls lst)
(filter (lambda (x) (not (memq x lst))) ls))
ls
lss))
(define (lset-union/eq? ls . lss)
(foldl
(lambda (ls lst)
(foldl
(lambda (ls x)
(if (any (lambda (y) (eq? y x)) ls)
ls
(cons x ls)))
ls lst))
ls lss))
(define (lset-intersection/eq? ls1 . lss)
(filter (lambda (x)
(every (lambda (lis) (memq x lis)) lss))
ls1))
(define (list-tabulate n proc)
(let loop ((i 0))
(if (fx>= i n)
'()
(cons (proc i) (loop (fx+ i 1))))))
(define (lset<=/eq? s1 s2)
(every (lambda (s) (memq s s2)) s1))
(define (lset=/eq? s1 s2)
(and (eq? (length s1) (length s2))
(every (lambda (s) (memq s s2)) s1)))
;; from SRFI-1 ref. impl.
(define (length+ x) ; Returns #f if X is circular.
(let lp ((x x) (lag x) (len 0))
(if (pair? x)
(let ((x (cdr x))
(len (fx+ len 1)))
(if (pair? x)
(let ((x (cdr x))
(lag (cdr lag))
(len (fx+ len 1)))
(and (not (eq? x lag)) (lp x lag len)))
len))
len)))
(define (find pred lst)
(let loop ((lst lst))
(cond ((null? lst) #f)
((pred (car lst)) (car lst))
(else (loop (cdr lst))))))
(define (find-tail pred ls)
(let lp ((ls ls))
(cond ((null? ls) #f)
((pred (car ls)) ls)
(else (lp (cdr ls))))))
(define (iota n) (list-tabulate n (lambda (i) i)))
(define (make-list n #!optional x)
(list-tabulate n (lambda _ x)))
(define (posq x lst)
(let loop ((i 0) (lst lst))
(cond ((null? lst) #f)
((eq? (car lst) x) i)
(else (loop (fx+ i 1) (cdr lst))))))
(define (posv x lst)
(let loop ((i 0) (lst lst))
(cond ((null? lst) #f)
((eqv? (car lst) x) i)
(else (loop (fx+ i 1) (cdr lst))))))
| false |
f0410ca0f641f94ca683b4cb25c4ddcd801a3f6e | 483a1c3d153edd17f637ad1c304062776651fb33 | /fib-cps-tramp.scm | b83428297463452d31ea33db9aba151d6b0c0aad | []
| no_license | namin/lambdajam | c4fb047044676ba52c800c1343ffd4360afeb085 | 1ea7b3e424551c3d389199f392abb83ea27b046c | refs/heads/master | 2023-08-30T19:54:06.203073 | 2023-08-12T19:56:36 | 2023-08-12T19:56:36 | 11,259,139 | 10 | 4 | null | null | null | null | UTF-8 | Scheme | false | false | 523 | scm | fib-cps-tramp.scm | (let ()
(define (fib-cps n k)
(begin
(show n)
(if (or (= n 0) (= n 1)) (k n)
(lambda ()
(fib-cps (- n 1)
(lambda (v1)
(lambda ()
(fib-cps (- n 2)
(lambda (v2)
(k (+ v1 v2)))))))))))
(define (loop r)
(while (procedure? r)
(set! r (r))
r))
(define (fib n)
(loop (fib-cps n (lambda (v) v))))
(show (fib 5)))
| false |
6862059e7c1e08c83ee1452b48d53a9ad45d4b83 | ff04929b266a237745260264b21715804d5da972 | /app.scm | f7d531ec7250e42ea90efbb02098a5def49d1a5f | []
| no_license | nathanielrb/mu-rdf-importer | 60d6765c54d38ad7c505040d07b838bde59bbf2a | 4f21d2fa1f85cb623ec45994a2963d40790ea301 | refs/heads/master | 2020-09-05T06:39:55.841102 | 2017-06-15T07:51:56 | 2017-06-15T07:51:56 | 94,414,481 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,669 | scm | app.scm | (use s-sparql)
(use csv csv-string srfi-127 matchable)
(define parse (csv-parser #\,))
(define (lazy-data path)
(let ((port (open-input-file path)))
(generator->lseq
(lambda ()
(let ((line (read-line port)))
(if (eof-object? line)
(close-input-pipe port)
(csv-record->list
(join
(parse line)))))))))
(define (load-csv path proc #!optional (lines #f))
(let loop ((data (lazy-data path))
(n 0)
(accum '()))
(if (and data
(lseq-car data)
(or (not lines)
(< n lines)))
(begin (proc (lseq-car data))
(loop (lseq-cdr data)
(+ n 1)
accum) )
accum)))
(define-syntax triples-template
(syntax-rules ()
((triples-template (vars ...) body)
(match-lambda
((vars ...)
body)))))
(define sparql/update print)
(define (load-dataset path template #!optional (lines #f))
(load-csv path
(compose sparql/update s-insert s-triples template)
lines))
(define (uuid label)
(->string (gensym label)))
(define (%uri template #!rest args)
(read-uri (apply format #f template args)))
(define (%str template #!rest args)
(apply format #f template args))
(define template
(triples-template
(supermarket ecoicop isba isba-desc
esba esba-desc gtin gtin-desc quantity unit)
(let* ((id (uuid "observation"))
(uri (%uri "http://data.europa.eu/eurostat/data/id/observation/~A" id)))
`((,uri mu:uuid ,id)))))
;; (define training-triples
;; (match-lambda
;; ((supermarket ecoicop ecoicop6 ecoicop6-desc
;; esba esba-desc gtin gtin-desc quantity unit)
;; (let ((p (obs (uuid "observation")))
| true |
63f71562007aa5832b1f577a6d5027c3522736ed | 3604661d960fac0f108f260525b90b0afc57ce55 | /SICP-solutions/1/1.43-fnx.scm | 4c92975f7d61b2479187d9e4f330a6ca680ea28e | []
| no_license | rythmE/SICP-solutions | b58a789f9cc90f10681183c8807fcc6a09837138 | 7386aa8188b51b3d28a663958b807dfaf4ee0c92 | refs/heads/master | 2021-01-13T08:09:23.217285 | 2016-09-27T11:33:11 | 2016-09-27T11:33:11 | 69,350,592 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 120 | scm | 1.43-fnx.scm | (load "1.42-compose.scm")
(define (repeated f n)
(if (= n 1)
(lambda (x) (f x))
(repeated (compose f f) (- n 1)))) | false |
ca251aa6334efccda26a43f6e0e64e6d27880d4e | 48014c4b362d33543413616c2a3a3bd2b4340290 | /test-srfi-78.scm | e2880451a39c232496ba52d50359b40d5706511b | []
| no_license | scheme-requests-for-implementation/srfi-189 | ff3ff02be0c0cd78d414ffeaf29766c0789d4795 | c6910d3e4d8f8f48c13455bc83a4ea7b93544999 | refs/heads/master | 2022-07-09T15:41:26.746225 | 2022-06-29T15:08:19 | 2022-06-29T15:08:19 | 251,177,602 | 2 | 3 | null | 2022-03-27T23:39:12 | 2020-03-30T02:05:06 | Scheme | UTF-8 | Scheme | false | false | 1,102 | scm | test-srfi-78.scm | ;;;; Test framework for SRFI 78.
(cond-expand
((library (srfi 78))
(import (srfi 78)))
(else
(begin
(define *tests-failed* 0)
(define-syntax check
(syntax-rules (=>)
((check expr => expected)
(if (equal? expr expected)
(begin
(display 'expr)
(display " => ")
(display expected)
(display " ; correct")
(newline))
(begin
(set! *tests-failed* (+ *tests-failed* 1))
(display "FAILED: for ")
(display 'expr)
(display " expected ")
(display expected)
(display " but got ")
(display expr)
(newline))))))
(define (check-report)
(if (zero? *tests-failed*)
(begin
(display "All tests passed.")
(newline))
(begin
(display "TESTS FAILED: ")
(display *tests-failed*)
(newline)))))))
(include "test-body.scm")
(include "test-syntax.scm")
| true |
8eb12a3a36d97a2ad4403f83931d1f58d432579d | fb9a1b8f80516373ac709e2328dd50621b18aa1a | /ch3/3-3-2_queue.scm | dce459bf4dd71636d17835a40184af575fff529a | []
| no_license | da1/sicp | a7eacd10d25e5a1a034c57247755d531335ff8c7 | 0c408ace7af48ef3256330c8965a2b23ba948007 | refs/heads/master | 2021-01-20T11:57:47.202301 | 2014-02-16T08:57:55 | 2014-02-16T08:57:55 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 2,084 | scm | 3-3-2_queue.scm | ;; 変更は単なる代入
(define (cons x y)
(define (dispatch m)
(cond ((eq? m 'car) x)
((eq? m 'cdr) y)
(else (else "Undefined operation -- CONS" m))))
dispatch)
(define (car z) (z 'car))
(define (cdr z) (z 'cdr))
(define (cons x y)
(define (set-x! v) (set! x v))
(define (set-y! v) (set! y v))
(define (dispatch m)
(cond ((eq? m 'car) x)
((eq? m 'cdr) y)
((eq? m 'set-car!) set-x!)
((eq? m 'set-cdr!) set-y!)
(else (error "Undefined operation -- CONS" m))))
dispatch)
(define (car z) (z 'car))
(define (cdr z) (z 'cdr))
(define (set-car! z new-value)
((z 'set-car!) new-value))
(define (set-cdr! z new-value)
((z 'set-cdr!) new-value)
z)
;; 3.3.2 キューの表現
;; (make-queue) 空のキューを返す
;; (empty-queue? <queue>) キューが空であることをテストする
;; (fron-queue <queue>) キューの先頭のオブジェクトを返す。空ならエラー、キューは変化しない
;; (insert-queue! <queue> <item>) キューの末尾に項目を挿入
;; (delete-queue! <queue>)
(define (front-ptr queue) (car queue))
(define (rear-ptr queue) (cdr queue))
(define (set-front-ptr! queue item) (set-car! queue item))
(define (set-rear-ptr! queue item) (set-cdr! queue item))
(define (empty-queue? queue) (null? (front-ptr queue)))
(define (make-queue) (cons '() '()))
(define (front-queue queue )
(if (empty-queue? queue)
(error "FRONT called with an empty queue" queue)
(car (front-ptr queue))))
(define (insert-queue! queue item)
(let ((new-pair (cons item '())))
(cond ((empty-queue? queue)
(set-front-ptr! queue new-pair)
(set-rear-ptr! queue new-pair)
queue)
(else
(set-cdr! (rear-ptr queue) new-pair)
(set-rear-ptr! queue new-pair)
queue))))
(define (delete-queue! queue)
(cond ((empty-queue? queue)
(error "DELETE! called with an empty queue" queue))
(else
(set-front-ptr! queue (cdr (front-ptr queue)))
queue)))
| false |
efe32b2be0409f73278f2cb9d1a35901e3129618 | a74932f6308722180c9b89c35fda4139333703b8 | /edwin48/midas.scm | e26690ffcdeeedbccce42206a99922bcfa67cfd0 | []
| no_license | scheme/edwin48 | 16b5d865492db5e406085e8e78330dd029f1c269 | fbe3c7ca14f1418eafddebd35f78ad12e42ea851 | refs/heads/master | 2021-01-19T17:59:16.986415 | 2014-12-21T17:50:27 | 2014-12-21T17:50:27 | 1,035,285 | 39 | 10 | null | 2022-02-15T23:21:14 | 2010-10-29T16:08:55 | Scheme | UTF-8 | Scheme | false | false | 2,553 | scm | midas.scm | #| -*-Scheme-*-
$Id: midas.scm,v 1.28 2008/01/30 20:02:03 cph Exp $
Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
2006, 2007, 2008 Massachusetts Institute of Technology
This file is part of MIT/GNU Scheme.
MIT/GNU Scheme is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or (at
your option) any later version.
MIT/GNU Scheme is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with MIT/GNU Scheme; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301,
USA.
|#
;;;; Midas Mode
(define-command midas-mode
"Enter Midas mode."
()
(lambda () (set-current-major-mode! (ref-mode-object midas))))
(define-major-mode midas fundamental "Midas"
"Major mode for editing assembly code."
(lambda (buffer)
(local-set-variable! syntax-table midas-mode:syntax-table buffer)
(local-set-variable! comment-column 40 buffer)
(local-set-variable! comment-locator-hook lisp-comment-locate buffer)
(local-set-variable! comment-indent-hook midas-comment-indentation buffer)
(local-set-variable! comment-start ";" buffer)
(local-set-variable! comment-end "" buffer)
(standard-alternate-paragraph-style! buffer)
(local-set-variable! indent-line-procedure (ref-command insert-tab) buffer)
(local-set-variable! local-abbrev-table
(ref-variable midas-mode-abbrev-table buffer)
buffer)
(event-distributor/invoke! (ref-variable midas-mode-hook buffer) buffer)))
(define midas-mode:syntax-table (make-char-syntax-table))
(set-char-syntax! midas-mode:syntax-table #\; "< ")
(set-char-syntax! midas-mode:syntax-table #\newline "> ")
(set-char-syntax! midas-mode:syntax-table #\. "w ")
(set-char-syntax! midas-mode:syntax-table #\' "' ")
(set-char-syntax! midas-mode:syntax-table #\$ "' ")
(set-char-syntax! midas-mode:syntax-table #\% "' ")
(set-char-syntax! midas-mode:syntax-table #\# "' ")
(define (midas-comment-indentation mark)
(if (match-forward ";;;" mark)
0
(max (+ (mark-column (horizontal-space-start mark)) 1)
(ref-variable comment-column mark)))) | false |
33fd642963e076b596090994f46920e02ec1071b | 665da87f9fefd8678b0635e31df3f3ff28a1d48c | /srfi/sorting/srfi-132-test.sps | 4938a674bcd754e52d2609b49429f29c00690506 | [
"MIT"
]
| permissive | justinethier/cyclone | eeb782c20a38f916138ac9a988dc53817eb56e79 | cc24c6be6d2b7cc16d5e0ee91f0823d7a90a3273 | refs/heads/master | 2023-08-30T15:30:09.209833 | 2023-08-22T02:11:59 | 2023-08-22T02:11:59 | 31,150,535 | 862 | 64 | MIT | 2023-03-04T15:15:37 | 2015-02-22T03:08:21 | Scheme | UTF-8 | Scheme | false | false | 55,079 | sps | srfi-132-test.sps | ;;; Test program for SRFI 132 (Sort Libraries).
;;; Copyright © William D Clinger (2016).
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use,
;;; copy, modify, merge, publish, distribute, sublicense, and/or
;;; sell copies of the Software, and to permit persons to whom the
;;; Software is furnished to do so, subject to the following
;;; conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
;;; OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
;;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
;;; OTHER DEALINGS IN THE SOFTWARE.
;;; Embeds Olin's test harness. Here is his copyright notice:
;;; This code is
;;; Copyright (c) 1998 by Olin Shivers.
;;; The terms are: You may do as you please with this code, as long as
;;; you do not delete this notice or hold me responsible for any outcome
;;; related to its use.
;;;
;;; Blah blah blah. Don't you think source files should contain more lines
;;; of code than copyright notice?
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; To run this program in Larceny, from this directory:
;;;
;;; % mkdir srfi
;;; % cp 132.sld *.scm srfi
;;; % larceny --r7rs --program srfi-132-test.sps --path .
;;;
;;; Other implementations of the R7RS may use other conventions
;;; for naming and locating library files, but the conventions
;;; assumed by this program are the most widely implemented.
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Olin's test harness tests some procedures that aren't part of SRFI 132,
;;; so the (local olin) library defined here is just to support Olin's tests.
;;; (Including Olin's code within the test program would create name
;;; conflicts.)
(define-library (local olin)
(export list-merge-sort vector-merge-sort ; not part of SRFI 132
list-merge-sort! vector-merge-sort! ; not part of SRFI 132
vector-insert-sort vector-insert-sort! ; not part of SRFI 132
vector-heap-sort vector-heap-sort! ; not part of SRFI 132
vector-quick-sort vector-quick-sort! ; not part of SRFI 132
; vector-binary-search vector-binary-search3 ; not part of SRFI 132
vector-quick-sort3 vector-quick-sort3! ; not part of SRFI 132
)
(import (except (scheme base) vector-copy vector-copy!)
(rename (only (scheme base) vector-copy vector-copy!)
(vector-copy r7rs-vector-copy)
(vector-copy! r7rs-vector-copy!))
(scheme cxr)
(only (srfi 27) random-integer))
(include "delndups.scm")
(include "lmsort.scm")
(include "sortp.scm")
(include "vector-util.scm")
(include "vhsort.scm")
(include "visort.scm")
(include "vmsort.scm")
(include "vqsort2.scm")
(include "vqsort3.scm")
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; The test program contains optional benchmarks that can be
;;; enabled by defining display-benchmark-results? as true.
(define-library (local benchmarking)
(export display-benchmark-results?
r6rs-list-sort
r6rs-vector-sort
r6rs-vector-sort!)
(import (scheme base)
(srfi 132))
(cond-expand
((library (rnrs sorting))
(import
(rename (rnrs sorting)
(list-sort r6rs-list-sort)
(vector-sort r6rs-vector-sort)
(vector-sort! r6rs-vector-sort!))))
(else
(begin
(define r6rs-list-sort list-sort)
(define r6rs-vector-sort vector-sort)
(define r6rs-vector-sort! vector-sort!))))
(begin
;; To display benchmark results, change this to true.
(define display-benchmark-results? #f)
))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(import (except (scheme base) vector-copy)
(rename (scheme base)
(vector-copy r7rs-vector-copy))
(scheme write)
(scheme process-context)
(scheme time)
(only (srfi 27) random-integer)
(srfi 132)
(local olin)
(local benchmarking))
;;; These definitions avoid having to change Olin's code.
(define-syntax define-test-suite
(syntax-rules ()
((_ name)
(define (name test-name thunk)
(thunk)))))
(define-syntax define-test-case
(syntax-rules ()
((_ test-name suite-name expr)
(define (test-name)
(suite-name 'test-name (lambda () expr))))))
(define (is x) x)
(define (check-that x y)
(or (if (procedure? y)
(y x)
(equal? x y))
(fail "some test failed")))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Olin's code.
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Little test harness, 'cause I'm paraoid about tricky code.
;;; This code is
;;; Copyright (c) 1998 by Olin Shivers.
;;; The terms are: You may do as you please with this code, as long as
;;; you do not delete this notice or hold me responsible for any outcome
;;; related to its use.
;;;
;;; Blah blah blah. Don't you think source files should contain more lines
;;; of code than copyright notice?
(define-test-suite sort-tests)
;; Three-way comparison for numbers
(define (my-c x y)
(cond ((= x y) 0)
((< x y) -1)
(else 1)))
;;; For testing stable sort -- 3 & -3 compare the same.
(define (my< x y) (< (abs x) (abs y)))
(define (unstable-sort-test v) ; quick & heap vs simple insert
(let ((v1 (vector-copy v))
(v2 (vector-copy v))
(v3 (vector-copy v))
(v4 (vector-copy v)))
(vector-heap-sort! < v1)
(vector-insert-sort! < v2)
(vector-quick-sort! < v3)
(vector-quick-sort3! my-c v4)
(check-that v2 (is v1))
(check-that v3 (is v1))
(check-that v4 (is v1))
(check-that v1 (is (lambda (v) (vector-sorted? < v))))))
(define (stable-sort-test v) ; insert, list & vector merge sorts
(let ((v1 (vector-copy v))
(v2 (vector-copy v))
(v3 (list->vector (list-merge-sort! my< (vector->list v))))
(v4 (list->vector (list-merge-sort my< (vector->list v)))))
(vector-merge-sort! my< v1)
(vector-insert-sort! my< v2)
(check-that v1 (is (lambda (v) (vector-sorted? my< v))))
(check-that v2 (is v1))
(check-that v3 (is v1))
(check-that v4 (is v1))))
(define (run-sort-test sort-test count max-size)
(let loop ((i 0))
(if (< i count)
(begin
(sort-test (random-vector (random-integer max-size)))
(loop (+ 1 i))))))
(define-test-case stable-sort sort-tests
(run-sort-test stable-sort-test 10 4096))
(define-test-case unstable-sort sort-tests
(run-sort-test unstable-sort-test 10 4096))
(define (random-vector size)
(let ((v (make-vector size)))
(fill-vector-randomly! v (* 10 size))
v))
(define (fill-vector-randomly! v range)
(let ((half (quotient range 2)))
(do ((i (- (vector-length v) 1) (- i 1)))
((< i 0))
(vector-set! v i (- (random-integer range) half)))))
(define (vector-portion-copy vec start end)
(let* ((len (vector-length vec))
(new-len (- end start))
(new (make-vector new-len)))
(do ((i start (+ i 1))
(j 0 (+ j 1)))
((= i end) new)
(vector-set! new j (vector-ref vec i)))))
(define (vector-copy vec)
(vector-portion-copy vec 0 (vector-length vec)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; End of Olin's code.
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (writeln . xs)
(for-each display xs)
(newline))
(define (fail token . more)
(writeln "Error: test failed: " token)
#f)
(stable-sort)
(unstable-sort)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Additional tests written specifically for SRFI 132.
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(or (list-sorted? > '())
(fail 'list-sorted?:empty-list))
(or (list-sorted? > '(987))
(fail 'list-sorted?:singleton))
(or (list-sorted? > '(9 8 7))
(fail 'list-sorted?:non-empty-list))
(or (vector-sorted? > '#())
(fail 'vector-sorted?:empty-vector))
(or (vector-sorted? > '#(987))
(fail 'vector-sorted?:singleton))
(or (vector-sorted? > '#(9 8 7 6 5))
(fail 'vector-sorted?:non-empty-vector))
(or (vector-sorted? > '#() 0)
(fail 'vector-sorted?:empty-vector:0))
(or (vector-sorted? > '#(987) 1)
(fail 'vector-sorted?:singleton:1))
(or (vector-sorted? > '#(9 8 7 6 5) 1)
(fail 'vector-sorted?:non-empty-vector:1))
(or (vector-sorted? > '#() 0 0)
(fail 'vector-sorted?:empty-vector:0:0))
(or (vector-sorted? > '#(987) 1 1)
(fail 'vector-sorted?:singleton:1:1))
(or (vector-sorted? > '#(9 8 7 6 5) 1 2)
(fail 'vector-sorted?:non-empty-vector:1:2))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(or (equal? (list-sort > (list))
'())
(fail 'list-sort:empty-list))
(or (equal? (list-sort > (list 987))
'(987))
(fail 'list-sort:singleton))
(or (equal? (list-sort > (list 987 654))
'(987 654))
(fail 'list-sort:doubleton))
(or (equal? (list-sort > (list 9 8 6 3 0 4 2 5 7 1))
'(9 8 7 6 5 4 3 2 1 0))
(fail 'list-sort:iota10))
(or (equal? (list-stable-sort > (list))
'())
(fail 'list-stable-sort:empty-list))
(or (equal? (list-stable-sort > (list 987))
'(987))
(fail 'list-stable-sort:singleton))
(or (equal? (list-stable-sort > (list 987 654))
'(987 654))
(fail 'list-stable-sort:doubleton))
(or (equal? (list-stable-sort > (list 9 8 6 3 0 4 2 5 7 1))
'(9 8 7 6 5 4 3 2 1 0))
(fail 'list-stable-sort:iota10))
(or (equal? (list-stable-sort (lambda (x y)
(> (quotient x 2)
(quotient y 2)))
(list 9 8 6 3 0 4 2 5 7 1))
'(9 8 6 7 4 5 3 2 0 1))
(fail 'list-stable-sort:iota10-quotient2))
(or (equal? (let ((v (vector)))
(vector-sort > v))
'#())
(fail 'vector-sort:empty-vector))
(or (equal? (let ((v (vector 987)))
(vector-sort > (vector 987)))
'#(987))
(fail 'vector-sort:singleton))
(or (equal? (let ((v (vector 987 654)))
(vector-sort > v))
'#(987 654))
(fail 'vector-sort:doubleton))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-sort > v))
'#(9 8 7 6 5 4 3 2 1 0))
(fail 'vector-sort:iota10))
(or (equal? (let ((v (vector)))
(vector-stable-sort > v))
'#())
(fail 'vector-stable-sort:empty-vector))
(or (equal? (let ((v (vector 987)))
(vector-stable-sort > (vector 987)))
'#(987))
(fail 'vector-stable-sort:singleton))
(or (equal? (let ((v (vector 987 654)))
(vector-stable-sort > v))
'#(987 654))
(fail 'vector-stable-sort:doubleton))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-stable-sort > v))
'#(9 8 7 6 5 4 3 2 1 0))
(fail 'vector-stable-sort:iota10))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-stable-sort (lambda (x y)
(> (quotient x 2)
(quotient y 2)))
v))
'#(9 8 6 7 4 5 3 2 0 1))
(fail 'vector-stable-sort:iota10-quotient2))
(or (equal? (let ((v (vector)))
(vector-sort > v 0))
'#())
(fail 'vector-sort:empty-vector:0))
(or (equal? (let ((v (vector 987)))
(vector-sort > (vector 987) 1))
'#())
(fail 'vector-sort:singleton:1))
(or (equal? (let ((v (vector 987 654)))
(vector-sort > v 1))
'#(654))
(fail 'vector-sort:doubleton:1))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-sort > v 3))
'#(7 5 4 3 2 1 0))
(fail 'vector-sort:iota10:3))
(or (equal? (let ((v (vector)))
(vector-stable-sort > v 0))
'#())
(fail 'vector-stable-sort:empty-vector:0))
(or (equal? (let ((v (vector 987)))
(vector-stable-sort > (vector 987) 1))
'#())
(fail 'vector-stable-sort:singleton:1))
(or (equal? (let ((v (vector 987 654)))
(vector-stable-sort < v 0 2))
'#(654 987))
(fail 'vector-stable-sort:doubleton:0:2))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-stable-sort > v 3))
'#(7 5 4 3 2 1 0))
(fail 'vector-stable-sort:iota10:3))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-stable-sort (lambda (x y)
(> (quotient x 2)
(quotient y 2)))
v
3))
'#(7 4 5 3 2 0 1))
(fail 'vector-stable-sort:iota10-quotient2:3))
(or (equal? (let ((v (vector)))
(vector-sort > v 0 0))
'#())
(fail 'vector-sort:empty-vector:0:0))
(or (equal? (let ((v (vector 987)))
(vector-sort > (vector 987) 1 1))
'#())
(fail 'vector-sort:singleton:1:1))
(or (equal? (let ((v (vector 987 654)))
(vector-sort > v 1 2))
'#(654))
(fail 'vector-sort:doubleton:1:2))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-sort > v 4 8))
'#(5 4 2 0))
(fail 'vector-sort:iota10:4:8))
(or (equal? (let ((v (vector)))
(vector-stable-sort > v 0 0))
'#())
(fail 'vector-stable-sort:empty-vector:0:0))
(or (equal? (let ((v (vector 987)))
(vector-stable-sort > (vector 987) 1 1))
'#())
(fail 'vector-stable-sort:singleton:1:1))
(or (equal? (let ((v (vector 987 654)))
(vector-stable-sort > v 1 2))
'#(654))
(fail 'vector-stable-sort:doubleton:1:2))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-stable-sort > v 2 6))
'#(6 4 3 0))
(fail 'vector-stable-sort:iota10:2:6))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-stable-sort (lambda (x y)
(> (quotient x 2)
(quotient y 2)))
v
1
8))
'#(8 6 4 5 3 2 0))
(fail 'vector-stable-sort:iota10-quotient2:1:8))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(or (equal? (list-sort! > (list))
'())
(fail 'list-sort!:empty-list))
(or (equal? (list-sort! > (list 987))
'(987))
(fail 'list-sort!:singleton))
(or (equal? (list-sort! > (list 987 654))
'(987 654))
(fail 'list-sort!:doubleton))
(or (equal? (list-sort! > (list 9 8 6 3 0 4 2 5 7 1))
'(9 8 7 6 5 4 3 2 1 0))
(fail 'list-sort!:iota10))
(or (equal? (list-stable-sort! > (list))
'())
(fail 'list-stable-sort!:empty-list))
(or (equal? (list-stable-sort! > (list 987))
'(987))
(fail 'list-stable-sort!:singleton))
(or (equal? (list-stable-sort! > (list 987 654))
'(987 654))
(fail 'list-stable-sort!:doubleton))
(or (equal? (list-stable-sort! > (list 9 8 6 3 0 4 2 5 7 1))
'(9 8 7 6 5 4 3 2 1 0))
(fail 'list-stable-sort!:iota10))
(or (equal? (list-stable-sort! (lambda (x y)
(> (quotient x 2)
(quotient y 2)))
(list 9 8 6 3 0 4 2 5 7 1))
'(9 8 6 7 4 5 3 2 0 1))
(fail 'list-stable-sort!:iota10-quotient2))
(or (equal? (let ((v (vector)))
(vector-sort! > v)
v)
'#())
(fail 'vector-sort!:empty-vector))
(or (equal? (let ((v (vector 987)))
(vector-sort! > (vector 987))
v)
'#(987))
(fail 'vector-sort!:singleton))
(or (equal? (let ((v (vector 987 654)))
(vector-sort! > v)
v)
'#(987 654))
(fail 'vector-sort!:doubleton))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-sort! > v)
v)
'#(9 8 7 6 5 4 3 2 1 0))
(fail 'vector-sort!:iota10))
(or (equal? (let ((v (vector)))
(vector-stable-sort! > v)
v)
'#())
(fail 'vector-stable-sort!:empty-vector))
(or (equal? (let ((v (vector 987)))
(vector-stable-sort! > (vector 987))
v)
'#(987))
(fail 'vector-stable-sort!:singleton))
(or (equal? (let ((v (vector 987 654)))
(vector-stable-sort! > v)
v)
'#(987 654))
(fail 'vector-stable-sort!:doubleton))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-stable-sort! > v)
v)
'#(9 8 7 6 5 4 3 2 1 0))
(fail 'vector-stable-sort!:iota10))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-stable-sort! (lambda (x y)
(> (quotient x 2)
(quotient y 2)))
v)
v)
'#(9 8 6 7 4 5 3 2 0 1))
(fail 'vector-stable-sort!:iota10-quotient2))
(or (equal? (let ((v (vector)))
(vector-sort! > v 0)
v)
'#())
(fail 'vector-sort!:empty-vector:0))
(or (equal? (let ((v (vector 987)))
(vector-sort! > (vector 987) 1)
v)
'#(987))
(fail 'vector-sort!:singleton:1))
(or (equal? (let ((v (vector 987 654)))
(vector-sort! > v 1)
v)
'#(987 654))
(fail 'vector-sort!:doubleton:1))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-sort! > v 3)
v)
'#(9 8 6 7 5 4 3 2 1 0))
(fail 'vector-sort!:iota10:3))
(or (equal? (let ((v (vector)))
(vector-stable-sort! > v 0)
v)
'#())
(fail 'vector-stable-sort!:empty-vector:0))
(or (equal? (let ((v (vector 987)))
(vector-stable-sort! > (vector 987) 1)
v)
'#(987))
(fail 'vector-stable-sort!:singleton:1))
(or (equal? (let ((v (vector 987 654)))
(vector-stable-sort! < v 0 2)
v)
'#(654 987))
(fail 'vector-stable-sort!:doubleton:0:2))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-stable-sort! > v 3)
v)
'#(9 8 6 7 5 4 3 2 1 0))
(fail 'vector-stable-sort!:iota10:3))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-stable-sort! (lambda (x y)
(> (quotient x 2)
(quotient y 2)))
v
3)
v)
'#(9 8 6 7 4 5 3 2 0 1))
(fail 'vector-stable-sort!:iota10-quotient2:3))
(or (equal? (let ((v (vector)))
(vector-sort! > v 0 0)
v)
'#())
(fail 'vector-sort!:empty-vector:0:0))
(or (equal? (let ((v (vector 987)))
(vector-sort! > (vector 987) 1 1)
v)
'#(987))
(fail 'vector-sort!:singleton:1:1))
(or (equal? (let ((v (vector 987 654)))
(vector-sort! > v 1 2)
v)
'#(987 654))
(fail 'vector-sort!:doubleton:1:2))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-sort! > v 4 8)
v)
'#(9 8 6 3 5 4 2 0 7 1))
(fail 'vector-sort!:iota10:4:8))
(or (equal? (let ((v (vector)))
(vector-stable-sort! > v 0 0)
v)
'#())
(fail 'vector-stable-sort!:empty-vector:0:0))
(or (equal? (let ((v (vector 987)))
(vector-stable-sort! > (vector 987) 1 1)
v)
'#(987))
(fail 'vector-stable-sort!:singleton:1:1))
(or (equal? (let ((v (vector 987 654)))
(vector-stable-sort! > v 1 2)
v)
'#(987 654))
(fail 'vector-stable-sort!:doubleton:1:2))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-stable-sort! > v 2 6)
v)
'#(9 8 6 4 3 0 2 5 7 1))
(fail 'vector-stable-sort!:iota10:2:6))
(or (equal? (let ((v (vector 9 8 6 3 0 4 2 5 7 1)))
(vector-stable-sort! (lambda (x y)
(> (quotient x 2)
(quotient y 2)))
v
1
8)
v)
'#(9 8 6 4 5 3 2 0 7 1))
(fail 'vector-stable-sort!:iota10-quotient2:1:8))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(or (equal? (list-merge > (list) (list))
'())
(fail 'list-merge:empty:empty))
(or (equal? (list-merge > (list) (list 9 6 3 0))
'(9 6 3 0))
(fail 'list-merge:empty:nonempty))
(or (equal? (list-merge > (list 9 7 5 3 1) (list))
'(9 7 5 3 1))
(fail 'list-merge:nonempty:empty))
(or (equal? (list-merge > (list 9 7 5 3 1) (list 9 6 3 0))
'(9 9 7 6 5 3 3 1 0))
(fail 'list-merge:nonempty:nonempty))
(or (equal? (list-merge! > (list) (list))
'())
(fail 'list-merge!:empty:empty))
(or (equal? (list-merge! > (list) (list 9 6 3 0))
'(9 6 3 0))
(fail 'list-merge!:empty:nonempty))
(or (equal? (list-merge! > (list 9 7 5 3 1) (list))
'(9 7 5 3 1))
(fail 'list-merge!:nonempty:empty))
(or (equal? (list-merge! > (list 9 7 5 3 1) (list 9 6 3 0))
'(9 9 7 6 5 3 3 1 0))
(fail 'list-merge!:nonempty:nonempty))
(or (equal? (vector-merge > (vector) (vector))
'#())
(fail 'vector-merge:empty:empty))
(or (equal? (vector-merge > (vector) (vector 9 6 3 0))
'#(9 6 3 0))
(fail 'vector-merge:empty:nonempty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector))
'#(9 7 5 3 1))
(fail 'vector-merge:nonempty:empty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector 9 6 3 0))
'#(9 9 7 6 5 3 3 1 0))
(fail 'vector-merge:nonempty:nonempty))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector))
v)
'#(#f #f #f #f #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:empty))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector 9 6 3 0))
v)
'#( 9 6 3 0 #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:nonempty))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector))
v)
'#( 9 7 5 3 1 #f #f #f #f #f #f #f))
(fail 'vector-merge!:nonempty:empty))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector 9 6 3 0))
v)
'#( 9 9 7 6 5 3 3 1 0 #f #f #f))
(fail 'vector-merge!:nonempty:nonempty))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector) 0)
v)
'#(#f #f #f #f #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:empty:0))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector 9 6 3 0) 0)
v)
'#( 9 6 3 0 #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:nonempty:0))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector) 0)
v)
'#( 9 7 5 3 1 #f #f #f #f #f #f #f))
(fail 'vector-merge!:nonempty:empty:0))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector 9 6 3 0) 0)
v)
'#( 9 9 7 6 5 3 3 1 0 #f #f #f))
(fail 'vector-merge!:nonempty:nonempty:0))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector) 2)
v)
'#(#f #f #f #f #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector 9 6 3 0) 2)
v)
'#(#f #f 9 6 3 0 #f #f #f #f #f #f))
(fail 'vector-merge!:empty:nonempty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector) 2)
v)
'#(#f #f 9 7 5 3 1 #f #f #f #f #f))
(fail 'vector-merge!:nonempty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector 9 6 3 0) 2)
v)
'#(#f #f 9 9 7 6 5 3 3 1 0 #f))
(fail 'vector-merge!:nonempty:nonempty:2))
(or (equal? (vector-merge > (vector) (vector) 0)
'#())
(fail 'vector-merge:empty:empty))
(or (equal? (vector-merge > (vector) (vector 9 6 3 0) 0)
'#(9 6 3 0))
(fail 'vector-merge:empty:nonempty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector) 2)
'#(5 3 1))
(fail 'vector-merge:nonempty:empty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector 9 6 3 0) 2)
'#(9 6 5 3 3 1 0))
(fail 'vector-merge:nonempty:nonempty))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector) 2 0)
v)
'#(#f #f #f #f #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector 9 6 3 0) 2 0)
v)
'#(#f #f 9 6 3 0 #f #f #f #f #f #f))
(fail 'vector-merge!:empty:nonempty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector) 2 2)
v)
'#(#f #f 5 3 1 #f #f #f #f #f #f #f))
(fail 'vector-merge!:nonempty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector 9 6 3 0) 2 2)
v)
'#(#f #f 9 6 5 3 3 1 0 #f #f #f))
(fail 'vector-merge!:nonempty:nonempty:2))
(or (equal? (vector-merge > (vector) (vector) 0 0)
'#())
(fail 'vector-merge:empty:empty))
(or (equal? (vector-merge > (vector) (vector 9 6 3 0) 0 0)
'#(9 6 3 0))
(fail 'vector-merge:empty:nonempty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector) 2 5)
'#(5 3 1))
(fail 'vector-merge:nonempty:empty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector 9 6 3 0) 2 5)
'#(9 6 5 3 3 1 0))
(fail 'vector-merge:nonempty:nonempty))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector) 2 0 0)
v)
'#(#f #f #f #f #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector 9 6 3 0) 2 0 0)
v)
'#(#f #f 9 6 3 0 #f #f #f #f #f #f))
(fail 'vector-merge!:empty:nonempty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector) 2 2 5)
v)
'#(#f #f 5 3 1 #f #f #f #f #f #f #f))
(fail 'vector-merge!:nonempty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector 9 6 3 0) 2 2 5)
v)
'#(#f #f 9 6 5 3 3 1 0 #f #f #f))
(fail 'vector-merge!:nonempty:nonempty:2))
;;; Some tests are duplicated to make the pattern easier to discern.
(or (equal? (vector-merge > (vector) (vector) 0 0)
'#())
(fail 'vector-merge:empty:empty))
(or (equal? (vector-merge > (vector) (vector 9 6 3 0) 0 0)
'#(9 6 3 0))
(fail 'vector-merge:empty:nonempty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector) 2 4)
'#(5 3))
(fail 'vector-merge:nonempty:empty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector 9 6 3 0) 2 4)
'#(9 6 5 3 3 0))
(fail 'vector-merge:nonempty:nonempty))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector) 2 0 0)
v)
'#(#f #f #f #f #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector 9 6 3 0) 2 0 0)
v)
'#(#f #f 9 6 3 0 #f #f #f #f #f #f))
(fail 'vector-merge!:empty:nonempty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector) 2 2 4)
v)
'#(#f #f 5 3 #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:nonempty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector 9 6 3 0) 2 2 4)
v)
'#(#f #f 9 6 5 3 3 0 #f #f #f #f))
(fail 'vector-merge!:nonempty:nonempty:2))
(or (equal? (vector-merge > (vector) (vector) 0 0 0)
'#())
(fail 'vector-merge:empty:empty))
(or (equal? (vector-merge > (vector) (vector 9 6 3 0) 0 0 0)
'#(9 6 3 0))
(fail 'vector-merge:empty:nonempty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector) 2 4 0)
'#(5 3))
(fail 'vector-merge:nonempty:empty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector 9 6 3 0) 2 4 0)
'#(9 6 5 3 3 0))
(fail 'vector-merge:nonempty:nonempty))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector) 2 0 0 0)
v)
'#(#f #f #f #f #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector 9 6 3 0) 2 0 0 0)
v)
'#(#f #f 9 6 3 0 #f #f #f #f #f #f))
(fail 'vector-merge!:empty:nonempty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector) 2 2 4 0)
v)
'#(#f #f 5 3 #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:nonempty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector 9 6 3 0) 2 2 4 0)
v)
'#(#f #f 9 6 5 3 3 0 #f #f #f #f))
(fail 'vector-merge!:nonempty:nonempty:2))
(or (equal? (vector-merge > (vector) (vector) 0 0 0)
'#())
(fail 'vector-merge:empty:empty))
(or (equal? (vector-merge > (vector) (vector 9 6 3 0) 0 0 1)
'#(6 3 0))
(fail 'vector-merge:empty:nonempty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector) 2 4 0)
'#(5 3))
(fail 'vector-merge:nonempty:empty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector 9 6 3 0) 2 4 1)
'#(6 5 3 3 0))
(fail 'vector-merge:nonempty:nonempty))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector) 2 0 0 0)
v)
'#(#f #f #f #f #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector 9 6 3 0) 2 0 0 1)
v)
'#(#f #f 6 3 0 #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:nonempty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector) 2 2 4 0)
v)
'#(#f #f 5 3 #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:nonempty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector 9 6 3 0) 2 2 4 1)
v)
'#(#f #f 6 5 3 3 0 #f #f #f #f #f))
(fail 'vector-merge!:nonempty:nonempty:2))
(or (equal? (vector-merge > (vector) (vector) 0 0 0 0)
'#())
(fail 'vector-merge:empty:empty))
(or (equal? (vector-merge > (vector) (vector 9 6 3 0) 0 0 1 4)
'#(6 3 0))
(fail 'vector-merge:empty:nonempty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector) 2 4 0 0)
'#(5 3))
(fail 'vector-merge:nonempty:empty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector 9 6 3 0) 2 4 1 4)
'#(6 5 3 3 0))
(fail 'vector-merge:nonempty:nonempty))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector) 2 0 0 0 0)
v)
'#(#f #f #f #f #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector 9 6 3 0) 2 0 0 1 4)
v)
'#(#f #f 6 3 0 #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:nonempty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector) 2 2 4 0 0)
v)
'#(#f #f 5 3 #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:nonempty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector 9 6 3 0) 2 2 4 1 4)
v)
'#(#f #f 6 5 3 3 0 #f #f #f #f #f))
(fail 'vector-merge!:nonempty:nonempty:2))
(or (equal? (vector-merge > (vector) (vector) 0 0 0 0)
'#())
(fail 'vector-merge:empty:empty))
(or (equal? (vector-merge > (vector) (vector 9 6 3 0) 0 0 1 2)
'#(6))
(fail 'vector-merge:empty:nonempty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector) 2 4 0 0)
'#(5 3))
(fail 'vector-merge:nonempty:empty))
(or (equal? (vector-merge > (vector 9 7 5 3 1) (vector 9 6 3 0) 2 4 1 2)
'#(6 5 3))
(fail 'vector-merge:nonempty:nonempty))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector) 2 0 0 0 0)
v)
'#(#f #f #f #f #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector) (vector 9 6 3 0) 2 0 0 1 2)
v)
'#(#f #f 6 #f #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:empty:nonempty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector) 2 2 4 0 0)
v)
'#(#f #f 5 3 #f #f #f #f #f #f #f #f))
(fail 'vector-merge!:nonempty:empty:2))
(or (equal? (let ((v (make-vector 12 #f)))
(vector-merge! > v (vector 9 7 5 3 1) (vector 9 6 3 0) 2 2 4 1 2)
v)
'#(#f #f 6 5 3 #f #f #f #f #f #f #f))
(fail 'vector-merge!:nonempty:nonempty:2))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(or (equal? (list-delete-neighbor-dups char=? (list))
'())
(fail 'list-delete-neighbor-dups:empty))
(or (equal? (list-delete-neighbor-dups char=? (list #\a))
'(#\a))
(fail 'list-delete-neighbor-dups:singleton))
(or (equal? (list-delete-neighbor-dups char=? (list #\a #\a #\a #\b #\b #\a))
'(#\a #\b #\a))
(fail 'list-delete-neighbor-dups:nonempty))
(or (equal? (list-delete-neighbor-dups! char=? (list))
'())
(fail 'list-delete-neighbor-dups!:empty))
(or (equal? (list-delete-neighbor-dups! char=? (list #\a))
'(#\a))
(fail 'list-delete-neighbor-dups!:singleton))
(or (equal? (list-delete-neighbor-dups! char=? (list #\a #\a #\a #\b #\b #\a))
'(#\a #\b #\a))
(fail 'list-delete-neighbor-dups!:nonempty))
(or (equal? (let ((v (vector)))
(vector-delete-neighbor-dups char=? v))
'#())
(fail 'vector-delete-neighbor-dups:empty))
(or (equal? (let ((v (vector #\a)))
(vector-delete-neighbor-dups char=? v))
'#(#\a))
(fail 'vector-delete-neighbor-dups:singleton))
(or (equal? (let ((v (vector #\a #\a #\a #\b #\b #\a)))
(vector-delete-neighbor-dups char=? v))
'#(#\a #\b #\a))
(fail 'vector-delete-neighbor-dups:nonempty))
(or (equal? (let ((v (vector)))
(list (vector-delete-neighbor-dups! char=? v) v))
'(0 #()))
(fail 'vector-delete-neighbor-dups!:empty))
(or (equal? (let ((v (vector #\a)))
(list (vector-delete-neighbor-dups! char=? v) v))
'(1 #(#\a)))
(fail 'vector-delete-neighbor-dups!:singleton))
(or (equal? (let ((v (vector #\a #\a #\a #\b #\b #\a)))
(list (vector-delete-neighbor-dups! char=? v) v))
'(3 #(#\a #\b #\a #\b #\b #\a)))
(fail 'vector-delete-neighbor-dups!:nonempty))
(or (equal? (let ((v (vector)))
(vector-delete-neighbor-dups char=? v 0))
'#())
(fail 'vector-delete-neighbor-dups:empty:0))
(or (equal? (let ((v (vector #\a)))
(vector-delete-neighbor-dups char=? v 0))
'#(#\a))
(fail 'vector-delete-neighbor-dups:singleton:0))
(or (equal? (let ((v (vector #\a #\a #\a #\b #\b #\a)))
(vector-delete-neighbor-dups char=? v 0))
'#(#\a #\b #\a))
(fail 'vector-delete-neighbor-dups:nonempty:0))
(or (equal? (let ((v (vector)))
(list (vector-delete-neighbor-dups! char=? v 0) v))
'(0 #()))
(fail 'vector-delete-neighbor-dups!:empty:0))
(or (equal? (let ((v (vector #\a)))
(list (vector-delete-neighbor-dups! char=? v 0) v))
'(1 #(#\a)))
(fail 'vector-delete-neighbor-dups!:singleton:0))
(or (equal? (let ((v (vector #\a #\a #\a #\b #\b #\a)))
(list (vector-delete-neighbor-dups! char=? v 0) v))
'(3 #(#\a #\b #\a #\b #\b #\a)))
(fail 'vector-delete-neighbor-dups!:nonempty:0))
(or (equal? (let ((v (vector)))
(vector-delete-neighbor-dups char=? v 0))
'#())
(fail 'vector-delete-neighbor-dups:empty:0))
(or (equal? (let ((v (vector #\a)))
(vector-delete-neighbor-dups char=? v 1))
'#())
(fail 'vector-delete-neighbor-dups:singleton:1))
(or (equal? (let ((v (vector #\a #\a #\a #\b #\b #\a)))
(vector-delete-neighbor-dups char=? v 3))
'#(#\b #\a))
(fail 'vector-delete-neighbor-dups:nonempty:3))
(or (equal? (let ((v (vector)))
(list (vector-delete-neighbor-dups! char=? v 0) v))
'(0 #()))
(fail 'vector-delete-neighbor-dups!:empty:0))
(or (equal? (let ((v (vector #\a)))
(list (vector-delete-neighbor-dups! char=? v 1) v))
'(1 #(#\a)))
(fail 'vector-delete-neighbor-dups!:singleton:1))
(or (equal? (let ((v (vector #\a #\a #\a #\b #\b #\a)))
(list (vector-delete-neighbor-dups! char=? v 3) v))
'(5 #(#\a #\a #\a #\b #\a #\a)))
(fail 'vector-delete-neighbor-dups!:nonempty:3))
(or (equal? (let ((v (vector)))
(vector-delete-neighbor-dups char=? v 0 0))
'#())
(fail 'vector-delete-neighbor-dups:empty:0:0))
(or (equal? (let ((v (vector #\a)))
(vector-delete-neighbor-dups char=? v 1 1))
'#())
(fail 'vector-delete-neighbor-dups:singleton:1:1))
(or (equal? (let ((v (vector #\a #\a #\a #\b #\b #\a)))
(vector-delete-neighbor-dups char=? v 3 5))
'#(#\b))
(fail 'vector-delete-neighbor-dups:nonempty:3:5))
(or (equal? (let ((v (vector)))
(list (vector-delete-neighbor-dups! char=? v 0 0) v))
'(0 #()))
(fail 'vector-delete-neighbor-dups!:empty:0:0))
(or (equal? (let ((v (vector #\a)))
(list (vector-delete-neighbor-dups! char=? v 0 1) v))
'(1 #(#\a)))
(fail 'vector-delete-neighbor-dups!:singleton:0:1))
(or (equal? (let ((v (vector #\a)))
(list (vector-delete-neighbor-dups! char=? v 1 1) v))
'(1 #(#\a)))
(fail 'vector-delete-neighbor-dups!:singleton:1:1))
(or (equal? (let ((v (vector #\a #\a #\a #\b #\b #\a)))
(list (vector-delete-neighbor-dups! char=? v 3 5) v))
'(4 #(#\a #\a #\a #\b #\b #\a)))
(fail 'vector-delete-neighbor-dups!:nonempty:3:5))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(or (equal? (vector-find-median < (vector) "knil")
"knil")
(fail 'vector-find-median:empty))
(or (equal? (vector-find-median < (vector 17) "knil")
17)
(fail 'vector-find-median:singleton))
(or (equal? (vector-find-median < (vector 18 1 12 14 12 5 18 2) "knil")
12)
(fail 'vector-find-median:8same))
(or (equal? (vector-find-median < (vector 18 1 11 14 12 5 18 2) "knil")
23/2)
(fail 'vector-find-median:8diff))
(or (equal? (vector-find-median < (vector 18 1 12 14 12 5 18 2) "knil" list)
(list 12 12))
(fail 'vector-find-median:8samelist))
(or (equal? (vector-find-median < (vector 18 1 11 14 12 5 18 2) "knil" list)
(list 11 12))
(fail 'vector-find-median:8difflist))
(or (equal? (vector-find-median < (vector 7 6 9 3 1 18 15 7 8) "knil")
7)
(fail 'vector-find-median:9))
(or (equal? (vector-find-median < (vector 7 6 9 3 1 18 15 7 8) "knil" list)
7)
(fail 'vector-find-median:9list))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(or (equal? (let ((v (vector 19)))
(vector-select! < v 0))
19)
(fail 'vector-select!:singleton:0))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 0))
3)
(fail 'vector-select!:ten:0))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 2))
9)
(fail 'vector-select!:ten:2))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 8))
22)
(fail 'vector-select!:ten:8))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 9))
23)
(fail 'vector-select!:ten:9))
(or (equal? (let ((v (vector 19)))
(vector-select! < v 0 0))
19)
(fail 'vector-select!:singleton:0:0))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 0 0))
3)
(fail 'vector-select!:ten:0:0))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 2 0))
9)
(fail 'vector-select!:ten:2:0))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 8 0))
22)
(fail 'vector-select!:ten:8:0))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 9 0))
23)
(fail 'vector-select!:ten:9:0))
(or (equal? (let ((v (vector 19)))
(vector-select! < v 0 0 1))
19)
(fail 'vector-select!:singleton:0:0:1))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 0 0 10))
3)
(fail 'vector-select!:ten:0:0:10))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 2 0 10))
9)
(fail 'vector-select!:ten:2:0:10))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 8 0 10))
22)
(fail 'vector-select!:ten:8:0:10))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 9 0 10))
23)
(fail 'vector-select!:ten:9:0:10))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 0 4 10))
3)
(fail 'vector-select!:ten:0:4:10))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 2 4 10))
13)
(fail 'vector-select!:ten:2:4:10))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 4 4 10))
21)
(fail 'vector-select!:ten:4:4:10))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 5 4 10))
23)
(fail 'vector-select!:ten:5:4:10))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 0 4 10))
3)
(fail 'vector-select!:ten:0:4:10))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 2 4 10))
13)
(fail 'vector-select!:ten:2:4:10))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 3 4 10))
13)
(fail 'vector-select!:ten:3:4:10))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 4 4 10))
21)
(fail 'vector-select!:ten:4:4:10))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 5 4 10))
23)
(fail 'vector-select!:ten:9:4:10))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 0 4 8))
9)
(fail 'vector-select!:ten:0:4:8))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 1 4 8))
13)
(fail 'vector-select!:ten:1:4:8))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 2 4 8))
13)
(fail 'vector-select!:ten:2:4:8))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-select! < v 3 4 8))
21)
(fail 'vector-select!:ten:3:4:8))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(or (equal? (let ((v (vector)))
(vector-separate! < v 0)
(vector-sort < (r7rs-vector-copy v 0 0)))
'#())
(fail 'vector-separate!:empty:0))
(or (equal? (let ((v (vector 19)))
(vector-separate! < v 0)
(vector-sort < (r7rs-vector-copy v 0 0)))
'#())
(fail 'vector-separate!:singleton:0))
(or (equal? (let ((v (vector 19)))
(vector-separate! < v 1)
(vector-sort < (r7rs-vector-copy v 0 1)))
'#(19))
(fail 'vector-separate!:singleton:1))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-separate! < v 0)
(vector-sort < (r7rs-vector-copy v 0 0)))
'#())
(fail 'vector-separate!:ten:0))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-separate! < v 3)
(vector-sort < (r7rs-vector-copy v 0 3)))
'#(3 8 9))
(fail 'vector-separate!:ten:3))
(or (equal? (let ((v (vector)))
(vector-separate! < v 0 0)
(vector-sort < (r7rs-vector-copy v 0 0)))
'#())
(fail 'vector-separate!:empty:0:0))
(or (equal? (let ((v (vector 19)))
(vector-separate! < v 0 0)
(vector-sort < (r7rs-vector-copy v 0 0)))
'#())
(fail 'vector-separate!:singleton:0:0))
(or (equal? (let ((v (vector 19)))
(vector-separate! < v 1 0)
(vector-sort < (r7rs-vector-copy v 0 1)))
'#(19))
(fail 'vector-separate!:singleton:1:0))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-separate! < v 0 0)
(vector-sort < (r7rs-vector-copy v 0 0)))
'#())
(fail 'vector-separate!:ten:0:0))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-separate! < v 3 0)
(vector-sort < (r7rs-vector-copy v 0 3)))
'#(3 8 9))
(fail 'vector-separate!:ten:3:0))
(or (equal? (let ((v (vector 19)))
(vector-separate! < v 0 1)
(vector-sort < (r7rs-vector-copy v 1 1)))
'#())
(fail 'vector-separate!:singleton:0:1))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-separate! < v 0 2)
(vector-sort < (r7rs-vector-copy v 2 2)))
'#())
(fail 'vector-separate!:ten:0:2))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-separate! < v 3 2)
(vector-sort < (r7rs-vector-copy v 2 5)))
'#(3 9 13))
(fail 'vector-separate!:ten:3:2))
(or (equal? (let ((v (vector)))
(vector-separate! < v 0 0 0)
(vector-sort < (r7rs-vector-copy v 0 0)))
'#())
(fail 'vector-separate!:empty:0:0:0))
(or (equal? (let ((v (vector 19)))
(vector-separate! < v 0 1 1)
(vector-sort < (r7rs-vector-copy v 1 1)))
'#())
(fail 'vector-separate!:singleton:0:1:1))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-separate! < v 0 2 8)
(vector-sort < (r7rs-vector-copy v 2 2)))
'#())
(fail 'vector-separate!:ten:0:2:8))
(or (equal? (let ((v (vector 8 22 19 19 13 9 21 13 3 23)))
(vector-separate! < v 3 2 8)
(vector-sort < (r7rs-vector-copy v 2 5)))
'#(9 13 13))
(fail 'vector-separate!:ten:3:2:8))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Sorting routines often have internal boundary cases or
;;; randomness, so it's prudent to run a lot of tests with
;;; different lengths.
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (all-sorts-okay? m n)
(if (> m 0)
(let* ((v (random-vector n))
(v2 (vector-copy v))
(lst (vector->list v))
(ans (vector-sort < v2))
(med (cond ((= n 0) -97)
((odd? n)
(vector-ref ans (quotient n 2)))
(else
(/ (+ (vector-ref ans (- (quotient n 2) 1))
(vector-ref ans (quotient n 2)))
2)))))
(define (dsort vsort!)
(let ((v2 (vector-copy v)))
(vsort! < v2)
v2))
(and (equal? ans (list->vector (list-sort < lst)))
(equal? ans (list->vector (list-stable-sort < lst)))
(equal? ans (list->vector (list-sort! < (list-copy lst))))
(equal? ans (list->vector (list-stable-sort! < (list-copy lst))))
(equal? ans (vector-sort < v2))
(equal? ans (vector-stable-sort < v2))
(equal? ans (dsort vector-sort!))
(equal? ans (dsort vector-stable-sort!))
(equal? med (vector-find-median < v2 -97))
(equal? v v2)
(equal? lst (vector->list v))
(equal? med (vector-find-median! < v2 -97))
(equal? ans v2)
(all-sorts-okay? (- m 1) n)))
#t))
(define (test-all-sorts m n)
(or (all-sorts-okay? m n)
(fail (list 'test-all-sorts m n))))
(for-each test-all-sorts
'( 3 5 10 10 10 20 20 10 10 10 10 10 10 10 10 10 10)
'( 0 1 2 3 4 5 10 20 30 40 50 99 100 101 499 500 501))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Benchmarks.
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (mostly-sorted-random-vector n)
(define fraction-not-sorted 1/20)
(define k (round (* n fraction-not-sorted)))
(let* ((v (random-vector n))
(v2 (r6rs-vector-sort < v)))
(do ((i 0 (+ i 1)))
((= i k))
(vector-set! v2 i (vector-ref v i)))
v2))
;;; Performs n calls of f on a fresh copy of the vector or list v
;;; and returns the average time per call in seconds, rounded to
;;; the nearest microsecond.
(define (average-time n f v)
(define (call-loop i jiffies)
(if (> i 0)
(let* ((v2 (if (vector? v)
(vector-copy v)
(list-copy v)))
(t0 (current-jiffy))
(result (f < v2))
(t1 (current-jiffy)))
(call-loop (- i 1) (+ jiffies (- t1 t0))))
(let* ((dt (/ jiffies (jiffies-per-second)))
(dt (/ dt n))
(dt (/ (round (* 1e6 dt)) 1e6)))
dt)))
(call-loop n 0))
(define (run-some-benchmarks m n)
(newline)
(display "Average time (in seconds) for a sequence of length ")
(write n)
(display " : ")
(newline)
(newline)
(display " random mostly sorted\n")
(let* ((v (random-vector n))
(l (vector->list v))
(v2 (mostly-sorted-random-vector n))
(l2 (vector->list v2)))
(define (run-sorter name f v v2)
(display name)
(display " ")
(write10 (average-time m f v))
(display " ")
(write10 (average-time m f v2))
(newline))
(define (write10 x)
(let* ((p (open-output-string))
(ignored (write x p))
(s (get-output-string p))
(k (string-length s))
(s (string-append s (make-string (max 0 (- 10 k)) #\space))))
(display s)))
(run-sorter "R6RS list-sort " r6rs-list-sort l l2)
(run-sorter "list-sort " list-sort l l2)
(run-sorter "list-stable-sort " list-stable-sort l l2)
(run-sorter "list-sort! " list-sort! l l2)
(run-sorter "list-stable-sort! " list-stable-sort! l l2)
(run-sorter "R6RS vector-sort " r6rs-vector-sort v v2)
(run-sorter "R6RS vector-sort! " r6rs-vector-sort! v v2)
(run-sorter "vector-sort " vector-sort v v2)
(run-sorter "vector-stable-sort " vector-stable-sort v v2)
(run-sorter "vector-sort! " vector-sort! v v2)
(run-sorter "vector-stable-sort!" vector-stable-sort! v v2)
(run-sorter "vector-find-median "
(lambda (< v)
(vector-find-median < v -1))
v v2)
(run-sorter "vector-find-median!"
(lambda (< v)
(vector-find-median! < v -1))
v v2)))
(if display-benchmark-results?
(run-some-benchmarks 1000 100))
(if display-benchmark-results?
(run-some-benchmarks 50 9999))
(if display-benchmark-results?
(run-some-benchmarks 50 10000))
(if display-benchmark-results?
(run-some-benchmarks 3 1000000))
(display "Done.\n")
| true |
4cf8d4bb6e5f410d325dc361f9860f6601ce8331 | 2e50e13dddf57917018ab042f3410a4256b02dcf | /t/renaming-import.scm | 628e3df4c19be5aaf5b9cea64ae6d454ec91b0c7 | [
"MIT"
]
| permissive | koba-e964/picrin | c0ca2596b98a96bcad4da9ec77cf52ce04870482 | 0f17caae6c112de763f4e18c0aebaa73a958d4f6 | refs/heads/master | 2021-01-22T12:44:29.137052 | 2016-07-10T16:12:36 | 2016-07-10T16:12:36 | 17,021,900 | 0 | 0 | MIT | 2019-05-17T03:46:41 | 2014-02-20T13:55:33 | Scheme | UTF-8 | Scheme | false | false | 341 | scm | renaming-import.scm | (define-library (foo)
(import (except (rename (prefix (only (scheme base) car cdr cons) my-)
(my-car my-kar)
(my-cdr my-kdr))
my-kar))
;; (import (rename (scheme base)
;; (car my-kar)
;; (cdr my-cdr)))
(export my-kdr my-cons))
| false |
5f817be4252474be281198ae9b1544447280641c | 92d1f9df75d93f3125b07b9830541577248723fa | /subst2.ss | 14161b3b3ef318000636dc36603e089a1baac6f6 | []
| no_license | liangxingguang/schemelearn | 94a8f804194ba554fd4f6fbc4959533daf08194e | 71e32238149fb50a8e78466dcdb4d652af846a9e | refs/heads/master | 2021-03-12T23:08:57.212246 | 2014-04-30T18:09:08 | 2014-04-30T18:09:08 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 464 | ss | subst2.ss | #lang racket
(define subst2
(lambda(new o1 o2 lat)
(cond
((null? lat) (quote ()))
(else(cond
((or (eq? (car lat) o1) (eq? (car lat) o2))
(cons new (subst2 new o1 o2 (cdr lat))))
(else
(cons (car lat) (subst2 new o1 o2 (cdr lat))))
)))))
(define new 'vanilla)
(define o1 'chocolate)
(define o2 'banana)
(define lat '(banana ice cream with chocolate topping))
(subst2 new o1 o2 lat) | false |
513dcd628f6cf33b567dc18e35d28c52e66a08aa | c74dcb1facbd920d762017345171f47f8e41d0c5 | /chapter_3/3.18.scm | f6945243264f974c86ae74cf99ca7fa07cd2e7d2 | []
| no_license | akash-akya/sicp-exercises | 5125c1118c7f0e4400cb823508797fb67c745592 | c28f73719740c2c495b7bc38ee8b790219482b67 | refs/heads/master | 2021-06-15T19:12:47.679967 | 2019-08-03T14:03:20 | 2019-08-03T14:03:20 | 136,158,517 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 718 | scm | 3.18.scm | #lang sicp
(#%require "utils.scm")
;; Exercise 3.18: Write a procedure that examines a list and
;; determines whether it contains a cycle, that is, whether a program
;; that tried to find the end of the list by taking successive cdrs
;; would go into an infinite loop. Exercise 3.13 constructed such
;; lists.
(define (check-cycle list)
(define visited '())
(define (iter list)
(cond ((null? list) #f)
((member (car list) visited)
#t)
(else (set! visited (cons (car list)
visited))
(iter (cdr list)))))
(iter list))
;; test
(define a '(1))
(test-equal (check-cycle a) #f)
(set-cdr! a a)
(test-equal (check-cycle a) #t)
| false |
880ed0f8bee1bb12e78f200e248b85fc533111bf | 370ebaf71b077579ebfc4d97309ce879f97335f7 | /littleSchemer/tests.sld | 4472de0584345aab54880087f07aac16a2885f81 | []
| no_license | jgonis/sicp | 7f14beb5b65890a86892a05ba9e7c59fc8bceb80 | fd46c80b98c408e3fd18589072f02ba444d35f53 | refs/heads/master | 2023-08-17T11:52:23.344606 | 2023-08-13T22:20:42 | 2023-08-13T22:20:42 | 376,708,557 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,201 | sld | tests.sld | (include "testsCh1.sld")
(include "testsCh2.sld")
(include "testsCh3.sld")
(include "testsCh4.sld")
(include "testsCh5.sld")
(include "testsCh6.sld")
(include "testsCh7.sld")
(include "testsCh8.sld")
(include "testsCh9.sld")
(include "testsCh10.sld")
(define-library (little-schemer tests all)
(export run-tests)
(import (scheme base)
(scheme write)
(srfi 78)
(little-schemer tests ch1)
(little-schemer tests ch2)
(little-schemer tests ch3)
(little-schemer tests ch4)
(little-schemer tests ch5)
(little-schemer tests ch6)
(little-schemer tests ch7)
(little-schemer tests ch8)
(little-schemer tests ch9)
(little-schemer tests ch10))
(begin
(define run-tests
(lambda ()
(check-reset!)
(check-set-mode! 'report-failed)
(run-tests-ch1)
(run-tests-ch2)
(run-tests-ch3)
(run-tests-ch4)
(run-tests-ch5)
(run-tests-ch6)
(run-tests-ch7)
(run-tests-ch8)
(run-tests-ch9)
(run-tests-ch10)
(check-report)
(check-reset!)))))
| false |
49fa07ba0976091ce27c94b800458dc3993c7477 | c9548b7e89f384fb53fc0d0a3c008d17416dd6c6 | /config.scm | d347766e4aee0c82d593af7a60b61371eb998031 | [
"Zlib"
]
| permissive | euccastro/sphere-energy | 8c4a02632ea848569f9acfb2ecb6eda1e2db492b | e532a7274be2dbf54a62620b658564710354d469 | refs/heads/master | 2021-01-15T09:18:44.389023 | 2014-10-25T14:28:37 | 2014-10-25T14:28:37 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 613 | scm | config.scm | (sphere: "energy")
(dependencies:
(condition
(load (fabric: algorithm/list)))
(filesystem
(include (core: base-macros))
(load (= log)))
(functional-arguments
(include (core: base-macros)))
(io
(include (core: base-macros)))
(inspect
(include (core: base-macros)))
(remote/debuggee
(include (core: base-macros))
(load (= remote/rdi)))
(repl-server
(include (core: base-macros)))
(rest-values
(load (fabric: algorithm/list)))
(template
(include (core: base-macros)))
(testing-macros
(include (core: base-macros)
(= condition-macros)))
(testing
(load (= condition))))
| false |
d79477d3db16cb4f008256c3701bfc863dd52a1d | d79ad513fcddd5ab555006c1f42a29c3b300da89 | /tests/run.scm | 25f699ee33901b0d5a603cba968fc2543ada1ae7 | []
| no_license | klutometis/R | edf2eac5c301426f23e3608cf529d8367621064d | 9945b7deeb388353ba9b947a0107f610290779c3 | refs/heads/master | 2016-09-10T21:40:28.881002 | 2015-09-08T20:07:33 | 2015-09-08T20:07:33 | 5,913,228 | 5 | 2 | null | 2015-09-08T20:00:33 | 2012-09-22T13:20:38 | Scheme | UTF-8 | Scheme | false | false | 2,182 | scm | run.scm | (use numbers R test)
(test-error "Test error"
(R* (ls "onthoeunth")))
(test "Pi via named arguments to get"
3.14159265358979
(R* (get x: "pi")))
(test "Scalar integer"
2
(R* 2))
(test "Vector integers"
'#(2 3)
(R* (c 2 3)))
(test "Nested vector-integers"
'#(2 3 4 5)
(R* (c 2 3 (c 4 5))))
(test "Nested list-integers"
'(2 3 (4 5))
(R* (list 2 3 (list 4 5))))
(test "String scalar"
"harro"
(R* "harro"))
(test "String vector"
'#("harro" "harro")
(R* (rep "harro" 2)))
(test "Scalar real"
2.1
(R* 2.1))
(test "Scalar vector"
'#(2.1 2.1)
(R* (rep 2.1 2)))
(test "Scalar boolean: false"
#f
(R* #f))
(test "Scalar boolean: true"
#t
(R* #t))
(test "Vector boolean"
'#(#f #f)
(R* (rep #f 2)))
;; Doesn't respect exactness; i.e., complex numbers are represented
;; by doubles in R.
(test "Scalar complex"
(make-rectangular 3.0 3.0)
(R* (c ,(make-rectangular 3 3))))
(test "Vector complex"
(make-vector 2 (make-rectangular 3.0 3.0))
(R* (rep ,(make-rectangular 3 3) 2)))
(test "Named arguments"
'#(3 3)
(R* (rep.int times: 2 x: 3)))
(let ((env (R (new.env))))
(R (assign "a" 2 pos: ,env))
(test-assert "Opaque object"
(R* (exists "a" envir: ,env))))
(test "Attributes"
'#("a" "b")
(R* (attr (list a: 1 b: 2) "names")))
;;; String here, because we can't otherwise compare NaNs.
(test "NaN and infinity"
"#(1.0 2.0 3.0 +nan.0 +nan.0 +inf.0 -inf.0)"
(->string (R* (c 1 2 3 ,+nan.0 ,-nan.0 ,+inf.0 ,-inf.0))))
(test "Scalar NA" NA (R* ,NA))
;;; Can't compare min-int, either.
(test "Integer NA"
`#(1 2 3 ,NA)
(R* (c 1 2 3 ,NA)))
(test "String NA"
`#("1" ,NA)
(R* (c "1" ,NA)))
(test "Complex NA"
`#(3.0+3.0i ,NA)
(R* (c ,(make-rectangular 3 3) ,NA)))
(test "Boolean NA"
'#(#f #t)
(R* (c #f ,NA)))
(test "Real NA"
`#(1 ,NA)
(R* (c 1.0 ,NA)))
(test "List NA"
`("harro" ,NA)
(R* (list "harro" ,NA)))
(test "Multiple expressions"
2
(R* (<- "a" 2) a))
(test-exit)
| false |
721a857bad61748942fab2971773bcbc93982426 | 1dcae2ac82bd47eac29d8f938ec51c9b724bede0 | /examples/list-car.scm | 2c36ee0eee4fbc69ce4e30efeea7fa11814a0f24 | [
"BSD-3-Clause"
]
| permissive | stjordanis/bsdscheme | 9730afab326c818daaea4ad96886ca0826320297 | ffdc0ab5e8a2cadabcc1ca394ae06072972b75de | refs/heads/master | 2021-09-21T23:30:57.615938 | 2018-09-03T02:48:41 | 2018-09-03T02:48:41 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 63 | scm | list-car.scm | (define a '(1 cons 123 8))
(display (car (cdr a)))
(newline)
| false |
5c1cb74c1b70d8d003b7fd2cadc86c050ac27df8 | f87e36a1ba00008d7e957c8595c86b5550af05b9 | /ch5/ex5.35.scm | e9257a6bbf91a99a359793c7d38ed9d7f6d05fa4 | []
| no_license | kouheiszk/sicp | 1b528898f825c0716acce6bdb36d378dcb04afec | eeb2f7d7634284faa7158c373a848b84084cc8cb | refs/heads/master | 2020-04-16T07:00:43.135389 | 2014-06-16T11:57:43 | 2014-06-16T11:57:43 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 2,532 | scm | ex5.35.scm | ;;; ex5.35
(load "../global.scm")
(load "./ch5-compiler.scm")
(assign val (op make-compiled-procedure) (label entry16) (reg env))
(goto (label after-lambda15))
entry16
(assign env (op compiled-procedure-env) (reg proc))
(assign env
(op extend-environment) (const (x)) (reg argl) (reg env)) ; xを引数にとる
(assign proc (op lookup-variable-value) (const +) (reg env))
;; 手続きの始まり
(save continue)
;; +を退避
(save proc)
(save env)
;; g
(assign proc (op lookup-variable-value) (const g) (reg env))
;; gを退避
(save proc)
;; (+ x 2)
(assign proc (op lookup-variable-value) (const +) (reg env))
(assign val (const 2))
(assign argl (op list) (reg val))
(assign val (op lookup-variable-value) (const x) (reg env))
(assign argl (op cons) (reg val) (reg argl))
(test (op primitive-procedure?) (reg proc)) ; procは+
(branch (label primitive-branch19))
compiled-branch18
(assign continue (label after-call17))
(assign val (op compiled-procedure-entry) (reg proc))
(goto (reg val))
primitive-branch19
(assign val (op apply-primitive-procedure) (reg proc) (reg argl))
after-call17 ; valには(+ x 2)の結果が入っている
(assign argl (op list) (reg val))
;; gを復活
(restore proc)
(test (op primitive-procedure?) (reg proc)) ; procはg
(branch (label primitive-branch22))
compiled-branch21
(assign continue (label after-call20))
(assign val (op compiled-procedure-entry) (reg proc))
(goto (reg val))
primitive-branch22
(assign val (op apply-primitive-procedure) (reg proc) (reg argl))
after-call20 ; valには (g (+ x 2))の結果が入っている
;; (x (g (+ x 2))) という被演算引数をつくる
(assign argl (op list) (reg val))
(restore env)
(assign val (op lookup-variable-value) (const x) (reg env))
(assign argl (op cons) (reg val) (reg argl))
;; +を復活
(restore proc)
(restore continue)
(test (op primitive-procedure?) (reg proc)) ; procは+
(branch (label primitive-branch25))
compiled-branch24
(assign val (op compiled-procedure-entry) (reg proc))
(goto (reg val))
primitive-branch25
;; (+ (x (g (+ x 2))))
(assign val (op apply-primitive-procedure) (reg proc) (reg argl))
(goto (reg continue)) ; 終了
after-call23
after-lambda15
;; (define f ,label-entry16)
(perform (op define-variable!) (const f) (reg val) (reg env))
(assign val (const ok))
;; こんな感じの手続き
(define (f x)
(+ (x (g (+ x 2)))))
;; compile
;(compile '(define (f x) (+ (x (g (+ x 2))))) 'val 'next)
| false |
2d85e54e52ec11ab405450a141b382432e70d6a1 | a74932f6308722180c9b89c35fda4139333703b8 | /edwin48/regops.scm | 9bbfe54b19ad1f3d76d85c98da309b0fc968e829 | []
| no_license | scheme/edwin48 | 16b5d865492db5e406085e8e78330dd029f1c269 | fbe3c7ca14f1418eafddebd35f78ad12e42ea851 | refs/heads/master | 2021-01-19T17:59:16.986415 | 2014-12-21T17:50:27 | 2014-12-21T17:50:27 | 1,035,285 | 39 | 10 | null | 2022-02-15T23:21:14 | 2010-10-29T16:08:55 | Scheme | UTF-8 | Scheme | false | false | 5,038 | scm | regops.scm | #| -*-Scheme-*-
$Id: regops.scm,v 1.94 2008/01/30 20:02:05 cph Exp $
Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
2006, 2007, 2008 Massachusetts Institute of Technology
This file is part of MIT/GNU Scheme.
MIT/GNU Scheme is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or (at
your option) any later version.
MIT/GNU Scheme is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with MIT/GNU Scheme; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301,
USA.
|#
;;;; Region/Mark Operations
(define (region-insert! mark region)
(let ((string (region->string region))
(group (mark-group mark))
(start (mark-index mark)))
(let ((n (string-length string)))
(group-insert-substring! group start string 0 n)
(%make-region (make-temporary-mark group start #f)
(make-temporary-mark group (+ start n) #t)))))
(define (region-insert-string! mark string)
(group-insert-substring! (mark-group mark) (mark-index mark)
string 0 (string-length string)))
(define (region-insert-substring! mark string start end)
(group-insert-substring! (mark-group mark) (mark-index mark)
string start end))
(define (region-insert-newline! mark)
(group-insert-char! (mark-group mark) (mark-index mark) #\newline))
(define (region-insert-char! mark char)
(group-insert-char! (mark-group mark) (mark-index mark) char))
(define (region->string region)
(group-extract-string (region-group region)
(region-start-index region)
(region-end-index region)))
(define (region-delete! region)
(group-delete! (region-group region)
(region-start-index region)
(region-end-index region)))
(define (mark-left-char mark)
(and (not (group-start? mark))
(group-left-char (mark-group mark) (mark-index mark))))
(define (mark-right-char mark)
(and (not (group-end? mark))
(group-right-char (mark-group mark) (mark-index mark))))
(define (mark-delete-left-char! mark)
(if (group-start? mark)
(error "No left char:" mark))
(group-delete-left-char! (mark-group mark) (mark-index mark)))
(define (mark-delete-right-char! mark)
(if (group-end? mark)
(error "No right char:" mark))
(group-delete-right-char! (mark-group mark) (mark-index mark)))
(define (region-transform! region operation)
(let ((start (region-start region)))
(group-replace-string! (mark-group start)
(mark-index start)
(operation (region->string region)))))
;;;; Clipping
(define (group-narrow! group start end)
(record-clipping! group start end)
(%group-narrow! group start end))
(define (%group-narrow! group start end)
(let ((start (make-permanent-mark group start #f))
(end (make-permanent-mark group end #t)))
(set-group-start-mark! group start)
(set-group-end-mark! group end)
(set-group-display-start! group start)
(set-group-display-end! group end)))
(define (group-widen! group)
(record-clipping! group 0 (group-length group))
(%group-widen! group))
(define (%group-widen! group)
(%group-narrow! group 0 (group-length group)))
(define (region-clip! region)
(let ((group (region-group region))
(start (region-start region))
(end (region-end region)))
(let ((point (group-point group)))
(cond ((mark< point start) (set-group-point! group start))
((mark> point end) (set-group-point! group end))))
(let ((buffer (group-buffer group)))
(if buffer
(for-each
(lambda (window)
(let ((point (window-point window)))
(cond ((mark< point start) (set-window-point! window start))
((mark> point end) (set-window-point! window end)))))
(buffer-windows buffer))))
(group-narrow! group (mark-index start) (mark-index end))))
(define (with-region-clipped! new-region thunk)
(let ((group (region-group new-region))
(old-region (unspecific)))
(dynamic-wind (lambda ()
(set! old-region (group-region group))
(region-clip! new-region)
(set! new-region (unspecific))
unspecific)
thunk
(lambda ()
(region-clip! old-region)))))
(define (without-group-clipped! group thunk)
(let ((old-region (unspecific)))
(dynamic-wind (lambda ()
(set! old-region (group-region group))
(group-widen! group))
thunk
(lambda ()
(region-clip! old-region)))))
(define (group-clipped? group)
(not (and (zero? (group-start-index group))
(= (group-end-index group) (group-length group)))))
(define (group-unclipped-region group)
(make-region (make-mark group 0)
(make-mark group (group-length group)))) | false |
97147cd77292d3cafa42bdbfec472583aef9bf8c | ae0d7be8827e8983c926f48a5304c897dc32bbdc | /nekoie/bin/wiliki-copydb | 19b8e16881113e8487cdf16b57829fd036c0a113 | []
| no_license | ayamada/copy-of-svn.tir.jp | 96c2176a0295f60928d4911ce3daee0439d0e0f4 | 101cd00d595ee7bb96348df54f49707295e9e263 | refs/heads/master | 2020-04-04T01:03:07.637225 | 2015-05-28T07:00:18 | 2015-05-28T07:00:18 | 1,085,533 | 3 | 2 | null | 2015-05-28T07:00:18 | 2010-11-16T15:56:30 | Scheme | UTF-8 | Scheme | false | false | 3,989 | wiliki-copydb | #!/usr/bin/env gosh
;;;
;;; Convert character encoding of WiLiKi database
;;; $Id: wiliki-copydb,v 1.1 2005/11/10 02:02:09 shirok Exp $
;;;
(use gauche.parseopt)
(use gauche.charconv)
(use util.match)
(use dbm)
(define-constant DEFAULT_DBM "gdbm")
(define-constant DEFAULT_ENCODING (gauche-character-encoding))
(define (usage)
(print "Usage: wiliki-copydb [-s <type>][-d <type>] <src-db> [<src-log>] <dst-db> [<dst-log>]")
(print " <type> specifies the dbm type and CES encoding of source (-s) and")
(print " destination (-d), respectively. Its format is:")
(print " [dbmtype][.encoding]")
(print " When ommitted, dbmtype is assumed gdbm, and encoding is assumed")
(print " the gauche's native encoding.")
(print "Examples:")
(print " Copy wiliki.dbm and wiliki.log, to new.dbm and new.log, changing")
(print " encoding from euc-jp to utf-8:")
(print " wiliki-copydb -s .euc-jp -d .utf-8 wiliki.dbm wiliki.log new.dbm new.log")
(print " Copy wiliki.dbm to new.dbm, discarding log file, and changing the")
(print " database format:")
(print " wiliki-copydb -s fsdbm.euc-jp -d gdbm.euc-jp wiliki.dbm new.dbm")
(exit 0)
)
(define-condition-type <app-error> <error> #f)
(define-method do-copy-dbm ((stype <dbm-meta>)
(senc <symbol>)
(dtype <dbm-meta>)
(denc <symbol>)
(src <string>)
(dst <string>))
(let ((sdb (dbm-open stype :path src :rw-mode :read))
(ddb (dbm-open dtype :path dst :rw-mode :write)))
(dbm-for-each sdb
(lambda (key val)
(dbm-put! ddb
(ces-convert key senc denc)
(ces-convert val senc denc))))
))
(define-method do-copy-log ((senc <symbol>)
(denc <symbol>)
(src <string>)
(dst <string>))
(call-with-input-file src
(lambda (s)
(call-with-output-file dst
(lambda (d)
(copy-port s d :unit 'char))
:encoding denc
:if-exists :supersede))
:encoding senc))
(define (load-dbm-class name)
(let ((s (string->symbol #`"dbm.,name"))
(c (string->symbol #`"<,|name|>")))
(guard (e
((<error> e)
(errorf <app-error> "Couldn't load ~a: wrong DBM class?" s)))
(eval `(use ,s) (current-module))
(global-variable-ref (current-module) c))))
(define (type->dbmclass&encoding type)
(rxmatch-case type
(test not (values (load-dbm-class DEFAULT_DBM) DEFAULT_ENCODING))
(#/^([\w-]+)?(?:\.([\w-]+))?$/ (#f dbmtype enc)
(values (load-dbm-class (or dbmtype DEFAULT_DBM))
(if enc (string->symbol enc) DEFAULT_ENCODING)))
(else
(error <app-error> "invalid type spec:" type))))
(define (check-destination dtype dst-db dst-log)
(when (dbm-db-exists? dtype dst-db)
(errorf <app-error> "Destination database exists: ~a" dst-db))
(when (and dst-log (file-exists? dst-log))
(errorf <app-error> "Destination log file exists: ~a" dst-log)))
(define (main args)
(let-args (cdr args) ((stypespec "s=s")
(dtypespec "d=s") . args)
(guard (e ((<app-error> e)
(format (current-error-port) "~a\n" (ref e 'message))
(exit 1)))
(receive (stype senc) (type->dbmclass&encoding stypespec)
(receive (dtype denc) (type->dbmclass&encoding dtypespec)
(match args
((sdb slog ddb dlog)
(check-destination dtype ddb dlog)
(do-copy-dbm stype senc dtype denc sdb ddb)
(do-copy-log senc denc slog dlog))
((sdb ddb)
(check-destination dtype ddb #f)
(do-copy-dbm stype senc dtype denc sdb ddb))
(else
(usage))))))
0))
;;; Local variables:
;;; mode: scheme
;;; end:
| false |
|
cf1d0ac6d8b6013c8b4b2f1a5ae44ed4b5d5a8ff | d47ddad953f999e29ce8ef02b059f945c76a791e | /lab4/homeworks/06/tests.scm | 1ff7c662ad247cb44ec44e8123619c4bb0feb95c | []
| no_license | IvanIvanov/fp2013 | 7f1587ef1f2261f8cd0cd3dd99ec147c4043a2ae | 2ac1bb1102cb65e0ecbfa8d2fb3ca69953ae4ecf | refs/heads/master | 2016-09-11T10:08:59.873239 | 2014-01-23T20:38:27 | 2014-01-23T20:40:34 | 13,211,029 | 5 | 2 | null | 2014-01-10T15:55:14 | 2013-09-30T09:18:33 | Scheme | UTF-8 | Scheme | false | false | 1,177 | scm | tests.scm | (load "cassie.scm")
(load "solution.scm")
(define-test nth-harmonic-test
(assert (nth-harmonic 1) 1/1)
(assert (nth-harmonic 2) 3/2)
(assert (nth-harmonic 10) 7381/2520)
(assert (nth-harmonic 42) 12309312989335019/2844937529085600))
(define-test magic-square?-test
(assert (magic-square? '((1 1)
(1 1))) #t)
(assert (magic-square? '((1 2)
(1 1))) #f)
(assert (magic-square? '((2 7 6)
(9 5 1)
(4 3 8))) #t)
(assert (magic-square? '((1 2 3)
(4 5 6)
(7 8 9))) #f)
(assert (magic-square? '((7 12 1 14)
(2 13 8 11)
(16 3 10 5)
(9 6 15 4))) #t))
(define-test histogram-test
(assert (histogram '(0 0 0 0 2 2)) '(4 0 2))
(assert (histogram '(1 1 1 4)) '(0 3 0 0 1))
(assert (histogram '(0)) '(1))
(assert (histogram '(0 1 2 3)) '(1 1 1 1))
(assert (histogram '(3 3 6 9 3 1)) '(0 1 0 3 0 0 1 0 0 1)))
(run-tests
nth-harmonic-test
magic-square?-test
histogram-test)
| false |
d985219892196630a8632f39178f3cf9b7505e83 | 5667f13329ab94ae4622669a9d53b649c4551e24 | /number-theory/math.number-theory.binomial.scm | e9e82199cc40b0ec0832a18653d74a40be64e337 | []
| no_license | dieggsy/chicken-math | f01260e53cdb14ba4807f7e662c9e5ebd2da4dda | 928c9793427911bb5bb1d6b5a01fcc86ddfe7065 | refs/heads/master | 2021-06-11T07:14:21.461591 | 2021-04-12T22:12:14 | 2021-04-12T22:12:14 | 172,310,771 | 2 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 1,416 | scm | math.number-theory.binomial.scm | (module math.number-theory.binomial (binomial)
(import scheme
chicken.type
(only chicken.base include error add1)
(only miscmacros ensure)
math.racket-shim)
(include "math-types.scm")
(: binomial* (integer integer -> integer))
(define (binomial* n k)
;; compute the binomial coeffecient n choose k
;; https://gmplib.org/manual/Binomial-Coefficients-Algorithm.html
(ensure
natural?
(let loop ([n n] [k k])
(assume ((n exact-rational) (k exact-rational))
(cond
[(= k 0) 1]
[(= k 1) n]
[(> k n) 0]
[(= k 2) (/ (* n (- n 1)) 2)]
[(> k (/ n 2)) (loop n (- n k))]
[else (* (+ n (- k) 1)
(let loop1 ((prod 1)
(i 2))
(assume ((prod exact-rational)
(i integer))
(if (> i k)
prod
(loop1 (* prod (/ (+ n (- k) i) i)) (add1 i))))))])))))
(: binomial (integer integer -> integer))
(define (binomial n k)
(cond [(< n 0) (error 'binomial "bad argument type - not a nonnegative integer" n)]
[(< k 0) (error 'binomial "bad argument type - not a nonnegative integer" k)]
[(zero? k) 1]
[(eqv? n 1) (if (eqv? k 1) 1 (binomial* n k))]
[else (binomial* n k)])))
| false |
c476ee6799754bb572bdb80043b291969760afdd | 657e87f648db5d739d8edc16c751e6ae65d2403c | /profiling/tinycpp/compile-correct.scm | ecbb8f762c4c2dd9a95c9e83a23e99b786244799 | [
"MIT",
"X11"
]
| permissive | 2bt/racr | b36537543d465338331b63263070fb680892289e | 7dccaefa16d5f0dd5c4a7239b1cdfb75f961cd55 | refs/heads/master | 2021-01-17T12:06:17.670321 | 2016-02-06T12:38:52 | 2016-02-06T12:38:52 | 36,306,301 | 0 | 1 | null | 2016-11-19T22:49:13 | 2015-05-26T15:44:05 | Scheme | UTF-8 | Scheme | false | false | 277 | scm | compile-correct.scm | ; This program and the accompanying materials are made available under the
; terms of the MIT license (X11 license) which accompanies this distribution.
; Author: C. Bürger
#!r6rs
(import (rnrs) (prefix (tinycpp-racr main) tcpp:))
(apply tcpp:compile (cdr (command-line))) | false |
9d920f4c9a1f1598b59ef3af08dd9f5c3a6810f0 | af3b4c56ca4b1b891cb10f08bd71555181f256d5 | /a4.scm | 250ac70e928eef1e95308d813e64b3eee4467c47 | []
| no_license | fangyuchen86/c311 | 7a9cd8b86072cc041b94e510faf33ff4c0075592 | 7da206f36922d876264f5f194a7a7dba789bde71 | refs/heads/master | 2020-12-28T21:39:56.087636 | 2014-12-05T06:17:21 | 2014-12-05T06:17:21 | 28,654,072 | 0 | 2 | null | null | null | null | UTF-8 | Scheme | false | false | 4,779 | scm | a4.scm | #|
Samuel Waggoner
[email protected]
CSCI-C311
Assignment 4 - Dynamic Scope
2010/10/04
I received assistance in debugging from Gavin Whelan.
... Countless hours of help from countless people contributed to me turning this in.
Thanks again, Professor Friedman, for spending three hours on it with me today.
|#
(load "pmatch.scm")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Functional Representation ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define value-of-fn
(lambda (exp env)
(pmatch exp
[,x (guard (symbol? x)) (apply-env-fn env x)]
[,b (guard (boolean? b)) b]
[,n (guard (number? n)) n]
[(zero? ,x) (zero? (value-of-fn x env))]
[(sub1 ,x) (sub1 (value-of-fn x env))]
[(* ,x ,y) (* (value-of-fn x env) (value-of-fn y env))]
[(let ([,x ,y]) ,body) (value-of-fn body (extend-env-fn x (value-of-fn y env) env))]
[(if ,test ,conseq ,alt) (if (value-of-fn test env)
(value-of-fn conseq env)
(value-of-fn alt))]
[(+ ,n-exp1 ,n-exp2) (+ (value-of-fn n-exp1 env)(value-of-fn n-exp2 env))]
[(lambda (,x) ,body) (closure-fn x body env)]
[(d-lambda (,x) ,body) (d-closure-fn x body env)]
[(,rator ,rand) (apply-proc-fn (value-of-fn rator env) (value-of-fn rand env) env)]
)))
(define apply-proc-fn
(lambda (proc exp env)
(proc exp env)
))
(define closure-fn
(lambda (x body env)
(lambda (a env^)
(value-of-fn body (extend-env-fn x a env)))))
(define d-closure-fn
(lambda (x body env)
(lambda (a env)
(value-of-fn body (extend-env-fn x a env)))))
(define apply-env-fn
(lambda (env y)
(env y)
))
(define extend-env-fn
(lambda (x a env)
(lambda (y)
(if (eq? x y)
a
(apply-env-fn env y)
))))
(define empty-env
(lambda ()
(lambda (y)
(errorf "error!" "Unbound Variable")
)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Data-structural Representation ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define value-of-ds
(lambda (exp env)
(pmatch exp
[,x (guard (symbol? x)) (apply-env-ds env x)]
[,b (guard (boolean? b)) b]
[,n (guard (number? n)) n]
[(zero? ,x) (zero? (value-of-ds x env))]
[(sub1 ,x) (sub1 (value-of-ds x env))]
[(* ,x ,y) (* (value-of-ds x env) (value-of-ds y env))]
[(let ([,x ,y]) ,body) (value-of-ds body (extend-env-ds x (value-of-ds y env) env))]
[(if ,test ,conseq ,alt) (if (value-of-ds test env)
(value-of-ds conseq env)
(value-of-ds alt))]
[(+ ,n-exp1 ,n-exp2) (+ (value-of-ds n-exp1 env)(value-of-ds n-exp2 env))]
[(lambda (,x) ,body) (closure-ds x body env)]
[(d-lambda (,x) ,body) (d-closure-ds x body env)]
[(,rator ,rand) (apply-proc-ds (value-of-ds rator env) (value-of-ds rand env) env)]
)))
(define empty-env-ds
(lambda ()
'error))
(define extend-env-ds
(lambda (x a env)
`(extend-env-ds ,x ,a ,env)
))
(define closure-ds
(lambda (x body env)
`(closure-ds ,x ,body ,env)))
(define d-closure-ds
(lambda (x body env)
`(d-closure-ds ,x ,body ,env)))
(define apply-env-ds
(lambda (env y)
(pmatch env
[(empty-env-ds) 'error]
[(extend-env-ds ,x ,a ,env)
(if (eq? x y)
a
(apply-env-ds env y))]
)))
(define apply-proc-ds
(lambda (p a env)
(pmatch p
[(closure-ds ,x ,body ,env) (value-of-ds body (extend-env-ds x a env))]
[(d-closure-ds ,x ,body ,env^) (value-of-ds body (extend-env-ds x a env))]
)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Test Cases! ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-syntax test
(syntax-rules ()
((_ title tested-expression expected-result)
(let* ((expected expected-result)
(produced tested-expression))
(if (equal? expected produced)
(printf "~s works!\n" title)
(errorf
'test
"Failed ~s: ~a\nExpected: ~a\nComputed: ~a"
title 'tested-expression expected produced))))))
(define let-static
'(let ([x 2])
(let ([f (lambda (e) x)])
(let ([x 5])
(f 0)))))
(define let-dynamic
'(let ([x 2])
(let ([f (d-lambda (e) x)])
(let ([x 5])
(f 0)))))
(define value-of value-of-fn)
(test "let-test-static-fn"
(value-of let-static (empty-env))
2)
(test "let-test-dynamic-fn"
(value-of let-dynamic (empty-env))
5)
(define value-of value-of-ds)
(test "let-test-static-ds"
(value-of let-static (empty-env))
2)
(test "let-test-dynamic-ds"
(value-of let-dynamic (empty-env))
5)
| true |
439ac1bc8936502287da4bf85fd9c194369793c4 | f916d100a0510989b96deaa9d2d2f90d86ecc399 | /slib/paramlst.scm | 77755f05720a7da5aad6940ea353d867e888ec81 | []
| no_license | jjliang/UMB-Scheme | 12fd3c08c420715812f933e873110e103236ca67 | d8479f2f2eb262b94be6040be5bd4e0fca073a4f | refs/heads/master | 2021-01-20T11:19:37.800439 | 2012-09-27T22:13:50 | 2012-09-27T22:13:50 | 5,984,440 | 2 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 6,828 | scm | paramlst.scm | ;;; "paramlst.scm" passing parameters by name.
; Copyright 1995 Aubrey Jaffer
;
;Permission to copy this software, to redistribute it, and to use it
;for any purpose is granted, subject to the following restrictions and
;understandings.
;
;1. Any copy made of this software must include this copyright notice
;in full.
;
;2. I have made no warrantee or representation that the operation of
;this software will be error-free, and I am under no obligation to
;provide any services, by way of maintenance, update, or otherwise.
;
;3. In conjunction with products arising from the use of this
;material, there shall be no use of my name in any advertising,
;promotional, or sales literature without prior written consent in
;each case.
;;; Format of arity-spec: (name predicate conversion)
(require 'common-list-functions)
(define arity->arity-spec
(let ((table
`((nary
,(lambda (a) #t)
,identity)
(nary1
,(lambda (a) (not (null? a)))
,identity)
(single
,(lambda (a) (and (pair? a) (null? (cdr a))))
,car)
(optional
,(lambda (a) (or (null? a) (and (pair? a) (null? (cdr a)))))
,identity)
(boolean
,(lambda (a)
(or (null? a)
(and (pair? a) (null? (cdr a)) (boolean? (car a)))))
,(lambda (a) (if (null? a) #f (car a)))))))
(lambda (arity)
(assq arity table))))
(define (fill-empty-parameters defaults parameter-list)
(map (lambda (default parameter)
(cond ((null? (cdr parameter))
(cons (car parameter)
(if default (default parameter-list) '())))
(else parameter)))
defaults parameter-list))
(define (check-parameters checks parameter-list)
(for-each (lambda (check parameter)
(for-each
(lambda (p)
(cond ((and check (not (check p)))
(slib:error "parameter is wrong type: " p))))
(cdr parameter)))
checks parameter-list)
parameter-list)
(define (check-arities arity-specs parameter-list)
(and (every identity arity-specs)
(every
(lambda (arity-spec param)
((cadr arity-spec) (cdr param)))
arity-specs parameter-list)))
(define (parameter-list->arglist positions arities parameter-list)
(and (= (length arities) (length positions) (length parameter-list))
(let ((arity-specs (map arity->arity-spec arities))
(ans (make-vector (length positions) #f)))
(and (check-arities arity-specs parameter-list)
(for-each
(lambda (pos arity-spec param)
(vector-set! ans (+ -1 pos)
((caddr arity-spec) (cdr param))))
positions arity-specs parameter-list)
(vector->list ans)))))
(define (make-parameter-list parameter-names)
(map list parameter-names))
(define (parameter-list-ref parameter-list i)
(let ((ans (assoc i parameter-list)))
(and ans (cdr ans))))
(define (parameter-list-expand expanders parms)
(do ((lens (map length parms) (map length parms))
(olens '() lens))
((equal? lens olens))
(for-each (lambda (expander parm)
(cond
(expander
(for-each
(lambda (news)
(cond ((adjoin-parameters! parms news))
(else (slib:error
"expanded feature unknown: " news))))
(apply append
(map (lambda (p)
(cond ((expander p))
((not '()) '())
(else (slib:error
"couldn't expand feature: " p))))
(cdr parm)))))))
expanders
parms)))
(define (adjoin-parameters! parameter-list . parameters)
(let ((apairs (map (lambda (param)
(cond ((pair? param)
(assoc (car param) parameter-list))
(else (assoc param parameter-list))))
parameters)))
(and (every identity apairs) ;same as APPLY AND?
(for-each
(lambda (apair param)
(cond ((pair? param)
(for-each (lambda (o)
(if (not (member o (cdr apair)))
(set-cdr! apair (cons o (cdr apair)))))
(cdr param)))
(else (if (not (memv #t (cdr apair)))
(set-cdr! apair (cons #t (cdr apair)))))))
apairs parameters)
parameter-list)))
(define (getopt->parameter-list argc argv optnames arities types aliases)
(define (can-take-arg? opt)
(not (eq? (list-ref arities (position opt optnames))
'boolean)))
(define (coerce-val val curopt)
(define ntyp (list-ref types (position curopt optnames)))
(case ntyp
((expression) val)
(else (coerce val ntyp))))
(require 'getopt)
(let ((optlist '())
(long-opt-list '())
(optstring #f)
(parameter-list (make-parameter-list optnames))
(curopt '*unclaimed-argument*))
(set! aliases (map (lambda (alias)
(define str (string-copy (car alias)))
(do ((i (+ -1 (string-length str)) (+ -1 i)))
((negative? i) (cons str (cdr alias)))
(cond ((char=? #\ (string-ref str i))
(string-set! str i #\-)))))
aliases))
(for-each
(lambda (alias)
(define opt (car alias))
(cond ((not (string? opt)))
((< 1 (string-length opt))
(set! long-opt-list (cons opt long-opt-list)))
((not (= 1 (string-length opt))))
((can-take-arg? (cadr alias))
(set! optlist (cons (string-ref opt 0)
(cons #\: optlist))))
(else (set! optlist (cons (string-ref opt 0) optlist)))))
aliases)
(set! optstring (list->string (cons #\: optlist)))
(let loop ()
(let ((opt (getopt-- argc argv optstring)))
(case opt
((#\: #\?)
(slib:error
'getopt->parameter-list "unrecognized option"
getopt:opt))
((#f)
(cond ((and (< *optind* argc)
(string=? "-" (list-ref argv *optind*)))
(set! *optind* (+ 1 *optind*)))
((< *optind* argc)
(cond ((adjoin-parameters!
parameter-list
(list curopt
(coerce-val (list-ref argv *optind*)
curopt)))
(set! *optind* (+ 1 *optind*))
(loop))
(else (slib:error 'getopt->parameter-list curopt
(list-ref argv *optind*)
"not supported"))))))
(else
(cond ((char? opt) (set! opt (string opt))))
(let ((topt (assoc opt aliases)))
(cond (topt (set! topt (cadr topt)))
(else (slib:error "Option not recognized -" opt)))
(cond
((not (can-take-arg? topt))
(adjoin-parameters! parameter-list (list topt #t)))
(*optarg*
(set! curopt topt)
(adjoin-parameters! parameter-list
(list topt (coerce-val *optarg* curopt))))
(else
(set! curopt topt)
(rdms:warn "No argument for option -" opt))))
(loop)))))
parameter-list))
(define (getopt->arglist argc argv optnames positions
arities types defaults checks aliases)
(let* ((params (getopt->parameter-list
argc argv optnames arities types aliases))
(fparams (fill-empty-parameters defaults params)))
(and (list? params) (check-parameters checks fparams))
(and (list? params) (parameter-list->arglist positions arities fparams))))
| false |
bf05d17d41fe454b35a409f042b8271ce557611b | 60832aa92c2f17fe8c4cfe4f92dcc365f921d697 | /r7rs-small/scheme_time.scm | b973cedd13bd714884fb565de59731710e7c9f35 | []
| no_license | lassik/scheme-identifier-lists | a1b6b13053022d1fdabfdaf8c460660291a5f2b6 | acee2afa7ffa927d2eedfbfc70381496424755f2 | refs/heads/master | 2023-08-27T06:42:01.068332 | 2021-10-30T19:16:45 | 2021-10-30T19:16:45 | 422,968,445 | 2 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 48 | scm | scheme_time.scm | current-jiffy
current-second
jiffies-per-second
| false |
9f242e30c2ef40ece004bfa2bff73dc53c87480b | ffd6cdc49ba0aa09366cf3091d2a657461d388cf | /19.ss | fe32884fece4f8a7966fba75d60ebe19adbb9fda | []
| no_license | hernanre/csse304-ProgrammingLanguageConcept | cba83977be2eff7dbf39da8eec483801ce939930 | 14cbbd604cd7cdb421d39741e96a7fd003b2579b | refs/heads/master | 2022-01-26T13:20:51.590843 | 2018-10-02T23:04:35 | 2018-10-02T23:04:35 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,610 | ss | 19.ss | (load "chez-init.ss")
(define v)
(define k)
(define ls)
(define L1)
(define L2)
(define-datatype kontinuation kontinuation?
[init-k]
[flatten-cdr-k (ls list?) (k kontinuation?)]
[flatten-car-k (flattened-cdr list?)
(k kontinuation?)]
[append-k (car-L1 symbol?) (k kontinuation?)]
)
(define apply-k
(lambda ()
(cases kontinuation k
[init-k ()
v]
[flatten-cdr-k (ls-cdr cdr-k)
(if (list? (car ls-cdr))
(begin
(set! ls (car ls-cdr))
(set! k (flatten-car-k v cdr-k))
(flatten-cps))
(begin
(set! v (cons (car ls-cdr) v))
(set! k cdr-k)
(apply-k)))]
[flatten-car-k (flattened-cdr flat-k)
(begin
(set! L1 v)
(set! L2 flattened-cdr)
(set! k flat-k)
(append-cps))]
[append-k (car-L1 car-k)
(begin
(set! k car-k)
(set! v (cons car-L1 v))
(apply-k))])))
(define append-cps
(lambda ()
(if (null? L1)
(begin
(set! v L2)
(apply-k))
(begin
(set! k (append-k (car L1) k))
(set! L1 (cdr L1))
(append-cps)))))
;'(trace append-cps flatten-cps apply-k)
;(define read-flatten-print
; (lambda ()
; (display "enter slist to flatten: ")
; (let ([slist (read)])
; (unless (eq? slist 'exit)
; (flatten-cps slist (init-k))))))
(define flatten-cps
(lambda ()
(if (null? ls)
(begin
(set! v ls)
(apply-k))
(begin
(set! k (flatten-cdr-k ls k))
(set! ls (cdr ls))
(flatten-cps)))))
| false |
84f9834b7f3b87468cd9985e477c1f33f97d75dc | 46244bb6af145cb393846505f37bf576a8396aa0 | /sicp/1_41.scm | 0e083bc18bc9cbb9f430edd134ec7fa83df0506d | []
| no_license | aoeuidht/homework | c4fabfb5f45dbef0874e9732c7d026a7f00e13dc | 49fb2a2f8a78227589da3e5ec82ea7844b36e0e7 | refs/heads/master | 2022-10-28T06:42:04.343618 | 2022-10-15T15:52:06 | 2022-10-15T15:52:06 | 18,726,877 | 4 | 3 | null | null | null | null | UTF-8 | Scheme | false | false | 767 | scm | 1_41.scm | #lang racket
; Exercise 1.41. Define a procedure double that takes a procedure of one argument as argument and
; returns a procedure that applies the original procedure twice.
; For example, if inc is a procedure that adds 1 to its argument,
; then (double inc) should be a procedure that adds 2. What value is returned by
; (((double (double double)) inc) 5)
(define (double f)
(lambda (x)
(f (f x))))
(define (inc x) (+ x 1))
(((double (double double)) inc) 5)
; Explaination
; expand (((double (double double)) inc) 5) to
(((double double) ((double double) inc)) 5)
(((double double) (double (double inc))) 5)
((double (double (double (double inc)))) 5)
((double
(double
(double
(double ; pow(2 4) is 16, so the result is 21
inc))))
5)
| false |
f179cc6d5c2b01f0e3cd64b4f1f680b9d2132e0e | a6a1c8eb973242fd2345878e5a871a89468d4080 | /lib/stream/display.scm | a8c2fc4c799494830c616eeadb57357293aba58d | []
| no_license | takkyuuplayer/sicp | ec20b6942a44e48d559e272b07dc8202dbb1845a | 37aa04ce141530e6c9803c3c7122016d432e924b | refs/heads/master | 2021-01-17T07:43:14.026547 | 2017-02-22T03:40:07 | 2017-02-22T03:40:07 | 15,771,479 | 1 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 263 | scm | display.scm | (define (display-stream s)
(stream-for-each print s))
(define (stream-head s n)
(define (iter s n)
(if (<= n 0)
(print "")
(begin
(display (stream-car s))
(display ", ")
(iter (stream-cdr s) (- n 1)))))
(iter s n))
| false |
2696b960b0118571b8e377264c55667da4dc19c8 | 80fba60217709813cdf8ed21ffb5d9daf3cb2b6d | /.local/lib/guile/jsullivan/guix-util.scm | a31097b6b155500ced86a5180b42809aea1e314a | []
| no_license | jjsullivan5196/dotfiles | 47e350e25f23edb3ce00c7e024e124164646c11b | 993a67e72848dc879ea6c82a32b4e72006743c10 | refs/heads/master | 2022-05-18T05:00:24.013168 | 2022-03-20T20:47:01 | 2022-03-20T20:47:01 | 194,798,926 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,565 | scm | guix-util.scm | (define-module (jsullivan guix-util)
#:use-module (jsullivan util)
#:use-module ((guix licenses) #:prefix license:)
#:use-module (gnu packages guile-xyz)
#:use-module (gnu services base)
#:use-module (guix packages)
#:use-module (guix build-system trivial)
#:use-module (guix utils)
#:use-module (guix gexp)
#:use-module (srfi srfi-1)
#:use-module (ice-9 match))
(define-public (shell-script name config script)
"Gexp which will take CONFIG options for guile-config, and run SCRIPT with
options defined in %SCRIPT-OPTIONS."
(define wrapper-script
#~(begin
(use-modules (config) (config api))
(define %script-options
(getopt-config-auto (configuration #$@config)
(command-line)))
#$script))
(program-file name
(with-extensions (list guile-config)
wrapper-script)))
(define-public (script-package name script)
"Create a base package that installs SCRIPT as a program."
(define bin-dir
(file-union "bin" `((,name ,script))))
(package
(name name)
(version "")
(source #f)
(build-system trivial-build-system)
(arguments '(#:builder (begin (mkdir %output) #t)))
(propagated-inputs (list bin-dir))
(synopsis "")
(description "")
(home-page "")
(license license:public-domain)))
(define-public (auto-login-to-tty config tty user)
(if (string=? tty (mingetty-configuration-tty config))
(mingetty-configuration
(inherit config)
(auto-login user))
config))
| false |
0597a62465e9549e966bd586ada24b37f7ae31be | 2bcf33718a53f5a938fd82bd0d484a423ff308d3 | /programming/sicp/ch2/ex-2.80.scm | d2557aa43e1ef12428023815e73e56814f27be16 | []
| no_license | prurph/teach-yourself-cs | 50e598a0c781d79ff294434db0430f7f2c12ff53 | 4ce98ebab5a905ea1808b8785949ecb52eee0736 | refs/heads/main | 2023-08-30T06:28:22.247659 | 2021-10-17T18:27:26 | 2021-10-17T18:27:26 | 345,412,092 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 417 | scm | ex-2.80.scm | #lang scheme
;; https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book-Z-H-18.html#%_thm_2.80
(define (install-generic-zero?)
(define (=zero-rat? x) (zero? (numer x)))
(define (=zero-complex? x) (zero? (magnitude x)))
(put '=zero? '(scheme-number) zero?)
(put '=zero? '(rational) =zero-rat?)
(put '=zero? '(complex) =zero-complex?)
'done)
(define (=zero? x)
(apply-generic '=zero? x))
| false |
ef97736b628aded36a5523efa6bdc6e5e916917b | 11b227f71ec01f2e497680cc5f9090c984e9f48e | /sources/core/tables/shipping-addresses-table.scm | 2f3c8eaad95189f76415de3b3a3b7ef72f7141dc | [
"MIT"
]
| permissive | Mathieu-Desrochers/Scheme-Experimentations | 30dd336abf40c422f6d9c2d49f31b3665b7a8f17 | 9879e811865fbef170681a7748784a525d950088 | refs/heads/master | 2020-03-30T22:55:35.004425 | 2015-04-23T20:08:33 | 2015-04-23T20:08:33 | 6,216,231 | 14 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 798 | scm | shipping-addresses-table.scm |
(declare (unit shipping-addresses-table))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; table definition
(define-table
(shipping-addresses-table
"shipping-addresses")
(shipping-address-row
("shipping-address-id" integer)
("customer-id" integer)
("street" string)
("city" string)
("state" string))
(custom-selects
(shipping-addresses-table-select-by-customer-id
(string-append
"SELECT * "
"FROM \"shipping-addresses\" "
"WHERE \"customer-id\" = ?1;")
customer-id))
(custom-single-value-selects)
(custom-executes
(shipping-addresses-table-delete-by-customer-id
(string-append
"DELETE "
"FROM \"shipping-addresses\" "
"WHERE \"customer-id\" = ?1;")
customer-id)))
| false |
e9243e79852427d38d68d32d02dadb9fdb995d8c | 1b1828426867c9ece3f232aaad1efbd2d59ebec7 | /Chapter 2/sicp2-05.scm | 6c6855e432f20934c81e84d6bc3ee94b10df036d | []
| no_license | vendryan/sicp | 60c1338354f506e02c714a96f643275d35a7dc51 | d42f0cc6f985aaf369f2760f962928381ca74332 | refs/heads/main | 2023-06-07T02:04:56.332591 | 2021-06-19T10:28:57 | 2021-06-19T10:28:57 | 369,958,898 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 787 | scm | sicp2-05.scm | ; Represent pair of number a and b in term of
; 2^a*3^b
(define (cons a b)
(* (expt 2 a) (expt 3 b)))
; 2^a*3^b can be expressed as 2x2x...x2x3x3x...x3
; where 2 appears a times and 3 appears b time and hence
; to get a we just modulo the number we got with two till the
; mod is not zero. The number of time modulo equal zero
; Is the a. This same method can applied to be but
; mod with number 3 instead
(define (carr pair)
(if (= (remainder pair 2) 0)
(+ 1 (carr (/ pair 2)))
0))
(define (cdrr pair)
(if (= (remainder pair 3) 0)
(+ 1 (cdrr (/ pair 3)))
0))
(define (print line)
(display line)
(newline))
; try
(define x (cons 3 4))
(print (carr x)) ; should be 3
(print (cdrr x)) ; should be 4
| false |
6485bab951f0e6a0741e113ce97039a501c8bfd2 | 6be443e2def01b1f9a5285f1287983e10e167515 | /ch2/2-10.scm | 6063ae212cfc2568a5cf4b83e9247ee5d4d57b90 | [
"MIT"
]
| permissive | ToruTakefusa/sicp | be62dbdc1e9965f9ad581635b2d73ecfd854c311 | 7ec1ae37845929dc2276bc5b83595ce0e2c52959 | refs/heads/master | 2020-04-08T09:41:41.936219 | 2019-09-28T05:15:18 | 2019-09-28T05:15:18 | 159,235,583 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,179 | scm | 2-10.scm | (define (make-interval a b) (cons a b))
(define (lower-bound interval)
(min (car interval) (cdr interval)))
(define (upper-bound interval)
(max (car interval)(cdr interval)))
(define (add-interval a b)
(make-interval (+ (lower-bound a) (lower-bound b))
(+ (upper-bound a) (upper-bound b))))
(define (sub-interval a b)
(add-interval a
(make-interval (- (upper-bound b))
(- (lower-bound b)))))
(define (mul-interval x y)
(if (or (< (* (lower-bound x) (upper-bound x)) 0)
(< (* (lower-bound y) (upper-bound y)) 0))
(print "mul-interval should not spans zero")
(let ((p1 (* (lower-bound x) (lower-bound y)))
(p2 (* (lower-bound x) (upper-bound y)))
(p3 (* (upper-bound x) (lower-bound y)))
(p4 (* (upper-bound x) (upper-bound y))))
(make-interval (min p1 p2 p3 p4)
(max p1 p2 p3 p4)))))
(print (lower-bound (make-interval 1 3)))
(print (upper-bound (make-interval 1 3)))
(print (lower-bound (make-interval 3 1)))
(print (upper-bound (make-interval 3 1)))
(print (mul-interval (make-interval -1 1) (make-interval 0 4)))
| false |
8902e4990af4cb053a1c861be47cdb82a01cbd68 | 000dbfe5d1df2f18e29a76ea7e2a9556cff5e866 | /ext/crypto/sagittarius/crypto/math/ec.scm | 1cd439ac229278352dd2c632c2da5a8bbfe54b36 | [
"BSD-3-Clause",
"LicenseRef-scancode-other-permissive",
"MIT",
"BSD-2-Clause"
]
| permissive | ktakashi/sagittarius-scheme | 0a6d23a9004e8775792ebe27a395366457daba81 | 285e84f7c48b65d6594ff4fbbe47a1b499c9fec0 | refs/heads/master | 2023-09-01T23:45:52.702741 | 2023-08-31T10:36:08 | 2023-08-31T10:36:08 | 41,153,733 | 48 | 7 | NOASSERTION | 2022-07-13T18:04:42 | 2015-08-21T12:07:54 | Scheme | UTF-8 | Scheme | false | false | 29,817 | scm | ec.scm | ;;; -*- mode:scheme; coding:utf-8; -*-
;;;
;;; sagittarius/crypto/math/ec.scm - Elliptic curve
;;;
;;; Copyright (c) 2017-2022 Takashi Kato <[email protected]>
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; 1. Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;;
;;; 2. Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
;;; TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
;;; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
;;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;;
;; moved from (math ec)
;; this library provides 3 things
;; - curve parameters
;; - constructors (ec point and curve)
;; - and arithmetic procedure for ec points
;;
;; there are 2 curves used, one is Fp and other one is F2m.
;; Fp is
;; y^2 = x^3 + ax + b (mod p)
;; F2m is
;; y^2 + xy = x^3 + ax^2 + b (mod p)
#!nounbound
(library (sagittarius crypto math ec)
(export make-ec-point ec-point-infinity?
ec-point?
ec-point-x
ec-point-y
ec-point-add
ec-point-twice
ec-point-negate
ec-point-sub
ec-point-mul
encode-ec-point
decode-ec-point
;; NIST parameters
NIST-P-192 (rename (NIST-P-192 secp192r1))
NIST-P-224 (rename (NIST-P-224 secp224r1))
NIST-P-256 (rename (NIST-P-256 secp256r1))
NIST-P-384 (rename (NIST-P-384 secp384r1))
NIST-P-521 (rename (NIST-P-521 secp521r1))
NIST-K-163 (rename (NIST-K-163 sect163k1))
NIST-K-233 (rename (NIST-K-233 sect233k1))
NIST-K-283 (rename (NIST-K-283 sect283k1))
NIST-K-409 (rename (NIST-K-409 sect409k1))
NIST-K-571 (rename (NIST-K-571 sect571k1))
NIST-B-163 (rename (NIST-B-163 sect163r2))
NIST-B-233 (rename (NIST-B-233 sect233r1))
NIST-B-283 (rename (NIST-B-283 sect283r1))
NIST-B-409 (rename (NIST-B-409 sect409r1))
NIST-B-571 (rename (NIST-B-571 sect571r1))
;; SEC 2 parameters
secp192k1
secp224k1
secp256k1
sect163r1
sect239k1
sect113r1
;; curve25519
curve25519
;; brainpool
brainpool-p160r1
brainpool-p160t1
brainpool-p192r1
brainpool-p192t1
brainpool-p224r1
brainpool-p224t1
brainpool-p256r1
brainpool-p256t1
brainpool-p320r1
brainpool-p320t1
brainpool-p384r1
brainpool-p384t1
brainpool-p512r1
brainpool-p512t1
;; elliptic curve accessors
elliptic-curve?
elliptic-curve-field
elliptic-curve-a
elliptic-curve-b
;; field
ec-field-fp?
ec-field-fp-p
ec-field-f2m?
ec-field-f2m-m
ec-field-f2m-k1
ec-field-f2m-k2
ec-field-f2m-k3
ec-field-size
;; parameter accessors
ec-parameter?
ec-parameter-curve
ec-parameter-g
ec-parameter-n
ec-parameter-h
ec-parameter-seed
ec-parameter-oid
lookup-ec-parameter
make-ec-parameter
make-fp-ec-parameter
make-f2m-ec-parameter
;; for testing
make-elliptic-curve
make-ec-field-fp
make-ec-field-f2m
ec-infinity-point
)
(import (core)
(core base)
(core errors)
(core syntax)
(core inline)
(core record)
(core misc) ;; for defaine-vector-type
(sagittarius)
(sagittarius crypto math modular) ;; these are needed on for Fp
(sagittarius crypto math ec fields))
;; to make constant foldable, we use vectors to represent
;; data structure
;;;
;; EC Curve
;; curve is a vector which contains type and parameters
;; for the curve.
(define-vector-type ec-curve (make-elliptic-curve field a b) elliptic-curve?
(field elliptic-curve-field)
(a elliptic-curve-a)
(b elliptic-curve-b))
(define-syntax define-predicate-generic
(syntax-rules ()
((_ (name field args ...) (pred body ...) ...)
(define (name field args ...)
(cond ((pred field) body ...)
...
(else (assertion-violation
'name "No predicate matched" field)))))))
(define (ec-curve=? a b) (equal? a b))
(define-predicate-generic (field-size field)
(ec-field-fp? (bitwise-length (ec-field-fp-p field)))
(ec-field-f2m? (ec-field-f2m-m field)))
(define ec-field-size field-size)
;; EC point
(define-vector-type ec-point (make-ec-point x y) ec-point?
(x ec-point-x)
(y ec-point-y))
;; keep it immutable...
(define ec-infinity-point '#(ec-point #f #f))
;; we don't check x and y, these can be #f for infinite point
(define (ec-point-infinity? p)
(or (not (ec-point-x p))
(not (ec-point-y p))))
(define (ec-point=? a b) (equal? a b))
(define (encode-ec-point curve ep)
(if (ec-point-infinity? ep)
#vu8(00)
(let ((size (div (+ (ec-field-size (elliptic-curve-field curve)) 7) 8)))
(bytevector-append #vu8(#x04)
(integer->bytevector (ec-point-x ep) size)
(integer->bytevector (ec-point-y ep) size)))))
(define (decode-ec-point curve bv)
(define size (div (+ (ec-field-size (elliptic-curve-field curve)) 7) 8))
(case (bytevector-u8-ref bv 0)
((#x00) ec-infinity-point)
;; TODO support compressed 0x02 and 0x03
((#x04)
(let ((x (bytevector->integer bv 1 (+ 1 size)))
(y (bytevector->integer bv (+ 1 size))))
(make-ec-point x y)))
(else
(implementation-restriction-violation 'decode-ec-point
"not supported"))))
;; Twice
(define-predicate-generic (field-ec-point-twice field curve x)
(ec-field-fp?
(if (zero? (ec-point-y x))
ec-infinity-point
(let* ((xx (ec-point-x x))
(xy (ec-point-y x))
(p (ec-field-fp-p field))
;; gamma = ((xx^2)*3 + curve.a)/(xy*2)
(gamma (mod-div (mod-add (mod-mul (mod-square xx p) 3 p)
(elliptic-curve-a curve)
p)
(mod-mul xy 2 p) p))
;; x3 = gamma^2 - x*2
(x3 (mod-sub (mod-square gamma p) (mod-mul xx 2 p) p))
;; y3 = gamma*(xx - x3) - xy
(y3 (mod-sub (mod-mul gamma (mod-sub xx x3 p) p) xy p)))
(make-ec-point x3 y3))))
(ec-field-f2m?
(if (zero? (ec-point-x x))
ec-infinity-point
(let* ((xx (ec-point-x x))
(xy (ec-point-y x))
(l1 (f2m-add field (f2m-div field xy xx) xx))
(x3 (f2m-add field (f2m-add field (f2m-square field l1) l1)
(elliptic-curve-a curve)))
(y3 (f2m-add field (f2m-add field (f2m-square field xx)
(f2m-mul field l1 x3))
x3)))
(make-ec-point x3 y3)))))
(define (ec-point-twice curve x)
(if (ec-point-infinity? x)
x
(field-ec-point-twice (elliptic-curve-field curve) curve x)))
;; Add
(define-predicate-generic (field-ec-point-add field curve x y)
(ec-field-fp?
(if (equal? (ec-point-x x) (ec-point-x y))
(if (equal? (ec-point-y x) (ec-point-y y))
(ec-point-twice curve x)
ec-infinity-point)
(let* ((xx (ec-point-x x))
(xy (ec-point-y x))
(yx (ec-point-x y))
(yy (ec-point-y y))
(p (ec-field-fp-p field))
;; gamma = (yy - xy)/(yx-xx)
(gamma (mod-div (mod-sub yy xy p) (mod-sub yx xx p) p))
;; x3 = gamma^2 - xx - yx
(x3 (mod-sub (mod-sub (mod-square gamma p) xx p) yx p))
;; y3 = gamma*(xx - x3) - xy
(y3 (mod-sub (mod-mul gamma (mod-sub xx x3 p) p) xy p)))
(make-ec-point x3 y3))))
(ec-field-f2m?
(let* ((xx (ec-point-x x))
(xy (ec-point-y x))
(yx (ec-point-x y))
(yy (ec-point-y y))
(dx (f2m-add field xx yx))
(dy (f2m-add field xy yy)))
(if (zero? dx)
(if (zero? dy)
(ec-point-twice curve x)
ec-infinity-point)
(let* ((L (f2m-div field dy dx))
(x3 (f2m-add field
(f2m-add field
(f2m-add field
(f2m-square field L) L)
dx)
(elliptic-curve-a curve)))
(y3 (f2m-add field
(f2m-add field
(f2m-mul field L
(f2m-add field xx x3))
x3)
xy)))
(make-ec-point x3 y3))))))
(define (ec-point-add curve x y)
(cond ((ec-point-infinity? x) y)
((ec-point-infinity? y) x)
(else
(field-ec-point-add (elliptic-curve-field curve) curve x y))))
;; Negate
(define-predicate-generic (field-ec-point-negate field x)
(ec-field-fp?
(make-ec-point (ec-point-x x)
(mod-negate (ec-point-y x) (ec-field-fp-p field))))
(ec-field-f2m?
(let ((xx (ec-point-x x)))
(make-ec-point xx (f2m-add field xx (ec-point-y x))))))
(define (ec-point-negate curve x)
(field-ec-point-negate (elliptic-curve-field curve) x))
(define (ec-point-sub curve x y)
(if (ec-point-infinity? y)
x
;; add -y
(ec-point-add curve x (ec-point-negate curve y))))
;; http://en.wikipedia.org/wiki/Non-adjacent_form
;; this is probably super slow but for now...
(define (ec-point-mul curve p k)
(unless (integer? k) (error 'ec-point-mul "integer required for k" k))
(let ((h (* k 3))
(neg (ec-point-negate curve p)))
(let loop ((R p) (i (- (bitwise-length h) 2)))
(if (zero? i)
R
(let ((R (ec-point-twice curve R))
(hbit? (bitwise-bit-set? h i)))
(if (eqv? hbit? (bitwise-bit-set? k i))
(loop R (- i 1))
(loop (ec-point-add curve R (if hbit? p neg)) (- i 1))))))))
;;;;
;;; Parameters
;; Parameter contains followings
;; - curve
;; - base point x y (as ec-point)
;; - Order q of the point G (and of the elliptic curve group E)
;; - h = (l - 1) / 160 where l is bit length of prime p
;; - seed
(define (ec-parameter? o)
(and (vector? o) (= (vector-length o) 7)
(eq? (vector-ref o 0) 'ec-parameter)))
(define (ec-parameter-curve o) (vector-ref o 1))
(define (ec-parameter-g o) (vector-ref o 2)) ;; as EC point
(define (ec-parameter-n o) (vector-ref o 3))
(define (ec-parameter-h o) (vector-ref o 4))
(define (ec-parameter-seed o) (vector-ref o 5))
(define (ec-parameter-oid o) (vector-ref o 6))
;;; Parameters
(define *lookup-table* (make-string-hashtable))
(define (register-ec-parameter oid value)
(when (string? oid)
(hashtable-set! *lookup-table* oid value)))
(define (lookup-ec-parameter oid) (hashtable-ref *lookup-table* oid #f))
;; from
;; https://www.nsa.gov/ia/_files/nist-routines.pdf (gone)
;; http://csrc.nist.gov/groups/ST/toolkit/documents/dss/NISTReCur.pdf (*)
;; http://koclab.cs.ucsb.edu/teaching/cren/docs/w02/nist-routines.pdf
;; http://www.secg.org/sec2-v2.pdf
;;
;; (*) is not used
(define (make-ec-parameter curve base n h S :optional (oid #f))
(let ((p `#(ec-parameter ,curve ,base ,n ,h ,S ,oid)))
(when oid (register-ec-parameter oid p))
p))
(define (make-fp-ec-parameter p a b Gx Gy n h S :optional (oid #f))
(make-ec-parameter (make-elliptic-curve (make-ec-field-fp p) a b)
(make-ec-point Gx Gy)
n h S oid))
;;; Fp
(define-syntax define-fp-parameter
(syntax-rules ()
((_ name p a b Gx Gy n h oid)
(define name
(make-fp-ec-parameter p a b Gx Gy n h #f oid)))
((_ name p a b Gx Gy n h S oid)
(define name
(make-fp-ec-parameter p a b Gx Gy n h (uinteger->bytevector S) oid)))))
(define-fp-parameter NIST-P-192
#xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF
#xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC
#x64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1
#x188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012
#x07192B95FFC8DA78631011ED6B24CDD573F977A11E794811
#xFFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831
1
#x3045AE6FC8422F64ED579528D38120EAE12196D5
"1.2.840.10045.3.1.1")
(define-fp-parameter secp192k1
#xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFEE37
0
3
#xDB4FF10EC057E9AE26B07D0280B7F4341DA5D1B1EAE06C7D
#x9B2F2F6D9C5628A7844163D015BE86344082AA88D95E2F9D
#xFFFFFFFFFFFFFFFFFFFFFFFE26F2FC170F69466A74DEFD8D
1
"1.3.132.0.31")
(define-fp-parameter NIST-P-224
#xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001
#xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE
#xB4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4
#xB70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21
#xBD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34
#xFFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D
1
#xBD71344799D5C7FCDC45B59FA3B9AB8F6A948BC5
"1.3.132.0.33")
(define-fp-parameter secp224k1
#xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFE56D
0
5
#xA1455B334DF099DF30FC28A169A467E9E47075A90F7E650EB6B7A45C
#x7E089FED7FBA344282CAFBD6F7E319F7C0B0BD59E2CA4BDB556D61A5
#x010000000000000000000000000001DCE8D2EC6184CAF0A971769FB1F7
1
"1.3.132.0.32")
(define-fp-parameter NIST-P-256
#xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF
#xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC
#x5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B
#x6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296
#x4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5
#xFFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551
1
#xC49D360886E704936A6678E1139D26B7819F7E90
"1.2.840.10045.3.1.7")
(define-fp-parameter secp256k1
#xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
0
7
#x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
#x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8
#xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
1
"1.3.132.0.10")
(define-fp-parameter NIST-P-384
#xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF
#xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFC
#xB3312FA7E23EE7E4988E056BE3F82D19181D9C6EFE8141120314088F5013875AC656398D8A2ED19D2A85C8EDD3EC2AEF
#xAA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7
#x3617DE4A96262C6F5D9E98BF9292DC29F8F41DBD289A147CE9DA3113B5F0B8C00A60B1CE1D7E819D7A431D7C90EA0E5F
#xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFc7634d81f4372ddf581a0db248b0a77aecec196accc52973
1
#xA335926AA319A27A1D00896A6773A4827ACDAC73
"1.3.132.0.34")
(define-fp-parameter NIST-P-521
#x000001FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
#x000001FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC
#x00000051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00
#x000000c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66
#x0000011839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650
#x000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409
1
#xD09E8800291CB85396CC6717393284AAA0DA64BA
"1.3.132.0.35")
;; RFC7748
(define-fp-parameter curve25519
;; (- (expt 2 255) 19)
#x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED
#x2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA984914A144
#x7B425ED097B425ED097B425ED097B425ED097B425ED097B4260B5E9C7710C864
#x2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD245A
#x20AE19A1B8A086B4E01EDD2C7748D14C923D4D7E6D7C61B229E9C5A27ECED3D9
#x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED ;; order
8 ;; cofactor
0 ;; S
"1.3.6.1.4.1.3029.1.5.1")
;; brainpool
;; https://www.rfc-editor.org/rfc/rfc5639
(define-fp-parameter brainpool-p160r1
#xE95E4A5F737059DC60DFC7AD95B3D8139515620F
#x340E7BE2A280EB74E2BE61BADA745D97E8F7C300
#x1E589A8595423412134FAA2DBDEC95C8D8675E58
#xBED5AF16EA3F6A4F62938C4631EB5AF7BDBCDBC3
#x1667CB477A1A8EC338F94741669C976316DA6321
#xE95E4A5F737059DC60DF5991D45029409E60FC09
#x1
"1.3.36.3.3.2.8.1.1.1")
(define-fp-parameter brainpool-p160t1
#xE95E4A5F737059DC60DFC7AD95B3D8139515620F
#xE95E4A5F737059DC60DFC7AD95B3D8139515620C
#x7A556B6DAE535B7B51ED2C4D7DAA7A0B5C55F380
#xB199B13B9B34EFC1397E64BAEB05ACC265FF2378
#xADD6718B7C7C1961F0991B842443772152C9E0AD
#xE95E4A5F737059DC60DF5991D45029409E60FC09
#x1
"1.3.36.3.3.2.8.1.1.2")
(define-fp-parameter brainpool-p192r1
#xC302F41D932A36CDA7A3463093D18DB78FCE476DE1A86297
#x6A91174076B1E0E19C39C031FE8685C1CAE040E5C69A28EF
#x469A28EF7C28CCA3DC721D044F4496BCCA7EF4146FBF25C9
#xC0A0647EAAB6A48753B033C56CB0F0900A2F5C4853375FD6
#x14B690866ABD5BB88B5F4828C1490002E6773FA2FA299B8F
#xC302F41D932A36CDA7A3462F9E9E916B5BE8F1029AC4ACC1
#x1
"1.3.36.3.3.2.8.1.1.3")
(define-fp-parameter brainpool-p192t1
#xC302F41D932A36CDA7A3463093D18DB78FCE476DE1A86297
#xC302F41D932A36CDA7A3463093D18DB78FCE476DE1A86294
#x13D56FFAEC78681E68F9DEB43B35BEC2FB68542E27897B79
#x3AE9E58C82F63C30282E1FE7BBF43FA72C446AF6F4618129
#x097E2C5667C2223A902AB5CA449D0084B7E5B3DE7CCC01C9
#xC302F41D932A36CDA7A3462F9E9E916B5BE8F1029AC4ACC1
#x1
"1.3.36.3.3.2.8.1.1.4")
(define-fp-parameter brainpool-p224r1
#xD7C134AA264366862A18302575D1D787B09F075797DA89F57EC8C0FF
#x68A5E62CA9CE6C1C299803A6C1530B514E182AD8B0042A59CAD29F43
#x2580F63CCFE44138870713B1A92369E33E2135D266DBB372386C400B
#x0D9029AD2C7E5CF4340823B2A87DC68C9E4CE3174C1E6EFDEE12C07D
#x58AA56F772C0726F24C6B89E4ECDAC24354B9E99CAA3F6D3761402CD
#xD7C134AA264366862A18302575D0FB98D116BC4B6DDEBCA3A5A7939F
#x1
"1.3.36.3.3.2.8.1.1.5")
(define-fp-parameter brainpool-p224t1
#xD7C134AA264366862A18302575D1D787B09F075797DA89F57EC8C0FF
#xD7C134AA264366862A18302575D1D787B09F075797DA89F57EC8C0FC
#x4B337D934104CD7BEF271BF60CED1ED20DA14C08B3BB64F18A60888D
#x6AB1E344CE25FF3896424E7FFE14762ECB49F8928AC0C76029B4D580
#x0374E9F5143E568CD23F3F4D7C0D4B1E41C8CC0D1C6ABD5F1A46DB4C
#xD7C134AA264366862A18302575D0FB98D116BC4B6DDEBCA3A5A7939F
#x1
"1.3.36.3.3.2.8.1.1.6")
(define-fp-parameter brainpool-p256r1
#xA9FB57DBA1EEA9BC3E660A909D838D726E3BF623D52620282013481D1F6E5377
#x7D5A0975FC2C3057EEF67530417AFFE7FB8055C126DC5C6CE94A4B44F330B5D9
#x26DC5C6CE94A4B44F330B5D9BBD77CBF958416295CF7E1CE6BCCDC18FF8C07B6
#x8BD2AEB9CB7E57CB2C4B482FFC81B7AFB9DE27E1E3BD23C23A4453BD9ACE3262
#x547EF835C3DAC4FD97F8461A14611DC9C27745132DED8E545C1D54C72F046997
#xA9FB57DBA1EEA9BC3E660A909D838D718C397AA3B561A6F7901E0E82974856A7
#x1
"1.3.36.3.3.2.8.1.1.7")
(define-fp-parameter brainpool-p256t1
#xA9FB57DBA1EEA9BC3E660A909D838D726E3BF623D52620282013481D1F6E5377
#xA9FB57DBA1EEA9BC3E660A909D838D726E3BF623D52620282013481D1F6E5374
#x662C61C430D84EA4FE66A7733D0B76B7BF93EBC4AF2F49256AE58101FEE92B04
#xA3E8EB3CC1CFE7B7732213B23A656149AFA142C47AAFBC2B79A191562E1305F4
#x2D996C823439C56D7F7B22E14644417E69BCB6DE39D027001DABE8F35B25C9BE
#xA9FB57DBA1EEA9BC3E660A909D838D718C397AA3B561A6F7901E0E82974856A7
#x1
"1.3.36.3.3.2.8.1.1.8")
(define-fp-parameter brainpool-p320r1
#xD35E472036BC4FB7E13C785ED201E065F98FCFA6F6F40DEF4F92B9EC7893EC28FCD412B1F1B32E27
#x3EE30B568FBAB0F883CCEBD46D3F3BB8A2A73513F5EB79DA66190EB085FFA9F492F375A97D860EB4
#x520883949DFDBC42D3AD198640688A6FE13F41349554B49ACC31DCCD884539816F5EB4AC8FB1F1A6
#x43BD7E9AFB53D8B85289BCC48EE5BFE6F20137D10A087EB6E7871E2A10A599C710AF8D0D39E20611
#x14FDD05545EC1CC8AB4093247F77275E0743FFED117182EAA9C77877AAAC6AC7D35245D1692E8EE1
#xD35E472036BC4FB7E13C785ED201E065F98FCFA5B68F12A32D482EC7EE8658E98691555B44C59311
#x1
"1.3.36.3.3.2.8.1.1.9")
(define-fp-parameter brainpool-p320t1
#xD35E472036BC4FB7E13C785ED201E065F98FCFA6F6F40DEF4F92B9EC7893EC28FCD412B1F1B32E27
#xD35E472036BC4FB7E13C785ED201E065F98FCFA6F6F40DEF4F92B9EC7893EC28FCD412B1F1B32E24
#xA7F561E038EB1ED560B3D147DB782013064C19F27ED27C6780AAF77FB8A547CEB5B4FEF422340353
#x925BE9FB01AFC6FB4D3E7D4990010F813408AB106C4F09CB7EE07868CC136FFF3357F624A21BED52
#x63BA3A7A27483EBF6671DBEF7ABB30EBEE084E58A0B077AD42A5A0989D1EE71B1B9BC0455FB0D2C3
#xD35E472036BC4FB7E13C785ED201E065F98FCFA5B68F12A32D482EC7EE8658E98691555B44C59311
#x1
"1.3.36.3.3.2.8.1.1.10")
(define-fp-parameter brainpool-p384r1
#x8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B412B1DA197FB71123ACD3A729901D1A71874700133107EC53
#x7BC382C63D8C150C3C72080ACE05AFA0C2BEA28E4FB22787139165EFBA91F90F8AA5814A503AD4EB04A8C7DD22CE2826
#x04A8C7DD22CE28268B39B55416F0447C2FB77DE107DCD2A62E880EA53EEB62D57CB4390295DBC9943AB78696FA504C11
#x1D1C64F068CF45FFA2A63A81B7C13F6B8847A3E77EF14FE3DB7FCAFE0CBD10E8E826E03436D646AAEF87B2E247D4AF1E
#x8ABE1D7520F9C2A45CB1EB8E95CFD55262B70B29FEEC5864E19C054FF99129280E4646217791811142820341263C5315
#x8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B31F166E6CAC0425A7CF3AB6AF6B7FC3103B883202E9046565
#x1
"1.3.36.3.3.2.8.1.1.11")
(define-fp-parameter brainpool-p384t1
#x8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B412B1DA197FB71123ACD3A729901D1A71874700133107EC53
#x8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B412B1DA197FB71123ACD3A729901D1A71874700133107EC50
#x7F519EADA7BDA81BD826DBA647910F8C4B9346ED8CCDC64E4B1ABD11756DCE1D2074AA263B88805CED70355A33B471EE
#x18DE98B02DB9A306F2AFCD7235F72A819B80AB12EBD653172476FECD462AABFFC4FF191B946A5F54D8D0AA2F418808CC
#x25AB056962D30651A114AFD2755AD336747F93475B7A1FCA3B88F2B6A208CCFE469408584DC2B2912675BF5B9E582928
#x8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B31F166E6CAC0425A7CF3AB6AF6B7FC3103B883202E9046565
#x1
"1.3.36.3.3.2.8.1.1.12")
(define-fp-parameter brainpool-p512r1
#xAADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA703308717D4D9B009BC66842AECDA12AE6A380E62881FF2F2D82C68528AA6056583A48F3
#x7830A3318B603B89E2327145AC234CC594CBDD8D3DF91610A83441CAEA9863BC2DED5D5AA8253AA10A2EF1C98B9AC8B57F1117A72BF2C7B9E7C1AC4D77FC94CA
#x3DF91610A83441CAEA9863BC2DED5D5AA8253AA10A2EF1C98B9AC8B57F1117A72BF2C7B9E7C1AC4D77FC94CADC083E67984050B75EBAE5DD2809BD638016F723
#x81AEE4BDD82ED9645A21322E9C4C6A9385ED9F70B5D916C1B43B62EEF4D0098EFF3B1F78E2D0D48D50D1687B93B97D5F7C6D5047406A5E688B352209BCB9F822
#x7DDE385D566332ECC0EABFA9CF7822FDF209F70024A57B1AA000C55B881F8111B2DCDE494A5F485E5BCA4BD88A2763AED1CA2B2FA8F0540678CD1E0F3AD80892
#xAADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA70330870553E5C414CA92619418661197FAC10471DB1D381085DDADDB58796829CA90069
#x1
"1.3.36.3.3.2.8.1.1.13")
(define-fp-parameter brainpool-p512t1
#xAADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA703308717D4D9B009BC66842AECDA12AE6A380E62881FF2F2D82C68528AA6056583A48F3
#xAADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA703308717D4D9B009BC66842AECDA12AE6A380E62881FF2F2D82C68528AA6056583A48F0
#x7CBBBCF9441CFAB76E1890E46884EAE321F70C0BCB4981527897504BEC3E36A62BCDFA2304976540F6450085F2DAE145C22553B465763689180EA2571867423E
#x640ECE5C12788717B9C1BA06CBC2A6FEBA85842458C56DDE9DB1758D39C0313D82BA51735CDB3EA499AA77A7D6943A64F7A3F25FE26F06B51BAA2696FA9035DA
#x5B534BD595F5AF0FA2C892376C84ACE1BB4E3019B71634C01131159CAE03CEE9D9932184BEEF216BD71DF2DADF86A627306ECFF96DBB8BACE198B61E00F8B332
#xAADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA70330870553E5C414CA92619418661197FAC10471DB1D381085DDADDB58796829CA90069
#x1
"1.3.36.3.3.2.8.1.1.14")
;;; F2m
(define (make-f2m-ec-parameter m k1 k2 k3 a b Gx Gy n h S :optional (oid #f))
(make-ec-parameter (make-elliptic-curve (make-ec-field-f2m m k1 k2 k3) a b)
(make-ec-point Gx Gy)
n h S oid))
(define-syntax define-f2m-parameter
(syntax-rules ()
((_ "body" name (m k1 k2 k3) a b Gx Gy n h S oid)
(define name
(make-f2m-ec-parameter m k1 k2 k3 a b Gx Gy n h S oid)))
((_ name (m k1 k2 k3) a b Gx Gy n h S oid)
(define-f2m-parameter "body" name (m k1 k2 k3) a b Gx Gy n h
(uinteger->bytevector S)
oid))
((_ name (m k1 k2 k3) a b Gx Gy n h oid)
(define-f2m-parameter "body" name (m k1 k2 k3) a b Gx Gy n h #f oid))))
;; f(x) = x^163 + x^7 + x^6 + x^3 + 1
(define-f2m-parameter NIST-K-163
(163 3 6 7)
1
1
#x02FE13C0537BBC11ACAA07D793DE4E6D5E5C94EEE8
#x0289070FB05D38FF58321F2E800536D538CCDAA3D9
#x04000000000000000000020108A2E0CC0D99F8A5EF
2
"1.3.132.0.1")
(define-f2m-parameter sect163r1
(163 3 6 7)
#x07B6882CAAEFA84F9554FF8428BD88E246D2782AE2
#x0713612DCDDCB40AAB946BDA29CA91F73AF958AFD9
#x0369979697AB43897789566789567F787A7876A654
#x00435EDB42EFAFB2989D51FEFCE3C80988F41FF883
#x03FFFFFFFFFFFFFFFFFFFF48AAB689C29CA710279B
2
"1.3.132.0.2")
(define-f2m-parameter NIST-B-163
(163 3 6 7)
1
#x020a601907b8c953ca1481eb10512f78744a3205fd
#x03f0eba16286a2d57ea0991168d4994637e8343e36
#x00d51fbc6c71a0094fa2cdd545b11c5c0c797324f1
#x040000000000000000000292fe77e70c12a4234c33
2
#x85E25BFE5C86226CDB12016F7553F9D0E693A268
"1.3.132.0.15")
(define-f2m-parameter NIST-K-233
(233 74 0 0)
0
1
#x017232BA853A7E731AF129F22FF4149563A419C26BF50A4C9D6EEFAD6126
#x01DB537DECE819B7F70F555A67C427A8CD9BF18AEB9B56E0C11056FAE6A3
#x8000000000000000000000000000069D5BB915BCD46EFB1AD5F173ABDF
4
"1.3.132.0.26")
(define-f2m-parameter NIST-B-233
(233 74 0 0)
1
#x0066647EDE6C332C7F8C0923BB58213B333B20E9CE4281FE115F7D8F90AD
#x00FAC9DFCBAC8313BB2139F1BB755FEF65BC391F8B36F8F8EB7371FD558B
#x01006A08A41903350678E58528BEBF8A0BEFF867A7CA36716F7E01F81052
#x1000000000000000000000000000013E974E72F8A6922031D2603CFE0D7
2
#x74D59FF07F6B413D0EA14B344B20A2DB049B50C3
"1.3.132.0.27")
(define-f2m-parameter sect239k1
(239 158 0 0)
0
1
#x29A0B6A887A983E9730988A68727A8B2D126C44CC2CC7B2A6555193035DC
#x76310804F12E549BDB011C103089E73510ACB275FC312A5DC6B76553F0CA
#x2000000000000000000000000000005A79FEC67CB6E91F1C1DA800E478A5
4
"1.3.132.0.3")
(define-f2m-parameter NIST-K-283
(283 5 7 12)
0
1
#x0503213F78CA44883F1A3B8162F188E553CD265F23C1567A16876913B0C2AC2458492836
#x01CCDA380F1C9E318D90F95D07E5426FE87E45C0E8184698E45962364E34116177DD2259
#x01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE9AE2ED07577265DFF7F94451E061E163C61
4
"1.3.132.0.16")
(define-f2m-parameter NIST-B-283
(283 5 7 12)
1
#x027B680AC8B8596DA5A4AF8A19A0303FCA97FD7645309FA2A581485AF6263E313B79A2F5
#x05F939258DB7DD90E1934F8C70B0DFEC2EED25B8557EAC9C80E2E198F8CDBECD86B12053
#x03676854FE24141CB98FE6D4B20D02B4516FF702350EDDB0826779C813F0DF45BE8112F4
#x03FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEF90399660FC938A90165B042A7CEFADB307
2
#x77E2B07370EB0F832A6DD5B62DFC88CD06BB84BE
"1.3.132.0.17")
(define-f2m-parameter NIST-K-409
(409 87 0 0)
0
1
#x0060F05F658F49C1AD3AB1890F7184210EFD0987E307C84C27ACCFB8F9F67CC2C460189EB5AAAA62EE222EB1B35540CFE9023746
#x01E369050B7C4E42ACBA1DACBF04299C3460782F918EA427E6325165E9EA10E3DA5F6C42E9C55215AA9CA27A5863EC48D8E0286B
#x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE5F83B2D4EA20400EC4557D5ED3E3E7CA5B4B5C83B8E01E5FCF
4
"1.3.132.0.36")
(define-f2m-parameter NIST-B-409
(409 87 0 0)
1
#x0021A5C2C8EE9FEB5C4B9A753B7B476B7FD6422EF1F3DD674761FA99D6AC27C8A9A197B272822F6CD57A55AA4F50AE317B13545F
#x015D4860D088DDB3496B0C6064756260441CDE4AF1771D4DB01FFE5B34E59703DC255A868A1180515603AEAB60794E54BB7996A7
#x0061B1CFAB6BE5F32BBFA78324ED106A7636B9C5A7BD198D0158AA4F5488D08F38514F1FDF4B4F40D2181B3681C364BA0273C706
#x010000000000000000000000000000000000000000000000000001E2AAD6A612F33307BE5FA47C3C9E052F838164CD37D9A21173
2
#x4099B5A457F9D69F79213D094C4BCD4D4262210B
"1.3.132.0.37")
(define-f2m-parameter NIST-K-571
(571 2 5 10)
0
1
#x026EB7A859923FBC82189631F8103FE4AC9CA2970012D5D46024804801841CA44370958493B205E647DA304DB4CEB08CBBD1BA39494776FB988B47174DCA88C7E2945283A01C8972
#x0349DC807F4FBF374F4AEADE3BCA95314DD58CEC9F307A54FFC61EFC006D8A2C9D4979C0AC44AEA74FBEBBB9F772AEDCB620B01A7BA7AF1B320430C8591984F601CD4C143EF1C7A3
#x020000000000000000000000000000000000000000000000000000000000000000000000131850E1F19A63E4B391A8DB917F4138B630D84BE5D639381E91DEB45CFE778F637C1001
4
"1.3.132.0.38")
(define-f2m-parameter NIST-B-571
(571 2 5 10)
1
#x02F40E7E2221F295DE297117B7F3D62F5C6A97FFCB8CEFF1CD6BA8CE4A9A18AD84FFABBD8EFA59332BE7AD6756A66E294AFD185A78FF12AA520E4DE739BACA0C7FFEFF7F2955727A
#x0303001D34B856296C16C0D40D3CD7750A93D1D2955FA80AA5F40FC8DB7B2ABDBDE53950F4C0D293CDD711A35B67FB1499AE60038614F1394ABFA3B4C850D927E1E7769C8EEC2D19
#x037BF27342DA639B6DCCFFFEB73D69D78C6C27A6009CBBCA1980F8533921E8A684423E43BAB08A576291AF8F461BB2A8B3531D2F0485C19B16E2F1516E23DD3C1A4827AF1B8AC15B
#x03FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE661CE18FF55987308059B186823851EC7DD9CA1161DE93D5174D66E8382E9BB2FE84E47
2
#x2AA058F73A0E33AB486B0F610410C53A7F132310
"1.3.132.0.39")
;; f(x) = x^113 + x^9 + 1
(define-f2m-parameter sect113r1
(113 9 0 0)
#x003088250CA6E7C7FE649CE85820F7
#x00E8BEE4D3E2260744188BE0E9C723
#x009D73616F35F4AB1407D73562C10F
#x00A52830277958EE84D1315ED31886
#x0100000000000000D9CCEC8A39E56F
2
#x10E723AB14D696E6768756151756FEBF8FCB49A9
#f)
)
| true |
b769c7475288f62f4d1673ae3e32a68915c7b656 | 7cc14e6ab8e064fa967251e3249863e2cfbcc920 | /chapter-2/huffman-tree.scm | 070f744fc716f1114b8a4abb04fae08fdf3303bc | []
| no_license | xueeinstein/sicp-code | 0bec79419286705f58175067d474169afd6ba5fe | 49602b0b13cb9c338b6af089f989c17890ba6085 | refs/heads/master | 2021-01-10T01:20:03.089038 | 2015-11-24T03:25:54 | 2015-11-24T03:25:54 | 43,536,317 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 4,704 | scm | huffman-tree.scm | ;;; Bill Xue
;;; 2015-10-13
;;; Huffman Tree
;; Represent Huffman tree
(define (make-leaf symbol weight)
(list 'leaf symbol weight))
(define (leaf? object)
(eq? (car object) 'leaf))
(define (symbol-leaf x)
(cadr x))
(define (weight-leaf x)
(caddr x))
(define (make-code-tree left right)
(list left
right
(append (symbols left) (symbols right))
(+ (weight left) (weight right))))
(define (left-branch tree) (car tree))
(define (right-branch tree) (cadr tree))
(define (symbols tree)
(if (leaf? tree)
(list (symbol-leaf tree))
; for code-tree
(caddr tree)))
(define (weight tree)
(if (leaf? tree)
(weight-leaf tree)
(cadddr tree)))
(define (choose-branch bit branch)
(cond ((= bit 0) (left-branch branch))
((= bit 1) (right-branch branch))
(else (error "bad bit -- CHOOSE-BRANCH" bit))))
(define (decode bits tree)
(define (decode-l bits current-branch)
(if (null? bits)
'()
(let ((next-branch
(choose-branch (car bits) current-branch)))
(if (leaf? next-branch)
(cons
(symbol-leaf next-branch)
; restart from the root
(decode-l (cdr bits) tree))
(decode-l (cdr bits) next-branch)))))
(decode-l bits tree))
; help rank the elements in list
; when insert
(define (adjoin-set x set)
(cond ((null? set) (list x))
((< (weight x) (weight (car set)))
(cons x set)) ; rank in ascend
(else (cons (car set)
(adjoin-set x (cdr set))))))
; init leaf pairs from input
(define (make-leaf-set pairs)
(if (null? pairs)
'()
(let ((pair (car pairs)))
(adjoin-set (make-leaf (car pair)
(cadr pair))
(make-leaf-set (cdr pairs))))))
;; Exercise 2.67
;; test decode
(define sample-Huffman-tree
(make-code-tree (make-leaf 'A 4)
(make-code-tree
(make-leaf 'B 2)
(make-code-tree
(make-leaf 'D 1)
(make-leaf 'C 1)))))
(define sample-message
'(0 1 1 0 0 1 0 1 0 1 1 1 0))
(decode sample-message sample-Huffman-tree)
; get decoded message (A D A B B C A)
;; Exercise 2.68
;; encode
(define (encode message tree)
(if (null? message)
'()
(append (encode-symbol (car message) tree)
(encode (cdr message) tree))))
(define (encode-symbol symbol tree)
; why not build a symbol-encode dic?
; here, in-order
(define (traverse symbol tree trace)
(cond ((and (leaf? tree)
(eq? (symbol-leaf tree)
symbol))
trace)
((memq symbol (symbols (left-branch tree)))
; symbol in left branch
(traverse
symbol
(left-branch tree)
(append trace (list 0))))
((memq symbol (symbols (right-branch tree)))
; symbol in left branch
(traverse
symbol
(right-branch tree)
(append trace (list 1))))
(else (error
"cannot encode symbol --ENCODE-SYMBOL: "
symbol))))
(traverse symbol tree '()))
;; Exercise 2.69
;; Generate Huffman Tree
(define (generate-huffman-tree pairs)
(define (successive-merge sub-trees)
(cond ((null? sub-trees) '())
((null? (cdr sub-trees))
; already got the Huffman tree
(car sub-trees))
(else
(successive-merge
(cons (make-code-tree
(cadr sub-trees)
(car sub-trees))
(cddr sub-trees))))))
(successive-merge (make-leaf-set pairs)))
;; Exercise 2.70
;; Huffman Tree using to compress lyrics
(define lyrics-symbol-pairs
'((A 2) (NA 16) (BOOM 1) (SHA 3)
(GET 2) (YIP 9) (JOB 2) (WAH 1)))
(define lyrics
'(GET A JOB SHA NA NA NA NA NA NA NA NA
GET A JOB SHA NA NA NA NA NA NA NA NA
WAH YIP YIP YIP YIP YIP YIP YIP YIP YIP
SHA BOOM))
(define encoded-lyrics
(encode lyrics
(generate-huffman-tree lyrics-symbol-pairs)))
; encoded lyrics length is 87 bits
; if using fixed-length code, we need
; 3 * (length lyrics) = 108
(define encoded-lyrics-length
(length encoded-lyrics))
;; Exercise 2.71
;; The symbols frequence in list
;; 1, 2, 4, ... , 2^(n-1)
;; We can generate the worst (with largest height)
;; binary tree
;; so the short symbol enocde length is 1
;; the longest symbol encode length is n-2
;; Exercise 2.72
;; For unbalanced tree, the total encode is O(n*n)
;; For perfect balanced tree, the total encode is O(nlgn)
| false |
f9de9a87e778567f1daee5404477799c5f1512ef | 4f6a6e56a909ffdeb9c6a73790200a68f8f0c82c | /lib/tooling/tooling/count.scm | 48999d1896df72fc1aa5006c781d1e58f4cbea7b | [
"MIT"
]
| permissive | eshoo/detroit-scheme | c5ddda1bc19ce85b87a309a2b36299e607e7da65 | 84c2333d1e04dd3425c2275da94375aedab34a9e | refs/heads/master | 2021-01-24T23:11:27.991392 | 2010-03-02T02:21:45 | 2010-03-02T02:21:45 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 305 | scm | count.scm | ; Copyright (c) 2009, Raymond R. Medeiros. All rights reserved.
; (count pair) ==> integer
;
; Count the atomic members of a pair.
;
; Arguments: x - list to count
;
(define (count x)
(cond ((null? x) 0)
((pair? x)
(+ (count (car x))
(count (cdr x))))
(else 1)))
| false |
48b6cead5f77310742c2bb9a2ebc247720e83ec8 | 2d19dc910d6635700bac6a1e5326edaa28979810 | /ext/crypto/crypto/ecdsa.scm | f23eb7487ff5a3ae7076a248ad65623a37ec5c7d | [
"BSD-3-Clause",
"LicenseRef-scancode-other-permissive",
"BSD-2-Clause",
"MIT"
]
| permissive | spurious/sagittarius-scheme-mirror | e88c68cd4a72c371f265f5174d4e5f7c9189fff5 | 53f104188934109227c01b1e9a9af5312f9ce997 | refs/heads/master | 2021-01-23T18:00:33.235458 | 2018-11-27T21:03:18 | 2018-11-27T21:03:18 | 2,843,561 | 5 | 2 | null | null | null | null | UTF-8 | Scheme | false | false | 17,019 | scm | ecdsa.scm | ;;; -*- mode:scheme; coding:utf-8; -*-
;;;
;;; crypto/key/ecdsa.scm - ECDSA cipher and so
;;;
;;; Copyright (c) 2017 Takashi Kato. All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; 1. Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;;
;;; 2. Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
;;; TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
;;; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
;;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;; references:
;; - https://tools.ietf.org/html/rfc5915
;; - https://tools.ietf.org/html/rfc5480
;; - https://tools.ietf.org/html/rfc6090
(library (crypto ecdsa)
(export ECDSA
<ecdsa-private-key>
<ecdsa-public-key>
;; NIST parameters
NIST-P-192
NIST-P-224
NIST-P-256
NIST-P-384
NIST-P-521
NIST-K-163
NIST-K-233
NIST-K-283
NIST-K-409
NIST-K-571
NIST-B-163
NIST-B-233
NIST-B-283
NIST-B-409
NIST-B-571
;; SEC 2 parameters
sect113r1
secp192r1 ;; the same as NIST-P-*
secp224r1
secp256r1
secp384r1
secp521r1
sect163k1 ;; the same as NIST-K-*
sect233k1
sect283k1
sect409k1
sect571k1
sect163r2 ;; the same as NIST-B-*
sect233r1
sect283r1
sect409r1
sect571r1
)
(import (rnrs)
(sagittarius)
(math)
(math ec)
(clos user)
(sagittarius crypto)
(crypto key pair)
(crypto k-generator)
(asn.1)
(util bytevector))
(define ECDSA :ecdsa)
(define-class <ecdsa-private-key> (<private-key>)
((d :init-keyword :d) ;; private key
(parameter :init-keyword :parameter :init-keyword #f) ;; domain parameter
(public-key :init-keyword :public-key :init-value #f))) ;; public key
(define-class <ecdsa-public-key> (<public-key>)
((Q :init-keyword :Q)
(parameter :init-keyword :parameter :init-keyword #f))) ;; domain parameter
(define (read-random-bits prng nbits)
(bytevector->uinteger (read-random-bytes prng (div nbits 8))))
(define-method generate-key-pair ((m (eql ECDSA))
:key (ec-parameter secp256r1)
(prng (secure-random RC4)))
(let* ((n (ec-parameter-n ec-parameter))
(nbits (bitwise-length n))
(G (ec-parameter-g ec-parameter))
(curve (ec-parameter-curve ec-parameter)))
(do ((d (read-random-bits prng nbits) (read-random-bits prng nbits)))
((and (> d 2) (< d n))
(let ((pub (make <ecdsa-public-key> :Q (ec-point-mul curve G d)
:parameter ec-parameter)))
(make-keypair (make <ecdsa-private-key> :d d
:parameter ec-parameter :public-key pub)
pub))))))
(define-method generate-private-key ((m (eql ECDSA)) d
:optional (parameter secp256r1)
(publick-key #f))
(make <ecdsa-private-key> :d d :parameter parameter
:public-key publick-key))
(define-method generate-public-key ((m (eql ECDSA)) x y
:optional (parameter secp256r1))
(make <ecdsa-public-key> :Q (make-ec-point x y) :parameter parameter))
(define (compute-e digest n bv)
(define M (hash digest bv))
(let ((len (bitwise-length n))
(M-bits (* (bytevector-length M) 8)))
(let ((e (bytevector->uinteger M)))
(if (< len M-bits)
(bitwise-arithmetic-shift-right e (- M-bits len))
e))))
(define default-k-generator (random-k-generator (secure-random RC4)))
(define (ecdsa-sign bv key
:key (k-generator default-k-generator)
(der-encode #t)
(digest :hash SHA-1))
(define (compute-r ec n d)
(define G (ec-parameter-g ec))
(define curve (ec-parameter-curve ec))
(let loop ()
(let* ((k (k-generator n d))
(p (ec-point-mul curve G k))
(r (mod (ec-point-x p) n)))
(if (zero? r)
(loop)
(values r k)))))
(define (compute-s r k e d n) (mod (* (mod-inverse k n) (+ e (* d r))) n))
(let* ((ec-param (slot-ref key 'parameter))
(n (ec-parameter-n ec-param))
(e (compute-e digest n bv))
(d (slot-ref key 'd)))
(let loop ()
(let-values (((r k) (compute-r ec-param n d)))
(let ((s (compute-s r k e d n)))
(cond ((zero? s) (loop))
(der-encode (encode (make-der-sequence
(make-der-integer r)
(make-der-integer s))))
(else
(let ((size (ceiling (/ (bitwise-length n) 8))))
(bytevector-append (integer->bytevector r size)
(integer->bytevector s size))))))))))
(define (ecdsa-verify M S key
:key (der-encode #t)
(digest :hash SHA-1))
;; FIXME this is almost copy&paste...
(define (parse-r&s S n)
(if der-encode
(let ((r&s (read-asn.1-object (open-bytevector-input-port S))))
(unless (and (is-a? r&s <asn.1-sequence>)
(= 2 (length (slot-ref r&s 'sequence))))
(error 'ecdsa-verify "invalid signature"))
(values (der-integer->integer (car (slot-ref r&s 'sequence)))
(der-integer->integer (cadr (slot-ref r&s 'sequence)))))
(let ((size (ceiling (/ (bitwise-length n) 8))))
(let*-values (((r s) (bytevector-split-at* S size)))
(values (bytevector->integer r) (bytevector->integer s))))))
(unless (is-a? key <ecdsa-public-key>) (error 'ecdsa-verify "invalid key"))
(let* ((ec (slot-ref key 'parameter))
(n (ec-parameter-n ec))
(e (compute-e digest n M)))
(let-values (((r s) (parse-r&s S n)))
(when (or (< r 1) (< n r) ;; r in range [1, n-1]
(< s 1) (< n s)) ;; s in range [1, n-1]
(error 'ecdsa-verify "inconsistent"))
(let* ((w (mod-inverse s n))
(u1 (mod (* e w) n))
(u2 (mod (* r w) n))
(G (ec-parameter-g ec))
(Q (slot-ref key 'Q))
(curve (ec-parameter-curve ec)))
(let ((point (ec-point-add curve
(ec-point-mul curve G u1)
(ec-point-mul curve Q u2))))
(or (= (mod (ec-point-x point) n) (mod r n))
(error 'ecdsa-verify "inconsistent")))))))
(define-class <ecdsa-cipher-spi> (<cipher-spi>) ())
(define-method initialize ((o <ecdsa-cipher-spi>) initargs)
(let ((key (car initargs)))
(slot-set! o 'name 'ECDSA)
(slot-set! o 'key key)
(slot-set! o 'encrypt
(lambda ignore (error 'encrypt "not supported in DSA")))
(slot-set! o 'decrypt
(lambda ignore (error 'decrypt "not supported in DSA")))
(slot-set! o 'padder #f)
(slot-set! o 'signer ecdsa-sign)
(slot-set! o 'verifier ecdsa-verify)
(slot-set! o 'keysize #f)))
(register-spi ECDSA <ecdsa-cipher-spi>)
;; key export/import
(define (lookup-named-curve-parameter oid)
(lookup-ec-parameter (slot-ref oid 'identifier)))
#|
SubjectPublicKeyInfo ::= SEQUENCE {
algorithm AlgorithmIdentifier,
subjectPublicKey BIT STRING
}
AlgorithmIdentifier ::= SEQUENCE {
algorithm OBJECT IDENTIFIER,
parameters ANY DEFINED BY algorithm OPTIONAL
}
parameters must be ECParameters
|#
(define id-ec-public-key (make-der-object-identifier "1.2.840.10045.2.1"))
(define-method export-public-key ((m (eql ECDSA)) (key <ecdsa-public-key>))
(define param (slot-ref key 'parameter))
(define curve (ec-parameter-curve param))
(unless curve
(assertion-violation 'export-public-key
"No EC parameter is set for the key"))
(let ((encoded (encode-ec-point curve (slot-ref key 'Q))))
(asn.1-encode
(make-der-sequence
(make-der-sequence
id-ec-public-key
(if (ec-parameter-oid param)
(make-der-object-identifier (ec-parameter-oid param))
(ec-parameter->asn.1-object param)))
(make-der-bit-string encoded)))))
(define-method export-public-key ((key <ecdsa-public-key>))
(export-public-key ECDSA key))
(define-method import-public-key ((marker (eql ECDSA)) (in <bytevector>))
(import-public-key ECDSA (open-bytevector-input-port in)))
(define-method import-public-key ((marker (eql ECDSA)) (in <port>))
(import-public-key ECDSA (read-asn.1-object in)))
(define id-prime-field (make-der-object-identifier "1.2.840.10045.1.1"))
(define id-f2m-field (make-der-object-identifier "1.2.840.10045.1.2"))
#|
ECParameters ::= SEQUENCE {
version INTEGER { ecpVer1(1) } (ecpVer1),
fieldID FieldID {{FieldTypes}},
curve Curve,
base ECPoint,
order INTEGER,
cofactor INTEGER OPTIONAL,
...
}
Curve ::= SEQUENCE {
a FieldElement,
b FieldElement,
seed BIT STRING OPTIONAL
}
|#
(define (->ec-parameter p)
(define objs (slot-ref p 'sequence))
(define (parse-field-id field-id)
(let ((objs (slot-ref field-id 'sequence)))
(values (car objs) (cadr objs))))
(define (parse-curve curve)
(let ((obj (slot-ref curve 'sequence)))
(values (bytevector->uinteger (slot-ref (car obj) 'string))
(bytevector->uinteger (slot-ref (cadr obj) 'string))
(if (= (length obj) 3)
(slot-ref (caddr obj) 'data)
#vu8()))))
(define (make-curve field-type field-param a b)
(define (parse-f2m-parameter f2m)
(define param (caddr f2m))
;; lazy way.
(cond ((is-a? param <der-null>) (values 0 0 0))
((is-a? param <der-integer>)
(values (der-integer->integer param) 0 0))
((is-a? param <der-sequence>)
(apply values
(map der-integer->integer
(slot-ref param 'sequence))))))
(cond ((equal? id-prime-field field-type)
(make-elliptic-curve (make-ec-field-fp
(der-integer->integer field-param)) a b))
((equal? id-f2m-field field-type)
(let* ((f2m (slot-ref field-param 'sequence))
(m (der-integer->integer (car f2m))))
(let-values (((k1 k2 k3) (parse-f2m-parameter f2m)))
(make-elliptic-curve (make-ec-field-f2m m k1 k2 k3) a b))))
(else
(error 'import-public-key "unknown field type" field-type))))
(let-values (((field-type field-param) (parse-field-id (cadr objs)))
((a b S) (parse-curve (caddr objs))))
(let* ((Gxy (cadddr objs))
(n (der-integer->integer (car (cddddr objs))))
(h (der-integer->integer (cadr (cddddr objs))))
(curve (make-curve field-type field-param a b))
(base (decode-ec-point curve (slot-ref Gxy 'string))))
(make-ec-parameter curve base n h S))))
(define (ec-parameter->asn.1-object ep)
(define curve (ec-parameter-curve ep))
(define field (elliptic-curve-field curve))
(define (make-asn.1-curve curve)
(define (uinteger->der-octet-string a)
(make-der-octet-string (uinteger->bytevector a)))
(let ((base (make-der-sequence
(uinteger->der-octet-string (elliptic-curve-a curve))
(uinteger->der-octet-string (elliptic-curve-b curve)))))
(and-let* ((S (ec-parameter-seed ep)))
(asn.1-sequence-add base (make-der-bit-string S)))
base))
(define (make-asn.1-field field)
(if (ec-field-fp? field)
(let ((p (ec-field-fp-p field)))
(make-der-sequence id-prime-field (make-der-integer p)))
(let ((m (ec-field-f2m-m field))
(k1 (ec-field-f2m-k1 field))
(k2 (ec-field-f2m-k2 field))
(k3 (ec-field-f2m-k3 field))
(param (make-der-sequence (make-der-integer m)))
(base (make-der-sequence id-f2m-field param)))
(cond ((and (zero? k1) (zero? k2) (zero? k3))
(asn.1-sequence-add param
(make-der-object-identifier "1.2.840.10045.1.2.3.1"))
(asn.1-sequence-add param (make-der-null)))
((and (zero? k2) (zero? k3))
(asn.1-sequence-add param
(make-der-object-identifier "1.2.840.10045.1.2.3.2"))
(asn.1-sequence-add param (make-der-integer k1)))
(else
(asn.1-sequence-add param
(make-der-object-identifier "1.2.840.10045.1.2.3.3"))
(asn.1-sequence-add param
(make-der-sequence
(make-der-integer k1)
(make-der-integer k2)
(make-der-integer k3)))))
base)))
(make-der-sequence
(make-der-integer 1)
(make-asn.1-field field)
(make-asn.1-curve curve)
(make-der-octet-string (encode-ec-point curve (ec-parameter-g ep)))
(make-der-integer (ec-parameter-n ep))
(make-der-integer (ec-parameter-h ep))))
(define-method import-public-key ((marker (eql ECDSA)) (in <asn.1-sequence>))
(let ((objs (slot-ref in 'sequence)))
(unless (= (length objs) 2)
(assertion-violation 'import-private-key "invalid sequence size" in))
(unless (and (is-a? (car objs) <asn.1-sequence>)
(is-a? (cadr objs) <der-bit-string>))
(assertion-violation who "bad component" in))
(let* ((aid (car objs))
(spk (cadr objs))
(ec-param (cadr (slot-ref aid 'sequence)))
(p (if (is-a? ec-param <der-object-identifier>)
(lookup-named-curve-parameter ec-param)
(->ec-parameter ec-param)))
(Q (decode-ec-point (ec-parameter-curve p) (slot-ref spk 'data))))
(make <ecdsa-public-key> :Q Q :parameter p))))
#|
ECParameters ::= CHOICE {
namedCurve OBJECT IDENTIFIER
-- implicitCurve NULL
-- specifiedCurve SpecifiedECDomain
}
|#
#|
ECPrivateKey ::= SEQUENCE {
version INTEGER { ecPrivkeyVer1(1) } (ecPrivkeyVer1),
privateKey OCTET STRING,
parameters [0] ECParameters {{ NamedCurve }} OPTIONAL,
publicKey [1] BIT STRING OPTIONAL
}
|#
(define-method export-private-key ((m (eql ECDSA)) (key <ecdsa-private-key>))
(define param (slot-ref key 'parameter))
(define curve (and param (ec-parameter-curve param)))
(define oid (and param (ec-parameter-oid param)))
(define pub (slot-ref key 'public-key))
(asn.1-encode
(apply make-der-sequence
(make-der-integer 1)
(make-der-octet-string (integer->bytevector (slot-ref key 'd)))
(filter values
(list
(and param
(make-der-tagged-object #t 0
(if oid
(make-der-object-identifier oid)
(ec-parameter->asn.1-object param))))
(and pub (slot-ref pub 'parameter)
(make-der-tagged-object #t 1
(make-der-bit-string
(encode-ec-point curve (slot-ref pub 'Q))))))))))
(define-method export-private-key ((key <ecdsa-private-key>))
(export-private-key ECDSA key))
(define-method import-private-key ((marker (eql ECDSA)) (in <bytevector>))
(import-private-key ECDSA (open-bytevector-input-port in)))
(define-method import-private-key ((marker (eql ECDSA)) (in <port>))
(import-private-key ECDSA (read-asn.1-object in)))
(define (find-tag objs n)
(exists (lambda (obj)
(and (is-a? obj <asn.1-tagged-object>)
(= (slot-ref obj 'tag-no) n)
(slot-ref obj 'obj))) objs))
(define-method import-private-key ((marker (eql ECDSA)) (in <asn.1-sequence>))
(let ((objs (slot-ref in 'sequence)))
(when (< (length objs) 2)
(assertion-violation 'import-private-key "invalid sequence size" in))
(unless (= 1 (der-integer->integer (car objs)))
(assertion-violation 'import-private-key "invalid version"))
(let ((tag0 (find-tag (cddr objs) 0)))
(if tag0
(import-private-key ECDSA in tag0)
(assertion-violation 'import-private-key
"ECParameter is not found")))))
;; for PKCS#8 format
(define-method import-private-key ((marker (eql ECDSA))
(in <asn.1-sequence>)
(param <asn.1-encodable>))
(let ((objs (slot-ref in 'sequence)))
(when (< (length objs) 2)
(assertion-violation 'import-private-key "invalid sequence size" in))
(unless (= 1 (der-integer->integer (car objs)))
(assertion-violation 'import-private-key "invalid version"))
(let ((param (if (is-a? param <der-object-identifier>)
(lookup-named-curve-parameter param)
(->ec-parameter param))))
(make <ecdsa-private-key>
:d (bytevector->uinteger (der-octet-string-octets (cadr objs)))
:parameter param
:public-key (and-let* ((p (find-tag (cddr objs) 1)))
(make <ecdsa-public-key>
:Q (decode-ec-point (ec-parameter-curve param)
(slot-ref p 'data))
:parameter param))))))
)
| false |
cf5d8acfec115c7032638382b7b9e589a8bfd397 | f40f97c37847103138c82d3f1b3956d9c2592b76 | /mvp/test-scp.scm | f1554e2f325d7ac8c3ec1709ddc88a85bc4210aa | [
"MIT"
]
| permissive | k-tsushima/Shin-Barliman | 34df6868aafcd2d36dbbc57ef56eab555da05a5c | abea8511d18273196ac806dcf14b88d4098e18f8 | refs/heads/master | 2021-06-25T13:47:22.721816 | 2020-01-24T04:11:24 | 2020-01-24T04:11:24 | 182,607,716 | 16 | 1 | MIT | 2020-12-02T00:12:39 | 2019-04-22T02:18:17 | Scheme | UTF-8 | Scheme | false | false | 2,418 | scm | test-scp.scm | (set! *task-queue* (let ((definitions '((define append
(lambda (l s)
(if (null? l)
,A
(cons ,B ,C))))))
(inputs '((append '() '())
(append '(,g1) '(,g2))
(append '(,g3) '(,g4))
(append '(,g5 ,g6) '(,g7 ,g8))))
(outputs '(()
(,g1 ,g2)
(,g3 ,g4)
(,g5 ,g6 ,g7 ,g8)))
(synthesis-id 1))
`((,definitions ,inputs ,outputs ,synthesis-id) . ())))
(set! *task-queue* (let ((definitions '((define append
(lambda (k s)
(if (null? k)
s
(cons (car k) (append (cdr k) s)))))))
(inputs '((append '() '())
(append '(,g1) '(,g2))
(append '(,g3) '(,g4))
(append '(,g5 ,g6) '(,g7 ,g8))))
(outputs '(()
(,g1 ,g2)
(,g3 ,g4)
(,g5 ,g6 ,g7 ,g8)))
(synthesis-id 1))
`((,definitions ,inputs ,outputs ,synthesis-id) . ,*task-queue*)))
(start-synthesis-with-free-subprocesses)
#!eof
; checked working with "tmp-mcp-client.rkt"
send hello message to MCP from client
(stop-all-subprocess) ; stopped (= quitted) all subprocesses (looking ./top)
(send-number-of-subprocess-to-mcp) ; message sent to MCP.
(start-synthesis-with-free-subprocesses) ; synthesis started & after using (check-for-synthesis-subprocess-messages) two times, the results sent to MCP.
(stop-one-task 59857) ; the number should be one of working number. stopped (= removed) the subprocess (looking ./top)
; todo
- (synthesis-subprocess-ready) ; what should we do for this?
- (status ,stat) ; what should we do for this?
- loop part ; there is a tentative definition after #!eof in scp.scm
| false |
53120df12cc0b98ce9340243b56d0745acee7c6e | 5355071004ad420028a218457c14cb8f7aa52fe4 | /5.4/e-5.26.scm | 8f31e6dfc01392b4e860d9934fc15eb3804fdfa6 | []
| no_license | ivanjovanovic/sicp | edc8f114f9269a13298a76a544219d0188e3ad43 | 2694f5666c6a47300dadece631a9a21e6bc57496 | refs/heads/master | 2022-02-13T22:38:38.595205 | 2022-02-11T22:11:18 | 2022-02-11T22:11:18 | 2,471,121 | 376 | 90 | null | 2022-02-11T22:11:19 | 2011-09-27T22:11:25 | Scheme | UTF-8 | Scheme | false | false | 1,520 | scm | e-5.26.scm | ; Exercise 5.26. Use the monitored stack to explore the tail-recursive
; property of the evaluator (section 5.4.2). Start the evaluator and define the
; iterative factorial procedure from section 1.2.1:
(define (factorial n)
(define (iter product counter)
(if (> counter n)
product
(iter (* counter product)
(+ counter 1))))
(iter 1 1))
; Run the procedure with some small values of n. Record the maximum stack depth
; and the number of pushes required to compute n! for each of these values.
; a. You will find that the maximum depth required to evaluate n! is
; independent of n. What is that depth?
; b. Determine from your data a formula in terms of n for the total number of
; push operations used in evaluating n! for any n > 1. Note that the number of
; operations used is a linear function of n and is thus determined by two
; constants.
; ------------------------------------------------------------
; a) The depth is indeed independent from n because it is not really doing the
; recursive calls but is just doing the iteration with same stack depth.
; n | depth | pushes
; ----------------------
; 1 | 10 | 64
; 2 | 10 | 99
; 3 | 10 | 134
; 4 | 10 | 169
; 10 | 10 | 379
; b) This is strange, since I am using for the REPL the code authors provided and it is somewhere around 40*n + c
; but it is not linear in fact but I guess it should be. Anyway order of growth is O(n) which is important to figure out.
| false |
b08f6f4aee5ef8f2da102e50da6e2e79799a63b4 | 6b961ef37ff7018c8449d3fa05c04ffbda56582b | /bbn_cl/mach/sf/toplev.scm | 7c3c2b0a8d6ff51b9be666b3adf7934f0062912c | []
| no_license | tinysun212/bbn_cl | 7589c5ac901fbec1b8a13f2bd60510b4b8a20263 | 89d88095fc2a71254e04e57cf499ae86abf98898 | refs/heads/master | 2021-01-10T02:35:18.357279 | 2015-05-26T02:44:00 | 2015-05-26T02:44:00 | 36,267,589 | 4 | 3 | null | null | null | null | UTF-8 | Scheme | false | false | 14,059 | scm | toplev.scm | ;;; ********
;;;
;;; Copyright 1992 by BBN Systems and Technologies, A division of Bolt,
;;; Beranek and Newman Inc.
;;;
;;; Permission to use, copy, modify and distribute this software and its
;;; documentation is hereby granted without fee, provided that the above
;;; copyright notice and this permission appear in all copies and in
;;; supporting documentation, and that the name Bolt, Beranek and Newman
;;; Inc. not be used in advertising or publicity pertaining to distribution
;;; of the software without specific, written prior permission. In
;;; addition, BBN makes no respresentation about the suitability of this
;;; software for any purposes. It is provided "AS IS" without express or
;;; implied warranties including (but not limited to) all implied warranties
;;; of merchantability and fitness. In no event shall BBN be liable for any
;;; special, indirect or consequential damages whatsoever resulting from
;;; loss of use, data or profits, whether in an action of contract,
;;; negligence or other tortuous action, arising out of or in connection
;;; with the use or performance of this software.
;;;
;;; ********
;;;
;;;#| -*-Scheme-*-
Copyright (c) 1988 Massachusetts Institute of Technology
This material was developed by the Scheme project at the Massachusetts
Institute of Technology, Department of Electrical Engineering and
Computer Science. Permission to copy this software, to redistribute
it, and to use it for any purpose is granted, subject to the following
restrictions and understandings.
1. Any copy made of this software must include this copyright notice
in full.
2. Users of this software agree to make their best efforts (a) to
return to the MIT Scheme project any improvements or extensions that
they make, so that these may be included in future releases; and (b)
to inform MIT of noteworthy uses of this software.
3. All materials developed as a consequence of the use of this
software shall duly acknowledge such use, in accordance with the usual
standards of acknowledging credit in academic research.
4. MIT has made no warrantee or representation that the operation of
this software will be error-free, and MIT is under no obligation to
provide any services, by way of maintenance, update, or otherwise.
5. In conjunction with products arising from the use of this material,
there shall be no use of the name of the Massachusetts Institute of
Technology nor of any adaptation thereof in any advertising,
promotional, or sales literature without prior written consent from
MIT in each case. |#
;;;; SCode Optimizer: Top Level
(declare (usual-integrations))
;;;; User Interface
(define (integrate/procedure procedure declarations)
(if (compound-procedure? procedure)
(procedure-components procedure
(lambda (*lambda environment)
(scode-eval (integrate/scode *lambda declarations false)
environment)))
(error "INTEGRATE/PROCEDURE: Not a compound procedure" procedure)))
(define (integrate/sexp s-expression syntax-table declarations receiver)
(integrate/simple (lambda (s-expressions)
(phase:syntax s-expressions syntax-table))
(list s-expression) declarations receiver))
(define (integrate/scode scode declarations receiver)
(integrate/simple identity-procedure scode declarations receiver))
(in-package system-global-environment
(define *eval-when-mode* 'evaling))
(define (sf input-string #!optional bin-string spec-string)
(if (unassigned? bin-string) (set! bin-string false))
(if (unassigned? spec-string) (set! spec-string false))
(fluid-let ((*eval-when-mode* 'compiling)
(*package* *package*)
(*syntax-time-env* (push-contour *syntax-time-env*)))
(fluid-let ((*syntax-time-global-env* *syntax-time-env*))
(let ((old-mode (touch-mode)))
(dynamic-wind
(lambda () #f)
(lambda ()
(syntax-file input-string bin-string spec-string))
(lambda ()
(syntaxer-proclaim! (list 'insert-touches old-mode))))))))
(define (scold input-string #!optional bin-string spec-string)
"Use this only for syntaxing the cold-load root file.
Currently only the 68000 implementation needs this."
(if (unassigned? bin-string) (set! bin-string false))
(if (unassigned? spec-string) (set! spec-string false))
(fluid-let ((wrapping-hook wrap-with-control-point))
(syntax-file input-string bin-string spec-string)))
(define (sf/set-default-syntax-table! syntax-table)
(if (or (false? syntax-table)
(syntax-table? syntax-table))
(set! default-syntax-table syntax-table)
(error "Illegal syntax table" syntax-table)))
(define (sf/set-file-syntax-table! pathname syntax-table)
(pathname-map/insert! file-info/syntax-table
(pathname/normalize pathname)
syntax-table))
(define (sf/add-file-declarations! pathname declarations)
(let ((pathname (pathname/normalize pathname)))
(pathname-map/insert! file-info/declarations
pathname
(append! (file-info/get-declarations pathname)
(list-copy declarations)))))
(define (file-info/find pathname)
(let ((pathname (pathname/normalize pathname)))
(return-2 (pathname-map/lookup file-info/syntax-table
pathname
identity-procedure
(lambda () default-syntax-table))
(file-info/get-declarations pathname))))
(define (file-info/get-declarations pathname)
(pathname-map/lookup file-info/declarations
pathname
identity-procedure
(lambda () '())))
(define (pathname/normalize pathname)
(pathname-new-version
(merge-pathnames (pathname->absolute-pathname (->pathname pathname))
sf/default-input-pathname)
false))
(define file-info/syntax-table
(pathname-map/make))
(define default-syntax-table
false)
(define file-info/declarations
(pathname-map/make))
;;;; File Syntaxer
(define sf/default-input-pathname
(make-pathname false false false false "scm" 'NEWEST))
(define sf/default-externs-pathname
(make-pathname false false false false "ext" 'NEWEST))
(define sf/output-pathname-type "bin")
(define sf/unfasl-pathname-type "unf")
(define (syntax-file input-string bin-string spec-string)
(for-each
(lambda (pathname)
(let ((input-path (pathname->input-truename pathname)))
(if (not input-path)
(error "SF: File does not exist" pathname))
(let ((bin-path
((lambda (x) (and x (pathname->absolute-pathname x)))
(let ((bin-path
(pathname-new-type input-path
sf/output-pathname-type)))
(if bin-string
(merge-pathnames-no-dir-append (->pathname bin-string) bin-path)
bin-path)))))
(let ((spec-path
((lambda (x) (and x (pathname->absolute-pathname x)))
(and (or spec-string sfu?)
(let ((spec-path
(pathname-new-type bin-path
sf/unfasl-pathname-type)))
(if spec-string
(merge-pathnames-no-dir-append (->pathname spec-string)
spec-path)
spec-path))))))
(syntax-file* input-path bin-path spec-path)))))
(stickify-input-filenames input-string sf/default-input-pathname)))
(define (syntax-file* input-pathname bin-pathname spec-pathname)
(let ((start-date (date))
(start-time (time))
(input-filename (pathname->string input-pathname))
(bin-filename (pathname->string bin-pathname))
(spec-filename (and spec-pathname (pathname->string spec-pathname))))
(newline)
(write-string "Syntax file: ")
(write input-filename)
(write-string " ")
(write bin-filename)
(write-string " ")
(write spec-filename)
(transmit-values
(transmit-values (file-info/find input-pathname)
(lambda (syntax-table declarations)
(integrate/file input-pathname syntax-table declarations
spec-pathname)))
(lambda (expression externs events)
(let ((expression-list (separate-expression expression)))
(call-with-fasl-output-file bin-pathname
(lambda (fd)
(fasdump-fd
(wrapping-hook
(make-comment `((SOURCE-FILE . ,input-filename)
(DATE . ,start-date)
(TIME . ,start-time)
(FLUID-LET . ,*fluid-let-type*))
(car expression-list)))
fd)
(let loop ((exprs (cdr expression-list)))
(if exprs
(begin
(fasdump-fd (car exprs) fd)
(loop (cdr exprs))))))))
(write-externs-file (pathname-new-type
bin-pathname
(pathname-type sf/default-externs-pathname))
(set! externs false))
(if spec-pathname
(begin (newline)
(write-string "Writing ")
(write spec-filename)
(with-output-to-file spec-pathname
(lambda ()
(newline)
(write `(DATE ,start-date ,start-time))
(newline)
(write `(FLUID-LET ,*fluid-let-type*))
(newline)
(write `(SOURCE-FILE ,input-filename))
(newline)
(write `(BINARY-FILE ,bin-filename))
(for-each (lambda (event)
(newline)
(write `(,(car event)
(RUNTIME ,(cdr event)))))
events)))
(write-string " -- done")))))))
(define (separate-expression expression)
(if (not (scode-sequence? expression))
(list expression)
(let ((l (trim-leading-splits (sequence-actions expression))))
(cond
((null? l)
(error "No valid forms in sequence"))
((null? (cdr l))
(make-sequence (car l))) ; only one expr
(else
(let loop ((current l)
(orig l)
(prev '()))
(cond
((null? orig)
'())
((null? current)
(list (make-sequence orig)))
((file-split-marker? (car current))
(let ((remainder (trim-leading-splits (cdr current))))
(set-cdr! prev '())
(cons (make-sequence orig)
(loop remainder remainder '()))))
(else (loop (cdr current) orig current)))))))))
(define (trim-leading-splits l)
(cond
((null? l)
'())
((file-split-marker? (car l))
(trim-leading-splits (cdr l)))
(else l)))
(define (file-split-marker? expr)
(and (symbol? expr)
(string=? (symbol->string expr) "$SPLIT-FILE")))
(define scode-combination? (access combination? system-global-environment))
(define scode-variable? (access variable? system-global-environment))
(define (read-externs-file pathname)
(let ((pathname
(merge-pathnames (->pathname pathname) sf/default-externs-pathname)))
(if (file-exists? pathname)
(fasload pathname)
(begin (warn "Nonexistent externs file" (pathname->string pathname))
'()))))
(define (write-externs-file pathname externs)
(cond ((not (null? externs))
(fasdump externs pathname))
((file-exists? pathname)
(delete-file pathname))))
(define (print-spec identifier names)
(newline)
(newline)
(write-string "(")
(write identifier)
(let loop
((names
(sort names
(lambda (x y)
(string<? (symbol->string x)
(symbol->string y))))))
(if (not (null? names))
(begin (newline)
(write (car names))
(loop (cdr names)))))
(write-string ")"))
(define (wrapping-hook scode)
scode)
(define control-point-tail
`(3 ,(primitive-set-type (microcode-type 'NULL) (* 4 4))
() () () () () () () () () () () () () () ()))
(define (wrap-with-control-point scode)
(system-list-to-vector type-code-control-point
`(,return-address-restart-execution
,scode
,system-global-environment
,return-address-non-existent-continuation
,@control-point-tail)))
(define type-code-control-point
(microcode-type 'CONTROL-POINT))
(define return-address-restart-execution
(make-return-address (microcode-return 'RESTART-EXECUTION)))
(define return-address-non-existent-continuation
(make-return-address (microcode-return 'NON-EXISTENT-CONTINUATION)))
;;;; Optimizer Top Level
(define (integrate/file file-name syntax-table declarations compute-free?)
(integrate/kernel (lambda ()
(phase:syntax (phase:read file-name) syntax-table))
declarations))
(define (integrate/simple preprocessor input declarations receiver)
(transmit-values
(integrate/kernel (lambda () (preprocessor input)) declarations)
(or receiver
(lambda (expression externs events)
expression))))
(define (integrate/kernel get-scode declarations)
(fluid-let ((previous-time false)
(previous-name false)
(events '()))
(transmit-values
(transmit-values
(transmit-values
(phase:transform (canonicalize-scode (get-scode) declarations))
phase:optimize)
phase:generate-scode)
(lambda (externs expression)
(end-phase)
(return-3 expression externs (reverse! events))))))
(define (canonicalize-scode scode declarations)
(let ((declarations
((access process-declarations syntaxer-package) declarations)))
(if (null? declarations)
scode
(scan-defines (make-sequence
(list (make-block-declaration declarations)
scode))
make-open-block))))
(define (phase:read filename)
(mark-phase "Read")
(*read-file* filename))
(define (phase:syntax s-expression #!optional syntax-table)
(if (or (unassigned? syntax-table) (not syntax-table))
(set! syntax-table (*get-default-syntax-table*)))
(mark-phase "Syntax")
(syntax* s-expression syntax-table))
(define (phase:transform scode)
(mark-phase "Transform")
(transform/expression scode))
(define (phase:optimize block expression)
(mark-phase "Optimize")
(integrate/expression block expression))
(define (phase:generate-scode operations environment expression)
(mark-phase "Generate SCode")
(return-2 (operations->external operations environment)
(cgen/expression expression)))
(define previous-time)
(define previous-name)
(define events)
(define (mark-phase this-name)
(end-phase)
(newline)
(write-string " ")
(write-string this-name)
(write-string "...")
(set! previous-name this-name))
(define (end-phase)
(let ((this-time (runtime)))
(if previous-time
(let ((dt (- this-time previous-time)))
(set! events (cons (cons previous-name dt) events))
(newline)
(write-string " Time: ")
(write dt)
(write-string " seconds.")))
(set! previous-time this-time)))
| false |
a704e7f1452f180947bbfed32e12024a7337d988 | 9b2eb10c34176f47f7f490a4ce8412b7dd42cce7 | /lib-runtime/selfboot/common/library-parser.scm | f5f0560205588ff092f3c7a78bbe085d4a4c279e | [
"LicenseRef-scancode-public-domain",
"CC0-1.0"
]
| permissive | okuoku/yuni | 8be584a574c0597375f023c70b17a5a689fd6918 | 1859077a3c855f3a3912a71a5283e08488e76661 | refs/heads/master | 2023-07-21T11:30:14.824239 | 2023-06-11T13:16:01 | 2023-07-18T16:25:22 | 17,772,480 | 36 | 6 | CC0-1.0 | 2020-03-29T08:16:00 | 2014-03-15T09:53:13 | Scheme | UTF-8 | Scheme | false | false | 245 | scm | library-parser.scm | (define (%selfboot-library-name sexp)
(cadr sexp))
(define (%selfboot-library-depends sexp)
(cdr (cadddr sexp)))
(define (%selfboot-library-exports sexp)
(cdr (caddr sexp)))
(define (%selfboot-program-depends sexp)
(cdr (car sexp)))
| false |
b1da16cbacf4b948ec6caace174cbd62d07bbdbf | 5c09aa4834adfc51ad966f99422f6db5bf70ed3d | /tests/run.scm | 18e8774d14f4965a348d4ad1628f207dc36c90d3 | []
| no_license | kdltr/poussin | c32e97473342fa30c618c590700a3d290cbfcb04 | 55d326484646f4cae5d6d80f7896816eabb4f17f | refs/heads/master | 2021-01-01T01:39:06.935560 | 2020-08-16T00:18:56 | 2020-08-16T00:18:56 | 239,125,353 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,352 | scm | run.scm | (import (chicken load) (chicken port) srfi-1 test utf8)
(load-relative "../poussin-chicken.scm")
(import poussin)
#;
(test-group "cyclic lists"
(load-relative "cycle.scm"))
(test-group "reader and writer"
(load-relative "reader-writer.scm"))
(test-group "parameter matching"
(test "matching ignore" '() (match-formal-parameter-tree +ignore+ 42 '()))
(test "matching symbol" '((a . 42)) (match-formal-parameter-tree 'a 42 '()))
(test "matching nil" '() (match-formal-parameter-tree '() '() '()))
(test-error "nil matching error" (match-formal-parameter-tree '() 42 '()))
(test "matching pair" '((a . 42) (b . 21)) (match-formal-parameter-tree '(a . b) '(42 . 21) '()))
(test "matching list" '((a . 42) (b . 21)) (match-formal-parameter-tree '(a b) '(42 21) '()))
(test-error "duplicate symbol error" (match-formal-parameter '(a (a b)) '(1 (2 3)) '()))
) ; parameter matching group
(test-group "eval"
(define empty-environment (make-environment))
(test "evaluating number" 42 (kernel-eval 42 empty-environment))
(test "evaluating strings" "foo" (kernel-eval "foo" empty-environment))
(test "evaluating #t" #t (kernel-eval #t empty-environment))
(test "evaluating #f" #f (kernel-eval #f empty-environment))
(define simple-environment (make-environment))
(add-bindings! simple-environment '((foo . 42)
(a . 1)
(b . 2)
(c . 3)))
(define simple-child-environment (make-environment simple-environment))
(define multi-parent-environment
(make-environment empty-environment simple-child-environment))
(test "evaluating bound symbol" 42 (kernel-eval 'foo simple-environment))
(test-error "evaluating unbound symbol" (kernel-eval 'bar simple-environment))
(test "evaluating bound symbol in parent environment" 42 (kernel-eval 'foo simple-child-environment))
(test "evaluating bould symbol deep in ancestors" 42 (kernel-eval 'foo multi-parent-environment))
(define k$vau (lookup '$vau core-environment))
(define kwrap (lookup 'wrap core-environment))
(define simple-operative (kernel-eval (list k$vau 'x 'e 'x) empty-environment))
(define simple-applicative (wrap simple-operative))
(define combiner-environment (make-environment simple-environment))
(add-bindings! combiner-environment (list (cons '$list simple-operative)
(cons 'list simple-applicative)))
(test "evaluating simple operative" '(a b c) (kernel-eval '($list a b c) combiner-environment))
(test "evaluating simple applicative" '(1 2 3) (kernel-eval '(list a b c) combiner-environment))
(test-group "primitive combiners"
(define primitive-environment (make-environment combiner-environment))
(add-bindings! primitive-environment (list (cons '$vau k$vau)
(cons 'wrap kwrap)))
(test "primitive wrap call" '(1 2 3) (kernel-eval '((wrap $list) a b c) primitive-environment))
(test "primitive $vau call" '(b a) (kernel-eval `(($vau (x y) ,+ignore+ (list y x)) a b) primitive-environment))
) ; primitive combiners group
) ; eval group
(test-group "regressions"
(test-assert "$define twice" (begin
(kernel-eval '($define! foo 42) core-environment)
(kernel-eval '($define! foo 42) core-environment)))
)
(test-exit)
| false |
244b36606732a97d057d15e05b698b6bbf9c4b10 | 8f1401b60f1a0b73577a80129ec7fe7027a27eba | /src/monads/maybe.scm | cb9e241922c8375e9ae17e05d7ca890194a6396d | [
"Apache-2.0"
]
| permissive | bluelight1324/geometric-algebra | 347409d5ef023ab1109b4d6079ef1e73721ebc0b | fdc9332a4f5e2dd526c55bbaa57fd043d78f40d1 | refs/heads/main | 2023-04-18T08:41:57.832044 | 2021-05-05T20:08:21 | 2021-05-05T20:08:21 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 490 | scm | maybe.scm | ; ~\~ language=Scheme filename=monads/maybe.scm
; ~\~ begin <<stdlib.md|monads/maybe.scm>>[0]
(library (monads maybe)
(export nothing? *nothing* maybe-bind maybe-return <maybe>)
(import (rnrs (6))
(monads syntax))
(define-record-type nothing)
(define *nothing* (make-nothing))
(define (maybe-bind value f)
(if (nothing? value)
value
(f value)))
(define maybe-return values)
(define <maybe> (make-monad maybe-bind maybe-return))
)
; ~\~ end
| false |
e5510fac1dcd28c4b1635a132d1ddb1063ebe49e | 5355071004ad420028a218457c14cb8f7aa52fe4 | /3.1/e-3.4.scm | 7fa69b8432c15d7f5002fd436c5a9fd993ea1f00 | []
| no_license | ivanjovanovic/sicp | edc8f114f9269a13298a76a544219d0188e3ad43 | 2694f5666c6a47300dadece631a9a21e6bc57496 | refs/heads/master | 2022-02-13T22:38:38.595205 | 2022-02-11T22:11:18 | 2022-02-11T22:11:18 | 2,471,121 | 376 | 90 | null | 2022-02-11T22:11:19 | 2011-09-27T22:11:25 | Scheme | UTF-8 | Scheme | false | false | 1,563 | scm | e-3.4.scm | ; Exercise 3.4. Modify the make-account procedure of exercise 3.3 by
; adding another local state variable so that, if an account is accessed
; more than seven consecutive times with an incorrect password, it
; invokes the procedure call-the-cops.
; ------------------------------------------------------------
(load "../helpers.scm")
(define (make-account balance account-password)
(define (withdraw amount)
(if (>= balance amount)
(begin (set! balance (- balance amount))
balance)
"Insufficient funds"))
(define (deposit amount)
(set! balance (+ balance amount))
balance)
; action dispatcher, protected by password
(let ((attempts 0))
(lambda (password m)
(if (eq? password account-password)
(cond ((eq? m 'withdraw) withdraw)
((eq? m 'deposit) deposit)
(else (error "Unknown request -- MAKE-ACCOUNT" m)))
; just return complaint, but has to accept argument
(lambda (n)
(set! attempts (+ attempts 1))
(if (>= attempts 7)
"Lizard detected. Calling cops"
"Incorrect password"))))))
(define acc (make-account 100 'wizards!lizards))
(output ((acc 'wizards!lizards 'withdraw) 40))
(output ((acc 'lizards!wizards 'withdraw) 40))
(output ((acc 'lizards!wizards 'withdraw) 40))
(output ((acc 'lizards!wizards 'withdraw) 40))
(output ((acc 'lizards!wizards 'withdraw) 40))
(output ((acc 'lizards!wizards 'withdraw) 40))
(output ((acc 'lizards!wizards 'withdraw) 40))
(output ((acc 'lizards!wizards 'withdraw) 40))
| false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.