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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
b465d6a35efe3967159999e0e72965cfd71f884c | 43612e5ed60c14068da312fd9d7081c1b2b7220d | /tools/benchtimes/resultVMIL-lc-gsc-lc/LC5/perm9.scm.scm | 6f3666182431108f2d99dae73a4647e76f73fd74 | [
"BSD-3-Clause"
]
| permissive | bsaleil/lc | b1794065183b8f5fca018d3ece2dffabda6dd9a8 | ee7867fd2bdbbe88924300e10b14ea717ee6434b | refs/heads/master | 2021-03-19T09:44:18.905063 | 2019-05-11T01:36:38 | 2019-05-11T01:36:38 | 41,703,251 | 27 | 1 | BSD-3-Clause | 2018-08-29T19:13:33 | 2015-08-31T22:13:05 | Scheme | UTF-8 | Scheme | false | false | 9,456 | scm | perm9.scm.scm | ;;------------------------------------------------------------------------------
;; Macros
(##define-macro (def-macro form . body)
`(##define-macro ,form (let () ,@body)))
(def-macro (FLOATvector-const . lst) `',(list->vector lst))
(def-macro (FLOATvector? x) `(vector? ,x))
(def-macro (FLOATvector . lst) `(vector ,@lst))
(def-macro (FLOATmake-vector n . init) `(make-vector ,n ,@init))
(def-macro (FLOATvector-ref v i) `(vector-ref ,v ,i))
(def-macro (FLOATvector-set! v i x) `(vector-set! ,v ,i ,x))
(def-macro (FLOATvector-length v) `(vector-length ,v))
(def-macro (nuc-const . lst)
`',(list->vector lst))
(def-macro (FLOAT+ . lst) `(+ ,@lst))
(def-macro (FLOAT- . lst) `(- ,@lst))
(def-macro (FLOAT* . lst) `(* ,@lst))
(def-macro (FLOAT/ . lst) `(/ ,@lst))
(def-macro (FLOAT= . lst) `(= ,@lst))
(def-macro (FLOAT< . lst) `(< ,@lst))
(def-macro (FLOAT<= . lst) `(<= ,@lst))
(def-macro (FLOAT> . lst) `(> ,@lst))
(def-macro (FLOAT>= . lst) `(>= ,@lst))
(def-macro (FLOATnegative? . lst) `(negative? ,@lst))
(def-macro (FLOATpositive? . lst) `(positive? ,@lst))
(def-macro (FLOATzero? . lst) `(zero? ,@lst))
(def-macro (FLOATabs . lst) `(abs ,@lst))
(def-macro (FLOATsin . lst) `(sin ,@lst))
(def-macro (FLOATcos . lst) `(cos ,@lst))
(def-macro (FLOATatan . lst) `(atan ,@lst))
(def-macro (FLOATsqrt . lst) `(sqrt ,@lst))
(def-macro (FLOATmin . lst) `(min ,@lst))
(def-macro (FLOATmax . lst) `(max ,@lst))
(def-macro (FLOATround . lst) `(round ,@lst))
(def-macro (FLOATinexact->exact . lst) `(inexact->exact ,@lst))
(def-macro (GENERIC+ . lst) `(+ ,@lst))
(def-macro (GENERIC- . lst) `(- ,@lst))
(def-macro (GENERIC* . lst) `(* ,@lst))
(def-macro (GENERIC/ . lst) `(/ ,@lst))
(def-macro (GENERICquotient . lst) `(quotient ,@lst))
(def-macro (GENERICremainder . lst) `(remainder ,@lst))
(def-macro (GENERICmodulo . lst) `(modulo ,@lst))
(def-macro (GENERIC= . lst) `(= ,@lst))
(def-macro (GENERIC< . lst) `(< ,@lst))
(def-macro (GENERIC<= . lst) `(<= ,@lst))
(def-macro (GENERIC> . lst) `(> ,@lst))
(def-macro (GENERIC>= . lst) `(>= ,@lst))
(def-macro (GENERICexpt . lst) `(expt ,@lst))
;;------------------------------------------------------------------------------
;; Functions used by LC to get time info
(def-macro (##lc-time expr)
(let ((sym (gensym)))
`(let ((r (##lc-exec-stats (lambda () ,expr))))
(##print-perm-string "CPU time: ")
(##print-double (+ (cdr (assoc "User time" (cdr r)))
(cdr (assoc "Sys time" (cdr r)))))
(##print-perm-string "\n")
(##print-perm-string "GC CPU time: ")
(##print-double (+ (cdr (assoc "GC user time" (cdr r)))
(cdr (assoc "GC sys time" (cdr r)))))
(##print-perm-string "\n")
(map (lambda (el)
(##print-perm-string (car el))
(##print-perm-string ": ")
(##print-double (cdr el))
(##print-perm-string "\n"))
(cdr r))
r)))
(define (##lc-exec-stats thunk)
(let* ((at-start (##process-statistics))
(result (thunk))
(at-end (##process-statistics)))
(define (get-info msg idx)
(cons msg
(- (f64vector-ref at-end idx)
(f64vector-ref at-start idx))))
(list
result
(get-info "User time" 0)
(get-info "Sys time" 1)
(get-info "Real time" 2)
(get-info "GC user time" 3)
(get-info "GC sys time" 4)
(get-info "GC real time" 5)
(get-info "Nb gcs" 6))))
;;------------------------------------------------------------------------------
(define (run-bench name count ok? run)
(let loop ((i count) (result '(undefined)))
(if (< 0 i)
(loop (- i 1) (run))
result)))
(define (run-benchmark name count ok? run-maker . args)
(let ((run (apply run-maker args)))
(let ((result (car (##lc-time (run-bench name count ok? run)))))
(if (not (ok? result))
(begin
(display "*** wrong result ***")
(newline)
(display "*** got: ")
(write result)
(newline))))))
; Gabriel benchmarks
(define boyer-iters 20)
(define browse-iters 600)
(define cpstak-iters 1000)
(define ctak-iters 100)
(define dderiv-iters 2000000)
(define deriv-iters 2000000)
(define destruc-iters 500)
(define diviter-iters 1000000)
(define divrec-iters 1000000)
(define puzzle-iters 100)
(define tak-iters 2000)
(define takl-iters 300)
(define trav1-iters 100)
(define trav2-iters 20)
(define triangl-iters 10)
; Kernighan and Van Wyk benchmarks
(define ack-iters 10)
(define array1-iters 1)
(define cat-iters 1)
(define string-iters 10)
(define sum1-iters 10)
(define sumloop-iters 10)
(define tail-iters 1)
(define wc-iters 1)
; C benchmarks
(define fft-iters 2000)
(define fib-iters 5)
(define fibfp-iters 2)
(define mbrot-iters 100)
(define nucleic-iters 5)
(define pnpoly-iters 100000)
(define sum-iters 20000)
(define sumfp-iters 20000)
(define tfib-iters 20)
; Other benchmarks
(define conform-iters 40)
(define dynamic-iters 20)
(define earley-iters 200)
(define fibc-iters 500)
(define graphs-iters 300)
(define lattice-iters 1)
(define matrix-iters 400)
(define maze-iters 4000)
(define mazefun-iters 1000)
(define nqueens-iters 2000)
(define paraffins-iters 1000)
(define peval-iters 200)
(define pi-iters 2)
(define primes-iters 100000)
(define ray-iters 5)
(define scheme-iters 20000)
(define simplex-iters 100000)
(define slatex-iters 20)
(define perm9-iters 10)
(define nboyer-iters 100)
(define sboyer-iters 100)
(define gcbench-iters 1)
(define compiler-iters 300)
(define nbody-iters 1)
(define fftrad4-iters 4)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; File: perm9.sch
; Description: memory system benchmark using Zaks's permutation generator
; Author: Lars Hansen, Will Clinger, and Gene Luks
; Created: 18-Mar-94
; Language: Scheme
; Status: Public Domain
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 940720 / lth Added some more benchmarks for the thesis paper.
; 970215 / wdc Increased problem size from 8 to 9; improved tenperm9-benchmark.
; 970531 / wdc Cleaned up for public release.
; 981116 / wdc Simplified to fit in with Feeley's benchmark suite.
; The perm9 benchmark generates a list of all 362880 permutations of
; the first 9 integers, allocating 1349288 pairs (typically 10,794,304
; bytes), all of which goes into the generated list. (That is, the
; perm9 benchmark generates absolutely no garbage.) This represents
; a savings of about 63% over the storage that would be required by
; an unshared list of permutations. The generated permutations are
; in order of a grey code that bears no obvious relationship to a
; lexicographic order.
;
; The 10perm9 benchmark repeats the perm9 benchmark 10 times, so it
; allocates and reclaims 13492880 pairs (typically 107,943,040 bytes).
; The live storage peaks at twice the storage that is allocated by the
; perm9 benchmark. At the end of each iteration, the oldest half of
; the live storage becomes garbage. Object lifetimes are distributed
; uniformly between 10.3 and 20.6 megabytes.
; Date: Thu, 17 Mar 94 19:43:32 -0800
; From: [email protected]
; To: will
; Subject: Pancake flips
;
; Procedure P_n generates a grey code of all perms of n elements
; on top of stack ending with reversal of starting sequence
;
; F_n is flip of top n elements.
;
;
; procedure P_n
;
; if n>1 then
; begin
; repeat P_{n-1},F_n n-1 times;
; P_{n-1}
; end
;
(define (permutations x)
(let ((x x)
(perms (list x)))
(define (P n)
(if (> n 1)
(do ((j (- n 1) (- j 1)))
((zero? j)
(P (- n 1)))
(P (- n 1))
(F n))))
(define (F n)
(set! x (revloop x n (list-tail x n)))
(set! perms (cons x perms)))
(define (revloop x n y)
(if (zero? n)
y
(revloop (cdr x)
(- n 1)
(cons (car x) y))))
(define (list-tail x n)
(if (zero? n)
x
(list-tail (cdr x) (- n 1))))
(P (length x))
perms))
; Given a list of lists of numbers, returns the sum of the sums
; of those lists.
;
; for (; x != NULL; x = x->rest)
; for (y = x->first; y != NULL; y = y->rest)
; sum = sum + y->first;
(define (sumlists x)
(do ((x x (cdr x))
(sum 0 (do ((y (car x) (cdr y))
(sum sum (+ sum (car y))))
((null? y) sum))))
((null? x) sum)))
(define (one..n n)
(do ((n n (- n 1))
(p '() (cons n p)))
((zero? n) p)))
(define (main . args)
(let ((n 9))
(define (factorial n)
(if (zero? n)
1
(* n (factorial (- n 1)))))
(run-benchmark
(string-append "perm" (number->string n))
perm9-iters
(lambda (result)
(= (sumlists result)
(* (quotient (* n (+ n 1)) 2) (factorial n))))
(lambda (lst)
(lambda ()
(permutations lst)))
(one..n n))))
(main)
| false |
a5dc62837f2a1f5dd2a684fb44f8784627e7b1cb | 47520277ce77f0ee17ee3ffab04a6f49a860daaa | /src/sxml.scm | 1825a8331f7c73a0ae2605780cd2bca3341a4356 | [
"MIT"
]
| permissive | niyarin/oreore-toy-webframework-scm | 8e209a910b0c5b2fc03ef2bd2d3533fb70f2cc90 | e4e08309de0520ea52bb101691e5f5d83f5f46bc | refs/heads/master | 2020-06-18T14:25:55.399167 | 2019-07-25T04:28:19 | 2019-07-25T04:28:19 | 196,332,084 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,007 | scm | sxml.scm | (define-library (niyarin sxml)
(import
(scheme base)
;(scheme list)
(srfi 1)
(scheme cxr)
)
(export sxml->xml-string)
(begin
(define (%attribute-list? sxml)
(and
(list? sxml)
(eq? (car sxml) '@)))
(define (%top? sxml)
(and
(list? sxml)
(eq? (car sxml) '*TOP*)))
(define (%PI? sxml)
(and
(list? sxml)
(eq? (car sxml) '*PI*)))
(define (%element? sxml)
(and
(list? sxml)
(pair? (cdr sxml))
(symbol? (car sxml))))
(define (sxml->xml-string sxml)
(let loop ((sxml sxml))
(cond
((string? sxml) sxml)
((%top? sxml)
(apply
string-append
(map loop (cdr sxml))))
((%PI? sxml)
(string-append
"<?"
(symbol->string (cadr sxml))
" "
(caddr sxml)
">"))
((and (%element? sxml) (eq? (car sxml) '*COMMENT*))
"")
((%element? sxml)
(let* ((have-attribute
(%attribute-list? (cadr sxml)))
(children (if have-attribute (cddr sxml) (cdr sxml)))
(attribute
(if have-attribute
(let loop ((attribute (cdadr sxml))
(res ""))
(if (null? attribute)
res
(loop
(cdr attribute)
(string-append
res
" "
(symbol->string (caar attribute))
"="
"\""
(if (null? (cdar attribute)) "" (cadar attribute))
"\""))))
"")))
(if (null? children)
(string-append
"<"
(symbol->string (car sxml))
attribute
"/>")
(string-append
"<"
(symbol->string (car sxml))
attribute
">"
(apply string-append (map loop (if have-attribute (cddr sxml) (cdr sxml))))
"</"
(symbol->string (car sxml))
">"
))))
(else
(error "ERROR:invalid sxml" sxml))
))
)
))
;(import (scheme base)(scheme write)(niyarin sxml))
;(display
; (sxml->xml-string '(html (body (div (@ (id "foo")) (*COMMENT* "piyoooo") "test")))))
;(newline)
| false |
21d05bfc9e86f55fd15dc245324d5cc2e9ded2a7 | bdcc255b5af12d070214fb288112c48bf343c7f6 | /slib-tests/determinant-test.sps | 5ff1449e508af56a52963e25e65b876692a51842 | []
| no_license | xaengceilbiths/chez-lib | 089af4ab1d7580ed86fc224af137f24d91d81fa4 | b7c825f18b9ada589ce52bf5b5c7c42ac7009872 | refs/heads/master | 2021-08-14T10:36:51.315630 | 2017-11-15T11:43:57 | 2017-11-15T11:43:57 | 109,713,952 | 5 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 1,194 | sps | determinant-test.sps | #!chezscheme
(import (except (scheme base) equal?)
(slib determinant)
(srfi 63)
(surfage s64 testing)
(robin srfi64-utils))
(test-begin "slib-determinant")
(test-equal '((1 2) (3 4)) (matrix->lists '((1 2) (3 4))))
(let ((arr (make-array #(1) 2 2)))
(array-set! arr 2 0 1)
(array-set! arr 3 1 0)
(array-set! arr 4 1 1)
(test-equal '((1 2) (3 4)) (matrix->lists arr))
(test-assert (equal? arr (matrix->array '((1 2) (3 4))))))
(test-equal -2 (determinant '((1 2) (3 4))))
(test-equal 0 (determinant '((1 2 3) (4 5 6) (7 8 9))))
(test-equal '((1 3) (2 4)) (transpose '((1 2) (3 4))))
(test-equal '((1 4 7) (2 5 8) (3 6 9)) (transpose '((1 2 3) (4 5 6) (7 8 9))))
(test-equal '((6 8) (10 12)) (matrix:sum '((1 2) (3 4)) '((5 6) (7 8))))
(test-equal '((-4 -4) (-4 -4)) (matrix:difference '((1 2) (3 4)) '((5 6) (7 8))))
(test-equal '((19 22) (43 50)) (matrix:product '((1 2) (3 4)) '((5 6) (7 8))))
(test-equal '((2 4) (6 8)) (matrix:product '((1 2) (3 4)) 2))
(test-equal '((2 4) (6 8)) (matrix:product 2 '((1 2) (3 4))))
(test-equal '((-2 1) (3/2 -1/2)) (matrix:inverse '((1 2) (3 4))))
(test-equal #f (matrix:inverse '((0 0) (0 0))))
(test-end)
| false |
088a1cfc70df80b295bf31351c86a55174ea7fbb | be32518c6f54b0ab1eaf33f53405ac1d2e1023c2 | /np/lang/macros/structure-nonterminals.sld | 76b401f6a8f788fdd2100c794483190ea73cbcff | [
"BSD-3-Clause",
"BSD-2-Clause"
]
| permissive | ilammy/np | 7990302bc30fe7802a7f4fc33d8fa7449ef8b011 | 0e3cbdea0eb2583f9b272d97bc408011af6a7947 | refs/heads/master | 2016-09-05T17:11:03.893011 | 2015-06-13T16:37:39 | 2015-06-13T16:37:39 | 23,740,287 | 1 | 0 | null | 2015-06-13T16:39:43 | 2014-09-06T17:19:46 | Scheme | UTF-8 | Scheme | false | false | 12,495 | sld | structure-nonterminals.sld | (define-library (np lang macros structure-nonterminals)
;;;
;;; Structural analysis of nonterminal definitions (standalone and extension)
;;;
(export $can-be:standalone-nonterminal?
$is-a:standalone-nonterminal?
$must-be:standalone-nonterminal
$can-be:nonterminal-addition?
$is-a:nonterminal-addition?
$must-be:nonterminal-addition
$can-be:nonterminal-removal?
$is-a:nonterminal-removal?
$must-be:nonterminal-removal
$can-be:nonterminal-modification?
$is-a:nonterminal-modification?
$must-be:nonterminal-modification
$expected-a:nonterminal-definition
$squash-extension-nonterminal-clauses
$get-nonterminal-modification-meta-vars
$set-nonterminal-modification-meta-vars
$get-nonterminal-modification-productions
$set-nonterminal-modification-productions)
(import (scheme base)
(sr ck)
(sr ck lists)
(sr ck maps)
(sr ck predicates)
(np lang macros structure-meta-vars)
(np lang macros structure-productions)
(np lang macros verify-utils))
(begin
;;;
;;; Nonterminal definitions (standalone)
;;;
(define-syntax $can-be:standalone-nonterminal?
(syntax-rules (quote)
((_ s '(name predicate-name (meta-vars ...) productions ...)) ($ s '#t))
((_ s '(name (meta-vars ...) productions ...)) ($ s '#t))
((_ s _) ($ s '#f)) ) )
(define-standard-checkers %verify:standalone-nonterminal
($is-a:standalone-nonterminal? $must-be:standalone-nonterminal) )
(define-verifier %verify:standalone-nonterminal
(syntax-rules (quote)
((_ s '(k t) 'term '(name (meta-vars ...) productions ...))
($ s ($and '(%verify:nonterminal-name '(k ((name (meta-vars ...)) . t)) 'name)
'($every? '(%verify:meta-var-name '(k (name . t))) '(meta-vars ...))
'(%verify:nonterminal-production-list '(k (name . t)) '(productions ...))
'($every? '(%verify:standalone-production '(k (name . t))) '(productions ...)) )))
((_ s '(k t) 'term '(name predicate-name (meta-vars ...) productions ...))
($ s ($and '(%verify:nonterminal-name '(k ((name predicate-name (meta-vars ...)) . t)) 'name)
'(%verify:nonterminal-predicate-name '(k ((name predicate-name (meta-vars ...)) . t)) 'predicate-name)
'($every? '(%verify:meta-var-name '(k (name . t))) '(meta-vars ...))
'(%verify:nonterminal-production-list '(k (name . t)) '(productions ...))
'($every? '(%verify:standalone-production '(k (name . t))) '(productions ...)) )))
((_ s '(k t) 'term _)
($ k '("Invalid syntax of the nonterminal" (term . t)))) ) )
;;;
;;; Nonterminal definitions (addition)
;;;
(define-syntax $can-be:nonterminal-addition?
(syntax-rules (quote +)
((_ s '(+ . added-nonterminals)) ($ s '#t))
((_ s _) ($ s '#f)) ) )
(define-standard-checked-verifier ($is-a:nonterminal-addition? $must-be:nonterminal-addition)
(syntax-rules (quote +)
((_ s '(k t) 'term '(+ added-nonterminals ...))
($ s ($and '(%verify:nonterminal-addition-list '(k (term . t)) '(added-nonterminals ...))
'($every? '(%verify:standalone-nonterminal '(k t)) '(added-nonterminals ...)) )))
((_ s '(k t) 'term _)
($ k '("Invalid syntax of the nonterminal extension" (term . t)))) ) )
;;;
;;; Nonterminal definitions (removal)
;;;
(define-syntax $can-be:nonterminal-removal?
(syntax-rules (quote -)
((_ s '(- . removed-nonterminals)) ($ s '#t))
((_ s _) ($ s '#f)) ) )
(define-standard-checked-verifier ($is-a:nonterminal-removal? $must-be:nonterminal-removal)
(syntax-rules (quote -)
((_ s '(k t) 'term '(- removed-nonterminals ...))
($ s ($and '(%verify:nonterminal-removal-list '(k (term . t)) '(removed-nonterminals ...))
'($every? '(%verify:nonterminal-name/concise-definition '(k t)) '(removed-nonterminals ...)) )))
((_ s '(k t) 'term _)
($ k '("Invalid syntax of the nonterminal extension" (term . t)))) ) )
(define-verifier %verify:nonterminal-name/concise-definition
(syntax-rules (quote)
((_ s '(k t) 'term '()) ($ s (%verify:nonterminal-concise-definition '(k t) 'term)))
((_ s '(k t) 'term '(a . d)) ($ s (%verify:nonterminal-concise-definition '(k t) 'term)))
((_ s '(k t) 'term '#(x ...)) ($ s (%verify:nonterminal-concise-definition '(k t) 'term)))
((_ s '(k t) 'term _) ($ s '#t)) ) )
;; Effectively this is %verify:standalone-nonterminal-definition that allows empty production list.
;; The difference is in usage of %verify:nonterminal-*concise*-production-list.
(define-verifier %verify:nonterminal-concise-definition
(syntax-rules (quote)
((_ s '(k t) 'term '(name (meta-vars ...) productions ...))
($ s ($and '(%verify:nonterminal-name '(k ((name (meta-vars ...)) . t)) 'name)
'($every? '(%verify:meta-var-name '(k (name . t))) '(meta-vars ...))
'($every? '(%verify:standalone-production '(k (name . t))) '(productions ...)) )))
((_ s '(k t) 'term '(name predicate-name (meta-vars ...) productions ...))
($ s ($and '(%verify:nonterminal-name '(k ((name predicate-name (meta-vars ...)) . t)) 'name)
'(%verify:nonterminal-predicate-name '(k ((name predicate-name (meta-vars ...)) . t)) 'predicate-name)
'($every? '(%verify:meta-var-name '(k (name . t))) '(meta-vars ...))
'($every? '(%verify:standalone-production '(k (name . t))) '(productions ...)) )))
((_ s '(k t) 'term _)
($ k '("Invalid syntax of the nonterminal" (term . t)))) ) )
;;;
;;; Nonterminal definitions (modification)
;;;
(define-syntax $can-be:nonterminal-modification?
(syntax-rules (quote !)
((_ s '(! . modified-nonterminals)) ($ s '#t))
((_ s _) ($ s '#f)) ) )
(define-standard-checked-verifier ($is-a:nonterminal-modification? $must-be:nonterminal-modification)
(syntax-rules (quote !)
((_ s '(k t) 'term '(! modified-nonterminals ...))
($ s ($and '(%verify:nonterminal-modification-list '(k (term . t)) '(modified-nonterminals ...))
'($every? '(%verify:nonterminal-modification '(k t)) '(modified-nonterminals ...)) )))
((_ s '(k t) 'term _)
($ k '("Invalid syntax of the nonterminal extension" (term . t)))) ) )
(define-verifier %verify:nonterminal-modification
(syntax-rules (quote)
((_ s '(k t) 'term '(name (meta-var-modifications ...) production-modifications ...))
($ s ($and '(%verify:nonterminal-name '(k ((name (meta-var-modifications ...)) . t)) 'name)
'($every? '(%verify:meta-var-modification '(k (name . t))) '(meta-var-modifications ...))
'($every? '(%verify:production-modification '(k (name . t))) '(production-modifications ...))
'(%verify:meta-vars-or-productions-are-modified '(k (name . t))
'(meta-var-modifications ...) '(production-modifications ...) ) )))
((_ s '(k t) 'term '(name predicate-name (meta-var-modifications ...) production-modifications ...))
($ s ($and '(%verify:nonterminal-name '(k ((name predicate-name (meta-var-modifications ...)) . t)) 'name)
'(%verify:nonterminal-predicate-name '(k (name . t)) 'predicate-name)
'($every? '(%verify:meta-var-modification '(k (name . t))) '(meta-var-modifications ...))
'($every? '(%verify:production-modification '(k (name . t))) '(production-modifications ...))
'(%verify:meta-vars-or-productions-are-modified '(k (name . t))
'(meta-var-modifications ...) '(production-modifications ...) ) )))
((_ s '(k t) 'term '(name predicate-name))
($ s ($and '(%verify:nonterminal-name '(k ((name predicate-name) . t)) 'name)
'(%verify:nonterminal-predicate-name '(k (name . t)) 'predicate-name) )))
((_ s '(k t) 'term _)
($ k '("Invalid syntax of the nonterminal modification" (term . t)))) ) )
(define-syntax %verify:meta-vars-or-productions-are-modified
(syntax-rules (quote)
((_ s '(k t) '() '())
($ k '("Nonterminal modification should modify either meta-variables or productions" t)))
((_ s '(k t) _ _) ($ s '#t)) ) )
;;;
;;; Getters, setters, squashers, etc. (Valid input is assumed everywhere.)
;;;
(define-syntax $expected-a:nonterminal-definition
(syntax-rules (quote)
((_ s 'lang 'invalid-definition)
(syntax-error "Invalid syntax of the nonterminal extension" lang invalid-definition)) ) )
(define-syntax $squash-extension-nonterminal-clauses
(syntax-rules (quote)
((_ s 'clauses) ($ s ($concatenate ($map '$cdr 'clauses)))) ) )
(define-syntax $get-nonterminal-modification-meta-vars
(syntax-rules (quote)
((_ s 'lang '(name (meta-var-modifications ...) production-modifications ...))
($ s '(meta-var-modifications ...)))
((_ s 'lang '(name predicate-name (meta-var-modifications ...) production-modifications ...))
($ s '(meta-var-modifications ...)))
((_ s 'lang '(name predicate-name)) ($ s '())) ) )
(define-syntax $set-nonterminal-modification-meta-vars
(syntax-rules (quote)
((_ s 'lang '(name (meta-var-modifications ...) production-modifications ...) '(meta-var-modifications* ...))
($ s '(name (meta-var-modifications* ...) production-modifications ...)))
((_ s 'lang '(name predicate-name (meta-var-modifications ...) production-modifications ...) '(meta-var-modifications* ...))
($ s '(name predicate-name (meta-var-modifications* ...) production-modifications ...)))
((_ s 'lang '(name predicate-name) '(meta-var-modifications* ...))
($ s '(name predicate-name (meta-var-modifications* ...)))) ) )
(define-syntax $get-nonterminal-modification-productions
(syntax-rules (quote)
((_ s 'lang '(name (meta-var-modifications ...) production-modifications ...))
($ s '(production-modifications ...)))
((_ s 'lang '(name predicate-name (meta-var-modifications ...) production-modifications ...))
($ s '(production-modifications ...)))
((_ s 'lang '(name predicate-name)) ($ s '())) ) )
(define-syntax $set-nonterminal-modification-productions
(syntax-rules (quote)
((_ s 'lang '(name (meta-var-modifications ...) production-modifications ...) '(production-modifications* ...))
($ s '(name (meta-var-modifications ...) (production-modifications* ...))))
((_ s 'lang '(name predicate-name (meta-var-modifications ...) production-modifications ...) '(production-modifications* ...))
($ s '(name predicate-name (meta-var-modifications ...) (production-modifications* ...))))
((_ s 'lang '(name predicate-name) '(production-modifications* ...))
($ s '(name predicate-name () (production-modifications* ...)))) ) )
;;;
;;; Common verifiers
;;;
(define-verifier/symbol %verify:nonterminal-name
("Name of the nonterminal must be an identifier") )
(define-verifier/symbol %verify:nonterminal-predicate-name
("Name of the nonterminal predicate must be an identifier") )
(define-verifier/nonempty-list %verify:nonterminal-production-list
("At least one production should be specified for a nonterminal") )
(define-verifier/nonempty-list %verify:nonterminal-addition-list
("At least one nonterminal should be specified for addition") )
(define-verifier/nonempty-list %verify:nonterminal-removal-list
("At least one nonterminal should be specified for removal") )
(define-verifier/nonempty-list %verify:nonterminal-modification-list
("At least one nonterminal should be specified for modification") )
) )
| true |
e97ad2f57d1175ab563c54e2c12fbfa12aee62a5 | ef242bb86c68a291a2ed1201b08ef962048f0d14 | /tests/run.scm | bd6e7c056e965897ca40e06f52ffb8e75f66abbc | [
"MIT",
"BSD-3-Clause"
]
| permissive | diamond-lizard/srfi-130 | dea26f4c3194069dbf94355d1cfad2c460366347 | c31da8e66c6aa53bda8e881e3d95474ac55375c4 | refs/heads/main | 2023-01-07T06:03:24.031767 | 2020-11-16T05:27:21 | 2020-11-16T05:27:21 | 310,743,980 | 0 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 30 | scm | run.scm | (include "srfi-130-test.scm")
| false |
510367934e21817a5a144ce11b07f962efc17bc1 | 763ce7166523c52b12d92ad48150e6e29dae22f3 | /leastsquares.scm | e11c73c9915ecaa8d2643715503bc480308122c3 | []
| no_license | seandepagnier/cruisingplot | 3cdbe87789267de0a1f8ca8354215167b334f51b | d3d83e7372e2c5ce1a8e8071286e30c2028088cf | refs/heads/master | 2020-03-29T18:19:13.647065 | 2013-11-13T03:14:11 | 2013-11-13T03:14:11 | 5,801,818 | 6 | 2 | null | null | null | null | UTF-8 | Scheme | false | false | 25,170 | scm | leastsquares.scm | ;; Copyright (C) 2010 Sean D'Epagnier <[email protected]>
;;
;; This Program 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 3 of the License, or (at your option) any later version.
(declare (unit leastsquares))
(declare (uses matrix vector))
; return (HH')^-1*H'Z'
(define (least-squares-apply H Z)
(let ((i (matrix* (matrix-transpose H) H)))
(let ((ii (matrix-inverse i)))
(if ii
(matrix* ii (matrix-transpose H) Z)
(zeroed-matrix (matrix-rows i) (matrix-cols i))))))
; the functions build build-jacobian-row takes state and measurements
(define (compute-least-squares state build-jacobian-residual-row measurements)
(let ((HZ (map (lambda (measurement)
(build-jacobian-residual-row state measurement))
measurements)))
(list (matrix (map car HZ)) (matrix (map cdr HZ)))))
(define (least-squares-iterate initial-state build-jacobian-residual-row measurements
complete? max-iterations)
(let each-iteration ((state initial-state) (iteration 0))
(let*((HZ (compute-least-squares state build-jacobian-residual-row measurements))
(updates (first (matrix->list (matrix-transpose (apply least-squares-apply HZ)))))
(nstate (map + state updates))
(update (vector-magnitude updates)))
(cond ((or (> iteration max-iterations)
(and complete? (complete? nstate update)))
(list nstate (vector-magnitude
(first (matrix->list (matrix-transpose (second HZ)))))))
(else (each-iteration nstate (+ iteration 1)))))))
; least squares to fit data
; use y = a
(define (constant-regression data)
(least-squares-iterate '(1) (lambda (state measurement)
(list (list 1) ; derivative
(- (second measurement) (first state)))) ;residual
data 1))
; use y = a*x + b
(define (linear-regression data)
(least-squares-iterate '(1 1) (lambda (state measurement)
(list (list (first measurement) 1)
(- (second measurement)
(* (first state) (first measurement))
(second state))))
data #f 1))
; use y = a*x^2 + b*x + c
(define (quadratic-regression data)
(least-squares-iterate
(cons 1 (first (linear-regression data)))
(lambda (state measurement)
(let ((j (list (square (first measurement)) (first measurement) 1)))
(list j (- (second measurement)
(vector-dot j state)))))
data #f 10))
;y = a*x^3 + b*x^2 + c*x + d
(define (cubic-regression data)
(least-squares-iterate
(cons 1 (first (quadratic-regression data)))
(lambda (state measurement)
(let ((j (list (cube (first measurement)) (square (first measurement)) (first measurement) 1)))
(list j (- (second measurement)
(vector-dot j state)))))
data #f 10))
; y = a + b*x + c*x^2 + ...
(define (polynomial-regression data max-order)
(let each-order ((order 0) (last-state '()))
(cond ((<= order max-order)
(let ((state
(least-squares-iterate
(cons 1 last-state)
(lambda (state measurement)
(let ((fm (first measurement)))
(let ((j (cons 1 (let build-j ((o 1) (m fm))
(cond ((<= o order)
(cons m (build-j (+ o 1) (* m fm))))
(else '()))))))
(list j (- (second measurement)
(vector-dot j state))))))
data #f 10)))
(cond (state
(display "order ")
(write order)
(display " state ")
(for-each (lambda (n)
(display-scientific-notation-places n 3)
(display " "))
(first state))
(display (string->symbol "residual "))
(display-scientific-notation-places (second state) 6)
(newline)
(each-order (+ 1 order) (first state)))
(else
(print "failed to compute least squares after order " order))))))))
; calibrate x and y offsets as well as radius
; best fit circle to data
;
; measurements: x y
; states: yb zb (bias) s (scale)
;
; truth equation:
; (x-xb)^2 + (y-yb)^2 = s^2
;
(define (calibrate-biases-and-scale-2d measurements)
(least-squares-iterate
`(,(average-list (map first measurements))
,(average-list (map second measurements))
1)
(lambda (state measurement)
(let-values (((xb yb s) (apply values state))
((x y) (apply values measurement)))
(let ((xs (- x xb)) (ys (- y yb)))
(list (list (* 2 xs)
(* 2 ys)
(* 2 s))
(- (+ (square xs) (square ys)) (square s))))))
measurements #f 10))
; measurements: x y
; states: xb yb (biase) s (scale) yrs (y relative scale)
; (x-xb)^2 + (yrs*(y-yb))^2 = s^2
;
; fit non-rotated ellipse to data
;
; convert yrs to sqrt on return
(define (calibrate-biases-scale-and-relative-scale-2d measurements)
(least-squares-iterate
`(,(average-list (map first measurements))
,(average-list (map second measurements))
1 1)
(lambda (state measurement)
(let-values (((xb yb s yrs) (apply values state))
((x y) (apply values measurement)))
(let ((xs (- x xb)) (ys (- y yb)))
(list (list (* 2 xs)
(* 2 (* (square yrs) ys))
(* 2 s)
(- (* 2 yrs (square ys))))
(- (+ (square xs) (square (* yrs ys))) (square s))))))
measurements #f 10))
; this equation calibrates biases and relative scales
; calibrate x, y and z offsets as well as radius
;
; measurements: x y z
; states: xb yb zb (bias) s (scale)
;
; truth equation:
; (x-xb)^2 + (y-yb)^2 + (z-zb)^2 - s^2 = 0
;
(define (calibrate-biases-and-scale-3d measurements)
(least-squares-iterate
`(,(average-list (map first measurements))
,(average-list (map second measurements))
,(average-list (map third measurements))
1)
(lambda (state measurement)
(let-values (((xb yb zb s) (apply values state))
((x y z) (apply values measurement)))
(let ((xs (- x xb)) (ys (- y yb)) (zs (- z zb)))
(list (list (* 2 xs)
(* 2 ys)
(* 2 zs)
(* 2 s))
(- (+ (square xs) (square ys) (square zs)) (square s))))))
measurements #f 20))
(define (constrain-states! state constraints)
(cond ((not (= (length state) (length constraints)))
(error "number of constraints does not match number of states"))
((not (null? state))
(cond ((< (car state) (caar constraints))
(set-car! state (caar constraints)))
((> (car state) (cadar constraints))
(set-car! state (cadar constraints))))
(constrain-states! (cdr state) (cdr constraints)))))
; measurements: x y z
; states: xb yb zb (biase) s (scale) yrs zrs (relative scales)
; (x-xb)^2 + (yrs*(y-yb))^2 + (zrs*(z-zb))^2 = s^2
;
; fit non-rotated ellipse to data
;
(define (calibrate-biases-scale-and-relative-scales-3d measurements)
(least-squares-iterate
(let ((lc (calibrate-biases-and-scale-3d measurements)))
(if lc
(append (first lc) '(1 1))
'(0 0 0 1 1 1)))
(lambda (state measurement)
(let-values (((xb yb zb s yrs zrs) (apply values state))
((x y z) (apply values measurement)))
(let ((xs (- x xb)) (ys (- y yb)) (zs (- z zb)))
(list (list (* 2 xs)
(* 2 yrs ys)
(* 2 zrs zs)
(* 2 s)
(- (square ys))
(- (square zs)))
(- (+ (square xs) (* yrs (square ys)) (* zrs (square zs))) (square s))))))
measurements (lambda (state update)
(constrain-states! state '((-2 2) (-2 2) (-2 2)
(.4 2) (.4 2) (.4 2)))
#f)
20))
; measurements: x y z
; states: xb yb zb (bias) s (scale) yrs zrs (relative scales) xyc xzc yzc (cross coupling)
; (x-xb)^2 + yrs*((y-yb) + xyc*(x-xb))^2 + zrs*((z-zb) + xzc*(x-xb) + yzc*(y-yb))^2 - s^2 = 0
;
; fit rotated ellipse to data
;
(define (calibrate-biases-scale-relative-scales-and-cross-coupling-3d measurements)
(least-squares-iterate
(let ((lc (calibrate-biases-scale-and-relative-scales-3d measurements)))
(if lc
(append (first lc) '(0 0 0))
'(0 0 0 1 1 1 0 0 0)))
(lambda (state measurement)
(let-values (((xb yb zb s yrs zrs xyc xzc yzc) (apply values state))
((x y z) (apply values measurement)))
(let ((xs (- x xb)) (ys (- y yb)) (zs (- z zb)))
(let ((xc xs)
(yc (+ ys (* xyc xs)))
(zc (+ zs (* xzc xs) (* yzc ys))))
(list (list (* 2 (+ xc (* xyc yrs yc) (* xzc zrs zc)))
(* 2 (+ (* yrs yc) (* yzc zrs zc)))
(* 2 zrs zc)
(* 2 s)
(- (square ys))
(- (square zs))
(* -2 xs yc yrs)
(* -2 xs zc zrs)
(* -2 ys zc zrs))
(- (+ (square xc) (* yrs (square yc)) (* zrs (square zc)))
(square s)))))))
measurements (lambda (state update)
(constrain-states! state '((-2 2) (-2 2) (-2 2)
(.4 2) (.4 2) (.4 2)
(-.5 .5) (-.5 .5) (-.5 .5)))
#f)
20))
; measurements: x y z
; states: a - f
;
; cx = a*x + b
; cy = c*y + d
; cz = e*z + f
(define (calibrate-basic-sensor-3d measurements)
(define avgx (average-list (map first measurements)))
(define avgy (average-list (map second measurements)))
(define avgz (average-list (map third measurements)))
(least-squares-iterate
(list 1 (- avgx) 1 (- avgy) 1 (- avgz))
(lambda (state measurement)
(let-values (((a b c d e f) (apply values state))
((ax ay az) (apply values measurement)))
(let ((cax (+ (* a ax) b)) (cay (+ (* c ay) d)) (caz (+ (* e az) f)))
(list (list (* 2 ax cax) (* 2 cax)
(* 2 ay cay) (* 2 cay)
(* 2 az caz) (* 2 caz))
(- 1 (square cax) (square cay) (square caz))))))
measurements
(lambda (state update)
(constrain-states! state '((.8 1.2) (-1 1) (.8 1.2) (-1 1) (.8 1.2) (-1 1)))
#f)
20))
; measurements: x y z
; states: a - i
;
; cx = a*x + b
; cy = c*x + d*y + e
; cz = f*x + g*y + h*z + i
(define (calibrate-sensor-3d measurements)
(least-squares-iterate
(let ((basic-cal (calibrate-basic-sensor-3d measurements)))
(let ((b (if (< (second basic-cal) 1) (first basic-cal) '(1 0 1 0 1 0))))
(list (first b) (second b)
0 (third b) (fourth b)
0 0 (fifth b) (sixth b))))
(lambda (state measurement)
(let-values (((a b c d e f g h i) (apply values state))
((x y z) (apply values measurement)))
(let ((cx (+ (* a x) b))
(cy (+ (* c x) (* d y) e))
(cz (+ (* f x) (* g y) (* h z) i)))
(list (list (* 2 x cx) (* 2 cx)
(* 2 x cy) (* 2 y cy) (* 2 cy)
(* 2 x cz) (* 2 y cz) (* 2 z cz) (* 2 cz))
(- 1 (square cx) (square cy) (square cz))))))
measurements
(lambda (state update)
(constrain-states! state '((.8 1.2) (-1 1)
(-.2 .2) (.8 1.2) (-1 1)
(-.2 .2) (-.2 .2) (.8 1.2) (-1 1)
))
#f)
20))
; measurements: x y z
; states: a - o
;
; rx = j*x^3 + k*x^2 + x
; ry = l*y^3 + m*y^2 + y
; rz = n*z^3 + o*z^2 + z
;
; cx = a*rx + b
; cy = c*rx + d*ry + e
; cz = f*rz + g*ry + h*rz + i
;
; cx = a*j*x^3 + a*k*x^2 + a*x + b
; cy = c*j*x^3 + c*k*x^2 + c*x + d*l*y^3 + d*m*y^2 + d*y + e
; cz = f*j*x^3 + f*k*x^2 + f*x + g*l*y^3 + g*m*y^2 + g*y + h*n*z^3 + h*o*z^2 + h*z + i
;
(define (calibrate-sensor-3rd-order-3d measurements)
(least-squares-iterate
(append (let ((linear-cal (calibrate-sensor-3d measurements)))
(first linear-cal))
(list 0 0 0 0 0 0))
(lambda (state measurement)
(let-values (((a b c d e f g h i j k l m n o) (apply values state))
((x y z) (apply values measurement)))
(let ((rx (+ (* j (cube x)) (* k (square x)) x))
(ry (+ (* l (cube y)) (* m (square y)) y))
(rz (+ (* n (cube z)) (* o (square z)) z)))
(let ((cx (+ (* a rx) b))
(cy (+ (* c rx) (* d ry) e))
(cz (+ (* f rx) (* g ry) (* h rz) i)))
(list (list (* 2 rx cx) (* 2 cx)
(* 2 rx cy) (* 2 ry cy) (* 2 cy)
(* 2 rx cz) (* 2 ry cz) (* 2 rz cz) (* 2 cz)
(* 2 (cube x) (+ (* f cz) (* c cy) (* a cx)))
(* 2 (square x) (+ (* f cz) (* c cy) (* a cx)))
(* 2 (cube y) (+ (* g cz) (* d cy)))
(* 2 (square y) (+ (* g cz) (* d cy)))
(* 2 (cube z) h cz)
(* 2 (square z) h cz))
(- 1 (square cx) (square cy) (square cz)))))))
measurements
(lambda (state update)
(constrain-states! state '((.8 1.2) (-1 1)
(-.2 .2) (.8 1.2) (-1 1)
(-.2 .2) (-.2 .2) (.8 1.2) (-1 1)
(-.001 .001) (-.01 .01)
(-.001 .001) (-.01 .01)
(-.001 .001) (-.01 .01)
))
#f)
20))
; measurements: ax ay az mx my mz
; states: a - s
;
; cax = a*ax + b
; cay = c*ay + d
; caz = e*az + f
;
; cmx = g*mx + h*my + i*mz + j
; cmy = k*mx + l*my + m*mz + n
; cmz = o*mx + p*my + q*mz + r
;
; cax^2 + cay^2 + caz^2 - 1 = 0
; cmx^2 + cmy^2 + cmz^2 - 1 = 0
; cmx*cax + cmy*cay + cmz*caz + s = 0
;
(define (apply-basic-accel-mag-3d accel mag calibration)
(let-values (((a b c d e f g h i j k l m n o p q r s) (apply values (first calibration)))
((ax ay az) (apply values accel))
((mx my mz) (apply values mag)))
(let ((cax (+ (* a ax) b)) (cay (+ (* c ay) d)) (caz (+ (* e az) f))
(cmx (+ (* g mx) (* h my) (* i mz) j))
(cmy (+ (* k mx) (* l my) (* m mz) n))
(cmz (+ (* o mx) (* p my) (* q mz) r)))
(list (list cax cay caz) (list cmx cmy cmz)))))
(define (calibrate-basic-accel-mag-3d measurements)
(let ((initial-accel (calibrate-basic-sensor-3d
(map (lambda (measurement) (take measurement 3)) measurements)))
(initial-mag (calibrate-basic-sensor-3d
(map (lambda (measurement) (take-right measurement 3)) measurements))))
(least-squares-iterate
(append
(if (< (second initial-accel) 1)
(let ((ia (first initial-accel)))
ia)
'(1 0 1 0 1 0))
(if (< (second initial-mag) 1)
(let ((im (first initial-mag)))
(list (first im) 0 0 (second im) 0 (third im) 0 (fourth im) 0 0 (fifth im) (sixth im)))
'(1 0 0 0 0 1 0 0 0 0 1 0))
'(.9)
)
(lambda (state measurement)
(let-values (((a b c d e f g h i j k l m n o p q r s) (apply values state))
((index ax ay az mx my mz) (apply values measurement)))
(let ((cax (+ (* a ax) b)) (cay (+ (* c ay) d)) (caz (+ (* e az) f))
(cmx (+ (* g mx) (* h my) (* i mz) j))
(cmy (+ (* k mx) (* l my) (* m mz) n))
(cmz (+ (* o mx) (* p my) (* q mz) r)))
(case index
((0) (list (list (* 2 ax cax) (* 2 cax)
(* 2 ay cay) (* 2 cay)
(* 2 az caz) (* 2 caz)
0 0 0 0 0 0 0 0 0 0 0 0 0
)
(- 1 (square cax) (square cay) (square caz))))
((1)
(list (list 0 0 0 0 0 0
(* 2 mx cmx) (* 2 my cmx) (* 2 mz cmx) (* 2 cmx)
(* 2 mx cmy) (* 2 my cmy) (* 2 mz cmy) (* 2 cmy)
(* 2 mx cmz) (* 2 my cmz) (* 2 mz cmz) (* 2 cmz) 0
)
(- 1 (square cmx) (square cmy) (square cmz))))
((2) (let ((nca (normalize (list cax cay caz)))
(ncm (normalize (list cmx cmy cmz))))
(let ((ncax (first nca)) (ncay (second nca)) (ncaz (third nca))
(ncmx (first ncm)) (ncmy (second ncm)) (ncmz (third ncm)))
(list (list
(* ax cmx) cmx
(* ay cmy) cmy
(* az cmz) cmz
(* mx cax) (* my cax) (* mz cax) cax
(* mx cay) (* my cay) (* mz cay) cay
(* mx caz) (* my caz) (* mz caz) caz
1
)
(- (+ (* cax cmx) (* cay cmy) (* caz cmz) s))))))
((3) (let ((amag (+ (square cax) (square cay) (square caz)))
(mmag (+ (square cmx) (square cmy) (square cmz)))
(madot (+ (* cax cmx) (* cay cmy) (* caz cmz))))
(list (list
0 0 0 0 0 0
(* -2 ax (+ (* cax mmag s) (* cmx madot)))
(* -2 (+ (* cax mmag s) (* cmx madot)))
(* -2 ay (+ (* cay mmag s) (* cmy madot)))
(* -2 (+ (* cay mmag s) (* cmy madot)))
(* -2 az (+ (* caz mmag s) (* cmz madot)))
(* -2 (+ (* caz mmag s) (* cmz madot)))
(* -2 mx (+ (* cmx amag s) (* cax madot)))
(* -2 my (+ (* cmx amag s) (* cax madot)))
(* -2 mz (+ (* cmx amag s) (* cax madot)))
(* -2 (+ (* cmx amag s) (* cax madot)))
(* -2 mx (+ (* cmy amag s) (* cay madot)))
(* -2 my (+ (* cmy amag s) (* cay madot)))
(* -2 mz (+ (* cmy amag s) (* cay madot)))
(* -2 (+ (* cmy amag s) (* cay madot)))
(* -2 mx (+ (* cmz amag s) (* caz madot)))
(* -2 my (+ (* cmz amag s) (* caz madot)))
(* -2 mz (+ (* cmz amag s) (* caz madot)))
(* -2 (+ (* cmz amag s) (* caz madot)))
(* amag mmag)
)
(+ (square (+ (* cax cmx) (* cay cmy) (* caz cmz))) (* s amag mmag)))))))))
(apply append (map (lambda (measurement)
(list (cons 0 measurement)
(cons 1 measurement)
(cons 2 measurement)
))
measurements))
(lambda (state update)
(constrain-states! state '((.8 1.2) (-.2 .2) (.8 1.2) (-.2 .2) (.8 1.2) (-.2 .2)
(.8 1.2) (-.2 .2) (-.2 .2) (-1 1)
(-.2 .2) (.8 1.2) (-.2 .2) (-1 1)
(-.2 .2) (-.2 .2) (.8 1.2) (-1 1)
(-1 1)
))
#f)
20)))
; measurements: ax ay az mx my mz
; states: a - v
;
; cax = a*ax + b
; cay = c*ax + d*ay + e
; caz = f*ax + g*ay + h*az + i
;
; cmx = j*mx + k*my + l*mz + m
; cmy = n*mx + o*my + p*mz + q
; cmz = r*mx + s*my + t*mz + u
;
; cax^2 + cay^2 + caz^2 - 1 = 0
; cmx^2 + cmy^2 + cmz^2 - 1 = 0
; cmx*cax + cmy*cay + cmz*caz + v = 0
;
(define (apply-accel-mag-3d accel mag calibration)
(let-values (((a b c d e f g h i j k l m n o p q r s t u v) (apply values (first calibration)))
((ax ay az) (apply values accel))
((mx my mz) (apply values mag)))
(let ((cax (+ (* a ax) b))
(cay (+ (* c ax) (* d ay) e))
(caz (+ (* f ax) (* g ay) (* h az) i))
(cmx (+ (* j mx) (* k my) (* l mz) m))
(cmy (+ (* n mx) (* o my) (* p mz) q))
(cmz (+ (* r mx) (* s my) (* t mz) u)))
(list (list cax cay caz) (list cmx cmy cmz)))))
(define (calibrate-accel-mag-3d measurements)
(let ((initial-accel (calibrate-sensor-3d
(map (lambda (measurement) (take measurement 3)) measurements)))
(initial-mag (calibrate-sensor-3d
(map (lambda (measurement) (take-right measurement 3)) measurements))))
(least-squares-iterate
(append
(if (< (second initial-accel) 1)
(first initial-accel)
'(1 0 0 1 0 0 0 1 0))
(if (< (second initial-mag) 1)
(let ((im (first initial-mag)))
(list (first im) 0 0 (second im) 0 (fourth im) 0 (fifth im) 0 0 (eighth im) (ninth im)))
'(1 0 0 0 0 1 0 0 0 0 1 0))
'(.9)
)
(lambda (state measurement)
(let-values (((a b c d e f g h i j k l m n o p q r s t u v) (apply values state))
((index ax ay az mx my mz) (apply values measurement)))
(let ((cax (+ (* a ax) b))
(cay (+ (* c ax) (* d ay) e))
(caz (+ (* f ax) (* g ay) (* h az) i))
(cmx (+ (* j mx) (* k my) (* l mz) m))
(cmy (+ (* n mx) (* o my) (* p mz) q))
(cmz (+ (* r mx) (* s my) (* t mz) u)))
(case index
((0) (list (list (* 2 ax cax) (* 2 cax)
(* 2 ax cay) (* 2 ay cay) (* 2 cay)
(* 2 ax caz) (* 2 ay caz) (* 2 az caz) (* 2 caz)
0 0 0 0 0 0 0 0 0 0 0 0 0)
(- 1 (square cax) (square cay) (square caz))))
((1)
(list (list 0 0 0 0 0 0 0 0 0
(* 2 mx cmx) (* 2 my cmx) (* 2 mz cmx) (* 2 cmx)
(* 2 mx cmy) (* 2 my cmy) (* 2 mz cmy) (* 2 cmy)
(* 2 mx cmz) (* 2 my cmz) (* 2 mz cmz) (* 2 cmz) 0)
(- 1 (square cmx) (square cmy) (square cmz))))
((2) (let ((nca (normalize (list cax cay caz)))
(ncm (normalize (list cmx cmy cmz))))
(let ((ncax (first nca)) (ncay (second nca)) (ncaz (third nca))
(ncmx (first ncm)) (ncmy (second ncm)) (ncmz (third ncm)))
(list (list
(* ax cmx) cmx
(* ax cmy) (* ay cmy) cmy
(* ax cmz) (* ay cmz) (* az cmz) cmz
(* mx cax) (* my cax) (* mz cax) cax
(* mx cay) (* my cay) (* mz cay) cay
(* mx caz) (* my caz) (* mz caz) caz
1
)
(- (+ (* cax cmx) (* cay cmy) (* caz cmz) v))))))))))
(apply append (map (lambda (measurement)
(list (cons 0 measurement)
(cons 1 measurement)
(cons 2 measurement)
))
measurements))
(lambda (state update)
(constrain-states! state '((.8 1.2) (-.2 .2)
(-.1 .1) (.8 1.2) (-.2 .2)
(-.1 .1) (-.1 .1) (.8 1.2) (-.2 .2)
(.8 1.2) (-.2 .2) (-.2 .2) (-1 1)
(-.2 .2) (.8 1.2) (-.2 .2) (-1 1)
(-.2 .2) (-.2 .2) (.8 1.2) (-1 1)
(-1 1)
))
#f)
20)))
| false |
fa5c9c48e2ad6b368ad365854f982941c6e4e644 | 958488bc7f3c2044206e0358e56d7690b6ae696c | /scheme/curry.scm | 2ad7572b244dbc9c4d8683b7db8d878980a6345d | []
| no_license | possientis/Prog | a08eec1c1b121c2fd6c70a8ae89e2fbef952adb4 | d4b3debc37610a88e0dac3ac5914903604fd1d1f | refs/heads/master | 2023-08-17T09:15:17.723600 | 2023-08-11T12:32:59 | 2023-08-11T12:32:59 | 40,361,602 | 3 | 0 | null | 2023-03-27T05:53:58 | 2015-08-07T13:24:19 | Coq | UTF-8 | Scheme | false | false | 60 | scm | curry.scm | (define (curry f)
(lambda (x)
(lambda (y) (f x y))))
| false |
8fcc80045479aaf21f750ae5af9c8f70315d2178 | 5bbc152058cea0c50b84216be04650fa8837a94b | /pre-benchmark/htdp/base/Images/box-diagram.ss | 3b9bbc31b0621e58a61f93ce746b3f24afce01a3 | []
| no_license | nuprl/gradual-typing-performance | 2abd696cc90b05f19ee0432fb47ca7fab4b65808 | 35442b3221299a9cadba6810573007736b0d65d4 | refs/heads/master | 2021-01-18T15:10:01.739413 | 2018-12-15T18:44:28 | 2018-12-15T18:44:28 | 27,730,565 | 11 | 3 | null | 2018-12-01T13:54:08 | 2014-12-08T19:15:22 | Racket | UTF-8 | Scheme | false | false | 1,214 | ss | box-diagram.ss | #lang slideshow
(require slideshow/pict "write.ss" "pict-aux.ss")
(provide
struct-pict ;; String [Listof (list String String)] -> Pict
;; (struct-pict s (list (list f1 c1) ...))
;; render struct-pict for struct of type s with fields f1 ... filled with
;; values v1 ... (possibly diagrams)
draw-box ;; String String [Listof (list String String)] -> Pict
;; (draw-box fl s (list (list f1 c1) ...))
;; create struct-pict for struct of type s with fields f1 ... filled with
;; values v1 ... (possibly diagrams)
;; effect: write it to specified file fl
)
(define (struct-pict name l #:color (c "black"))
;; String String -> Pict
;; a field of a structure
(define (compartment label content)
(define l (it-small label))
(define c (if (pict? content) content (t content)))
(define b (padded-frame (vl-append l c)))
(pin-line b c lt-find c rt-find))
(define base
(vr-append
(padded-frame (it-small name))
(frame (apply ht-append (map (curry apply compartment) l)))))
(colorize (padded-blank base 3) c))
(define (draw-box filename struct-name field-values #:color (c "black"))
(write-pict filename (struct-pict #:color c struct-name field-values))) | false |
7cebf6d31e728e1137dae1b32b4b160b566b4d35 | 688feb2eac8bc384583c4f0960cfbc86c3470d91 | /chicken/learn/reverse.scm | abfd8012a1f9e75000bd4a2a564efd1948579a62 | []
| no_license | halida/code_example | 7d2873e92707b4bab673046ff3d0c742e1984b4c | 5c882a24b93696c2122a78425ef6b3775adc80fa | refs/heads/master | 2023-06-08T15:51:23.150728 | 2022-03-27T09:57:43 | 2022-03-27T09:57:43 | 2,458,466 | 2 | 1 | null | 2023-06-06T02:07:28 | 2011-09-26T06:01:29 | Ruby | UTF-8 | Scheme | false | false | 598 | scm | reverse.scm | ;; reverse string
(define (reverse-word string)
(let ((data (string->list string)))
(define (for-each-word f data)
(define (for-each-word-inner f data is-word-now)
(let ((c (car data)) (remain (cdr data)))
todo)
)
(for-each-word-inner f data #f)
)
(define (reverse-words data)
(for-each-word
(lambda (word is-word)
(if is-word
(reverse word)
word))
data)
)
(list->string
(reverse (reverse-words data)))
))
(string=?
(reverse-word "please help me")
"me help please")
| false |
f42411954a1f62849d57a24f68455367863315f9 | 6cf2e78840970768168f583716e8826b1902dafa | /learning-functional/work-in-university/home-practice/scheme-practice/part-5-data-structures/matrix.scm | dff643a5841fb8d12ba78f6169a9d7312c81e5a6 | []
| no_license | dianvaltodorov/learning-code | e4b3e5034c68cdf9d1e38f8b6a12af1d51d2e167 | a92605345829e051c0b2420de6f3dfc1fe5eb65a | refs/heads/master | 2021-01-17T12:24:58.618311 | 2016-02-02T17:48:55 | 2018-06-21T06:53:16 | 49,488,021 | 2 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 2,174 | scm | matrix.scm | (define mat '((1 2 3)(2 3 4)))
(define m '((1 2 3) (4 5 6) (9 2 8) (1 3 5)))
(define (foldl op nv l)
(if (null? l) nv
(foldl op (op nv (car l)) (cdr l))))
(define (foldr op nv l)
(if (null? l) nv
(op (car l) (foldr op nv (cdr l)))))
(define (accumulate op nv a b term next)
(if (> a b) nv
(op (term a) (accumulate op nv (next a) b term next))))
(define (all p? l) (foldr (lambda (x y) (and x y)) #t 1))
(define (matrix? m)
(and (list? m)
(not (null? (car m)))
(all list? m)
(all (lambda (row) (= (length row)
(length (car m))))m)))
(define (get-first-row m) (car m))
(define (get-firts-column) (map car m))
(define (get-column i m) (map (lambda (row) (list-ref row i)) m))
(define (get-row i m) (list-ref m i))
(define (diagonal1 m)
(define (helper i mat)
(if(null? mat)
'()
(cons (list-ref (car mat) i) (helper (+ i 1) (cdr mat)))))
(helper 0 mat))
(define (diagonal1-optimized m)
(if(null? m)
'()
(cons (caar m) (diagonal1-optimized (map cdr (cdr m))))))
(define (diagonal2 m)
(define (helper i mat)
(if(null? mat)
'()
(cons (list-ref (car mat) i) (helper (- i 1) (cdr mat)))))
(helper (- (length (car mat)) 1) mat))
(define (diagonal2-optimized m)
(if(null? m)
'()
(cons (car (car m)) (diagonal1-optimized (map cdr (cdr m))))))
(define (skip-row m r)
(define (helper i m)
(cond ((null? m) '())
((= i r) (helper (+ i 1) (cdr m)))
(else (cons (car m) (helper (+ i 1) (cdr m))))))
(helper 0 m))
(define (remove-nth-element n l)
(define (helper i l)a
(cond ((null? l) '())
((= i n) (helper (+ i 1) (cdr l)))
(else (cons (car l
) (helper (+ i 1) (cdr l))))))
(helper 0 l))
(define (skip-column m c)
(map (lambda (row) (remove-nth-element c row)) m))
(define (skip-row-column m r c)
(skip-column (skip-row m r) c))
(define (transpose m)
(apply map list m))
(define (row-reverse matrix)
(map reverse-row matrix))
(define (reverse-row row)
(if (null? row)
'()
(append (reverse-row (cdr row)) (list (car row)))))
| false |
f69dca8a306c13be7be15a23f0d6e2c53d07cfd2 | 4b480cab3426c89e3e49554d05d1b36aad8aeef4 | /chapter-05/ex5.08-comkid-test.scm | aa98af1c93d1dc1f90982ee710202266c73a7157 | []
| no_license | tuestudy/study-sicp | a5dc423719ca30a30ae685e1686534a2c9183b31 | a2d5d65e711ac5fee3914e45be7d5c2a62bfc20f | refs/heads/master | 2021-01-12T13:37:56.874455 | 2016-10-04T12:26:45 | 2016-10-04T12:26:45 | 69,962,129 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 383 | scm | ex5.08-comkid-test.scm | (load "comkid-simulator.scm")
(define ambiguous-machine
(make-machine
'(a)
'()
'(start
(goto (label here))
here
(assign a (const 3))
(goto (label there))
here
(assign a (const 4))
(goto (label there))
there)))
(set-register-contents! ambiguous-machine 'a 1)
(start ambiguous-machine)
(get-register-contents ambiguous-machine 'a)
| false |
e8d8bc0b6cb7183c2a6a97ae6a7d8f31f7198698 | 8a0660bd8d588f94aa429050bb8d32c9cd4290d5 | /lib/rnrs/base.scm | d5464fe869ad40ea4a9797d747f181e6b3d676f3 | [
"BSD-2-Clause"
]
| permissive | david135/sagittarius-scheme | dbec76f6b227f79713169985fc16ce763c889472 | 2fbd9d153c82e2aa342bfddd59ed54d43c5a7506 | refs/heads/master | 2016-09-02T02:44:31.668025 | 2013-12-21T07:24:08 | 2013-12-21T07:24:08 | 32,497,456 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,624 | scm | base.scm | ;; -*- scheme -*-
(library (rnrs base (6))
(export
;; base
define define-syntax
quote lambda if set! cond case and or
let let* letrec letrec* let-values let*-values
begin quasiquote unquote unquote-splicing
let-syntax letrec-syntax syntax-rules
identifier-syntax assert
else => ... _
eq?
eqv?
equal?
procedure?
number? complex? real? rational? integer?
real-valued? rational-valued? integer-valued?
exact? inexact?
inexact exact
= < > <= >=
zero? positive? negative? odd? even?
finite? infinite? nan?
max min + * - / abs
div-and-mod div mod div0-and-mod0 div0 mod0
gcd lcm numerator denominator
floor ceiling truncate round
rationalize
exp log sin cos tan asin acos atan
sqrt
exact-integer-sqrt
expt
make-rectangular make-polar real-part imag-part
magnitude angle
number->string string->number
not boolean? boolean=?
pair? cons car cdr
caar cadr cdar cddr caaar caadr cadar
caddr cdaar cdadr cddar cdddr caaaar caaadr
caadar caaddr cadaar cadadr caddar cadddr cdaaar
cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr
null? list? list length append reverse list-tail
list-ref map for-each
symbol? symbol->string string->symbol symbol=?
char? char->integer integer->char
char=? char<? char>? char<=? char>=?
string? make-string string string-length string-ref
string=? string<? string>? string<=? string>=?
substring string-append string->list list->string string-copy string-for-each
vector? make-vector vector vector-length vector-ref vector-set!
vector->list list->vector vector-fill!
vector-map vector-for-each
error assertion-violation
apply call-with-current-continuation call/cc
values call-with-values dynamic-wind)
;; TODO use import only
(import (core)
(core base)
(core errors)
(core arithmetic)
(core syntax)
(core inline) ;; some of the procedures are inlined in here
(sagittarius))
;; we can make simple inliner here
;; hope nobody use (core base) directly... well no promise though...
(define-inliner map (core base)
((_ p arg)
(let ((proc p))
(let loop ((l arg) (r '()))
(if (null? l)
(reverse! r)
(loop (cdr l) (cons (proc (car l)) r)))))))
(define-inliner for-each (core base)
((_ p arg)
(let ((proc p))
(let loop ((l arg))
(unless (null? l)
(proc (car l))
(loop (cdr l)))))))
;; from nmosh start
(define-syntax identifier-syntax
(lambda (x)
(syntax-case x (set!)
((_ e)
(syntax (lambda (x)
(syntax-case x ()
(id (identifier? (syntax id)) (syntax e))
((_ x (... ...)) (syntax (e x (... ...))))))))
((_ (id exp1)
((set! var val) exp2))
(and (identifier? (syntax id))
(identifier? (syntax var)))
(syntax
(make-variable-transformer
(lambda (x)
(syntax-case x (set!)
((set! var val) (syntax exp2))
((id x (... ...)) (syntax (exp1 x (... ...))))
(id (identifier? (syntax id)) (syntax exp1))))))))))
(define-syntax assert
(syntax-rules ()
((_ expression)
(let ((p expression))
(if p
p
(assertion-violation #f "assertion failed" 'expression))))))
;; from nmosh end
) ;[end]
;; end of file
;; Local Variables:
;; coding: utf-8-unix
;; End:
| true |
18ae01953c2336f17c959681d35ddb4c0b7252ad | bf1c9803ae38f9aad027fbe4569ccc6f85ba63ab | /chapter_2/2.2.Hierarchical.Data.and.the.Closure.Property/1_listing.scm | 764cf1e87e6fb38bbbe33724337db273408bf86c | []
| 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 | 1,389 | scm | 1_listing.scm | #lang sicp
(cons 2 nil)
(define (make-list n)
(define (list-iter i)
(if (= i n)
(cons n nil)
(cons i (list-iter (inc i)))))
(cons 0 (list-iter 1)))
(make-list 10)
(define one-through-four (list 1 2 3 4))
one-through-four
(car one-through-four)
(car (cdr one-through-four))
(car (cdr (cdr one-through-four)))
(car (cdr (cdr (cdr one-through-four))))
(cons 99 one-through-four)
(display "Search list by index")(newline)
(define (list-ref lst i)
(if (= i 0)
(car lst)
(list-ref (cdr lst) (dec i))))
(define lett-list (list "a" "b" "c" "d" "e"))
(list-ref lett-list 0)
(list-ref lett-list 3)
(list-ref lett-list 4)
(display "Measure list length")(newline)
(define (length-rec lst)
(if (null? lst)
0
(+ 1 (length-rec (cdr lst)))))
(length-rec one-through-four)
(length-rec lett-list)
(length-rec (list))
(display "----------------")(newline)
(define (length lst)
(define (length-iter acc lst)
(if (null? lst)
acc
(length-iter (inc acc) (cdr lst))))
(length-iter 0 lst))
(length one-through-four)
(length lett-list)
(length (list))
(display "Concatenate two lists")(newline)
(define (concatenate list-1 list-2)
(if (null? list-1)
list-2
(cons (car list-1) (concatenate (cdr list-1) list-2))))
(concatenate (list 1 2 3) (list "a" "b" "c"))
(concatenate (list "a" "b" "c") (list 1 2 3)) | false |
dd76dc49b475d53516566dec8f32fae3aabf0af5 | ab05b79ab17619f548d9762a46199dc9eed6b3e9 | /sitelib/ypsilon/gtkglext.scm | 9650824cd2f89c2234d8936e29938373523ce724 | [
"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 | 25,407 | scm | gtkglext.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 gtkglext)
(export GDK_GL_ACCUM_ALPHA_SIZE
GDK_GL_ACCUM_BLUE_SIZE
GDK_GL_ACCUM_BUFFER_BIT
GDK_GL_ACCUM_GREEN_SIZE
GDK_GL_ACCUM_RED_SIZE
GDK_GL_ALPHA_SIZE
GDK_GL_AUX_BUFFERS
GDK_GL_AUX_BUFFERS_BIT
GDK_GL_BACK_LEFT_BUFFER_BIT
GDK_GL_BACK_RIGHT_BUFFER_BIT
GDK_GL_BAD_ATTRIBUTE
GDK_GL_BAD_CONTEXT
GDK_GL_BAD_ENUM
GDK_GL_BAD_SCREEN
GDK_GL_BAD_VALUE
GDK_GL_BAD_VISUAL
GDK_GL_BLUE_SIZE
GDK_GL_BUFFER_SIZE
GDK_GL_COLOR_INDEX_BIT
GDK_GL_COLOR_INDEX_TYPE
GDK_GL_CONFIG_CAVEAT
GDK_GL_CONFIG_CAVEAT_DONT_CARE
GDK_GL_CONFIG_CAVEAT_NONE
GDK_GL_DAMAGED
GDK_GL_DEPTH_BUFFER_BIT
GDK_GL_DEPTH_SIZE
GDK_GL_DIRECT_COLOR
GDK_GL_DOUBLEBUFFER
GDK_GL_DRAWABLE_TYPE
GDK_GL_EVENT_MASK
GDK_GL_FBCONFIG_ID
GDK_GL_FRONT_LEFT_BUFFER_BIT
GDK_GL_FRONT_RIGHT_BUFFER_BIT
GDK_GL_GRAY_SCALE
GDK_GL_GREEN_SIZE
GDK_GL_HEIGHT
GDK_GL_LARGEST_PBUFFER
GDK_GL_LEVEL
GDK_GL_MAX_PBUFFER_HEIGHT
GDK_GL_MAX_PBUFFER_PIXELS
GDK_GL_MAX_PBUFFER_WIDTH
GDK_GL_MODE_ACCUM
GDK_GL_MODE_ALPHA
GDK_GL_MODE_DEPTH
GDK_GL_MODE_DOUBLE
GDK_GL_MODE_INDEX
GDK_GL_MODE_MULTISAMPLE
GDK_GL_MODE_RGB
GDK_GL_MODE_RGBA
GDK_GL_MODE_SINGLE
GDK_GL_MODE_STENCIL
GDK_GL_MODE_STEREO
GDK_GL_NON_CONFORMANT_CONFIG
GDK_GL_NO_EXTENSION
GDK_GL_PBUFFER
GDK_GL_PBUFFER_BIT
GDK_GL_PBUFFER_CLOBBER_MASK
GDK_GL_PBUFFER_HEIGHT
GDK_GL_PBUFFER_LARGEST_PBUFFER
GDK_GL_PBUFFER_PRESERVED_CONTENTS
GDK_GL_PBUFFER_WIDTH
GDK_GL_PIXMAP_BIT
GDK_GL_PRESERVED_CONTENTS
GDK_GL_PSEUDO_COLOR
GDK_GL_RED_SIZE
GDK_GL_RENDER_TYPE
GDK_GL_RGBA
GDK_GL_RGBA_BIT
GDK_GL_RGBA_TYPE
GDK_GL_SAMPLES
GDK_GL_SAMPLE_BUFFERS
GDK_GL_SAVED
GDK_GL_SCREEN
GDK_GL_SLOW_CONFIG
GDK_GL_STATIC_COLOR
GDK_GL_STATIC_GRAY
GDK_GL_STENCIL_BUFFER_BIT
GDK_GL_STENCIL_SIZE
GDK_GL_STEREO
GDK_GL_TRANSPARENT_ALPHA_VALUE
GDK_GL_TRANSPARENT_BLUE_VALUE
GDK_GL_TRANSPARENT_GREEN_VALUE
GDK_GL_TRANSPARENT_INDEX
GDK_GL_TRANSPARENT_INDEX_VALUE
GDK_GL_TRANSPARENT_NONE
GDK_GL_TRANSPARENT_RED_VALUE
GDK_GL_TRANSPARENT_RGB
GDK_GL_TRANSPARENT_TYPE
GDK_GL_TRUE_COLOR
GDK_GL_USE_GL
GDK_GL_VISUAL_ID
GDK_GL_VISUAL_TYPE_DONT_CARE
GDK_GL_WIDTH
GDK_GL_WINDOW
GDK_GL_WINDOW_BIT
GDK_GL_X_RENDERABLE
GDK_GL_X_VISUAL_TYPE
gdk_gl_buffer_mask_get_type
gdk_gl_config_attrib_get_type
gdk_gl_config_caveat_get_type
gdk_gl_config_error_get_type
gdk_gl_config_get_attrib
gdk_gl_config_get_colormap
gdk_gl_config_get_depth
gdk_gl_config_get_layer_plane
gdk_gl_config_get_n_aux_buffers
gdk_gl_config_get_n_sample_buffers
gdk_gl_config_get_screen
gdk_gl_config_get_type
gdk_gl_config_get_visual
gdk_gl_config_has_accum_buffer
gdk_gl_config_has_alpha
gdk_gl_config_has_depth_buffer
gdk_gl_config_has_stencil_buffer
gdk_gl_config_is_double_buffered
gdk_gl_config_is_rgba
gdk_gl_config_is_stereo
gdk_gl_config_mode_get_type
gdk_gl_config_new
gdk_gl_config_new_by_mode
gdk_gl_config_new_by_mode_for_screen
gdk_gl_config_new_for_screen
gdk_gl_context_copy
gdk_gl_context_destroy
gdk_gl_context_get_current
gdk_gl_context_get_gl_config
gdk_gl_context_get_gl_drawable
gdk_gl_context_get_render_type
gdk_gl_context_get_share_list
gdk_gl_context_get_type
gdk_gl_context_is_direct
gdk_gl_context_new
gdk_gl_draw_cone
gdk_gl_draw_cube
gdk_gl_draw_dodecahedron
gdk_gl_draw_icosahedron
gdk_gl_draw_octahedron
gdk_gl_draw_sphere
gdk_gl_draw_teapot
gdk_gl_draw_tetrahedron
gdk_gl_draw_torus
gdk_gl_drawable_attrib_get_type
gdk_gl_drawable_get_current
gdk_gl_drawable_get_gl_config
gdk_gl_drawable_get_size
gdk_gl_drawable_get_type
gdk_gl_drawable_gl_begin
gdk_gl_drawable_gl_end
gdk_gl_drawable_is_double_buffered
gdk_gl_drawable_make_current
gdk_gl_drawable_swap_buffers
gdk_gl_drawable_type_get_type
gdk_gl_drawable_type_mask_get_type
gdk_gl_drawable_wait_gdk
gdk_gl_drawable_wait_gl
gdk_gl_event_mask_get_type
gdk_gl_event_type_get_type
gdk_gl_font_use_pango_font
gdk_gl_font_use_pango_font_for_display
gdk_gl_get_proc_address
gdk_gl_init
gdk_gl_init_check
gdk_gl_parse_args
gdk_gl_pbuffer_attrib_get_type
gdk_gl_pixmap_destroy
gdk_gl_pixmap_get_pixmap
gdk_gl_pixmap_get_type
gdk_gl_pixmap_new
gdk_gl_query_extension
gdk_gl_query_extension_for_display
gdk_gl_query_gl_extension
gdk_gl_query_version
gdk_gl_query_version_for_display
gdk_gl_render_type_get_type
gdk_gl_render_type_mask_get_type
gdk_gl_transparent_type_get_type
gdk_gl_visual_type_get_type
gdk_gl_window_destroy
gdk_gl_window_get_type
gdk_gl_window_get_window
gdk_gl_window_new
gdk_pixmap_get_gl_pixmap
gdk_pixmap_is_gl_capable
gdk_pixmap_set_gl_capability
gdk_pixmap_unset_gl_capability
gdk_window_get_gl_window
gdk_window_is_gl_capable
gdk_window_set_gl_capability
gdk_window_unset_gl_capability
gtk_gl_init
gtk_gl_init_check
gtk_gl_parse_args
gtk_widget_create_gl_context
gtk_widget_get_gl_config
gtk_widget_get_gl_context
gtk_widget_get_gl_window
gtk_widget_is_gl_capable
gtk_widget_set_gl_capability)
(import (rnrs) (ypsilon ffi))
(define libgtk-name
(cond (on-darwin "libgtkglext-x11-1.0.0.dylib")
(on-linux "libgtkglext-x11-1.0.so.0")
(on-sunos "libgtkglext-x11-1.0.so.0")
(on-freebsd "libgtkglext-x11-1.0.so")
(on-openbsd "libgtkglext-x11-1.0.so")
(on-windows "libgtkglext-win32-1.0-0.dll")
(else
(assertion-violation #f "can not locate GtkGLExt library, unknown operating system"))))
(define libgdk-name
(cond (on-darwin "libgdkglext-x11-1.0.0.dylib")
(on-linux "libgdkglext-x11-1.0.so.0")
(on-sunos "libgdkglext-x11-1.0.so.0")
(on-freebsd "libgdkglext-x11-1.0.so")
(on-openbsd "libgdkglext-x11-1.0.so")
(on-windows "libgdkglext-win32-1.0-0.dll")
(else
(assertion-violation #f "can not locate GdkGLExt library, unknown operating system"))))
(define libgtk (load-shared-object libgtk-name))
(define libgdk (load-shared-object libgdk-name))
(define-syntax define-function/gtk
(syntax-rules ()
((_ ret name args)
(define name (c-function libgtk libgtk-name ret name args)))))
(define-syntax define-function/gdk
(syntax-rules ()
((_ ret name args)
(define name (c-function libgdk libgdk-name ret name args)))))
(define GDK_GL_USE_GL 1)
(define GDK_GL_BUFFER_SIZE 2)
(define GDK_GL_LEVEL 3)
(define GDK_GL_RGBA 4)
(define GDK_GL_DOUBLEBUFFER 5)
(define GDK_GL_STEREO 6)
(define GDK_GL_AUX_BUFFERS 7)
(define GDK_GL_RED_SIZE 8)
(define GDK_GL_GREEN_SIZE 9)
(define GDK_GL_BLUE_SIZE 10)
(define GDK_GL_ALPHA_SIZE 11)
(define GDK_GL_DEPTH_SIZE 12)
(define GDK_GL_STENCIL_SIZE 13)
(define GDK_GL_ACCUM_RED_SIZE 14)
(define GDK_GL_ACCUM_GREEN_SIZE 15)
(define GDK_GL_ACCUM_BLUE_SIZE 16)
(define GDK_GL_ACCUM_ALPHA_SIZE 17)
(define GDK_GL_CONFIG_CAVEAT 32)
(define GDK_GL_X_VISUAL_TYPE 34)
(define GDK_GL_TRANSPARENT_TYPE 35)
(define GDK_GL_TRANSPARENT_INDEX_VALUE 36)
(define GDK_GL_TRANSPARENT_RED_VALUE 37)
(define GDK_GL_TRANSPARENT_GREEN_VALUE 38)
(define GDK_GL_TRANSPARENT_BLUE_VALUE 39)
(define GDK_GL_TRANSPARENT_ALPHA_VALUE 40)
(define GDK_GL_DRAWABLE_TYPE 32784)
(define GDK_GL_RENDER_TYPE 32785)
(define GDK_GL_X_RENDERABLE 32786)
(define GDK_GL_FBCONFIG_ID 32787)
(define GDK_GL_MAX_PBUFFER_WIDTH 32790)
(define GDK_GL_MAX_PBUFFER_HEIGHT 32791)
(define GDK_GL_MAX_PBUFFER_PIXELS 32792)
(define GDK_GL_VISUAL_ID 32779)
(define GDK_GL_SCREEN 32780)
(define GDK_GL_SAMPLE_BUFFERS 100000)
(define GDK_GL_SAMPLES 100001)
(define GDK_GL_CONFIG_CAVEAT_DONT_CARE 4294967295)
(define GDK_GL_CONFIG_CAVEAT_NONE 32768)
(define GDK_GL_SLOW_CONFIG 32769)
(define GDK_GL_NON_CONFORMANT_CONFIG 32781)
(define GDK_GL_VISUAL_TYPE_DONT_CARE 4294967295)
(define GDK_GL_TRUE_COLOR 32770)
(define GDK_GL_DIRECT_COLOR 32771)
(define GDK_GL_PSEUDO_COLOR 32772)
(define GDK_GL_STATIC_COLOR 32773)
(define GDK_GL_GRAY_SCALE 32774)
(define GDK_GL_STATIC_GRAY 32775)
(define GDK_GL_TRANSPARENT_NONE 32768)
(define GDK_GL_TRANSPARENT_RGB 32776)
(define GDK_GL_TRANSPARENT_INDEX 32777)
(define GDK_GL_WINDOW_BIT 1)
(define GDK_GL_PIXMAP_BIT 2)
(define GDK_GL_PBUFFER_BIT 4)
(define GDK_GL_RGBA_BIT 1)
(define GDK_GL_COLOR_INDEX_BIT 2)
(define GDK_GL_FRONT_LEFT_BUFFER_BIT 1)
(define GDK_GL_FRONT_RIGHT_BUFFER_BIT 2)
(define GDK_GL_BACK_LEFT_BUFFER_BIT 4)
(define GDK_GL_BACK_RIGHT_BUFFER_BIT 8)
(define GDK_GL_AUX_BUFFERS_BIT 16)
(define GDK_GL_DEPTH_BUFFER_BIT 32)
(define GDK_GL_STENCIL_BUFFER_BIT 64)
(define GDK_GL_ACCUM_BUFFER_BIT 128)
(define GDK_GL_BAD_SCREEN 1)
(define GDK_GL_BAD_ATTRIBUTE 2)
(define GDK_GL_NO_EXTENSION 3)
(define GDK_GL_BAD_VISUAL 4)
(define GDK_GL_BAD_CONTEXT 5)
(define GDK_GL_BAD_VALUE 6)
(define GDK_GL_BAD_ENUM 7)
(define GDK_GL_RGBA_TYPE 32788)
(define GDK_GL_COLOR_INDEX_TYPE 32789)
(define GDK_GL_PRESERVED_CONTENTS 32795)
(define GDK_GL_LARGEST_PBUFFER 32796)
(define GDK_GL_WIDTH 32797)
(define GDK_GL_HEIGHT 32798)
(define GDK_GL_EVENT_MASK 32799)
(define GDK_GL_PBUFFER_PRESERVED_CONTENTS 32795)
(define GDK_GL_PBUFFER_LARGEST_PBUFFER 32796)
(define GDK_GL_PBUFFER_HEIGHT 32832)
(define GDK_GL_PBUFFER_WIDTH 32833)
(define GDK_GL_PBUFFER_CLOBBER_MASK 134217728)
(define GDK_GL_DAMAGED 32800)
(define GDK_GL_SAVED 32801)
(define GDK_GL_WINDOW 32802)
(define GDK_GL_PBUFFER 32803)
(define GDK_GL_MODE_RGB 0)
(define GDK_GL_MODE_RGBA 0)
(define GDK_GL_MODE_INDEX 1)
(define GDK_GL_MODE_SINGLE 0)
(define GDK_GL_MODE_DOUBLE 2)
(define GDK_GL_MODE_STEREO 4)
(define GDK_GL_MODE_ALPHA 8)
(define GDK_GL_MODE_DEPTH 16)
(define GDK_GL_MODE_STENCIL 32)
(define GDK_GL_MODE_ACCUM 64)
(define GDK_GL_MODE_MULTISAMPLE 128)
;; GType gdk_gl_buffer_mask_get_type (void)
(define-function/gdk unsigned-long gdk_gl_buffer_mask_get_type ())
;; GType gdk_gl_config_attrib_get_type (void)
(define-function/gdk unsigned-long gdk_gl_config_attrib_get_type ())
;; GType gdk_gl_config_caveat_get_type (void)
(define-function/gdk unsigned-long gdk_gl_config_caveat_get_type ())
;; GType gdk_gl_config_error_get_type (void)
(define-function/gdk unsigned-long gdk_gl_config_error_get_type ())
;; gboolean gdk_gl_config_get_attrib (GdkGLConfig* glconfig, int attribute, int* value)
(define-function/gdk int gdk_gl_config_get_attrib (void* int void*))
;; GdkColormap* gdk_gl_config_get_colormap (GdkGLConfig* glconfig)
(define-function/gdk void* gdk_gl_config_get_colormap (void*))
;; gint gdk_gl_config_get_depth (GdkGLConfig* glconfig)
(define-function/gdk int gdk_gl_config_get_depth (void*))
;; gint gdk_gl_config_get_layer_plane (GdkGLConfig* glconfig)
(define-function/gdk int gdk_gl_config_get_layer_plane (void*))
;; gint gdk_gl_config_get_n_aux_buffers (GdkGLConfig* glconfig)
(define-function/gdk int gdk_gl_config_get_n_aux_buffers (void*))
;; gint gdk_gl_config_get_n_sample_buffers (GdkGLConfig* glconfig)
(define-function/gdk int gdk_gl_config_get_n_sample_buffers (void*))
;; GdkScreen* gdk_gl_config_get_screen (GdkGLConfig* glconfig)
(define-function/gdk void* gdk_gl_config_get_screen (void*))
;; GType gdk_gl_config_get_type (void)
(define-function/gdk unsigned-long gdk_gl_config_get_type ())
;; GdkVisual* gdk_gl_config_get_visual (GdkGLConfig* glconfig)
(define-function/gdk void* gdk_gl_config_get_visual (void*))
;; gboolean gdk_gl_config_has_accum_buffer (GdkGLConfig* glconfig)
(define-function/gdk int gdk_gl_config_has_accum_buffer (void*))
;; gboolean gdk_gl_config_has_alpha (GdkGLConfig* glconfig)
(define-function/gdk int gdk_gl_config_has_alpha (void*))
;; gboolean gdk_gl_config_has_depth_buffer (GdkGLConfig* glconfig)
(define-function/gdk int gdk_gl_config_has_depth_buffer (void*))
;; gboolean gdk_gl_config_has_stencil_buffer (GdkGLConfig* glconfig)
(define-function/gdk int gdk_gl_config_has_stencil_buffer (void*))
;; gboolean gdk_gl_config_is_double_buffered (GdkGLConfig* glconfig)
(define-function/gdk int gdk_gl_config_is_double_buffered (void*))
;; gboolean gdk_gl_config_is_rgba (GdkGLConfig* glconfig)
(define-function/gdk int gdk_gl_config_is_rgba (void*))
;; gboolean gdk_gl_config_is_stereo (GdkGLConfig* glconfig)
(define-function/gdk int gdk_gl_config_is_stereo (void*))
;; GType gdk_gl_config_mode_get_type (void)
(define-function/gdk unsigned-long gdk_gl_config_mode_get_type ())
;; GdkGLConfig* gdk_gl_config_new (const int* attrib_list)
(define-function/gdk void* gdk_gl_config_new (void*))
;; GdkGLConfig* gdk_gl_config_new_by_mode (GdkGLConfigMode mode)
(define-function/gdk void* gdk_gl_config_new_by_mode (int))
;; GdkGLConfig* gdk_gl_config_new_by_mode_for_screen (GdkScreen* screen, GdkGLConfigMode mode)
(define-function/gdk void* gdk_gl_config_new_by_mode_for_screen (void* int))
;; GdkGLConfig* gdk_gl_config_new_for_screen (GdkScreen* screen, const int* attrib_list)
(define-function/gdk void* gdk_gl_config_new_for_screen (void* void*))
;; gboolean gdk_gl_context_copy (GdkGLContext* glcontext, GdkGLContext* src, unsigned long mask)
(define-function/gdk int gdk_gl_context_copy (void* void* unsigned-long))
;; void gdk_gl_context_destroy (GdkGLContext* glcontext)
(define-function/gdk void gdk_gl_context_destroy (void*))
;; GdkGLContext* gdk_gl_context_get_current (void)
(define-function/gdk void* gdk_gl_context_get_current ())
;; GdkGLConfig* gdk_gl_context_get_gl_config (GdkGLContext* glcontext)
(define-function/gdk void* gdk_gl_context_get_gl_config (void*))
;; GdkGLDrawable* gdk_gl_context_get_gl_drawable (GdkGLContext* glcontext)
(define-function/gdk void* gdk_gl_context_get_gl_drawable (void*))
;; int gdk_gl_context_get_render_type (GdkGLContext* glcontext)
(define-function/gdk int gdk_gl_context_get_render_type (void*))
;; GdkGLContext* gdk_gl_context_get_share_list (GdkGLContext* glcontext)
(define-function/gdk void* gdk_gl_context_get_share_list (void*))
;; GType gdk_gl_context_get_type (void)
(define-function/gdk unsigned-long gdk_gl_context_get_type ())
;; gboolean gdk_gl_context_is_direct (GdkGLContext* glcontext)
(define-function/gdk int gdk_gl_context_is_direct (void*))
;; GdkGLContext* gdk_gl_context_new (GdkGLDrawable* gldrawable, GdkGLContext* share_list, gboolean direct, int render_type)
(define-function/gdk void* gdk_gl_context_new (void* void* int int))
;; void gdk_gl_draw_cone (gboolean solid, double base, double height, int slices, int stacks)
(define-function/gdk void gdk_gl_draw_cone (int double double int int))
;; void gdk_gl_draw_cube (gboolean solid, double size)
(define-function/gdk void gdk_gl_draw_cube (int double))
;; void gdk_gl_draw_dodecahedron (gboolean solid)
(define-function/gdk void gdk_gl_draw_dodecahedron (int))
;; void gdk_gl_draw_icosahedron (gboolean solid)
(define-function/gdk void gdk_gl_draw_icosahedron (int))
;; void gdk_gl_draw_octahedron (gboolean solid)
(define-function/gdk void gdk_gl_draw_octahedron (int))
;; void gdk_gl_draw_sphere (gboolean solid, double radius, int slices, int stacks)
(define-function/gdk void gdk_gl_draw_sphere (int double int int))
;; void gdk_gl_draw_teapot (gboolean solid, double scale)
(define-function/gdk void gdk_gl_draw_teapot (int double))
;; void gdk_gl_draw_tetrahedron (gboolean solid)
(define-function/gdk void gdk_gl_draw_tetrahedron (int))
;; void gdk_gl_draw_torus (gboolean solid, double inner_radius, double outer_radius, int nsides, int rings)
(define-function/gdk void gdk_gl_draw_torus (int double double int int))
;; GType gdk_gl_drawable_attrib_get_type (void)
(define-function/gdk unsigned-long gdk_gl_drawable_attrib_get_type ())
;; GdkGLDrawable* gdk_gl_drawable_get_current (void)
(define-function/gdk void* gdk_gl_drawable_get_current ())
;; GdkGLConfig* gdk_gl_drawable_get_gl_config (GdkGLDrawable* gldrawable)
(define-function/gdk void* gdk_gl_drawable_get_gl_config (void*))
;; void gdk_gl_drawable_get_size (GdkGLDrawable* gldrawable, gint* width, gint* height)
(define-function/gdk void gdk_gl_drawable_get_size (void* void* void*))
;; GType gdk_gl_drawable_get_type (void)
(define-function/gdk unsigned-long gdk_gl_drawable_get_type ())
;; gboolean gdk_gl_drawable_gl_begin (GdkGLDrawable* gldrawable, GdkGLContext* glcontext)
(define-function/gdk int gdk_gl_drawable_gl_begin (void* void*))
;; void gdk_gl_drawable_gl_end (GdkGLDrawable* gldrawable)
(define-function/gdk void gdk_gl_drawable_gl_end (void*))
;; gboolean gdk_gl_drawable_is_double_buffered (GdkGLDrawable* gldrawable)
(define-function/gdk int gdk_gl_drawable_is_double_buffered (void*))
;; gboolean gdk_gl_drawable_make_current (GdkGLDrawable* gldrawable, GdkGLContext* glcontext)
(define-function/gdk int gdk_gl_drawable_make_current (void* void*))
;; void gdk_gl_drawable_swap_buffers (GdkGLDrawable* gldrawable)
(define-function/gdk void gdk_gl_drawable_swap_buffers (void*))
;; GType gdk_gl_drawable_type_get_type (void)
(define-function/gdk unsigned-long gdk_gl_drawable_type_get_type ())
;; GType gdk_gl_drawable_type_mask_get_type (void)
(define-function/gdk unsigned-long gdk_gl_drawable_type_mask_get_type ())
;; void gdk_gl_drawable_wait_gdk (GdkGLDrawable* gldrawable)
(define-function/gdk void gdk_gl_drawable_wait_gdk (void*))
;; void gdk_gl_drawable_wait_gl (GdkGLDrawable* gldrawable)
(define-function/gdk void gdk_gl_drawable_wait_gl (void*))
;; GType gdk_gl_event_mask_get_type (void)
(define-function/gdk unsigned-long gdk_gl_event_mask_get_type ())
;; GType gdk_gl_event_type_get_type (void)
(define-function/gdk unsigned-long gdk_gl_event_type_get_type ())
;; PangoFont* gdk_gl_font_use_pango_font (const PangoFontDescription* font_desc, int first, int count, int list_base)
(define-function/gdk void* gdk_gl_font_use_pango_font (void* int int int))
;; PangoFont* gdk_gl_font_use_pango_font_for_display (GdkDisplay* display, const PangoFontDescription* font_desc, int first, int count, int list_base)
(define-function/gdk void* gdk_gl_font_use_pango_font_for_display (void* void* int int int))
;; GdkGLProc gdk_gl_get_proc_address (const char* proc_name)
(define-function/gdk void* gdk_gl_get_proc_address (char*))
;; void gdk_gl_init (int* argc, char** *argv)
(define-function/gdk void gdk_gl_init ((int) (* (char*))))
;; gboolean gdk_gl_init_check (int* argc, char** *argv)
(define-function/gdk int gdk_gl_init_check ((int) (* (char*))))
;; gboolean gdk_gl_parse_args (int* argc, char** *argv)
(define-function/gdk int gdk_gl_parse_args ((int) (* (char*))))
;; GType gdk_gl_pbuffer_attrib_get_type (void)
(define-function/gdk unsigned-long gdk_gl_pbuffer_attrib_get_type ())
;; void gdk_gl_pixmap_destroy (GdkGLPixmap* glpixmap)
(define-function/gdk void gdk_gl_pixmap_destroy (void*))
;; GdkPixmap* gdk_gl_pixmap_get_pixmap (GdkGLPixmap* glpixmap)
(define-function/gdk void* gdk_gl_pixmap_get_pixmap (void*))
;; GType gdk_gl_pixmap_get_type (void)
(define-function/gdk unsigned-long gdk_gl_pixmap_get_type ())
;; GdkGLPixmap* gdk_gl_pixmap_new (GdkGLConfig* glconfig, GdkPixmap* pixmap, const int* attrib_list)
(define-function/gdk void* gdk_gl_pixmap_new (void* void* void*))
;; gboolean gdk_gl_query_extension (void)
(define-function/gdk int gdk_gl_query_extension ())
;; gboolean gdk_gl_query_extension_for_display (GdkDisplay* display)
(define-function/gdk int gdk_gl_query_extension_for_display (void*))
;; gboolean gdk_gl_query_gl_extension (const char* extension)
(define-function/gdk int gdk_gl_query_gl_extension (char*))
;; gboolean gdk_gl_query_version (int* major, int* minor)
(define-function/gdk int gdk_gl_query_version (void* void*))
;; gboolean gdk_gl_query_version_for_display (GdkDisplay* display, int* major, int* minor)
(define-function/gdk int gdk_gl_query_version_for_display (void* void* void*))
;; GType gdk_gl_render_type_get_type (void)
(define-function/gdk unsigned-long gdk_gl_render_type_get_type ())
;; GType gdk_gl_render_type_mask_get_type (void)
(define-function/gdk unsigned-long gdk_gl_render_type_mask_get_type ())
;; GType gdk_gl_transparent_type_get_type (void)
(define-function/gdk unsigned-long gdk_gl_transparent_type_get_type ())
;; GType gdk_gl_visual_type_get_type (void)
(define-function/gdk unsigned-long gdk_gl_visual_type_get_type ())
;; void gdk_gl_window_destroy (GdkGLWindow* glwindow)
(define-function/gdk void gdk_gl_window_destroy (void*))
;; GType gdk_gl_window_get_type (void)
(define-function/gdk unsigned-long gdk_gl_window_get_type ())
;; GdkWindow* gdk_gl_window_get_window (GdkGLWindow* glwindow)
(define-function/gdk void* gdk_gl_window_get_window (void*))
;; GdkGLWindow* gdk_gl_window_new (GdkGLConfig* glconfig, GdkWindow* window, const int* attrib_list)
(define-function/gdk void* gdk_gl_window_new (void* void* void*))
;; GdkGLPixmap* gdk_pixmap_get_gl_pixmap (GdkPixmap* pixmap)
(define-function/gdk void* gdk_pixmap_get_gl_pixmap (void*))
;; gboolean gdk_pixmap_is_gl_capable (GdkPixmap* pixmap)
(define-function/gdk int gdk_pixmap_is_gl_capable (void*))
;; GdkGLPixmap* gdk_pixmap_set_gl_capability (GdkPixmap* pixmap, GdkGLConfig* glconfig, const int* attrib_list)
(define-function/gdk void* gdk_pixmap_set_gl_capability (void* void* void*))
;; void gdk_pixmap_unset_gl_capability (GdkPixmap* pixmap)
(define-function/gdk void gdk_pixmap_unset_gl_capability (void*))
;; GdkGLWindow* gdk_window_get_gl_window (GdkWindow* window)
(define-function/gdk void* gdk_window_get_gl_window (void*))
;; gboolean gdk_window_is_gl_capable (GdkWindow* window)
(define-function/gdk int gdk_window_is_gl_capable (void*))
;; GdkGLWindow* gdk_window_set_gl_capability (GdkWindow* window, GdkGLConfig* glconfig, const int* attrib_list)
(define-function/gdk void* gdk_window_set_gl_capability (void* void* void*))
;; void gdk_window_unset_gl_capability (GdkWindow* window)
(define-function/gdk void gdk_window_unset_gl_capability (void*))
;; void gtk_gl_init (int* argc, char** *argv)
(define-function/gtk void gtk_gl_init ((int) (* (char*))))
;; gboolean gtk_gl_init_check (int* argc, char** *argv)
(define-function/gtk int gtk_gl_init_check ((int) (* (char*))))
;; gboolean gtk_gl_parse_args (int* argc, char** *argv)
(define-function/gtk int gtk_gl_parse_args ((int) (* (char*))))
;; GdkGLContext* gtk_widget_create_gl_context (GtkWidget* widget, GdkGLContext* share_list, gboolean direct, int render_type)
(define-function/gtk void* gtk_widget_create_gl_context (void* void* int int))
;; GdkGLConfig* gtk_widget_get_gl_config (GtkWidget* widget)
(define-function/gtk void* gtk_widget_get_gl_config (void*))
;; GdkGLContext* gtk_widget_get_gl_context (GtkWidget* widget)
(define-function/gtk void* gtk_widget_get_gl_context (void*))
;; GdkGLWindow* gtk_widget_get_gl_window (GtkWidget* widget)
(define-function/gtk void* gtk_widget_get_gl_window (void*))
;; gboolean gtk_widget_is_gl_capable (GtkWidget* widget)
(define-function/gtk int gtk_widget_is_gl_capable (void*))
;; gboolean gtk_widget_set_gl_capability (GtkWidget* widget, GdkGLConfig* glconfig, GdkGLContext* share_list, gboolean direct, int render_type)
(define-function/gtk int gtk_widget_set_gl_capability (void* void* void* int int))
) ;[end]
| true |
bd3a57620fb42e10c4bf30f733dafe1ded233c74 | ac2a3544b88444eabf12b68a9bce08941cd62581 | /tests/unit-tests/01-fixnum/fxoddp.scm | 1a622d965123f538c237735d9067f30de51e5421 | [
"Apache-2.0",
"LGPL-2.1-only"
]
| permissive | tomelam/gambit | 2fd664cf6ea68859d4549fdda62d31a25b2d6c6f | d60fdeb136b2ed89b75da5bfa8011aa334b29020 | refs/heads/master | 2020-11-27T06:39:26.718179 | 2019-12-15T16:56:31 | 2019-12-15T16:56:31 | 229,341,552 | 1 | 0 | Apache-2.0 | 2019-12-20T21:52:26 | 2019-12-20T21:52:26 | null | UTF-8 | Scheme | false | false | 462 | scm | fxoddp.scm | (include "#.scm")
(check-eqv? (##fxodd? 1) #t)
(check-eqv? (##fxodd? 0) #f)
(check-eqv? (fxodd? 1) #t)
(check-eqv? (fxodd? 0) #f)
(check-tail-exn type-exception? (lambda () (fxodd? 0.0)))
(check-tail-exn type-exception? (lambda () (fxodd? 0.5)))
(check-tail-exn type-exception? (lambda () (fxodd? 1/2)))
(check-tail-exn wrong-number-of-arguments-exception? (lambda () (fxodd?)))
(check-tail-exn wrong-number-of-arguments-exception? (lambda () (fxodd? 2 4)))
| false |
588b3bc4b57867c972e2002389bec4a5e6973269 | 124373bea147b7dc1c81c9933b82c06b7206b01d | /test-closure-cps.ss | 556e195b69ec50743b0e21e24913e6a32b0ceabf | []
| no_license | jams2/scheme-scheme-interpreter | 2d2f7b555998ca9adab11377dd9bbe592e3cf54d | a9b9346d78b475190b0221c2ceb048a0b0fa61ba | refs/heads/master | 2022-11-10T18:45:09.937875 | 2020-06-30T14:07:37 | 2020-06-30T14:07:37 | 274,166,990 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 55 | ss | test-closure-cps.ss | (include "closure-cps.ss")
(include "common-tests.ss")
| false |
7bed2e27b5e5f1b7e69378a06c84639c9a3ded43 | 185024f40e1ceed452781a1f3f57e6d16f57d799 | /bonfire/screen.ss | c46cc55aace2b8a74b2d00b8c93e6aa041ec6c94 | []
| 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 | 5,740 | ss | screen.ss | #lang scheme/gui
(require
"mark.ss"
"plot.ss"
(except-in "frame.ss" Frame))
(define default-width 300)
(define default-height 300)
(define default-padding 20)
(define (plot-screen frame #:title [title "Bonfire"])
(define scale 0)
(define origin-x 0)
(define origin-y 0)
(define f (new frame%
[label title]
[width (inexact->exact (ceiling (+ (* 2 default-padding) default-width)))]
[height (inexact->exact (ceiling (+ (* 2 default-padding) default-height)))]))
(define c (new (class canvas%
(super-new)
(define/override (on-event evt)
(when (send evt button-down?)
(let ([x (send evt get-x)]
[y (send evt get-y)])
(printf "~a ~a ~a\n" scale origin-x origin-y)
(printf "Screen: [~a ~a]\n" x y)
(printf "Data: [~a ~a]\n"
(- (/ x scale) origin-x)
(- (/ y scale) origin-y))))))
[parent f]
[paint-callback
(lambda (canvas dc)
(setup-dc-and-draw dc frame)
(let-values (([s-x s-y] (send dc get-scale))
([o-x o-y] (send dc get-origin)))
(set! scale s-x)
(set! origin-x (/ o-x scale))
(set! origin-y (/ o-y scale))))]))
(send f show #t)
f)
;; (Listof Frame) -> Void
;;
;; Click on the window to advance through a list of Frames
(define (slides frames #:title [title "Slides"])
(define f (new frame%
[label title]
[width (inexact->exact (ceiling (+ (* 2 default-padding) default-width)))]
[height (inexact->exact (ceiling (+ (* 2 default-padding) default-height)))]))
;; (Channelof 'forward 'backward 'current)
(define t-chan (make-channel))
;; (Channelof Frame)
(define c-chan (make-channel))
(define t
(let* ([frames (list->vector frames)]
[n (vector-length frames)])
(thread
(lambda ()
(let loop ([idx 0] [saved null])
(match (channel-get t-chan)
['forward
(loop (modulo (add1 idx) n) saved)]
['backward
(loop (modulo (sub1 idx) n) saved)]
['current
(printf "Displaying slide ~a\n" idx)
(channel-put c-chan (vector-ref frames idx))
(loop idx saved)]
['save
(if (member idx saved)
(loop idx saved)
(loop idx (cons idx saved)))]
['dump
(printf "Saved slides:\n~a\n" saved)
(loop idx saved)]))))))
(define c (new (class canvas%
(super-new)
(define (forward)
(channel-put t-chan 'forward)
(send this refresh)
(yield))
(define (backward)
(channel-put t-chan 'backward)
(send this refresh)
(yield))
(define (save)
(channel-put t-chan 'save)
(yield))
(define (dump)
(channel-put t-chan 'dump)
(yield))
(define/override (on-char evt)
(case (send evt get-key-code)
[(left up) (backward)]
[(right down) (forward)]
[(#\space) (save)]
[(#\return) (dump)]))
(define/override (on-event evt)
(cond
[(send evt button-down? 'left)
(forward)]
[(send evt button-down? 'right)
(backward)])))
[parent f]
[paint-callback
(lambda (canvas dc)
(channel-put t-chan 'current)
(setup-dc-and-draw dc (channel-get c-chan)))]))
(send f show #t)
f)
;;; Utilities
(define white-brush (make-object brush% "white" 'solid))
(define white-pen (make-object pen% "white" 1 'solid))
(define clear-brush (make-object brush% "white" 'transparent))
;; Hack so match can work with Typed Scheme structs
(define-struct Frame (offset-x offset-y left top width height style) #:omit-define-values)
;; For plotting to the screen we setup a square DC and scale
;; the plot to fit
(define (setup-dc-and-draw dc f)
(match-define (struct Frame (ox oy l t w h s)) f)
(define bottom (+ t h))
(define right (+ l w))
(define data-bounding-square-width (max w h))
(define-values (width height) (send dc get-size))
(define canvas-bounding-square-width (min width height))
(define scale (/ canvas-bounding-square-width data-bounding-square-width))
(define origin (vector-immutable ox oy))
(printf "Scale ~a\n" scale)
(parameterize
([current-scale scale])
;; Clearing the DC doesn't always work, so we attempt
;; drawing a white rectangle over it
(send dc set-origin 0 0)
(send dc set-scale 1 1)
(send dc set-brush white-brush)
(send dc set-pen white-pen)
(send dc draw-rectangle 0 0 width height)
(send dc clear)
(send dc set-smoothing 'smoothed)
(send dc set-origin (* scale (- l)) (* scale (- t)))
(send dc set-scale scale scale)
(send dc set-brush clear-brush)
(draw-frame dc origin f)))
(provide
plot-screen
slides) | false |
30acf02e0ee3f43f19fc5dc1fbf1333024610d53 | 636e10279a19e26c8060f1944259af5ecd06393c | /bin/carrot-read.scm | 49a49c8f3fa298c4f841b7c7cada42bc862ec311 | [
"MIT"
]
| permissive | ympbyc/Carrot | 675eab6c9d98523204db90f4a8a2cfc9996e979d | c5258a878864fa4c91727c99820d8348185c84e7 | refs/heads/master | 2022-12-21T04:03:34.327669 | 2022-12-16T10:59:04 | 2022-12-16T10:59:04 | 6,885,775 | 60 | 4 | null | 2017-03-21T12:48:51 | 2012-11-27T15:31:45 | Scheme | UTF-8 | Scheme | false | false | 1,002 | scm | carrot-read.scm | #!/usr/local/bin/gosh
(add-load-path "../lib/" :relative)
(add-load-path "/usr/local/share/Carrot/2.2.0/lib/" :absolute)
(use DataTypes)
(use Read)
(define banner
"
----------------------
| CARROT 2.2.0 |
----------------------
https://github.com/ympbyc/Carrot
Reading your carrot...
")
(define (read-list port)
(let ((exp (read port)))
(if (eof-object? exp) '()
(cons exp (read-list port)))))
(define (main _)
(let* ([program (read-list (standard-input-port))]
[_ (format (standard-error-port) banner)]
[exprs*types*genmap
(read-s-exprs* program
(make-hash-table 'eq?)
(make-hash-table 'eq?)
(make-hash-table 'eq?))])
(display
(triple (write-hash-table (fst exprs*types*genmap))
(write-hash-table (snd exprs*types*genmap))
(write-hash-table (thd exprs*types*genmap))))))
| false |
2ae455abb3183478a7131da1ff1d999476bb54b6 | c3523080a63c7e131d8b6e0994f82a3b9ed901ce | /hertfordstreet/schemes/queensbuggered.scm | 224cb9b1a41ae90073df24f0d04f6e3d76a791e5 | []
| no_license | johnlawrenceaspden/hobby-code | 2c77ffdc796e9fe863ae66e84d1e14851bf33d37 | d411d21aa19fa889add9f32454915d9b68a61c03 | refs/heads/master | 2023-08-25T08:41:18.130545 | 2023-08-06T12:27:29 | 2023-08-06T12:27:29 | 377,510 | 6 | 4 | null | 2023-02-22T00:57:49 | 2009-11-18T19:57:01 | Clojure | UTF-8 | Scheme | false | false | 3,984 | scm | queensbuggered.scm | (load "johnlib.scm")
(define (enumerate-interval low high)
(if (> low high) '() (cons low (enumerate-interval (+ low 1) high))))
(define empty-board '())
(define (adjoin-position x l)
(cons x l))
(define (queens board-size)
(queen-cols board-size board-size))
(define (louisqueens board-size)
(louisqueen-cols board-size board-size))
(define (safe? l)
(and (safe-horizontal? l)
(safe-upperdiagonal? l)
(safe-lowerdiagonal? l)))
(define (safe-horizontal? l) (notin? (car l) (cdr l)))
(define (safe-lowerdiagonal? l) (notcheckinglower? (car l)(cdr l)))
(define (safe-upperdiagonal? l) (notcheckingupper? (car l)(cdr l)))
(define (notcheckingupper? a l)
(if (null? l) #t
(and (not (= (- a 1) (car l))) (notcheckingupper? (- a 1) (cdr l)))))
(define (notcheckinglower? a l)
(if (null? l) #t
(and (not (= (+ a 1) (car l))) (notcheckinglower? (+ a 1) (cdr l)))))
(define (notin? a l)
(if (null? l) #t (and (not(= a (car l))) (notin? a (cdr l)))))
(define (positions k n) (length (queen-cols k n)))
(define (fold-right op initial sequence) ;(fold-right cons () (a b c)) is (cons a(cons b(cons c ())))
(if (null? sequence) initial (op (car sequence) (fold-right op initial (cdr sequence)))))
(define positionpattern (lambda (n) (map (lambda (k) (positions k n)) (enumerate-interval 1 n))))
(define (sumlist l) (fold-right + 0 l))
(define (complexity n) (sumlist(positionpattern n)))
(define (complexityratio n) (/ (complexity n) (expt 3 (- n 1))))
(define (printsuccessivevalues function a b) (for-each (lambda (n) (begin (display (function n))(newline))) (enumerate-interval a b)))
(define (strip l)
(filter (lambda (positions) (safe? positions)) l))
(define (flatmap proc seq) (fold-right append '() (map proc seq)))
(define (queen-cols k board-size)
(if (= k 0)
(list empty-board)
(strip
(flatmap
(lambda (rest-of-queens)
(map (lambda (new-row)
(adjoin-position new-row rest-of-queens))
(enumerate-interval 1 board-size)))
(queen-cols (- k 1) board-size))
)))
(define (louisqueen-cols k board-size)
(if (= k 0)
(list empty-board)
(strip
(flatmap (lambda (new-row)
(map
(lambda (rest-of-queens)
(adjoin-position new-row rest-of-queens))
(louisqueen-cols (- k 1) board-size) ))
(enumerate-interval 1 board-size))
)))
(define (displayresults n cpu louiscpu )
(printf "~s: ~s ~s ~s " n louiscpu cpu (floor (/ louiscpu cpu)) )
(display (sumlist (map (lambda (x) (expt n x))(enumerate-interval 0 n))))
(display (map (lambda (x) (expt n x))(enumerate-interval 0 n)))
(newline))
;profiling on
;(displayresults 3 2 8)
;(displayresults 4 7 73)
;(displayresults 5 25 948)
;(displayresults 6 104 17680)
;(displayresults 7 444 314667)
;
;debugging and profiling off
;(displayresults 4 1 5)
;(displayresults 5 2 59)
;(displayresults 6 7 924)
;(displayresults 7 33 24248)
;(displayresults 8 159 515568)
;(displayresults 9 6173 0)
;;syntactic test coverage on
;(displayresults 3 3 17)
;(displayresults 4 16 116)
;(displayresults 5 53 1437)
;(displayresults 6 194 28102)
(for-each (lambda (n)
(newline)
(display n)
(time (queens n))
(time (louisqueens n))
) (list 3 4 5 6 7 8 9))
;(queen-cols 1 3)
;(queen-cols 2 3)
;
;(strip(flatmap
; (lambda (a)
; (map
; (lambda (b)
; (list a b))
; '(1 2 3)))
; '(1 2 3 4)))
;
;(define (doublemap f l1 l2)
; (flatmap (lambda(a) (map (lambda(b) (f a b)) l1)) l2))
;
;(define (doublerevmap f l1 l2)
; (doublemap (lambda (a b) (f b a)) l2 l1))
;
;(doublemap cons '(1 2 3) '(a b c d))
;
;(doublemap cons '( a b c d) (list 1 2 3))
;
;
;(doublerevmap cons '(1 2 3) '(a b c d))
;
;(doublerevmap cons '( a b c d) (list 1 2 3))
| false |
2d7f360d1f9da9b69fe6d1afaf2c4cde58ffaee8 | 30c99bf023dad4dba127217f72d20d2cf72f365d | /examples/Benchmark/splay.scm | 96e7753db65b244c1112b62c0fe9df6876212d34 | []
| no_license | peterthiemann/pgg | 4154b9e2b79657db3c6b984ba462b7270e5d0dbf | 556eac6ffddecd2ef5cfd67ebe2fc6be514b3372 | refs/heads/master | 2016-09-05T10:44:45.881487 | 2012-05-28T17:29:54 | 2012-05-28T17:29:54 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 130,597 | scm | splay.scm | ; Generated by CF Analysis Development Version, June 1, 1995
; (cf:control 'poly 'if-split '!const-split '!verbose '!times '(cons-limit 8) '!check '!inline '!simplify '!clean)
(define (main)
(let ((*numTest* 100000))
(let ((node (lambda (v l r) (vector v l r))))
(let ((tree-foreach
(lambda (t f)
(letrec ((foreach
(lambda (t)
(if (null? t)
((lambda () ()))
(if (and (vector? t)
(equal? (vector-length t) 3))
((lambda (v l r)
(begin (f v) (foreach l) (foreach r)))
(vector-ref t 0)
(vector-ref t 1)
(vector-ref t 2))
((lambda (G10)
(match:error
G10
'(match
t
(() ())
(#(v l r)
(begin (f v)
(foreach l)
(foreach r))))))
t))))))
(foreach t)))))
(let ((tree-forall?
(lambda (t f)
(letrec ((forall?
(lambda (t)
(if (null? t)
((lambda () #t))
(if (and (vector? t)
(equal? (vector-length t) 3))
((lambda (v l r)
(and (f v) (forall? l) (forall? r)))
(vector-ref t 0)
(vector-ref t 1)
(vector-ref t 2))
((lambda (G16)
(match:error
G16
'(match
t
(() #t)
(#(v l r)
(and (f v)
(forall? l)
(forall? r))))))
t))))))
(forall? t)))))
(let ((tree-exists?
(lambda (t f)
(not (tree-forall? t (lambda (x) (not (f x))))))))
(let ((tree-fold
(lambda (t b f)
(letrec ((fold
(lambda (t)
(if (null? t)
((lambda () b))
(if (and (vector? t)
(equal? (vector-length t) 3))
((lambda (v l r)
(f v (fold l) (fold r)))
(vector-ref t 0)
(vector-ref t 1)
(vector-ref t 2))
((lambda (G22)
(match:error
G22
'(match
t
(() b)
(#(v l r)
(f v
(fold l)
(fold r))))))
t))))))
(fold t)))))
(let ((tree-size
(lambda (t) (tree-fold t 0 (lambda (_ l r) (+ 1 l r))))))
(let ((tree->list
(lambda (t)
(letrec ((x->list
(lambda (t accum)
(if (null? t)
((lambda () accum))
(if (and (vector? t)
(equal?
(vector-length t)
3))
((lambda (v l r)
(x->list
l
(cons v (x->list r accum))))
(vector-ref t 0)
(vector-ref t 1)
(vector-ref t 2))
((lambda (G28)
(match:error
G28
'(match
t
(() accum)
(#(v l r)
(x->list
l
(cons v
(x->list
r
accum)))))))
t))))))
(x->list t ())))))
(let ((splay
(lambda (t k)
(letrec ((splay
(lambda (t)
(if (and (vector? t)
(equal? (vector-length t) 3))
((lambda (v l r)
(if (= k v)
t
(if (< k v)
(if (null? l)
((lambda () t))
(if (and (vector?
l)
(equal?
(vector-length
l)
3))
((lambda (v1
l1
r1)
(if (= k v1)
(node v1
l1
(node v
r1
r))
(if (< k
v1)
(if (null?
l1)
(node v1
()
(node v
r1
r))
(let ((G43
(splay
l1)))
(if (and (vector?
G43)
(equal?
(vector-length
G43)
3))
((lambda (v2
l2
r2)
(node v2
l2
(node v1
r2
(node v
r1
r))))
(vector-ref
G43
0)
(vector-ref
G43
1)
(vector-ref
G43
2))
((lambda (G46)
(match:error
G46
'(match
(splay
l1)
(#(v2
l2
r2)
(node v2
l2
(node v1
r2
(node v
r1
r)))))))
G43))))
(if (null?
r1)
(node v1
l1
(node v
()
r))
(let ((G49
(splay
r1)))
(if (and (vector?
G49)
(equal?
(vector-length
G49)
3))
((lambda (v2
l2
r2)
(node v2
(node v1
l1
l2)
(node v
r2
r)))
(vector-ref
G49
0)
(vector-ref
G49
1)
(vector-ref
G49
2))
((lambda (G52)
(match:error
G52
'(match
(splay
r1)
(#(v2
l2
r2)
(node v2
(node v1
l1
l2)
(node v
r2
r))))))
G49)))))))
(vector-ref
l
0)
(vector-ref
l
1)
(vector-ref
l
2))
((lambda (G39)
(match:error
G39
'(match
l
(() t)
(#(v1
l1
r1)
(cond
((= k
v1)
(node v1
l1
(node v
r1
r)))
((< k
v1)
(if (null?
l1)
(node v1
()
(node v
r1
r))
(match-let
((#(v2
l2
r2)
(splay
l1)))
(node v2
l2
(node v1
r2
(node v
r1
r))))))
((null?
r1)
(node v1
l1
(node v
()
r)))
(else
(match-let
((#(v2
l2
r2)
(splay
r1)))
(node v2
(node v1
l1
l2)
(node v
r2
r)))))))))
l)))
(if (null? r)
t
(if (and (vector?
r)
(equal?
(vector-length
r)
3))
((lambda (v1
l1
r1)
(if (= k v1)
(node v1
(node v
l
l1)
r1)
(if (< k
v1)
(if (null?
l1)
(node v1
(node v
l
())
r1)
(let ((G60
(splay
l1)))
(if (and (vector?
G60)
(equal?
(vector-length
G60)
3))
((lambda (v2
l2
r2)
(node v2
(node v
l
l2)
(node v1
r2
r1)))
(vector-ref
G60
0)
(vector-ref
G60
1)
(vector-ref
G60
2))
((lambda (G63)
(match:error
G63
'(match
(splay
l1)
(#(v2
l2
r2)
(node v2
(node v
l
l2)
(node v1
r2
r1))))))
G60))))
(if (null?
r1)
(node v1
(node v
l
l1)
())
(let ((G66
(splay
r1)))
(if (and (vector?
G66)
(equal?
(vector-length
G66)
3))
((lambda (v2
l2
r2)
(node v2
(node v1
(node v
l
l1)
l2)
r2))
(vector-ref
G66
0)
(vector-ref
G66
1)
(vector-ref
G66
2))
((lambda (G69)
(match:error
G69
'(match
(splay
r1)
(#(v2
l2
r2)
(node v2
(node v1
(node v
l
l1)
l2)
r2)))))
G66)))))))
(vector-ref
r
0)
(vector-ref
r
1)
(vector-ref
r
2))
((lambda (G57)
(match:error
G57
'(match
r
(#(v1
l1
r1)
(cond
((= k
v1)
(node v1
(node v
l
l1)
r1))
((< k
v1)
(if (null?
l1)
(node v1
(node v
l
())
r1)
(match-let
((#(v2
l2
r2)
(splay
l1)))
(node v2
(node v
l
l2)
(node v1
r2
r1)))))
((null?
r1)
(node v1
(node v
l
l1)
()))
(else
(match-let
((#(v2
l2
r2)
(splay
r1)))
(node v2
(node v1
(node v
l
l1)
l2)
r2))))))))
r))))))
(vector-ref t 0)
(vector-ref t 1)
(vector-ref t 2))
((lambda (G34)
(match:error
G34
'(match
t
(#(v l r)
(cond
((= k v) t)
((< k v)
(match
l
(() t)
(#(v1 l1 r1)
(cond
((= k v1)
(node v1
l1
(node v
r1
r)))
((< k v1)
(if (null? l1)
(node v1
()
(node v
r1
r))
(match-let
((#(v2
l2
r2)
(splay
l1)))
(node v2
l2
(node v1
r2
(node v
r1
r))))))
((null? r1)
(node v1
l1
(node v
()
r)))
(else
(match-let
((#(v2
l2
r2)
(splay
r1)))
(node v2
(node v1
l1
l2)
(node v
r2
r))))))))
((null? r) t)
(else
(match-let
((#(v1 l1 r1) r))
(cond
((= k v1)
(node v1
(node v
l
l1)
r1))
((< k v1)
(if (null? l1)
(node v1
(node v
l
())
r1)
(match-let
((#(v2
l2
r2)
(splay
l1)))
(node v2
(node v
l
l2)
(node v1
r2
r1)))))
((null? r1)
(node v1
(node v
l
l1)
()))
(else
(match-let
((#(v2 l2 r2)
(splay
r1)))
(node v2
(node v1
(node v
l
l1)
l2)
r2)))))))))))
t)))))
(splay t)))))
(let ((splay-to-max
(letrec ((splay
(lambda (G72)
(let ((G74
(lambda (G75)
(match:error
G75
'(match
G72
(#(v l ())
(vector v l))
(#(v l #(v1 l1 ()))
(vector
v1
(node v l l1)))
(#(v l #(v1 l1 r1))
(match-let
((#(v2 l2)
(splay r1)))
(vector
v2
(node v1
(node v
l
l1)
l2)))))))))
(if (and (vector? G72)
(equal?
(vector-length G72)
3))
(if (null? (vector-ref G72 2))
((lambda (v l) (vector v l))
(vector-ref G72 0)
(vector-ref G72 1))
(if (and (vector?
(vector-ref
G72
2))
(equal?
(vector-length
(vector-ref
G72
2))
3))
(if (null?
(vector-ref
(vector-ref
G72
2)
2))
((lambda (v l v1 l1)
(vector
v1
(node v l l1)))
(vector-ref G72 0)
(vector-ref G72 1)
(vector-ref
(vector-ref
G72
2)
0)
(vector-ref
(vector-ref
G72
2)
1))
((lambda (v
l
v1
l1
r1)
(let ((G80
(splay
r1)))
(if (and (vector?
G80)
(equal?
(vector-length
G80)
2))
((lambda (v2
l2)
(vector
v2
(node v1
(node v
l
l1)
l2)))
(vector-ref
G80
0)
(vector-ref
G80
1))
((lambda (G83)
(match:error
G83
'(match
(splay
r1)
(#(v2
l2)
(vector
v2
(node v1
(node v
l
l1)
l2))))))
G80))))
(vector-ref G72 0)
(vector-ref G72 1)
(vector-ref
(vector-ref
G72
2)
0)
(vector-ref
(vector-ref
G72
2)
1)
(vector-ref
(vector-ref
G72
2)
2)))
(G74 G72)))
(G74 G72))))))
splay)))
(let ((splay-to-min
(letrec ((splay
(lambda (G86)
(let ((G88
(lambda (G89)
(match:error
G89
'(match
G86
(#(v () r)
(vector v r))
(#(v #(v1 () r1) r)
(vector
v1
(node v r1 r)))
(#(v #(v1 l1 r1) r)
(match-let
((#(v2 r2)
(splay l1)))
(vector
v2
(node v1
r2
(node v
r1
r))))))))))
(if (and (vector? G86)
(equal?
(vector-length G86)
3))
(if (null? (vector-ref G86 1))
((lambda (v r)
(vector v r))
(vector-ref G86 0)
(vector-ref G86 2))
(if (and (vector?
(vector-ref
G86
1))
(equal?
(vector-length
(vector-ref
G86
1))
3))
(if (null?
(vector-ref
(vector-ref
G86
1)
1))
((lambda (v
v1
r1
r)
(vector
v1
(node v
r1
r)))
(vector-ref
G86
0)
(vector-ref
(vector-ref
G86
1)
0)
(vector-ref
(vector-ref
G86
1)
2)
(vector-ref
G86
2))
((lambda (v
v1
l1
r1
r)
(let ((G94
(splay
l1)))
(if (and (vector?
G94)
(equal?
(vector-length
G94)
2))
((lambda (v2
r2)
(vector
v2
(node v1
r2
(node v
r1
r))))
(vector-ref
G94
0)
(vector-ref
G94
1))
((lambda (G97)
(match:error
G97
'(match
(splay
l1)
(#(v2
r2)
(vector
v2
(node v1
r2
(node v
r1
r)))))))
G94))))
(vector-ref
G86
0)
(vector-ref
(vector-ref
G86
1)
0)
(vector-ref
(vector-ref
G86
1)
1)
(vector-ref
(vector-ref
G86
1)
2)
(vector-ref
G86
2)))
(G88 G86)))
(G88 G86))))))
splay)))
(let ((join
(lambda (G100) ;pjt: g100 -> (g100)
(let ((G102
(lambda (G103)
(match:error
G103
'(match
G100
((() ()) ())
((() t) t)
((t ()) t)
((t t1)
(match-let
((#(v l)
(splay-to-max t)))
(node v l t1))))))))
(if (pair? G100)
(if (null? (car G100))
(if (pair? (cdr G100))
(if (null? (cadr@1 G100))
(if (null? (cddr@1 G100))
((lambda () ()))
(G102 G100))
(if (null? (cddr@1 G100))
((lambda (t) t)
(cadr@1 G100))
(G102 G100)))
(G102 G100))
(if (pair? (cdr G100))
(if (null? (cadr@1 G100))
(if (null? (cddr@1 G100))
((lambda (t) t)
(car G100))
(G102 G100))
(if (null? (cddr@1 G100))
((lambda (t t1)
(let ((G109
(splay-to-max
t)))
(if (and (vector?
G109)
(equal?
(vector-length
G109)
2))
((lambda (v
l)
(node v
l
t1))
(vector-ref
G109
0)
(vector-ref
G109
1))
((lambda (G112)
(match:error
G112
'(match
(splay-to-max
t)
(#(v
l)
(node v
l
t1)))))
G109))))
(car G100)
(cadr@1 G100))
(G102 G100)))
(G102 G100)))
(G102 G100))))))
(let ((split
(lambda (t x no yes)
(if (and (vector? t)
(equal? (vector-length t) 3))
((lambda (x1 l r)
(if (= x x1)
(yes l r)
(if (< x x1)
(no l (node x1 () r))
(no (node x1 l ()) r))))
(vector-ref t 0)
(vector-ref t 1)
(vector-ref t 2))
((lambda (G117)
(match:error
G117
'(match
t
(#(x1 l r)
(cond
((= x x1) (yes l r))
((< x x1)
(no l (node x1 () r)))
(else
(no (node x1 l ())
r)))))))
t)))))
(let ((splay-and-split
(lambda (t x no yes)
(if (null? t)
(no () ())
(split (splay t x) x no yes)))))
(let ((splay-keep-all
(lambda (t p?)
(tree-fold
t
()
(lambda (v l r)
(if (p? v)
(node v l r)
(join l r)))))))
(let ((splay-combine
(lambda (base
alone-left
alone-right
left
both)
(letrec ((combine
(lambda (G120) ;pjt: g120 -> (g120)
(let ((G122
(lambda (G123)
(match:error
G123
'(match
G120
((() ())
base)
((() t)
(alone-right
t))
((t ())
(alone-left
t))
((#(x
l
r)
t)
(let ((continue
(lambda (c)
(lambda (l1
r1)
(c x
(lambda ()
(combine
l
l1))
(lambda ()
(combine
r
r1)))))))
(splay-and-split
t
x
(continue
left)
(continue
both)))))))))
(if (pair? G120)
(if (null?
(car G120))
(if (pair?
(cdr G120))
(if (null?
(cadr@1
G120))
(if (null?
(cddr@1
G120))
((lambda ()
base))
(G122 G120))
(if (null?
(cddr@1
G120))
((lambda (t)
(alone-right
t))
(cadr@1
G120))
(G122 G120)))
(G122 G120))
(if (pair?
(cdr G120))
(if (null?
(cadr@1
G120))
(if (null?
(cddr@1
G120))
((lambda (t)
(alone-left
t))
(car G120))
(G122 G120))
(if (and (vector?
(car G120))
(equal?
(vector-length
(car G120))
3)
(null?
(cddr@1
G120)))
((lambda (x
l
r
t)
(let ((continue
(lambda (c)
(lambda (l1
r1)
(c x
(lambda ()
(combine
l
l1))
(lambda ()
(combine
r
r1)))))))
(splay-and-split
t
x
(continue
left)
(continue
both))))
(vector-ref
(car G120)
0)
(vector-ref
(car G120)
1)
(vector-ref
(car G120)
2)
(cadr@1
G120))
(G122 G120)))
(G122 G120)))
(G122 G120))))))
combine))))
(let ((empty (lambda () (make-cell ()))))
(let ((empty?
(lambda (s)
(null? (cell-ref s)))))
(let ((singleton
(lambda (x)
(make-cell (node x () ())))))
(let ((size
(lambda (s)
(tree-size (cell-ref s)))))
(let ((extremum
(lambda (splay-to
node)
(lambda (s)
(let ((t (cell-ref s)))
(if (null? t)
(error 'ordset-extremum
"empty set")
(let ((G129
(splay-to
t)))
(if (and (vector?
G129)
(equal?
(vector-length
G129)
2))
((lambda (x
lr)
(begin (cell-set!
s
(node x
lr))
x))
(vector-ref
G129
0)
(vector-ref
G129
1))
((lambda (G132)
(match:error
G132
'(match
(splay-to
t)
(#(x
lr)
(cell-set!
s
(node x
lr))
x))))
G129)))))))))
(let ((min@1
(extremum
splay-to-min
(lambda (x r)
(node x () r)))))
(let ((max@1
(extremum
splay-to-max
(lambda (x l)
(node x
l
())))))
(let ((set-split
(lambda (s
x
no
yes)
(let ((t
(cell-ref s)))
(if (null?
t)
(no ()
())
(let ((t
(splay
(cell-ref s)
x)))
(begin (cell-set!
s
t)
(split
t
x
no
yes))))))))
(let ((contains?
(lambda (s x)
(set-split
s
x
(lambda (_) ;pjt _ -> (_)
#f)
(lambda (_) ;pjt _ -> (_)
#t)))))
(let ((add
(lambda (s
x)
(set-split
s
x
(lambda (l
r)
(make-cell (node x
l
r)))
(lambda (_) ;pjt: _ -> (_)
s)))))
(let ((remove@1
(lambda (s
x)
(set-split
s
x
(lambda (_) ;pjt _ -> (_)
s)
(lambda (l
r)
(make-cell (if (null?
l)
r
(if (null?
r)
l
(let ((G135
(splay-to-max
l)))
(if (and (vector?
G135)
(equal?
(vector-length
G135)
2))
((lambda (v
l)
(begin (cell-set!
s
(node x
(node v
l
())
r))
(node v
l
r)))
(vector-ref
G135
0)
(vector-ref
G135
1))
((lambda (G138)
(match:error
G138
'(match
(splay-to-max
l)
(#(v
l)
(cell-set!
s
(node x
(node v
l
())
r))
(node v
l
r)))))
G135)))))))))))
(let ((subset
(lambda (s
p?)
(make-cell (splay-keep-all
(cell-ref s)
p?)))))
(let ((set-combine
(lambda (base
alone
no
yes
top)
(lambda (left
both
right)
(let ((node
(lambda (b)
(if b
yes
no))))
(let ((combine
(splay-combine
base
(alone
left)
(alone
right)
(node left)
(node both))))
(lambda (s
s1)
(top (combine
(cell-ref s)
(cell-ref s1))))))))))
(let ((combine-bool
(set-combine
#t
(lambda (b)
(lambda (_)
b))
(lambda (_)
#f)
(lambda (_
l
r)
(and (l)
(r)))
(lambda (b)
b))))
(let ((subset?
(combine-bool
#f
#t
#t)))
(let ((superset?
(combine-bool
#t
#t
#f)))
(let ((disjoint?
(combine-bool
#t
#f
#t)))
(let ((splay-equal?
(combine-bool
#f
#t
#f)))
(let ((combine-sets
(set-combine
()
(lambda (b)
(if b
(lambda (t)
t)
(lambda (_)
())))
(lambda (_
l
r)
(join (l)
(r)))
(lambda (x
l
r)
(node x
(l)
(r)))
(lambda (x) (make-cell x)))))
(let ((union
(combine-sets
#t
#t
#t)))
(let ((intersection
(combine-sets
#f
#t
#f)))
(let ((difference
(combine-sets
#t
#f
#f)))
(let ((list->
(lambda (l)
(letrec ((loop
(lambda (l
s)
(if (null?
l)
s
(loop (cdr l)
(add s
(car l)))))))
(loop l
(empty))))))
(let ((x->list
(lambda (s)
(tree->list
(cell-ref s)))))
(let ((exists?
(lambda (s
p?)
(tree-exists?
(cell-ref s)
p?))))
(let ((forall?
(lambda (s
p?)
(tree-forall?
(cell-ref s)
p?))))
(let ((foreach
(lambda (s
f)
(tree-foreach
(cell-ref s)
f))))
(letrec ((loop
(lambda (i)
(or (= i
*numTest*)
(let ((empty@1
(empty))
(odds
(list->
(list@1
1
3
5
7
9)))
(evens
(list->
(list@1
2
4
6
8
10)))
(mix
(list->
(list@1
1
2
4
7
8))))
(begin (if (and (empty?
empty@1)
(not (empty?
odds))
(= 0
(size empty@1))
(= 5
(size odds))
(splay-equal?
odds
odds)
(not (splay-equal?
odds
evens))
(= 10
(max@1
evens))
(= 1
(min@1
odds))
(contains?
odds
5)
(not (contains?
odds
6))
(subset?
odds
odds)
(not (subset?
mix
odds))
(subset?
mix
(union
odds
evens))
(superset?
(add odds
11)
odds)
(superset?
odds
(difference
mix
evens))
(disjoint?
(difference
mix
odds)
odds)
(not (disjoint?
evens
evens))
(superset?
odds
(remove@1
odds
1))
(splay-equal?
odds
(remove@1
odds
2))
(forall?
odds
(lambda (x) (odd? x)))
(forall?
evens
(lambda (x) (even? x)))
(subset?
(subset
mix
(lambda (x) (even? x)))
evens)
(let ((sum
0))
(begin (foreach
odds
(lambda (x)
(set! sum
(+ sum
x))))
(= sum
25)))
(subset?
(intersection
mix
odds)
odds))
(void)
(error 'splay-test
""))
(loop (+ i
1))))))))
(loop 0))))))))))))))))))))))))))))))))))))))))))))))
| false |
fbbda6262f6c39fdd16aec8d0744202f5e77de56 | 3508dcd12d0d69fec4d30c50334f8deb24f376eb | /tests/runtime/test-sha3.scm | 5de0e3031b92cb0d74bdeeb81e473fa7b11a1868 | []
| no_license | barak/mit-scheme | be625081e92c2c74590f6b5502f5ae6bc95aa492 | 56e1a12439628e4424b8c3ce2a3118449db509ab | refs/heads/master | 2023-01-24T11:03:23.447076 | 2022-09-11T06:10:46 | 2022-09-11T06:10:46 | 12,487,054 | 12 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 1,840 | scm | test-sha3.scm | #| -*-Scheme-*-
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, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016,
2017, 2018, 2019, 2020, 2021, 2022 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.
|#
;;;; Tests of SHA-3 functions
(define-test 'SHA3-256-EMPTY
(lambda ()
(assert-equal (sha3256 #u8())
#u8(
#xa7 #xff #xc6 #xf8 #xbf #x1e #xd7 #x66
#x51 #xc1 #x47 #x56 #xa0 #x61 #xd6 #x62
#xf5 #x80 #xff #x4d #xe4 #x3b #x49 #xfa
#x82 #xd8 #x0a #x4b #x80 #xf8 #x43 #x4a
))))
(define-test 'SHA3-256-HELLOWORLD
(lambda ()
(assert-equal (sha3256 (string->utf8 "hello world"))
#u8(
#x64 #x4b #xcc #x7e #x56 #x43 #x73 #x04
#x09 #x99 #xaa #xc8 #x9e #x76 #x22 #xf3
#xca #x71 #xfb #xa1 #xd9 #x72 #xfd #x94
#xa3 #x1c #x3b #xfb #xf2 #x4e #x39 #x38
)))) | false |
bcef4186e955f59d068e2d6ba0afbbebc86b345f | 165a4ff581651cdad1bc512ec1c82cebc0ac575a | /src/SICP/4/4.1/ex4.12.ss | 2a343e6aa74b957d4ec6c2bb524d7e2f000d11d7 | []
| no_license | haruyama/yami | 5028e416a2caa40a0193d46018fe4be81d7820dc | 32997caecc18d9d82a28b88fabe5b414a55e0e18 | refs/heads/master | 2020-12-25T09:47:04.240216 | 2018-06-16T08:28:41 | 2018-06-16T08:28:41 | 898,824 | 1 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 4,734 | ss | ex4.12.ss | (load "./4.1_2.ss")
(define (make-frame variables values)
(cons variables values))
(define (frame-variables frame) (car frame))
(define (frame-values frame) (cdr frame))
(define (add-binding-to-frame! var val frame)
(set-car! frame (cons var (car frame)))
(set-cdr! frame (cons val (cdr frame))))
(define (lookup-variable-value var env)
(define (env-loop env)
(define (scan vars vals)
(cond ((null? vars)
(env-loop (enclosing-environment env)))
((eq? var (car vars))
(car vals))
(else (scan (cdr vars) (cdr vals)))))
(if (eq? env the-empty-environment)
(error "Unbound variable" var)
(let ((frame (first-frame env)))
(scan (frame-variables frame)
(frame-values frame)))))
(env-loop env))
(define (set-variable-value! var val env)
(define (env-loop env)
(define (scan vars vals)
(cond ((null? vars)
(env-loop (enclosing-environment env)))
((eq? var (car vars))
(set-car! vals val))
(else (scan (cdr vars) (cdr vals)))))
(if (eq? env the-empty-environment)
(error "Unbound variable -- SET!" var)
(let ((frame (first-frame env)))
(scan (frame-variables frame)
(frame-values frame)))))
(env-loop env))
(define (define-variable! var val env)
(let ((frame (first-frame env)))
(define (scan vars vals)
(cond ((null? vars)
(add-binding-to-frame! var val frame))
((eq? var (car vars))
(set-car! vals val))
(else (scan (cdr vars) (cdr vals)))))
(scan (frame-variables frame)
(frame-values frame))))
(driver-loop)
(define i 0)
(while (< i 10)
(display i)
(newline)
(set! i (+ i 1)))
end
(define (scan var val frame null-func eq-func)
(define (iter vars vals)
(cond ((null? vars)
(null-func var val))
((eq? var (car vars))
(eq-func vals val))
(else (iter
(cdr vars) (cdr vals)))))
(iter (frame-variables frame)
(frame-values frame)))
(define (lookup-variable-value var env)
(define (null-func var val)
(env-loop (enclosing-environment env)))
(define (eq-func vals val)
(car vals))
(define (env-loop env)
(if (eq? env the-empty-environment)
(error "Unbound variable" var)
(let ((frame (first-frame env)))
(scan
var
0
frame
null-func
eq-func
))))
(env-loop env))
(define (set-variable-value! var val env)
(define (null-func var val)
(env-loop (enclosing-environment env)))
(define (eq-func vals val)
(set-car! vals val))
(define (env-loop env)
(if (eq? env the-empty-environment)
(error "Unbound variable -- SET!" var)
(let ((frame (first-frame env)))
(scan
var
val
frame
null-func
eq-func
))))
(env-loop env))
(define (define-variable! var val env)
(let ((frame (first-frame env)))
(define (null-func var val)
(add-binding-to-frame! var val frame))
(define (eq-func vals val)
(set-car! vals val))
(scan var val
frame
null-func
eq-func
)))
(driver-loop)
(define i 0)
(while (< i 10)
(display i)
(newline)
(set! i (+ i 1)))
end
;別解
(define (scan var vars vals)
(cond ((null? vars) '())
((eq? var (car vars)) vals)
(else
(scan var (cdr vars) (cdr vals)))))
(define (lookup-variable-value var env)
(define (env-loop env)
(if (eq? env the-empty-environment)
(error "Unbound variable" var)
(let ((frame (first-frame env)))
(let ((result-of-scan (scan var (frame-variables frame) (frame-values frame))))
(if (null? result-of-scan)
(env-loop (enclosing-environment env))
(car result-of-scan))))))
(env-loop env))
(define (set-variable-value! var val env)
(define (env-loop env)
(if (eq? env the-empty-environment)
(error "Unbound variable -- SET!" var)
(let ((frame (first-frame env)))
(let ((result-of-scan (scan var (frame-variables frame) (frame-values frame))))
(if (null? result-of-scan)
(env-loop (enclosing-environment env))
(set-car! result-of-scan val))))))
(env-loop env))
(define (define-variable! var val env)
(let ((frame (first-frame env)))
(let ((result-of-scan (scan var (frame-variables frame) (frame-values frame))))
(if (null? result-of-scan)
(add-binding-to-frame! var val frame)
(set-car! result-of-scan val)))))
(driver-loop)
(define i 0)
(while (< i 10)
(display i)
(newline)
(set! i (+ i 1)))
end
| false |
62a1e14b3a41690618580fa4a6c587eb2bfc5d0a | 51861d4b51fc7692449550da7fd2e0035eabca30 | /oldsrc/helpers.scm | 51d75c4b8e4bc7b34df32610a18e5a04b5c7a93e | [
"MIT"
]
| permissive | stjordanis/probKanren | e611429b197e236c5df1a10369f6bfb4a167c2c7 | 00cd62c8211a8a210099c36be961b8927b298ce8 | refs/heads/master | 2020-09-18T20:53:33.468153 | 2015-10-20T21:40:23 | 2015-10-20T21:40:23 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,444 | scm | helpers.scm | (define printg
(lambda (format-str . args)
(lambda (sk fk c)
(let ((args (walk* args (get-s c))))
(apply printf format-str args))
(newline)
(sk fk c))))
(define repeato
(lambda (n f q)
(cond
[(= n 0) (== q '())]
[else
(fresh (x res)
(f x)
(repeato (sub1 n) f res)
(== (cons x res) q))])))
(define seq-goalo
(lambda (f ls)
(conde
((== '() ls))
((fresh (a d)
(== `(,a . ,d) ls)
(f a)
(seq-goalo f d))))))
(define map-goalo
(lambda (f ls out)
(conde
((== '() ls) (== '() out))
((fresh (a d v res)
(== `(,a . ,d) ls)
(== `(,v . ,res) out)
(f a v)
(map-goalo f d res))))))
(define zipwitho
(lambda (f l s out)
(conde
[(== '() l) (== '() s) (== '() out)]
[(fresh (al dl as ds v res)
(== `(,al . ,dl) l)
(== `(,as . ,ds) s)
(== `(,v . ,res) out)
(f al as v)
(zipwitho f dl ds res))])))
;;; old and busted
#|
(define seq-goalo
(lambda (f ls)
(conj*-aux (map f ls))))
|#
#|
(define map-goalo
(lambda (f ls g)
(conj*-aux (map (lambda (x)
(f x q)) ls))))
|#
#|
(define zipwitho
(lambda (f a b g)
(cond
[(null? a) (== '() g)]
[else
(fresh (x xs)
(f (car a) (car b) res)
(zipwitho f (cdr a) (cdr b) xs)
(== (cons x xs) g))])))
|#
| false |
8b4e27c2b68655f3828a8c583821aecce6ea08a0 | 3c3e79da5fa173750dd941c4bb94c71de8ee9c2d | /s9/ext/sys-plan9/9p.scm | 5c94026dc7d6826c553f783366d7a00dd0f456fd | [
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-public-domain",
"CC0-1.0"
]
| permissive | smazga/m9scm | 2b9d6f1f4d44e7e1f14dbb206db686044f8be88a | 7da5f719654951d255942dfa210ac4176f66e1bc | refs/heads/master | 2022-11-22T13:39:36.111041 | 2020-07-10T19:53:04 | 2020-07-10T19:53:04 | 278,719,406 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 4,809 | scm | 9p.scm | (require-extension sys-plan9)
(load-from-library "simple-modules.scm")
(load-from-library "hash-table.scm")
(load-from-library "appendb.scm")
(define *9p:paths-table* (make-hash-table))
(define *9p:path-map* (make-hash-table))
(define *9p:path-id* 0)
(define *9p:root* '())
;(module 9p
;; actions: attach auth clone create flush open read remove stat version write wstat walk
(define-structure fs srvname funcs)
(define-structure fcall action tag fid (u1 '()) (u2 '()) (u3 '()))
(define-structure dir
(type 0) (dev 0) (qid "") (mode 0) (atime 0) (mtime 0) (length 0)
(name "") (uid "nobody") (gid "nobody") (muid "nobody") (path 0)
(contents '()) (msg ""))
;; TODO: it's silly to store the converted message here and convert it in
;; sys_convS2M, but we do it to be able to understand the offsets
(define (next-path-id)
(let ((id *9p:path-id*))
(set! *9p:path-id* (+ *9p:path-id* 1))
id))
(define (parse-path tree)
(format #t "TREE: ~A~%" tree)
(let* ((dir (car tree))
(path (dir-path dir))
(contents (dir-contents dir)))
(format #t "ADDING ~A~%" dir)
(format #t "CONTENTS (~A): ~A~%" (type-of contents) contents)
(hash-table-set! *9p:paths-table* path dir)
(cond ((null? contents) #t
(pair? contents) (parse-path contents)
(list? contents)
(for-each (lambda (x)
(parse-path x) contents))
(default (parse-path contents))))))
(define (9p:root mode . contents)
(let ((root (9p:entry "" mode sys:QTDIR contents)))
(set! *9p:root* root)
root))
(define (9p:dir name mode . contents)
(9p:entry name mode sys:QTDIR contents))
(define (9p:file name mode . contents)
(9p:entry name mode sys:QTFILE contents))
(define (9p:entry name mode type contents)
(let ((d (make-dir))
(path (next-path-id)))
(dir-set-qid! d (format #f "~X:~X:~X" path mode type))
(dir-set-name! d name)
(dir-set-path! d path)
(dir-set-contents! d contents)
(format #t "9p:entry: ~A~%" (stat d))
(dir-set-msg! d (sys:convD2M (stat d)))
(format #t " path: ~A~%" path)
(hash-table-set! *9p:path-map* path d)
d))
(define (get-entry path)
(car (hash-table-ref *9p:path-map* path)))
(define (get-root)
(car (hash-table-ref *9p:path-map* (dir-path *9p:root*))))
(define msize 8192)
(define version "9P2000")
(define (stat d)
(vector (string->symbol "dir")
(dir-type d)
(dir-dev d)
(dir-qid d)
(dir-mode d)
(dir-atime d)
(dir-mtime d)
(dir-length d)
(dir-name d)
(dir-uid d)
(dir-gid d)
(dir-muid d)))
(define (handle f fc)
(let* ((x (format #t "~%handle::~A~%" fc))
(ftype (symbol->string (fcall-action fc)))
(action (substring ftype 1 (string-length ftype)))
(handler (hash-table-ref (fs-funcs f) action))
(response (string->symbol (string-append "R" action))))
(format #t "read: ~A~%" fc)
(format #t "action: ~A~%" action)
(format #t "fid: ~A~%" (fcall-fid fc))
(if (not (list? handler))
(vector (string->symbol "Rerror") (fcall-tag fc)
(format #f "unhandled function: ~A" action))
(list->vector (append (list response (fcall-tag fc)) ((car handler) fc))))))
(define (register f action func)
(hash-table-set! (fs-funcs f) action func))
(define (srv f)
(let ((pipe (initsrv (fs-srvname f))))
(let loop ((msg (sys:read9pmsg pipe)))
(if (zero? (string-length msg)) (format #t "disconnected")
(let* ((fc (apply make-fcall (vector->list (sys:convM2S msg))))
(result (handle f fc)))
(format #t "result: ~A~%" result)
(if (vector? result) (9p:write pipe result))
(loop (sys:read9pmsg pipe)))))))
(define (initsrv srvname)
(let* ((p (sys:pipe))
(ptmp (car p))
(pipe (cadr p))
(srvpath (string-append "/srv/" srvname))
(srvfd (sys:create srvpath sys:OWRITE #o0600)))
(format #t "serving ~A on fd ~D~%" srvpath pipe)
(defer (sys:remove srvpath))
(sys:write srvfd (format #f "~D" ptmp))
(sys:close srvfd)
(sys:close ptmp)
pipe))
(define (instance srvname tree)
(let ((f (make-fs srvname (make-hash-table))))
(if (null? tree) (error "tree must be defined")
(begin
(format #t "parse: ~A~%" tree)
(parse-path tree)))
(format #t "PATHS: ~A~%" *9p:path-map*)
(register f "version" versionstub)
f))
(define (versionstub fc) (list msize version))
(define (authstub fc) (list '() '()))
;)
(define-syntax 9p:fs
(lambda (srvname tree)
`(format #t "9p:fs: ~A~%" ,srvname)
`(instance ,srvname ,tree)))
;; `(using 9p (instance) (instance ,srvname ,tree))))
(define-syntax 9p:srv
(lambda (f)
(format #t "9p:srv: ~A~%" f)
`(srv ,f)))
;; `(using 9p (srv) (srv ,f))))
| true |
25e6c64e0aa56fcdaa96e22592489b538cf999a3 | 174072a16ff2cb2cd60a91153376eec6fe98e9d2 | /Chap-one/1-36.scm | 4bbcae12c8c5df15e0ddb89880927e959b8a27f6 | []
| no_license | Wang-Yann/sicp | 0026d506ec192ac240c94a871e28ace7570b5196 | 245e48fc3ac7bfc00e586f4e928dd0d0c6c982ed | refs/heads/master | 2021-01-01T03:50:36.708313 | 2016-10-11T10:46:37 | 2016-10-11T10:46:37 | 57,060,897 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 576 | scm | 1-36.scm | (define (fixed-point f first-guess)
(define (close-enough? a b) (< (abs ( - a b)) tolerance))
(define (try guess)
( newline)
(display guess)
(let ((next ( f guess)))
(if (close-enough? guess next)
next
(try next))))
(try first-guess))
(define tolerance 0.0001)
(load "square.scm")
(define (sqrt1 x)
(fixed-point (lambda(y) (average y (/ x y))) 1.0))
(define xyx (lambda (y) (/ (log 1000) (log y))))
(define (average-damp f)(lambda (x) (average x (f x))))
(define xyx2 (average-damp xyx))
| false |
ad108a78ce525026444d2991f103fc3e338863d2 | 52b0b749db0b7fb7a4ec1a8b78c5b6a0208bf1b5 | /tests/server.scm | 4c14d8db0170cc384cbd93cf91394ba022a77d39 | []
| no_license | mario-goulart/spiffy-request-vars | 9802c50847d391f1a1d79cbda012c4b6d5962ff7 | 659b7536f7f5ed3ead0e7c6e8b73926f7ad8afb5 | refs/heads/master | 2021-01-19T08:12:22.368118 | 2018-08-24T19:30:05 | 2018-08-24T19:30:05 | 9,183,358 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,909 | scm | server.scm | (import scheme)
(cond-expand
(chicken-4
(use srfi-69 srfi-13 spiffy-request-vars spiffy intarweb uri-common))
(chicken-5
(import (chicken port)
(chicken string))
(import intarweb spiffy spiffy-request-vars srfi-13 srfi-69 uri-common))
(else
(error "Unsupported CHICKEN version.")))
(include "mini-awful.scm")
(define (show var)
(with-output-to-string (cut write var)))
;;; Tests
(define-page "as-string" (lambda () (show ($ 'var))))
(define-page "as-symbol" (lambda () (show ($ 'var as-symbol))))
(define-page "as-number" (lambda () (show ($ 'var as-number))))
(define-page "as-boolean" (lambda () (show ($ 'var as-boolean))))
(define-page "as-list" (lambda () (show ($ 'var as-list))))
(define-page "as-vector" (lambda () (show ($ 'var as-vector))))
(define-page "as-alist" (lambda () (show ($ 'var as-alist))))
(define-page "as-hash-table"
(lambda ()
(show (and-let* ((var ($ 'var as-hash-table)))
(hash-table->alist var)))))
(define-page "as-nonempty-string" (lambda () (show ($ 'var (nonempty as-string)))))
(define-page "as-nonempty-symbol" (lambda () (show ($ 'var (nonempty as-symbol)))))
(define-page "as-nonempty-number" (lambda () (show ($ 'var (nonempty as-number)))))
;;; with-request-vars
(define-page "wrv-as-string"
(lambda ()
(with-request-vars* $ (var)
(show var))))
(define-page "wrv-as-symbol"
(lambda ()
(with-request-vars ((var as-symbol))
(show var))))
(define-page "wrv-as-number"
(lambda ()
(with-request-vars ((var as-number))
(show var))))
(define-page "wrv-as-boolean"
(lambda ()
(with-request-vars ((var as-boolean))
(show var))))
(define-page "wrv-as-list"
(lambda ()
(with-request-vars ((var as-list))
(show var))))
(define-page "wrv-as-vector"
(lambda ()
(with-request-vars ((var as-vector))
(show var))))
(define-page "wrv-as-alist"
(lambda ()
(with-request-vars ((var as-alist))
(show var))))
(define-page "wrv-as-hash-table"
(lambda ()
(with-request-vars ((var as-hash-table))
(show (and var (hash-table->alist var))))))
;;; test1
(define-page "test1"
(lambda ()
(with-request-vars (foo (bar as-list) (baz 5))
(show (list foo bar baz)))))
;;; test2
(define-page "test2"
(lambda ()
(with-request-vars* $ (foo (bar as-list) (baz 5))
(show (list foo bar baz)))))
;;; test3
(define-page "test3"
(lambda ()
(with-request-vars ((foo as-alist) (bar as-number) (baz as-vector) (bool as-boolean))
(show (list foo bar baz bool)))))
;;; test4
(define-page "test4"
(lambda ()
(with-request-vars* $ ((foo as-alist) (bar as-number) (baz as-vector) (bool as-boolean))
(show (list foo bar baz bool)))))
;;; test5
(define-page "test5"
(lambda ()
(with-request-vars (foo bar baz)
(show (list foo bar baz)))))
;;; test6
(define-page "test6"
(lambda ()
(with-request-vars* $ (foo bar baz)
(show (list foo bar baz)))))
;;; test7 (POST)
(define-page "test7"
(lambda ()
(with-request-vars* $ (foo bar baz blah)
(show (list foo bar baz blah))))
method: 'POST)
;;; test8
(define-page "test8"
(lambda ()
(with-request-vars* (request-vars source: 'query-string) (foo bar baz blah)
(show (list foo bar baz blah))))
method: 'POST)
;;; test9
(define-page "test9"
(lambda ()
(with-request-vars* (request-vars source: 'request-body) (foo bar baz blah)
(show (list foo bar baz blah))))
method: 'POST)
;;; test10
(define-page "test10"
(lambda ()
(with-request-vars* (request-vars source: 'request-method) (foo bar baz blah)
(show (list foo bar baz blah))))
method: 'POST)
;;; test11
(define-page "test11"
(lambda ()
(with-request-vars* (request-vars source: 'both) (foo bar baz blah)
(show (list foo bar baz blah))))
method: 'POST)
(root-path ".")
(start-server)
| false |
4b94ea360d675bc7f94aec4021596d26b9c721a5 | 9046fb7fa896d41aecd0f98c8cdd26447ccf9a1a | /2.ss | 65fbc5772e728cdc80a5c268ecf60a99aab8bb31 | []
| no_license | Joycexuy2/CSSE304 | 25743e01c1fb7e743ba0a83145872517229617b5 | 6e405e5a277ad14228d031d9fcbdc54325e9a88a | refs/heads/master | 2021-01-11T06:59:53.372832 | 2016-10-25T22:27:11 | 2016-10-25T22:27:11 | 71,944,384 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 193 | ss | 2.ss | ;; Assignment 02
;; Joyce Xu
;;Question 1
(define fact
(lambda (n)
(if (zero? n(
1
(* n (fact (- n 1))))))))
(define choose
(lambda (n k)
(/ (fact n) ((fact (- n k)) (fact k))))) | false |
c6c48f4e86ae1ff87469de8d68a9ab56998a82f9 | ec0f122fdcf4ceaf5e9e183575a460006c19ebe0 | /output-csv.scm | c4865fe4bcb1404cb229d80c837cacb98ae1bfdf | []
| 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 | 4,403 | scm | output-csv.scm | (use srfi-13)
(load "src/utils/macs") (import macs)
(load "src/db/db-interface") (import db-interface)
;; (load "src/utils/misc-utils") (import misc-utils)
(load "storage-funcs")
;; (load "demo-data")
;; (load "handlers")
;; (load "pdf")
;; (load "src/sections/sections") (import sections)
;; (load "rest")
;; (load "sessions")
;; (load "src/utils/date-time-utils") (import date-time-utils)
(include "etc/database.scm")
(db:connect)
(define m-church "monterey-baptist-church0")
(define s-church "steamboat-rock-baptist-church0")
(define ++ string-append)
(define clubber-items
`(("name" ,name) ("grade" ,grade) ("birthday" ,birthday)
("club" ,club-level) ("notes" ,notes) ("allergies" ,allergies)
("primary parent" ,primary-parent) ("points" ,total-points)
("date registered" ,date-registered)))
(define parent-items
`(("name" ,parent-name) ("spouse" ,parent-spouse)
("email" ,parent-email) ("phone 1" ,parent-phone-1)
("phone 2" ,parent-phone-2) ("address" ,parent-address)
("release to" ,parent-release-to)))
(define clubber-date-items
`(("present" ,present) ("bible" ,bible) ("handbook" ,handbook) ("uniform" ,uniform)
("friend" ,friend) ("extra" ,extra) ("sunday school" ,sunday-school) ("dues" ,dues) ("on time" ,on-time)))
(define (item-columns items)
(map (cut car <>) items))
(define (item-funcs items)
(map (cut cadr <>) items))
(define (csv-record s)
(++ "\""
(string-fold
(lambda (c o)
(++ o
(if (char=? c #\")
"\"\""
(->string c))))
""
s)
"\""))
(define (csv-headers columns)
(fold (lambda (c o) (++ o c ",")) "" columns))
(define (csv-rows club clubbers funcs)
(fold
(lambda (c o)
(++ o
(fold (lambda (f o)
(++ o
(csv-record (->string (apply f `(,club ,c))))
","))
""
funcs)
"\n"))
""
clubbers))
(define (csv-headers-date columns club)
(fold (lambda (d o)
(++ o
(fold (lambda (c o)
(++ o d "-" c ","))
""
columns)))
""
(sorted-club-meetings club)))
(define (csv-rows-date club clubbers dates funcs)
(fold
(lambda (c o)
(++ o
(name club c)
","
(fold (lambda (d o)
(++ o
(fold (lambda (f o)
(++ o
(csv-record (if (apply f `(,club ,c ,d)) "1" "0"))
","))
""
funcs)))
""
dates)
"\n"))
""
clubbers))
(define (to-csv items club clubbers)
(++ (csv-headers (item-columns items))
"\n"
(csv-rows club clubbers (item-funcs items))))
(define (output-clubbers club)
(with-output-to-file (++ club "-clubbers.csv")
(lambda () (display (to-csv clubber-items club
(db:list "clubs" club "clubbers"))))))
(define (output-parents club)
(with-output-to-file (++ club "-parents.csv")
(lambda () (display (to-csv parent-items club
(map (lambda (c) (primary-parent club c))
(db:list "clubs" club "clubbers")))))))
(define (output-clubber-dates club)
(with-output-to-file (++ club "-attendance.csv")
(lambda ()
(display
(++ "," ; first one blank
(csv-headers-date (item-columns clubber-date-items) club)
"\n"
(csv-rows-date club (db:list "clubs" club "clubbers") (sorted-club-meetings club)
(item-funcs clubber-date-items)))))))
(output-clubber-dates s-church)
(define club "evangel-baptist-church1")
(define meets (sorted-club-meetings club))
(define (sorted-club-meetings club)
(define (num-attendees club-meeting)
(cdr club-meeting))
(define (string->date< sd1 sd2)
(date<? (string->date sd1 "~Y/~m/~d") (string->date sd2 "~Y/~m/~d")))
(define (club-meeting-date club-meeting)
(car club-meeting))
(let ((cm (filter (lambda (meeting)
(> (num-attendees meeting) 0))
(club-meetings club))))
(sort (map (lambda (m) (club-meeting-date m)) cm) string->date<)))
(define mem "anna-green")
(present club mem d1)
| false |
460ee2c5676a7908cd23b20614bfa458cc3097d5 | f033ff2c78c89e2d7d24d7b8e711fa6d1b230142 | /ccc/concurrent/benchmarks/tel-bst/telephone-catalogue.ss | b6f541936457eedd61d8e612fcac745cf9915c6e | []
| 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 | 11,445 | ss | telephone-catalogue.ss | (module telephone-catalogue scheme
(require "../../contract.ss")
(provide
valid-telephone-entry?
valid-telephone-catalogue?
spine-telephone-entry?
gtq-telephone-entry
eq-telephone-entry
create-telephone-entry
telephone-entry-last-name
make-telephone-entry-node
telephone-entry-node-right
telephone-entry-node-left
telephone-entry-node-entry
telephone-catalogue-height
telephone-entry-node-factor
left-rotation
right-rotation)
;;+ create-telephone-entry, telephone-entry->string
;;a name-string is a String that consists of alphabetic chars
;name-string?: string? -> boolean?
(define name-string?
(lambda (s)
(and (string? s)
(andmap
char-alphabetic?
(string->list s)))))
(define-struct telephone-number (description tel-no))
;;a telephone-number is (make-telephone-number string? number?)
;;where 10000000 <= tel-no <= 9999999999
;;valid-telephone-no?: number? -> boolean?
(define valid-telephone-no?
(lambda (no)
(and (<= 1000000000 no) (<= no 9999999999))))
;;valid-telephone-nuber?:telephone-number? -> bookean?
(define valid-telephone-number?
(lambda (tn)
(and (string? (telephone-number-description tn))
(number? (telephone-number-tel-no tn))
(valid-telephone-no? (telephone-number-tel-no tn)))))
(define-struct email (description address))
;;an email is (make-email string? string?)
;;where address has form [email protected] where x,y,z
;;are nane-string
;;valid-address: string? -> boolean?
;;returns #t if str is in the form [email protected] where
;;x,y,y are name-string
(define (valid-address? str)
(letrec
((valid-address?-aux
(lambda (s level)
(cond ((null? s) (= level 3))
(else
(cond ((= level 1)
(cond ((char-alphabetic? (car s))
(valid-address?-aux (cdr s) level))
((char=? (car s) #\@)
(valid-address?-aux (cdr s)
(+ 1 level)))
(else #f)))
((= level 2)
(cond ((char-alphabetic? (car s))
(valid-address?-aux (cdr s) level))
((char=? (car s) #\.)
(valid-address?-aux (cdr s)
(+ 1 level)))
(else #f)))
((= level 3)
(cond ((char-alphabetic? (car s))
(valid-address?-aux (cdr s) level))
(else #f)))))))))
(valid-address?-aux (string->list str) 1)))
;;valid-email?: email? -> boolean?
(define valid-email?
(lambda (e)
(and (email? e)
(string? (email-description e))
(string? (email-address e))
(valid-address? (email-address e)))))
(define-struct telephone-entry (last-name
first-name
telephone-numbers
emails))
;; a telephone-entry is a (make-telephone-entry
;; name-string?
;; name-string?
;; (listof valid-telephone-number?)
;; (listof valid-emails?))
;;valid-telephone-entry?: telephone-entry? -> boolean?
(define valid-telephone-entry?
(lambda (te)
(and (name-string? (telephone-entry-last-name te))
(name-string? (telephone-entry-first-name te))
(andmap (lambda (x) (valid-telephone-number? x))
(telephone-entry-telephone-numbers te))
(andmap (lambda (x) (valid-email? x))
(telephone-entry-emails te)))))
(define (gtq-telephone-entry te1 te2)
(or (string<? (telephone-entry-last-name te1)
(telephone-entry-last-name te2))
(and (string=?
(telephone-entry-last-name te1)
(telephone-entry-last-name te2))
(string<=?
(telephone-entry-first-name te1)
(telephone-entry-first-name te2)))))
(define (eq-telephone-entry te1 te2)
(and (string=? (telephone-entry-last-name te1)
(telephone-entry-last-name te2))
(string=? (telephone-entry-first-name te1)
(telephone-entry-first-name te2))))
(define (merge-telephone-entry te1 te2)
(make-telephone-entry
(telephone-entry-last-name te1)
(telephone-entry-first-name te1)
(append
(telephone-entry-telephone-numbers te1)
(telephone-entry-telephone-numbers te2))
(append
(telephone-entry-emails te1)
(telephone-entry-emails te2))))
;spine-telephone-entry: telephone-entry? -> boolean?
(define (spine-telephone-entry? te)
(and (null? (telephone-entry-telephone-numbers te))
(null? (telephone-entry-emails te))))
;;a telephone-catalogue is an AVL tree in descending order
;;by the last and first name of the ;;telephone entries
(define-struct telephone-entry-node (left entry right))
;; a telephnone-catalogue is ether
;; -- null
;; -- (make-telephone-entry-node tc te rc)
(define (telephone-catalogue-height tc)
(cond ((null? tc) 0)
(else (+ 1 (max (telephone-catalogue-height (telephone-entry-node-left tc))
(telephone-catalogue-height (telephone-entry-node-right tc)))))))
(define (telephone-entry-node-factor te)
(cond ((null? te) 0)
(else (- (telephone-catalogue-height (telephone-entry-node-right te))
(telephone-catalogue-height (telephone-entry-node-left te))))))
(define (left-rotation te)
(let* ((tmp-root (telephone-entry-node-right te))
(new-left (make-telephone-entry-node
(telephone-entry-node-left te)
(telephone-entry-node-entry te)
(telephone-entry-node-left tmp-root)))
(new-right (telephone-entry-node-right tmp-root)))
(make-telephone-entry-node
new-left
(telephone-entry-node-entry tmp-root)
new-right)))
(define (right-rotation te)
(let* ((tmp-root (telephone-entry-node-left te))
(new-right (make-telephone-entry-node
(telephone-entry-node-right tmp-root)
(telephone-entry-node-entry te)
(telephone-entry-node-right te)))
(new-left (telephone-entry-node-left tmp-root)))
(make-telephone-entry-node
new-left
(telephone-entry-node-entry tmp-root)
new-right)))
(define (balanced? te)
(<= -1 (telephone-entry-node-factor te) 1))
(define (sorted? te)
(cond ((null? te) #t)
(else
(let*
((entry (telephone-entry-node-entry te))
(right (telephone-entry-node-right te))
(left (telephone-entry-node-left te)))
(cond ((and (null? right) (null? left)) #t)
((null? left)
(and (sorted? right)
(gtq-telephone-entry
entry
(telephone-entry-node-entry right))))
((null? right)
(and (sorted? left)
(gtq-telephone-entry
(telephone-entry-node-entry left)
entry)))
(else
(and (sorted? left)
(sorted? right)
(gtq-telephone-entry
(telephone-entry-node-entry left)
entry)
(gtq-telephone-entry
entry
(telephone-entry-node-entry right)))))))))
(define (valid-entries? te)
(cond ((null? te) #t)
(else
(let*
((entry (telephone-entry-node-entry te))
(right (telephone-entry-node-right te))
(left (telephone-entry-node-left te)))
(and
(valid-telephone-entry? entry)
(valid-entries? left)
(valid-entries? right))))))
(define (avl? te)
(and (balanced? te)
(sorted? te)
valid-entries? te))
(define (valid-telephone-catalogue? tc)
(or (null? tc)
(avl? tc)))
;;create-telephone-numbers:
;; [listof (string? x number?)] -> [listof telephone-number?]
(define (create-telephone-numbers tel-nos)
(map (lambda (tn)
(make-telephone-number (car tn) (cdr tn)))
tel-nos))
;;create-emails:
;; [listof (string? x string?)] -> [listof email?]
(define (create-emails emails)
(map (lambda (e)
(make-email (car e) (cdr e)))
emails))
(define (create-telephone-entry last-name first-name tel-nos emails)
(make-telephone-entry
last-name
first-name
(create-telephone-numbers tel-nos)
(create-emails emails)))
)
| false |
62f6aa4ed1d97733237f7eec12fdfb7b4ebb53ce | defeada37d39bca09ef76f66f38683754c0a6aa0 | /System.Transactions/system/transactions/transaction-interop.sls | e8adaa7b439bf54772ee1c3a423a7c04f6d5b49c | []
| 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 | 1,978 | sls | transaction-interop.sls | (library (system transactions transaction-interop)
(export is?
transaction-interop?
get-transaction-from-dtc-transaction
get-export-cookie
get-transmitter-propagation-token
get-transaction-from-transmitter-propagation-token
get-dtc-transaction
get-whereabouts
get-transaction-from-export-cookie)
(import (ironscheme-clr-port))
(define (is? a) (clr-is System.Transactions.TransactionInterop a))
(define (transaction-interop? a)
(clr-is System.Transactions.TransactionInterop a))
(define-method-port
get-transaction-from-dtc-transaction
System.Transactions.TransactionInterop
GetTransactionFromDtcTransaction
(static:
System.Transactions.Transaction
System.Transactions.IDtcTransaction))
(define-method-port
get-export-cookie
System.Transactions.TransactionInterop
GetExportCookie
(static:
System.Byte[]
System.Transactions.Transaction
System.Byte[]))
(define-method-port
get-transmitter-propagation-token
System.Transactions.TransactionInterop
GetTransmitterPropagationToken
(static: System.Byte[] System.Transactions.Transaction))
(define-method-port
get-transaction-from-transmitter-propagation-token
System.Transactions.TransactionInterop
GetTransactionFromTransmitterPropagationToken
(static: System.Transactions.Transaction System.Byte[]))
(define-method-port
get-dtc-transaction
System.Transactions.TransactionInterop
GetDtcTransaction
(static:
System.Transactions.IDtcTransaction
System.Transactions.Transaction))
(define-method-port
get-whereabouts
System.Transactions.TransactionInterop
GetWhereabouts
(static: System.Byte[]))
(define-method-port
get-transaction-from-export-cookie
System.Transactions.TransactionInterop
GetTransactionFromExportCookie
(static: System.Transactions.Transaction System.Byte[])))
| false |
6de86063343aa2002891366454f03a3edafb7024 | ea4e27735dd34917b1cf62dc6d8c887059dd95a9 | /table-simple.scm | a8d19498616279e88cfe4a138c16d75f7b6bc857 | [
"MIT"
]
| permissive | feliposz/sicp-solutions | 1f347d4a8f79fca69ef4d596884d07dc39d5d1ba | 5de85722b2a780e8c83d75bbdc90d654eb094272 | refs/heads/master | 2022-04-26T18:44:32.025903 | 2022-03-12T04:27:25 | 2022-03-12T04:27:25 | 36,837,364 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 601 | scm | table-simple.scm | ; Example from Lecture 11 on Advanced Data Types (iTutor 6.001)
(define nil '())
(define (find-assoc key alist)
(cond
((null? alist) #f)
((equal? key (caar alist)) (cadar alist))
(else (find-assoc key (cdr alist)))))
(define (add-assoc key val alist)
(cons (list key val) alist))
(define table1-tag 'table1)
(define (make-table1) (cons table1-tag nil))
(define (table1-get tbl key)
(find-assoc key (cdr tbl)))
(define (table1-put! tbl key val)
(set-cdr! tbl (add-assoc key val (cdr tbl))))
; Test case
(define tt1 (make-table1))
(table1-put! tt1 'y 20)
(table1-put! tt1 'x 15) | false |
6772d1f221b97e5dd997e6deda53f77e1240d3f8 | 12fc725f8273ebfd9ece9ec19af748036823f495 | /tools/schemelib/wg/ast-spec.scm | efae404f6aec5fdca0978411f909e4af8e7a206f | []
| no_license | contextlogger/contextlogger2 | 538e80c120f206553c4c88c5fc51546ae848785e | 8af400c3da088f25fd1420dd63889aff5feb1102 | refs/heads/master | 2020-05-05T05:03:47.896638 | 2011-10-05T23:50:14 | 2011-10-05T23:50:14 | 1,675,623 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 21,455 | scm | ast-spec.scm | ;;
;; Copyright 2007 Helsinki Institute for Information Technology (HIIT)
;; and the authors. All rights reserved.
;;
;; Authors: Tero Hasu <[email protected]>
;;
;; 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.
;;
;; This module serves as a specification for our AST. It also provides
;; some very basic AST node constructors. The naming of the
;; constructors is one-to-one with the AST node naming.
;;
;; Our rules for node naming:
;; * no name may clash with a built-in Scheme name
;; * a node name must uniquely identify node semantics; there may be
;; no two nodes with the same name but different semantics
;;
;; For instance, "name" in (cxx-class (name NAME)) and (name-ref (name
;; NAME)) does have the same semantics, and hence this is okay.
(module
ast-spec
mzscheme
(require (lib "usual.scm" "wg"))
(require (lib "compact.scm" "wg"))
(require (lib "ast-util.scm" "wg"))
(require (lib "adt.scm" "wg"))
;; -------------------------
;; common attributes...
;; (name SYMBOL)
(def-symbol-ctor* name)
;; (type TYPE-EXPR)
(def-list-ctor* type)
;; (expr EXPR)
(def-list-ctor* expr)
;; (expr1 EXPR)
(def-list-ctor* expr1)
;; (expr2 EXPR)
(def-list-ctor* expr2)
;; (exprs EXPR ...)
(def-list-ctor* exprs)
;; A variable-initializer expression.
;;
;; (init EXPR)
;;
;; Note that for classes with a suitable single-argument constructor,
;; it is equivalent to say "X x = 3;" and "X x = X(3);" or whatever;
;; this does not work with multi-argument ctors, as initializer lists
;; cannot be used with types for which a ctor is defined, i.e. it is
;; not okay to say "X x = {1,2};" instead of "X x = X(1,2);".
(def-list-ctor* init)
;; -------------------------
;; documentation...
(define-data
(new-adt* named docstring
;; (doc STRING)
(new-cdt* (named doc def-doc-ctor))
;; (cxx-doc STRING)
(new-cdt* (named cxx-doc def-doc-ctor))
;; (cxx-cmt-doc STRING)
(new-cdt* (named cxx-cmt-doc def-doc-ctor))))
;; -------------------------
;; directives...
;; Includes. An attribute of cxx-unit.
;;
;; (includes (include ...) ...)
;; (include (incl-kind system) (file STRING) ...)
;; (include (incl-kind local) (file STRING) ...)
(def-list-ctor* includes)
(def-list-ctor* include)
(def-string-ctor* file)
(def-symbol-ctor* incl-kind)
;; -------------------------
;; type expressions...
(define-data
(new-adt* named ast-node))
(define-data
(existing-dt named ast-node
(new-adt* named type-expression)))
;; (ptr-to (type TYPE-EXPR) ...)
(extend-adt* type-expression ptr-to)
;; (ptr-to-member (of-class (type TYPE-EXPR) ...) (class-member (type TYPE-EXPR) ...) ...)
(extend-adt* type-expression ptr-to-member)
(def-list-ctor* of-class)
(def-list-ctor* class-member)
;; (ref-to (type TYPE-EXPR) ...)
(extend-adt* type-expression ref-to)
;; (array-of (type TYPE-EXPR) (num-elems CONST-EXPR) ...)
(extend-adt* type-expression array-of)
(def-list-ctor* num-elems)
;; (func-t (args (arg (type TYPE-EXPR) (name SYMBOL) ...) ...) (returns (type TYPE-EXPR) ...) ...)
(extend-adt* type-expression func-t)
(def-list-ctor* args)
(def-list-ctor* arg)
(def-list-ctor* varargs)
(def-list-ctor* returns)
;; (const (type TYPE-EXPR) ...)
(extend-adt* type-expression const)
;; (volatile (type TYPE-EXPR) ...)
(extend-adt* type-expression volatile)
;; (tname-ref (name SYMBOL) ...)
(extend-adt* type-expression tname-ref)
;; Type variable.
;; (tvar (type-id SYMBOL) ...)
(extend-adt* type-expression tvar)
(def-symbol-ctor* type-id)
(extend-adt* type-expression self-type def-null-ctor)
(define* (this-type) '(ptr-to (type (self-type))))
;; These are not type expressions, but they are related nonetheless.
(define* this '(name-ref (name this)))
(define* self `(deref-expr (expr ,this)))
(define* (check-type-expression expr)
(check-with type-expression? "~s is not a type expression" expr))
;; -------------------------
;; namespace declarations...
(define-data
(existing-dt named ast-node
(new-adt* named declaration)))
;; Compilation unit definition. The unnamed top-level namespace.
;;
;; (cxx-unit (body DEFINITION ...) ...)
(extend-adt* declaration cxx-unit)
;; Full or partial namespace content definition.
;;
;; (cxx-namespace (name SYMBOL) (body DEFINITION ...) ...)
(extend-adt* declaration cxx-namespace)
(def-string-ctor* basename)
;; -------------------------
;; type declarations...
(define-data
(existing-dt named declaration
(new-adt* named type-decl)))
;; Fundamental type. A type that cannot be expressed in terms of
;; other types.
;;
;; (cxx-fund-type (name SYMBOL) ...)
(extend-adt* type-decl cxx-fund-type)
;; Type alias (i.e. typedef-based type definition).
;;
;; (cxx-typedef (name SYMBOL) (type TYPE-EXPR) ...)
(extend-adt* type-decl cxx-typedef)
;; Class definition/declaration.
;;
;; (cxx-class (name SYMBOL) (body DEFINITION ...) ...)
(define-data
(existing-dt named type-decl
(new-adt* named record-type-decl
(new-cdt* named cxx-class)
(new-cdt* named cxx-struct)
(new-cdt* named cxx-union))))
;; Enumeration type definition/declaration.
;;
;; (cxx-enum (name SYMBOL) (enum-items (enum-item (name SYMBOL) (enum-value CONST-INT-EXPR) ...) ...) ...)
(extend-adt* type-decl cxx-enum)
(def-list-ctor* enum-items)
(def-list-ctor* enum-item)
(def-list-ctor* enum-value)
(def-list-ctor* body)
;; (bases (base ...) (base ...) ...)
(def-list-ctor* bases)
;; (base (base-access ACCESS) (type TYPE-EXPR) (virtual #t) ...)
(extend-adt* ast-node base)
(def-list-ctor* base-access)
;; xxx friend
;; xxx template
;; xxx using
;; -------------------------
;; variable declarations...
;; Variable definition/declaration. Is one of:
;; * local variable, in a function or method
;; * global variable, at top level or in a namespace
;; * class variable, i.e. static variable within a class
;; * instance variable, in a class, struct, or union
;;
;; (cxx-var (name SYMBOL) (type TYPE-EXPR) (init EXPR) (exprs EXPR
;; ...) ...)
;;
;; where "exprs" can be used to specify ctor arguments. "init" and
;; "exprs" are mutually exclusive.
(define-data
(existing-dt named declaration
(new-adt* named value-decl
(new-adt* named var-decl
(new-cdt* named cxx-var)
(new-cdt* named global-var)
(new-cdt* named class-var)
(new-cdt* named inst-var)
(new-cdt* named local-var)))))
;; -------------------------
;; function and method declarations...
;; Function or method definition/declaration.
;;
;; (cxx-func (name SYMBOL) (args (arg (type TYPE-EXPR) (name SYMBOL)) ...) (returns (type TYPE-EXPR) ...) (block ...) ...)
(define-data
(existing-dt named value-decl
(new-adt* named func-like-decl
(new-adt* named func-decl
(new-cdt* named cxx-func)
(new-cdt* named global-func)
(new-adt* named method-decl
(new-cdt* named class-meth)
(new-cdt* named inst-meth)))
(new-cdt* named cxx-ctor)
(new-cdt* named cxx-dtor)
(new-cdt* named cxx-oper) ;; operator
(new-cdt* named cxx-conv) ;; defined-cast in SPECS
)))
;; Constructor initializer list.
;;
;; (ctor-init-list (ctor-super ...) (ctor-var ...) ...)
(def-list-ctor* ctor-init-list)
;; (ctor-super (type TYPE-EXPR) (exprs CTOR-ARG-EXPR ...) ...)
(extend-adt* ast-node ctor-super)
;; (ctor-var (name VAR-NAME) (exprs CTOR-ARG-EXPR ...) ...)
(extend-adt* ast-node ctor-var)
;; -------------------------
;; public, protected, private
;; These are attributes associated with declarations.
(def-symbol* public)
(def-symbol* protected)
(def-symbol* private)
;; (access public|protected|private)
(def-list-ctor* access)
;; This represents an access label (public, protected, private);
;; there may be many of these within a class body.
;;
;; (access-label SYMBOL)
(def-list-ctor* access-label)
;; -------------------------
;; statements...
(define-data
(existing-dt named ast-node
(new-adt* named statement)))
;; Block of code.
;;
;; (block (stmts BLOCK-ITEM ...) ...)
;;
;; where BLOCK-ITEM is one of
;; * variable declaration
;; * block
;; * statement
;;
;; This is a statement in the sense that it can invariably appear
;; where a statement is expected.
(extend-adt* statement block)
;; (stmt-seq (stmts BLOCK-ITEM ...) ...)
;;
;; Like a block, but does not introduce new scope. Not valid in C++.
;; Translated by turning into a block in a single-statement context,
;; and by splicing into a multi-statement context otherwise.
(extend-adt* statement stmt-seq)
;; Expression statement.
;;
;; (expr-stmt (expr EXPR) ...)
(extend-adt* statement expr-stmt)
;; Return statement. "expr" is optional.
;;
;; (return-stmt (expr EXPR) ...)
(extend-adt* statement return-stmt)
;; (goto-stmt (addr-label SYMBOL) ...)
(extend-adt* statement goto-stmt)
(def-list-ctor* addr-label)
(extend-adt* statement break-stmt)
(extend-adt* statement continue-stmt)
;; (if-stmt (cond-expr EXPR) (then-stmt STATEMENT) (else-stmt STATEMENT) ...)
(extend-adt* statement if-stmt)
(def-list-ctor* then-stmt)
(def-list-ctor* else-stmt)
;; (while-stmt (cond-expr EXPR) (stmt STATEMENT) ...)
(extend-adt* statement while-stmt)
;; (do-while-stmt (cond-expr EXPR) (stmt STATEMENT) ...)
(extend-adt* statement do-while-stmt)
;; "init" is an optional expression or simple declaration. "cond" is
;; an optional conditional expression. "step" is an optional
;; expression.
;;
;; (for-stmt (init-expr EXPR) (cond-expr EXPR) (step-expr STEP-EXPR) (stmt STATEMENT) ...)
(extend-adt* statement for-stmt)
(def-list-ctor* init-expr)
(def-list-ctor* step-expr)
(def-list-ctor* stmt)
;; This is the C++ style switch, not SPECS style. Any SPECS style one
;; will have to be translated.
;;
;; We are using "switch-expr" rather than "expr" to indicate the
;; somewhat different semantics here. Not just any expression, but
;; one that is legal in C++. Note that while some C++ compilers allow
;; multiple values per "case", the C++ standard does not allow that.
;; We really do not need to support non-standard features, except
;; maybe temporarily, as we can compile such things to legal code.
;;
;; (switch-stmt (switch-expr EXPR) (stmts STATEMENT ...))
;;
;; Here a STATEMENT may also be either (switch-case (switch-expr
;; EXPRESSION)) or (switch-default), and hence the statement
;; classification for these constructs.
(extend-adt* statement switch-stmt) ; "switch" statement
(def-list-ctor* switch-expr)
(def-list-ctor* stmts)
(extend-adt* statement switch-case) ; "case", as in C++
(extend-adt* statement switch-default) ; "default", as in C++
;; Symbian specific.
;;
;; (trap-block (expr LVALUE-EXPR) (stmt STATEMENT) ...)
(extend-adt* statement trap-block)
;; -------------------------
;; expressions...
(define-data
(existing-dt named ast-node
(new-adt* named expression)))
;; (name-ref (name SYMBOL) ...)
(extend-adt* expression name-ref)
;; Unusual in that holds a type expression.
;;
;; (sizeof-expr (type-expr TYPE-EXPR) ...)
(extend-adt* expression sizeof-expr)
;; Types can not normally appear as an expression, but these rules
;; don't hold for when one is using a macro. This expression type
;; lets you put a type expression anywhere in a controlled way, to be
;; printed as is. With this one can let the compiler know that the
;; usual rules do not apply.
;;
;; (texpr-expr (type-expr TYPE-EXPR) ...)
(extend-adt* expression texpr-expr)
;; Method/function call expression.
;;
;; A "target" expression must always be given. A simple "name-ref" is
;; sufficient with functions, static methods, and when the receiver
;; is implicit, i.e. when the receiver is "*this". Otherwise you will
;; want to provide a function reference, a dereferenced function
;; pointer, or perhaps either a "dot-expr" or an "arrow-expr", for
;; method calls with an explicit receiver. Specifying a type (for
;; overload resolution) would usually be unnecessary, since "exprs"
;; ought to reveal enough, except maybe if there are overloads that
;; differ only in return value type (const and non-const variants are
;; common). We do not consider the option of passing a pointer to
;; member, since that is not presently supported.
;;
;; (call-expr (target EXPR) (exprs EXPR ...) ...)
;;
;; While any "decl-id-ref" indicating the possibly resolved target
;; would naturally go within "target", we are putting it directly
;; under "call-expr" at present.
(extend-adt* expression call-expr)
(def-list-ctor* target)
;; Can be used to create a value of a given type, assuming the value
;; has a constructor matching the arguments specified in "exprs".
;;
;; (ctor-call-expr (type TYPE-EXPR) (exprs EXPR ...) ...)
(extend-adt* expression ctor-call-expr)
;; Calls the specified method in a superclass. XXX Not presently
;; supported, and do not know if even C++ supports this.
(extend-adt* expression super-call-expr)
;; (new-expr (type-expr TYPE-EXPR) (exprs EXPR ...) ...)
;;
;; These should be annotated with a "decl-id-ref" indicating the
;; corresponding constructor definition.
(extend-adt* expression new-expr)
;; "new[]" operator.
;;
;; does the num items arg here need to be constant? XXX
(extend-adt* expression new-array-expr)
;; XXX new and new[] must support overloading also; I guess in
;; addition to having to specify type and count, we must also be able
;; to specify call arguments, of which there usually are none
;; "delete" operator. Yes, its application is an expression.
;;
;; (delete-expr (expr EXPR) ...)
(extend-adt* expression delete-expr)
;; "delete[]" operator. Yes, its application is an expression.
;;
;; (delete-array-expr (expr EXPR) ...)
(extend-adt* expression delete-array-expr)
;; Index-based array value reference.
;;
;; (index-expr (expr EXPR) (index INDEX-EXPR) ...)
(extend-adt* expression index-expr)
(def-list-ctor* index)
;; Field reference.
;;
;; We do not yet support ptr-to-member, if it is even appropriate for
;; fields.
;;
;; (dot-expr (expr1 EXPR) (expr2 (name-ref (name SYMBOL) ...)) ...)
;;
;; (arrow-expr (expr1 EXPR) (expr2 (name-ref (name SYMBOL) ...)) ...)
;;
;; The first expression must resolve to a structure type (for
;; dot-expr), or to a pointer to a structure type (for arrow-expr).
;; The second expression is a name-ref, unless we come up with any
;; exceptions.
(extend-adt* expression dot-expr)
(extend-adt* expression arrow-expr)
;; A comma-separated list of expressions. There may be some
;; restrictions as to what types of expressions may appear where,
;; but we do not care.
;;
;; (expr-list-expr (exprs EXPR ...) ...)
(extend-adt* expression expr-list-expr)
;; (lift-stmt-expr (stmt STATEMENT) (expr EXPRESSION))
(extend-adt* expression lift-stmt-expr)
;; -------------------------
;; unary operator expressions...
(define-data (existing-dt named expression
(new-adt* named unary-op-expr)
(new-adt* named binary-op-expr)
(new-adt* named multi-op-expr)
(new-adt* named trinary-op-expr)))
;; &expr
(extend-adt* unary-op-expr addr-of-expr)
;; *expr
(extend-adt* unary-op-expr deref-expr)
;; -expr
(extend-adt* unary-op-expr uminus-expr)
;; +expr
;;
;; Yes, we do support uplus-expr in our AST, and C++ does also
;; support it; supporting it makes sense in the context of operator
;; overloading.
(extend-adt* unary-op-expr uplus-expr)
;; !expr. Logical not.
(extend-adt* unary-op-expr not-expr)
;; ~expr. Bitwise two's complement.
(extend-adt* unary-op-expr neg-expr)
;; ++expr
(extend-adt* unary-op-expr pre-inc-expr)
;; --expr
(extend-adt* unary-op-expr pre-dec-expr)
;; expr++
(extend-adt* unary-op-expr post-inc-expr)
;; expr--
(extend-adt* unary-op-expr post-dec-expr)
;; -------------------------
;; binary operator expressions...
;; These are all binary operations.
;;
(extend-adt* binary-op-expr eq-expr) ;; == (in C++), = (in SPECS)
(extend-adt* binary-op-expr neq-expr) ;; !=
(extend-adt* binary-op-expr lt-expr) ;; <
(extend-adt* binary-op-expr gt-expr) ;; >
(extend-adt* binary-op-expr lte-expr) ;; <=
(extend-adt* binary-op-expr gte-expr) ;; >=
;; These are binary operations, but could all conceivably operate on
;; more than two arguments, assuming we know their associativity, and
;; make things happen. I do not know what C++ itself supports.
(extend-adt* multi-op-expr add-expr) ; +
(extend-adt* multi-op-expr sub-expr) ; -
(extend-adt* multi-op-expr mul-expr) ; *
(extend-adt* multi-op-expr div-expr) ; /
(extend-adt* binary-op-expr mod-expr) ; %
(extend-adt* multi-op-expr or-expr) ; ||
(extend-adt* multi-op-expr and-expr) ; &&
(extend-adt* binary-op-expr lshift-expr) ; <<
(extend-adt* binary-op-expr rshift-expr) ; >>
(extend-adt* multi-op-expr xor-expr) ; ^
(extend-adt* multi-op-expr bit-or-expr) ; |
(extend-adt* multi-op-expr bit-and-expr) ; &
;; These are all binary operations.
;;
(extend-adt* binary-op-expr assign-expr) ; = (in C++), := (in SPECS)
(extend-adt* binary-op-expr add-assign-expr) ; +=
(extend-adt* binary-op-expr sub-assign-expr) ; -=
(extend-adt* binary-op-expr mul-assign-expr) ; *=
(extend-adt* binary-op-expr div-assign-expr) ; /=
(extend-adt* binary-op-expr mod-assign-expr) ; %=
(extend-adt* binary-op-expr lshift-assign-expr) ; <<=
(extend-adt* binary-op-expr rshift-assign-expr) ; >>=
(extend-adt* binary-op-expr xor-assign-expr) ; ^=
(extend-adt* binary-op-expr bit-or-assign-expr) ; |=
(extend-adt* binary-op-expr bit-and-assign-expr) ; &=
;; -------------------------
;; trinary operator expressions...
;; c-expr ? t-expr : e-expr
;; (if-expr (cond-expr EXPR) (then-expr EXPR) (else-expr EXPR) ...)
(extend-adt* trinary-op-expr if-expr)
(def-list-ctor* cond-expr)
(def-list-ctor* then-expr)
(def-list-ctor* else-expr)
;; -------------------------
;; cast expressions...
(define-data
(existing-dt named expression
(new-adt* named cast-expr)))
;; Cast expressions.
;;
;; (static-cast-expr (type TYPE-EXPR) (expr EXPR) ...)
;; (const-cast-expr (type TYPE-EXPR) (expr EXPR) ...)
;; (reinterpret-cast-expr (type TYPE-EXPR) (expr EXPR) ...)
;; (dynamic-cast-expr (type TYPE-EXPR) (expr EXPR) ...)
;; (old-style-cast-expr (type TYPE-EXPR) (expr EXPR) ...)
(extend-adt* cast-expr static-cast-expr)
(extend-adt* cast-expr const-cast-expr)
(extend-adt* cast-expr reinterpret-cast-expr)
(extend-adt* cast-expr dynamic-cast-expr)
(extend-adt* cast-expr old-style-cast-expr)
;; -------------------------
;; literal expressions...
;; Literal expressions. It is up to the parser to determine the type
;; of a literal expression. Some implicit coercions are supported by
;; C++, so not all literal types need be expressible in the syntax;
;; presumably not all are expressible in C++ syntax, but there
;; probably is nothing stopping one from supporting all of them.
;;
;; In particular, we _could_ support a typed NULL literal, unlike C++
;; itself.
;;
;; VALUE is dependent on type. For literals of complex types such as
;; arrays and structures the VALUE may be an S-expression of some
;; sort, but in other cases a primitive Scheme value will probably
;; suffice.
;;
;; "literal-format" is optional, but may be provided to guide pretty
;; printing. For instance, one could indicate whether to print an
;; integer in octal ("oct"), decimal ("dec"), or hexadecimal ("hex"),
;; or whether a char should be printed as a quoted character or a
;; quoted escaped number.
;;
;; (literal (type TYPE-EXPR) (literal-value VALUE) (literal-format
;; SYMBOL) ...)
(extend-adt* expression literal)
(def-list-ctor* literal-value)
(def-list-ctor* literal-format)
;; -------------------------
;; inline foreign language...
;; C++ code to be retained as is.
;;
;; (cxx-chunk (pp-code AST) ...)
;;
;; These nodes contain code-print.scm language rather than a text
;; string and directives. This is simpler and more flexible.
(define-data
(existing-dt named ast-node
(new-cdt* named cxx-chunk)))
) ; end module
#;
(begin
(require ast-spec)
(require (lib "util.scm" "wg"))
(require (lib "compact.scm" "wg"))
(require (lib "ast-util.scm" "wg"))
(write-nl (statement? (switch-stmt)))
(write-nl (statement? (literal)))
)
| false |
e1b44b889e91f84006067dc37bd7cab47e53ca72 | e28e5bd06f08ba86edcdfcf5d50de37a90e1cd19 | /scheme/priority-queue.scm | e4eb3380a80a89d5a62aa64113ae3a1270b2ebd8 | []
| no_license | edoardo90/swKnights-plp | 4384a9dedc6c3ec15181b5e201d66207b331579a | 870b3f4f37c73bfe4a913b8da079a778314117c9 | refs/heads/master | 2021-01-18T01:43:48.024605 | 2016-03-19T20:37:51 | 2016-03-19T20:37:51 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,185 | scm | priority-queue.scm | #lang racket
;) Swap two vector elements
(define (vector-swap! v x y)
(let ((tmp (vector-ref v x)))
(vector-set! v x (vector-ref v y))
(vector-set! v y tmp)
v))
;) heapify function (max or min depending of orderer)
(define (heapify! heap heap-size i orderer)
(let ([l (* 2 i)]
[r (+ (* 2 i) 1)])
(let ((max1
(if (and (<= l heap-size)
(orderer (vector-ref heap (- l 1))
(vector-ref heap (- i 1))))
l
i)))
(let ((max2
(if (and (<= r heap-size)
(orderer (vector-ref heap (- r 1))
(vector-ref heap (- max1 1))))
r
max1)))
(when (not (= max2 i))
(begin
(vector-swap! heap (- max2 1) (- i 1))
(heapify! heap heap-size max2 orderer)))))))
;) Min priority queue object
(define (make-priority-queue orderer max-size)
(let ([queue (make-vector max-size)]
[size 0])
;) Extract the firs element of the queue
(define (extract)
(if (< size 1)
(error "heap underflow")
(let ([max (vector-ref queue 0)])
(begin
(set! size (- size 1))
(vector-set! queue 0 (vector-ref queue size))
(heapify! queue size 1 orderer)
max))))
;) Private change key method, performs swap without checking
(define (change-key-private index key)
(begin
(vector-set! queue (- index 1) key)
(let loop ([i index])
(when (and (> i 1)
(orderer (vector-ref queue (- i 1))
(vector-ref queue (- (quotient i 2) 1))))
(begin
(vector-swap! queue (- i 1) (- (quotient i 2) 1))
(loop (quotient i 2)))))))
;) Change key value, only following the ordering (if ordering is max, the key must be min)
(define (change-key index key)
(if (orderer (vector-ref queue index) key)
(error "invalid new key value")
(change-key-private index key)))
;) Insert a new object in the queue
(define (insert key)
(begin
(vector-set! queue size 'inf)
(set! size (+ size 1))
(change-key-private size key)))
;) Insert all the elements from a list into the queue
(define (insert-all list)
(unless (empty? list)
(let ([head (car list)]
[rest (cdr list)])
(insert head)
(insert-all rest))))
;) Object message dispatcher
(λ (method . args)
(apply (case method
((extract) extract)
((change-key) change-key)
((insert) insert)
((insert-all) insert-all)
(else (error "Unknown Method!")))
args))))
;) Debug code
;(define coda1 (make-priority-queue < 20))
;(coda1 'insert-all '(5 6 45 85 96 33 45 78 42 42 456))
;(newline)
;(coda1 'extract)
;(coda1 'extract)
;(coda1 'extract)
| false |
0ff38f0b85c246a075464cb1e01d57f2dd4cf091 | defeada37d39bca09ef76f66f38683754c0a6aa0 | /mscorlib/system/text/encoding.sls | ee1225afd63f2864edb835eb95a90fb827423119 | []
| 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 | 7,525 | sls | encoding.sls | (library (system text encoding)
(export is?
encoding?
get-encoder
get-hash-code
get-chars
get-preamble
convert
is-always-normalized?
get-string
get-bytes
get-encoding
get-max-byte-count
get-byte-count
get-char-count
get-max-char-count
get-encodings
clone
equals?
get-decoder
is-read-only?
is-single-byte?
decoder-fallback-get
decoder-fallback-set!
decoder-fallback-update!
encoder-fallback-get
encoder-fallback-set!
encoder-fallback-update!
body-name
code-page
encoding-name
header-name
is-browser-display?
is-browser-save?
is-mail-news-display?
is-mail-news-save?
web-name
windows-code-page
ascii
big-endian-unicode
default
utf7
utf8
unicode
utf32)
(import (ironscheme-clr-port))
(define (is? a) (clr-is System.Text.Encoding a))
(define (encoding? a) (clr-is System.Text.Encoding a))
(define-method-port
get-encoder
System.Text.Encoding
GetEncoder
(System.Text.Encoder))
(define-method-port
get-hash-code
System.Text.Encoding
GetHashCode
(System.Int32))
(define-method-port
get-chars
System.Text.Encoding
GetChars
(System.Int32 System.Byte* System.Int32 System.Char* System.Int32)
(System.Char[] System.Byte[])
(System.Char[] System.Byte[] System.Int32 System.Int32)
(System.Int32
System.Byte[]
System.Int32
System.Int32
System.Char[]
System.Int32))
(define-method-port
get-preamble
System.Text.Encoding
GetPreamble
(System.Byte[]))
(define-method-port
convert
System.Text.Encoding
Convert
(static:
System.Byte[]
System.Text.Encoding
System.Text.Encoding
System.Byte[]
System.Int32
System.Int32)
(static:
System.Byte[]
System.Text.Encoding
System.Text.Encoding
System.Byte[]))
(define-method-port
is-always-normalized?
System.Text.Encoding
IsAlwaysNormalized
(System.Boolean System.Text.NormalizationForm)
(System.Boolean))
(define-method-port
get-string
System.Text.Encoding
GetString
(System.String System.Byte[])
(System.String System.Byte[] System.Int32 System.Int32))
(define-method-port
get-bytes
System.Text.Encoding
GetBytes
(System.Int32 System.Char* System.Int32 System.Byte* System.Int32)
(System.Byte[] System.Char[])
(System.Byte[] System.Char[] System.Int32 System.Int32)
(System.Byte[] System.String)
(System.Int32
System.String
System.Int32
System.Int32
System.Byte[]
System.Int32)
(System.Int32
System.Char[]
System.Int32
System.Int32
System.Byte[]
System.Int32))
(define-method-port
get-encoding
System.Text.Encoding
GetEncoding
(static: System.Text.Encoding System.String)
(static:
System.Text.Encoding
System.String
System.Text.EncoderFallback
System.Text.DecoderFallback)
(static:
System.Text.Encoding
System.Int32
System.Text.EncoderFallback
System.Text.DecoderFallback)
(static: System.Text.Encoding System.Int32))
(define-method-port
get-max-byte-count
System.Text.Encoding
GetMaxByteCount
(System.Int32 System.Int32))
(define-method-port
get-byte-count
System.Text.Encoding
GetByteCount
(System.Int32 System.Char* System.Int32)
(System.Int32 System.Char[])
(System.Int32 System.String)
(System.Int32 System.Char[] System.Int32 System.Int32))
(define-method-port
get-char-count
System.Text.Encoding
GetCharCount
(System.Int32 System.Byte* System.Int32)
(System.Int32 System.Byte[])
(System.Int32 System.Byte[] System.Int32 System.Int32))
(define-method-port
get-max-char-count
System.Text.Encoding
GetMaxCharCount
(System.Int32 System.Int32))
(define-method-port
get-encodings
System.Text.Encoding
GetEncodings
(static: System.Text.EncodingInfo[]))
(define-method-port clone System.Text.Encoding Clone (System.Object))
(define-method-port
equals?
System.Text.Encoding
Equals
(System.Boolean System.Object))
(define-method-port
get-decoder
System.Text.Encoding
GetDecoder
(System.Text.Decoder))
(define-field-port
is-read-only?
#f
#f
(property:)
System.Text.Encoding
IsReadOnly
System.Boolean)
(define-field-port
is-single-byte?
#f
#f
(property:)
System.Text.Encoding
IsSingleByte
System.Boolean)
(define-field-port
decoder-fallback-get
decoder-fallback-set!
decoder-fallback-update!
(property:)
System.Text.Encoding
DecoderFallback
System.Text.DecoderFallback)
(define-field-port
encoder-fallback-get
encoder-fallback-set!
encoder-fallback-update!
(property:)
System.Text.Encoding
EncoderFallback
System.Text.EncoderFallback)
(define-field-port
body-name
#f
#f
(property:)
System.Text.Encoding
BodyName
System.String)
(define-field-port
code-page
#f
#f
(property:)
System.Text.Encoding
CodePage
System.Int32)
(define-field-port
encoding-name
#f
#f
(property:)
System.Text.Encoding
EncodingName
System.String)
(define-field-port
header-name
#f
#f
(property:)
System.Text.Encoding
HeaderName
System.String)
(define-field-port
is-browser-display?
#f
#f
(property:)
System.Text.Encoding
IsBrowserDisplay
System.Boolean)
(define-field-port
is-browser-save?
#f
#f
(property:)
System.Text.Encoding
IsBrowserSave
System.Boolean)
(define-field-port
is-mail-news-display?
#f
#f
(property:)
System.Text.Encoding
IsMailNewsDisplay
System.Boolean)
(define-field-port
is-mail-news-save?
#f
#f
(property:)
System.Text.Encoding
IsMailNewsSave
System.Boolean)
(define-field-port
web-name
#f
#f
(property:)
System.Text.Encoding
WebName
System.String)
(define-field-port
windows-code-page
#f
#f
(property:)
System.Text.Encoding
WindowsCodePage
System.Int32)
(define-field-port
ascii
#f
#f
(static: property:)
System.Text.Encoding
ASCII
System.Text.Encoding)
(define-field-port
big-endian-unicode
#f
#f
(static: property:)
System.Text.Encoding
BigEndianUnicode
System.Text.Encoding)
(define-field-port
default
#f
#f
(static: property:)
System.Text.Encoding
Default
System.Text.Encoding)
(define-field-port
utf7
#f
#f
(static: property:)
System.Text.Encoding
UTF7
System.Text.Encoding)
(define-field-port
utf8
#f
#f
(static: property:)
System.Text.Encoding
UTF8
System.Text.Encoding)
(define-field-port
unicode
#f
#f
(static: property:)
System.Text.Encoding
Unicode
System.Text.Encoding)
(define-field-port
utf32
#f
#f
(static: property:)
System.Text.Encoding
UTF32
System.Text.Encoding))
| false |
e26070cabef68a18716a8e1d6fe08dcd665d8a0c | b9eb119317d72a6742dce6db5be8c1f78c7275ad | /racket/generator-primes.ss | 1a36e361729df2d2f6f3f165b5751d82bb04ab35 | []
| no_license | offby1/doodles | be811b1004b262f69365d645a9ae837d87d7f707 | 316c4a0dedb8e4fde2da351a8de98a5725367901 | refs/heads/master | 2023-02-21T05:07:52.295903 | 2022-05-15T18:08:58 | 2022-05-15T18:08:58 | 512,608 | 2 | 1 | null | 2023-02-14T22:19:40 | 2010-02-11T04:24:52 | Scheme | UTF-8 | Scheme | false | false | 648 | ss | generator-primes.ss | #! /bin/sh
#| Hey Emacs, this is -*-scheme-*- code!
#$Id: v4-script-template.ss 6182 2009-11-10 04:59:27Z erich $
exec mzscheme -l errortrace --require "$0" --main -- ${1+"$@"}
|#
#lang scheme
(require (planet schematics/schemeunit:3)
(planet schematics/schemeunit:3/text-ui)
scheme/generator)
(define (naturals)
(for ([i (in-naturals)])
(yield i)))
(define (sans-factors g n)
(for ([i (in-generator (g))])
(when (positive? (remainder i n))
(yield i))))
(define (main)
(for ([i (in-generator (sans-factors naturals 3))])
(if (= i 10)
(exit 0)
(printf "It's ~a~%" i))))
(provide main)
| false |
d904e65a1e7b2272934626aadaf178b1bdf06664 | 1ed47579ca9136f3f2b25bda1610c834ab12a386 | /sec3/stream-common.scm | 385b75acfec6e4e48e03880029e55a059763dd51 | []
| no_license | thash/sicp | 7e89cf020e2bf5ca50543d10fa89eb1440f700fb | 3fc7a87d06eccbe4dcd634406e3b400d9405e9c4 | refs/heads/master | 2021-05-28T16:29:26.617617 | 2014-09-15T21:19:23 | 2014-09-15T21:19:23 | 3,238,591 | 0 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 3,105 | scm | stream-common.scm | ;; The only difference is imprementation of "delay".
(define (force delayed-object)
(delayed-object))
;; cons, car, cdr
(define-macro (cons-stream a b)
`(cons ,a (delay ,b)))
(define (stream-car stream) (car stream))
(define (stream-cdr stream) (force (cdr stream)))
;; null
(define the-empty-stream '())
(define stream-null? null?)
;; display
(define (display-stream s)
(stream-for-each display-line s))
;; display limited items in the given stream.
(define (display-stream-n s n)
(stream-for-each-n display-comma s n))
;;(stream-for-each-n display-line s n))
(define (take n s) (display-stream-n s (+ n 1)))
(define (stream-head s n)
(display-stream-n s n))
(define (display-line x)
(newline)
(display x))
(define (display-comma x)
(display x)
(display ", "))
;; utils
(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-for-each-n proc s n)
(define (iter proc s n i)
(if (or (stream-null? s) (= n i))
'done
(begin (proc (stream-car s))
(iter proc (stream-cdr s) n (+ i 1)))))
(iter proc s n 1))
; (define (stream-map proc s)
; (if (stream-null? s)
; the-empty-stream
; (cons-stream (proc (stream-car s))
; (stream-map proc (stream-cdr s)))))
;; ↓
;; stream-map is improved in *q3.50.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))))))
;; add, scale (using stream-map)
(define (scale-stream stream factor)
(stream-map (lambda (x) (* x factor)) stream))
(define (add-streams s1 s2)
(stream-map + s1 s2))
(define (stream-ref s n)
(if (= n 0)
(stream-car s)
(stream-ref (stream-cdr s) (- n 1))))
;; stream-enumerate-interval
(define (stream-enumerate-interval low high)
(if (> low high)
the-empty-stream
(cons-stream
low
(stream-enumerate-interval (+ low 1) high))))
;; stream-filter
(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 (merge s1 s2)
(cond ((stream-null? s1) s2)
((stream-null? s2) s1)
(else
(let ((s1car (stream-car s1))
(s2car (stream-car s2)))
(cond ((< s1car s2car)
(cons-stream s1car (merge (stream-cdr s1) s2)))
((> s1car s2car)
(cons-stream s2car (merge s1 (stream-cdr s2))))
(else
;; s1carとs2carが等しいときは1個だけ。
(cons-stream s1car
(merge (stream-cdr s1)
(stream-cdr s2)))))))))
| false |
7898a710ba42bc9b883773a0bb9cd9a8a6534508 | 4b570eebce894b4373cba292f09883932834e543 | /ch2/2.18.scm | d6185dcad425f9b74d36794096eac0a8b263a301 | []
| no_license | Pulkit12083/sicp | ffabc406c66019e5305ad701fbc022509319e4b1 | 8ea6c57d2b0be947026dd01513ded25991e5c94f | refs/heads/master | 2021-06-17T13:44:06.381879 | 2021-05-14T16:52:30 | 2021-05-14T16:52:30 | 197,695,022 | 0 | 0 | null | 2021-04-14T17:04:01 | 2019-07-19T03:25:41 | Scheme | UTF-8 | Scheme | false | false | 131 | scm | 2.18.scm | (define (reverse-list lst)
(define (revlist l r)
(if (null? l)
r
(revlist (cdr l) (cons (car l) r))))
(revlist lst '()))
| false |
714b677cf3a8cbaf64abd3062db33a5e4e40fa95 | 6759550fc33a498102bb62413d4b89d0868983a1 | /lib/kirjasto/koukku.scm | 9480f9a917990ea40895fb89cab66c749e7f2a3c | []
| no_license | mytoh/kirjasto | 96140f507bc89eb85c0a104d6f48b5c05b305925 | 68fd7bedf34dd1abbed88a30f9f8d86faba38cc6 | refs/heads/master | 2016-09-10T16:38:20.480131 | 2014-10-06T20:54:26 | 2014-10-06T20:54:26 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 881 | scm | koukku.scm | ;;; koukku.scm
(define-library (kirjasto koukku)
(export define-hook
add-hook
remove-hook
run-hooks)
(import (scheme base)
(scheme write)
(srfi 1))
(begin
(define-syntax define-hook
(syntax-rules ()
((_ name value)
(define name
(make-parameter (list value))))))
(define (add-hook name fn)
(if (null? (car (name)))
(name (list fn))
(name (append (name) (list fn)))))
(define (remove-hook name fn)
(let ((old (name)))
(name
(remove
(lambda (x) (eq? x fn))
old))))
(define (run-hooks . hooks)
(for-each
(lambda (hook)
(for-each
(lambda (h)
(if (not (null? h))
(h)))
(hook)))
hooks))
))
| true |
e9d94e775438410fb6a7ec961399e279ce7c2cf5 | d074b9a2169d667227f0642c76d332c6d517f1ba | /sicp/ch_2/exercise.2.71.scm | 6de50b0ab335d2761909a94d4f30adb37f5cf50e | []
| 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 | 1,277 | scm | exercise.2.71.scm | #lang racket/base
(require "../lib/test.rkt")
(require "../lib/myutils.scm")
;;; Exercise 2.71:
;; Suppose we have a Huffman tree for an alphabet of n symbols, and
;; that the relative frequencies of the symbols are 1, 2, 4, ...,
;; 2^(n-1). Sketch the tree for n=5; for n=10. In such a tree (for
;; general n) how many bits are required to encode the most frequent
;; symbol? the least frequent symbol?
;; sketch? fuck you! we just wrote all this damn code...
;; n = 5
;; (generate-huffman-tree '((a 1) (b 2) (c 4) (d 8) (e 16)))
'(((((leaf a 1)
(leaf b 2) (a b) 3)
(leaf c 4) (a b c) 7)
(leaf d 8) (a b c d) 15)
(leaf e 16) (a b c d e) 31)
;; (map (lambda (n) (list 'x (expt 2 (- n 1)))) (enumerate-interval 1 10))
;; (generate-huffman-tree
;; '((a 1) (b 2) (c 4) (d 8) (e 16) (f 32) (g 64) (h 128) (i 256) (j 512)))
'((((((((((leaf a 1) (leaf b 2) (a b) 3)
(leaf c 4) (a b c) 7)
(leaf d 8) (a b c d) 15)
(leaf e 16) (a b c d e) 31)
(leaf f 32) (a b c d e f) 63)
(leaf g 64) (a b c d e f g) 127)
(leaf h 128) (a b c d e f g h) 255)
(leaf i 256) (a b c d e f g h i) 511)
(leaf j 512) (a b c d e f g h i j) 1023)
;; most frequent is always one: 0
;; least frequent looks like n - 1
;; (assert-equal x y)
(done)
| false |
164014a29977bdc766dcb386365a8ce34e8b61db | 6b961ef37ff7018c8449d3fa05c04ffbda56582b | /bbn_cl/mach/zcomp/rtlgen/opncod.scm | 5c680764190b0136176f1e4a5caf57f3e5f4c878 | []
| 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 | 16,210 | scm | opncod.scm | #| -*-Scheme-*-
$Header: opncod.scm,v 1.8 88/08/31 10:43:02 jinx Exp $
$MIT-Header: opncod.scm,v 4.4 88/03/31 21:35:23 GMT mhwu Exp $
Copyright (c) 1987 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. |#
;;;; RTL Generation: Inline Combinations
(declare (usual-integrations))
;; *** NOTE *** this is a horrible kludge!
;; This section should be split into a separate file and loaded into
;; the appropriate environment to avoid (THE-ENVIRONMENT) in code.
(define open-coder-package)
(package (open-coding-analysis combination/inline)
(set! open-coder-package (the-environment))
;;;; Analysis
(define-export (open-coding-analysis applications)
(for-each (if compiler:open-code-primitives?
(lambda (application)
(if (eq? (application-type application) 'COMBINATION)
(set-combination/inliner!
application
(analyze-combination application))))
(lambda (application)
(if (eq? (application-type application) 'COMBINATION)
(set-combination/inliner! application false))))
applications))
(define (analyze-combination combination)
(let ((operator (combination/operator combination)))
(let ((entry (reference-open-coder operator)))
(if entry
(try-reference-handler combination entry)
(let ((callee (rvalue-known-value operator)))
(and callee
(rvalue/constant? callee)
(let ((value (constant-value callee)))
(and (scode/primitive-procedure? value)
(let ((entry
(assq (primitive-procedure-name value)
name->open-coders)))
(and entry
(try-handler combination value (cdr entry))))))))))))
(define (reference-open-coder node)
(and (rvalue/reference? node)
(let ((name (variable-name (reference-lvalue node))))
(assq name name->open-coders))))
(define (reference-open-code-arity name)
(let ((entry (assq name reference-open-coder-name->arity)))
(and entry
(cdr entry))))
(define (try-reference-handler combination entry)
(let* ((operands (combination/operands combination))
(name (car entry))
(open-coder-info (cdr entry))
(arity (reference-open-code-arity name)))
(if (and arity
(or (= arity -1)
(= arity (length operands))))
(let ((result ((vector-ref open-coder-info 0) operands)))
(and result
(transmit-values result
(lambda (generator indices)
(make-inliner open-coder-info generator indices))))))))
(define (try-handler combination primitive entry)
(let ((operands (combination/operands combination)))
(and (primitive-arity-correct? primitive (length operands))
(let ((result ((vector-ref entry 0) operands)))
(and result
(transmit-values result
(lambda (generator indices)
(make-inliner entry generator indices))))))))
;;;; Code Generator
(define-export (combination/inline combination)
(let ((offset (node/offset combination)))
(generate/return* (combination/block combination)
(combination/continuation combination)
(let ((inliner (combination/inliner combination)))
(let ((handler (inliner/handler inliner))
(generator (inliner/generator inliner))
(expressions
(map (subproblem->expression offset)
(inliner/operands inliner))))
(make-return-operand
(lambda (offset)
((vector-ref handler 1) generator expressions))
(lambda (offset finish)
((vector-ref handler 2) generator
expressions
finish))
(lambda (offset finish)
((vector-ref handler 3) generator
expressions
finish))
false)))
offset)))
(define (subproblem->expression offset)
(lambda (subproblem)
(let ((rvalue (subproblem-rvalue subproblem)))
(let ((value (rvalue-known-value rvalue)))
(cond ((and value (rvalue/constant? value))
(rtl:make-constant (constant-value value)))
((and value
(rvalue/procedure? value)
(procedure/closure? value)
(procedure/trivial-closure? value))
(make-trivial-closure-cons value))
((and (rvalue/reference? rvalue)
(not (variable/value-variable? (reference-lvalue rvalue)))
(reference-to-known-location? rvalue))
(rtl:make-fetch
(find-known-variable (reference-block rvalue)
(reference-lvalue rvalue)
offset)))
(else
(rtl:make-fetch
(continuation*/register
(subproblem-continuation subproblem)))))))))
(define (invoke/effect->effect generator expressions)
(generator expressions false))
(define (invoke/predicate->value generator expressions finish)
(generator expressions
(lambda (pcfg)
(let ((temporary (rtl:make-pseudo-register)))
(scfg*scfg->scfg!
(pcfg*scfg->scfg!
pcfg
(rtl:make-assignment temporary (rtl:make-constant true))
(rtl:make-assignment temporary (rtl:make-constant false)))
(finish (rtl:make-fetch temporary)))))))
(define (invoke/value->effect generator expressions)
(make-null-cfg))
(define (invoke/value->predicate generator expressions finish)
(generator expressions
(lambda (expression)
(finish (rtl:make-true-test expression)))))
(define (invoke/value->value generator expressions finish)
(generator expressions finish))
;;;; Definers
(define (open-coder-definer ->effect ->predicate ->value)
(let ((per-name
(lambda (name handler arity)
(if arity
(let ((arity-entry (assq name reference-open-coder-name->arity)))
(if arity-entry
(set-cdr! arity-entry arity)
(set! reference-open-coder-name->arity
(cons (cons name arity) reference-open-coder-name->arity)))))
(let ((entry (assq name name->open-coders))
(item (vector handler ->effect ->predicate ->value)))
(if entry
(set-cdr! entry item)
(set! name->open-coders
(cons (cons name item) name->open-coders)))))))
(lambda (name handler #!optional arity)
(if (unassigned? arity) (set! arity #f))
(if (pair? name)
(for-each (lambda (name)
(per-name name handler arity))
name)
(per-name name handler arity))
name)))
(define name->open-coders
'())
(define reference-open-coder-name->arity
'())
(in-package system-global-environment
(define compiler:change-name-of-open-coder!)
(define compiler:copy-open-coder!))
(set! compiler:change-name-of-open-coder!
(named-lambda (compiler:change-name-of-open-coder! from-name to-name)
(let loop ((l name->open-coders))
(cond
((null? l)
#f)
((eq? (caar l) from-name)
(set-car! (car l) to-name))
(else
(loop (cdr l)))))
(let loop ((l reference-open-coder-name->arity))
(cond
((null? l)
#f)
((eq? (caar l) from-name)
(set-car! (car l) to-name))
(else
(loop (cdr l)))))))
(set! compiler:copy-open-coder!
(named-lambda (compiler:copy-open-coder! from-name to-name)
(let ((entry (assq from-name name->open-coders)))
(if entry
(set! name->open-coders
(cons (cons to-name (cdr entry)) name->open-coders))))
(let ((entry (assq from-name reference-open-coder-name->arity)))
(if entry
(set! reference-open-coder-name->arity
(cons (cons to-name (cdr entry)) reference-open-coder-name->arity))))
#f))
(define define-open-coder/effect
(open-coder-definer invoke/effect->effect
invoke/value->predicate
invoke/value->value))
(define define-open-coder/predicate
(open-coder-definer invoke/value->effect
invoke/value->value
invoke/predicate->value))
(define define-open-coder/value
(open-coder-definer invoke/value->effect
invoke/value->predicate
invoke/value->value))
;;;; Operand Filters
(define (filter/constant rvalue predicate generator)
(let ((operand (rvalue-known-value rvalue)))
(and operand
(rvalue/constant? operand)
(let ((value (constant-value operand)))
(and (predicate value)
(generator value))))))
(define (filter/nonnegative-integer operand generator)
(filter/constant operand
(lambda (value)
(and (integer? value)
(not (negative? value))))
generator))
(define (filter/positive-integer operand generator)
(filter/constant operand
(lambda (value)
(and (integer? value)
(positive? value)))
generator))
;;;; Open Coders
(define-open-coder/predicate 'NULL?
(lambda (operands)
(return-2 (lambda (expressions finish)
(finish (pcfg-invert (rtl:make-true-test (car expressions)))))
'(0))))
(let ((open-code/type-test
(lambda (type)
(lambda (expressions finish)
(finish
(rtl:make-type-test (rtl:make-object->type (car expressions))
type))))))
(let ((define/type-test
(lambda (name type)
(define-open-coder/predicate name
(lambda (operands)
(return-2 (open-code/type-test type) '(0)))))))
(define/type-test 'PAIR? (ucode-type pair))
(define/type-test 'STRING? (ucode-type string))
(define/type-test 'BIT-STRING? (ucode-type vector-1b)))
(define-open-coder/predicate 'PRIMITIVE-TYPE?
(lambda (operands)
(filter/nonnegative-integer (car operands)
(lambda (type)
(return-2 (open-code/type-test type) '(1))))))
(define-open-coder/predicate 'NON-TOUCHING-PRIMITIVE-TYPE?
(lambda (operands)
(filter/nonnegative-integer (car operands)
(lambda (type)
(return-2 (open-code/type-test type) '(1)))))))
(let ((open-code/eq-test
(lambda (expressions finish)
(finish (rtl:make-eq-test (car expressions) (cadr expressions))))))
(define-open-coder/predicate 'EQ?
(lambda (operands)
(return-2 open-code/eq-test '(0 1)))))
(let ((open-code/pair-cons
(lambda (type)
(lambda (expressions finish)
(finish
(rtl:make-typed-cons:pair (rtl:make-constant type)
(car expressions)
(cadr expressions)))))))
(define-open-coder/value 'CONS
(lambda (operands)
(return-2 (open-code/pair-cons (ucode-type pair)) '(0 1))))
(define-open-coder/value 'SYSTEM-PAIR-CONS
(lambda (operands)
(filter/nonnegative-integer (car operands)
(lambda (type)
(return-2 (open-code/pair-cons type) '(1 2)))))))
(define-open-coder/value 'VECTOR
(lambda (operands)
(and (< (length operands) 32)
(return-2 (lambda (expressions finish)
(finish
(rtl:make-typed-cons:vector
(rtl:make-constant (ucode-type vector))
expressions)))
(all-operand-indices operands)))))
(define (all-operand-indices operands)
(let loop ((operands operands) (index 0))
(if (null? operands)
'()
(cons index (loop (cdr operands) (1+ index))))))
(let ((open-code/memory-length
(lambda (index)
(lambda (expressions finish)
(finish
(rtl:make-cons-pointer
(rtl:make-constant (ucode-type fixnum))
(rtl:make-fetch
(rtl:locative-offset (car expressions) index))))))))
(let ((define/length
(lambda (name index)
(define-open-coder/value name
(lambda (operands)
(return-2 (open-code/memory-length index) '(0)))))))
(define/length '(VECTOR-LENGTH SYSTEM-VECTOR-SIZE) 0)
(define/length '(STRING-LENGTH BIT-STRING-LENGTH) 1)))
(let ((open-code/memory-ref
(lambda (index name)
(lambda (expressions finish)
(let ((expression (car expressions)))
(if (rtl:constant? expression)
(finish
(list 'CONSTANT
((make-primitive-procedure name) (cadr expression))))
(finish
(rtl:make-fetch (rtl:locative-offset expression index)))))))))
(let ((define/ref
(lambda (name index)
(define-open-coder/value name
(lambda (operands)
(return-2 (open-code/memory-ref index name) '(0)))))))
(define/ref 'CAR 0)
(define/ref 'SYSTEM-PAIR-CAR 0)
(define/ref 'CELL-CONTENTS 0)
(define/ref 'SYSTEM-HUNK3-CXR0 0)
(define/ref 'CDR 1)
(define/ref 'SYSTEM-PAIR-CDR 1)
(define/ref 'SYSTEM-HUNK3-CXR1 1)
(define/ref 'SYSTEM-HUNK3-CXR2 2))
(for-each (lambda (name)
(define-open-coder/value name
(lambda (operands)
(filter/nonnegative-integer (cadr operands)
(lambda (index)
(return-2 (open-code/memory-ref (1+ index) name) '(0)))))))
'(VECTOR-REF SYSTEM-VECTOR-REF)))
;;;
;;; Reference (non-primitive) inline code for commonlisp car/cdr
;;;
(let ((open-code/safe-memory-ref
(lambda (index)
(lambda (expressions finish)
(let ((temporary (rtl:make-pseudo-register))
(expression (car expressions)))
(if (rtl:constant? expression)
(finish
(let ((constant (cadr expression)))
(cond
((null? constant)
'(CONSTANT ()))
((pair? constant)
`(CONSTANT
,((if (= index 0) car cdr)
constant)))
(else (error "CAR/CDR of non-list" constant)))))
(scfg*scfg->scfg!
(pcfg*scfg->scfg!
(rtl:make-true-test expression)
(rtl:make-assignment temporary
(rtl:make-fetch
(rtl:locative-offset expression index)))
(rtl:make-assignment temporary expression))
(finish (rtl:make-fetch temporary)))))))))
(let ((define/ref
(lambda (name index)
(define-open-coder/value name
(lambda (operands)
(return-2 (open-code/safe-memory-ref index) '(0)))
1))))
(define/ref '(CL-CAR) 0)
(define/ref '(CL-CDR) 1)))
(let ((open-code/general-car-cdr
(lambda (pattern)
(lambda (expressions finish)
(finish
(let loop ((pattern pattern) (expression (car expressions)))
(if (= pattern 1)
expression
(let ((qr (integer-divide pattern 2)))
(loop (integer-divide-quotient qr)
(rtl:make-fetch
(rtl:locative-offset
expression
(- 1 (integer-divide-remainder qr)))))))))))))
(define-open-coder/value 'GENERAL-CAR-CDR
(lambda (operands)
(filter/positive-integer (cadr operands)
(lambda (pattern)
(return-2 (open-code/general-car-cdr pattern) '(0)))))))
(let ((open-code/memory-assignment
(lambda (index)
(lambda (expressions finish)
(let ((locative (rtl:locative-offset (car expressions) index)))
(let ((assignment
(rtl:make-assignment locative (cadr expressions))))
(if finish
(let ((temporary (rtl:make-pseudo-register)))
(scfg-append!
(rtl:make-assignment temporary (rtl:make-fetch locative))
assignment
(finish (rtl:make-fetch temporary))))
assignment)))))))
(let ((define/set!
(lambda (name index)
(define-open-coder/effect name
(lambda (operands)
(return-2 (open-code/memory-assignment index) '(0 1)))))))
(define/set! '(SET-CAR! SYSTEM-PAIR-SET-CAR!
SET-CELL-CONTENTS!
SYSTEM-HUNK3-SET-CXR0!)
0)
(define/set! '(SET-CDR! SYSTEM-PAIR-SET-CDR! SYSTEM-HUNK3-SET-CXR1!) 1)
(define/set! 'SYSTEM-HUNK3-SET-CXR2! 2))
(define-open-coder/effect '(VECTOR-SET! SYSTEM-VECTOR-SET!)
(lambda (operands)
(filter/nonnegative-integer (cadr operands)
(lambda (index)
(return-2 (open-code/memory-assignment (1+ index)) '(0 2)))))))
;;; end COMBINATION/INLINE
)
| false |
cb909bc78e7be3590df0c4c6d7094400e296c8f8 | bf6fad8f5227d0b0ef78598065c83b89b8f74bbc | /chapter03/internal-definitions_sample.ss | bc6e523719439a0ad2e5a16824d49f77cded9ad8 | []
| no_license | e5pe0n/tspl | 931d1245611280457094bd000e20b1790c3e2499 | bc76cac2307fe9c5a3be2cea36ead986ca94be43 | refs/heads/main | 2023-08-18T08:21:29.222335 | 2021-09-28T11:04:54 | 2021-09-28T11:04:54 | 393,668,056 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 914 | ss | internal-definitions_sample.ss | (define print
(lambda (x)
(for-each display `(,x "\n"))
)
)
(define f (lambda (x) (* x x)))
(print
(let ([x 3])
(define f (lambda (y) (+ y x)))
(f 4)
)
) ; 7
(print (f 4)) ; 16
(let ()
(define even?
(lambda (x)
(or (= x 0) (odd? (- x 1)))
)
)
(define odd?
(lambda (x)
(and (not (= x 0)) (even? (- x 1)))
)
)
(print (even? 20)) ; #t
(print (odd? 20)) ; #f
)
(define list?
(lambda (x)
(define race
(lambda (h t)
(if (pair? h)
(let ([h (cdr h)])
(if (pair? h)
(and
(not (eq? h t))
(race (cdr h) (cdr t))
)
(null? h)
)
)
(null? h)
)
)
)
(race x x)
)
)
(let ([x 3])
(define-syntax set-x!
(syntax-rules ()
[(_ e) (set! x e)]
)
)
(set-x! (+ x x))
(print x) ; 6
) | true |
1eabd4330f249b7d32eb2eb9a3ec93d593b19961 | f59b3ca0463fed14792de2445de7eaaf66138946 | /section-2/2_10.scm | 9a0dc4aad7217375230e11322b3ba24f13e1f3fc | []
| no_license | uryu1994/sicp | f903db275f6f8c2da0a6c0d9a90c0c1cf8b1e718 | b14c728bc3351814ff99ace3b8312a651f788e6c | refs/heads/master | 2020-04-12T01:34:28.289074 | 2018-06-26T15:17:06 | 2018-06-26T15:17:06 | 58,478,460 | 0 | 1 | null | 2018-06-20T11:32:33 | 2016-05-10T16:53:00 | Scheme | UTF-8 | Scheme | false | false | 263 | scm | 2_10.scm | (load "./2_7")
(define (div-interval-error x y)
(if (< (* (lower-bound y) (upper-bound y)) 0)
(print "error")
(mul-interval x
(make-interval (/ 1.0 (upper-bound y))
(/ 1.0 (lower-bound y))))))
| false |
b5671784024e5d68aa15a2012e09d57645a00e9c | 557c51d080c302a65e6ef37beae7d9b2262d7f53 | /workspace/scheme-tester/notes/pl-25.scm | d3eb8f4e197cab73b33d26cd66ed151e1ff8ae69 | []
| no_license | esaliya/SchemeStack | 286a18a39d589773d33e628f81a23bcdd0fc667b | dcfa1bbfa63b928a7ea3fc244f305369763678ad | refs/heads/master | 2020-12-24T16:24:08.591437 | 2016-03-08T15:30:37 | 2016-03-08T15:30:37 | 28,023,003 | 3 | 4 | null | null | null | null | UTF-8 | Scheme | false | false | 1,284 | scm | pl-25.scm | ;Type Inferencing
(if (zero? 5) 6 'six)
;Function Type
(→ int int)
Thre argument function
1. Γ |- (intc n) : int
From Gamma We can derive (intc n) is of type int; intc is a tag
2. Γ |- (intc n1) : int
3. Γ |- (intc n2) : int
---------------------
4. Γ |- (+ ,n1 ,n2) : int
Inorder to prove 4 we have to prove 1,2,3 ("the proof tree")
if condition
1. Γ |- (boolc b-exp) : bool
2. Γ |- exp1 : t
3. Γ |- exp2 : t
---------------------
4. Γ |- (if ,b-exp ,exp1 ,exp2) : t
lambda
Γ,x:tx ;Extending the env (cons (cons x tx) Γ)
----------------------
Γ |- (λ(,x),body) : (→ ,tx ,tbody)
Variable
Γ,x:tx
----------------------
Γ |- (var ,x) : tx
application
Γ |- rator : (→ trand t) Γ |- rand : trand
----------------------
Γ |- (app ,rator ,rand) : t
i missed getting this part right
(define !-
(lambda (gamma exp type)
(matche `(,exp ,type)
(((intc ,n) int))
(((boolc ,b) bool))
(((not ,e) bool)
(!- gamma e 'bool))
(((+ ,n1 ,n2) int)
(!- gamma n1 'int)
(!- gamma n2 'int))
(((if ,b-exp ,exp1 ,exp2) ,t)
(!- gamma b-exp 'bool)
(!- gamma exp1 t)
(!- gamma exp2 t))
(((lambda (,x) ,body) (-> ,t-x ,t-body))
(!- `((,x . ,t-x) . ,bgamma) body t-body))
(((var ,x) ,t-x)
(lookupo x gamma t-x))
)))
| false |
0c782caa0a140d84976bd989f34a0dd23bd1292b | 626ee70444644610003a9796f7c541b4b83f7277 | /server/data/config.scm | 65ba7b1d3ccd00f49e247e2a8dfa9952522d7ebc | []
| no_license | yarnoiser/weird | f2ab638c3a2814cd85a154bdc7ba7ac6d3b66c03 | cb10bac855ca12e75ff86f3c457e48de6ef0ad64 | refs/heads/master | 2020-04-10T21:48:26.117501 | 2016-11-30T21:04:14 | 2016-11-30T21:04:14 | 65,263,033 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 61 | scm | config.scm | (load "server/data/lib.scm")
(load "server/data/world.scm")
| false |
0c1ce0748a2f8f1c358c2b2b3aef57d352416c14 | c3523080a63c7e131d8b6e0994f82a3b9ed901ce | /hertfordstreet/schemes/streams.scm | f1c52bc6391056b0ce5a9ced4fd500bac4351c99 | []
| no_license | johnlawrenceaspden/hobby-code | 2c77ffdc796e9fe863ae66e84d1e14851bf33d37 | d411d21aa19fa889add9f32454915d9b68a61c03 | refs/heads/master | 2023-08-25T08:41:18.130545 | 2023-08-06T12:27:29 | 2023-08-06T12:27:29 | 377,510 | 6 | 4 | null | 2023-02-22T00:57:49 | 2009-11-18T19:57:01 | Clojure | UTF-8 | Scheme | false | false | 4,420 | scm | streams.scm | (require (lib "trace.ss"))
(define-macro (my-delay a)
`(lambda () ,a))
(define (my-force a) (a))
(define-macro (cons-stream a b)
`(cons ,a (delay ,b)))
(define (head a)
(car a))
(define (tail a)
(force (cdr a)))
(define the-empty-stream '())
(define (empty-stream? a)
(null? a))
(define (stream-filter filter? s)
(if (empty-stream? s) the-empty-stream
(let ((a (head s)))
(if (filter? a) (cons-stream a (stream-filter filter? (tail s)))
(stream-filter filter? (tail s))))))
;(define (stream-map f s)
; (if (empty-stream? s) the-empty-stream
; (cons-stream (f (head s)) (stream-map f (tail s)))))
(define (stream-map proc . argstreams)
(if (empty-stream? (car argstreams))
the-empty-stream
(cons-stream (apply proc (map head argstreams))
(apply stream-map (cons proc (map tail argstreams))))))
(define (list->stream l)
(if (null? l) the-empty-stream
(cons-stream (car l) (list->stream (cdr l)))))
(define (display-stream max s)
(if (= max 0) (newline)
(if (not (empty-stream? s))
(begin
(display (head s))
(display ", ")
(display-stream (- max 1) (tail s))))))
(define (add-streams a b)
(cond ((or (empty-stream? a) (empty-stream? b)) the-empty-stream)
(else (cons-stream (+ (head a) (head b)) (add-streams (tail a) (tail b))))))
(define (scale-stream c s)
(stream-map (lambda (x) (* c x)) s))
(define (stream-ref s n)
(if (= n 0)
(head s)
(stream-ref (tail s) (- n 1))))
(define (stream-enumerate-interval a b)
(if (<= a b)
(cons-stream a (stream-enumerate-interval (+ a 1) b))
the-empty-stream))
(define (integers-from n) (cons-stream n (integers-from (+ n 1))))
(define integers (integers-from 1))
(define q (add-streams (cons-stream 1 q) (cons-stream 0 q)))
(define p (cons-stream 0 (cons-stream 1 (add-streams p (tail p)))))
(define ones (cons-stream 1 ones))
(define integers
(cons-stream 1
(add-streams integers ones)))
(define (square n) (* n n))
(define (divides? a b) (= 0 (remainder b a)))
;definition of primality by trying all possible divisors up to square root
(define (prime? n)
(define (smallest-divisor n)
(test-divisor n 2))
(define (test-divisor n i)
(cond ((> (square i) n) n)
((divides? i n) i)
(else (test-divisor n (+ i 1)))))
(= (smallest-divisor n) n))
(define primes-using-prime (stream-filter prime? (integers-from 2)))
;clever definition of the primes by sieving. Why on earth is it so much slower than the one above?
(define (sieve s)
(cons-stream (head s)
(sieve
(stream-filter
(lambda (x) (not (divides? (head s) x)))
(tail s)))))
(define primes-using-sieve (sieve (integers-from 2)))
(define (integral-old s initial-value dx)
(cons-stream initial-value
(add-streams (integral-old s initial-value dx) (scale-stream dx s))))
(define (integral s initial-value dx)
(define int
(cons-stream
initial-value
(add-streams
(scale-stream dx s)
int)))
int)
(define fibs
(cons-stream 0
(cons-stream 1
(add-streams fibs (tail fibs)))))
(define y (cons-stream 1 (integral (stream-map square (cons-stream 1 y)) 0.1 0.01)))
(define-macro (display-line a)
`(begin (display ,a) (newline)))
(define (show x)
(display-line x)
x)
;(begin (define x (stream-map show (stream-enumerate-interval 0 10)))
; (stream-ref x 5)
; (stream-ref x 7)) ; try with and without memoization of delay
;(begin
; (define sum 0)
;
; (define (accum x)
; (set! sum (+ x sum))
; sum)
;
; (display-line sum)
; (define seq (stream-map accum (stream-enumerate-interval 1 20)))
; (display-line sum)
; (define y (stream-filter even? seq))
; (display-line sum)
; (define z (stream-filter (lambda (x) (= (remainder x 5) 0)) seq))
; (display-line sum)
; (stream-ref y 7)
; (display-line sum)
; (display-stream 10 z)
; (display-line sum)) ; assignment and streams really don't mix. try that without the memoization!
;(stream-ref primes-using-sieve 100) ;5853 calls to divide
;(stream-ref primes-using-prime 100) ;2368
;(stream-ref primes-using-sieve 1000) ; 517416 calls to divide
;(stream-ref primes-using-prime 1000) ; 85810
| false |
e5604e9aba72bcf6d53217510ee090f0f7023208 | de82217869618b0a975e86918184ecfddf701172 | /reference/bytevectors/bvec-core.sch | 2152982fcfec096ecf4be21d5bb25bdf6d3f25f5 | []
| no_license | schemedoc/r6rs | 6b4ef7fd87d8883d6c4bcc422b38b37f588e20f7 | 0009085469e47df44068873f834a0d0282648750 | refs/heads/master | 2021-06-18T17:44:50.149253 | 2020-01-04T10:50:50 | 2020-01-04T10:50:50 | 178,081,881 | 5 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 2,813 | sch | bvec-core.sch | ; Bytevectors
; 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.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Modified for Larceny by William D Clinger, beginning 2 August 2006.
;
; This file is Larceny-specific: it uses bytevectors.
;
; Although bytevectors could be implemented as records
; that encapsulate a vector, that representation would
; require 4 to 8 times as much space as a native representation,
; and I believe most systems already have something analogous to
; bytevectors. It therefore seems reasonable to expect
; implementors to rewrite the core operations that are defined
; in this file.
;
; For a big-endian implementation, the other files should work
; as is once the core operations of this file are implemented.
;
; If the (native-endianness) is to be little, then some parts
; of the bytes-ieee.sch file will have to be converted.
;
(library bytevector-core
(export native-endianness
bytevector? make-bytevector bytevector-length
bytevector-u8-ref bytevector-u8-set!
bytevector:div bytevector:mod)
(import (r6rs base) (r6rs r5rs) bytevectors)
; FIXME
; The bytevectors library that is imported above is
; assumed to export all but native-endianness,
; bytevector:div, and bytevector:mod.
; For R5RS-compatible definitions of those, see r5rs.sch.
; FIXME
; The purpose of the next two definitions is to make this
; reference implementation easier to load into an R5RS system:
; Just define a fake library macro and load all the files.
(define bytevector:div quotient)
(define bytevector:mod remainder)
; change this to the endianness of your architecture
(define (native-endianness)
;(cdr (assq 'arch-endianness (system-features)))
'big)
)
| false |
469331477eb7e3d6f5a3f9190bb1f003ba507b5c | 2c5774719a8627262e37af566166eb4788b8d436 | /src/main/scm/com/lmig/joey/jdbc.scm | b52ad64ccfb81e8c5cea9bfa671aa8af03089e90 | [
"Apache-2.0"
]
| permissive | libertymutual/Joey | 324284783878836870d76ccb8f9f4f664d10facd | 8f3a6eb9683c05bd4862c9bffe536630c3962dec | refs/heads/master | 2022-12-28T14:24:00.765709 | 2020-09-04T23:50:09 | 2020-10-20T06:44:37 | 291,128,518 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,025 | scm | jdbc.scm | (module-name jdbc)
(import
(class java.sql Connection DriverManager Statement PreparedStatement ResultSet)
(com lmig joey config))
(define (open-jdbc)
(DriverManager:getConnection
(config-ref 'jdbc-url)
(config-ref 'jdbc-username)
(config-ref 'jdbc-password)))
(define (close-jdbc conn)
(Connection:close conn))
(define (run-sql* conn sql . rest)
(let* ((stmt (Connection:prepareStatement conn sql))
(rs
(let loop ((i 1)
(params rest))
(cond
((null? params) (PreparedStatement:executeQuery stmt))
(else
(PreparedStatement:setObject stmt i (car params))
(loop (+ i 1) (cdr params)))))))
(ResultSet:first rs)
rs))
(define (run-sql sql . rest)
(let* ((conn #f))
(dynamic-wind
(lambda () (set! conn (open-jdbc)))
(lambda () (apply run-sql* (cons conn (cons sql rest))))
(lambda () (close-jdbc conn)))))
(define (result-set-ref rs field-name)
(ResultSet:getObject rs (string-upcase (symbol->string field-name))))
(export run-sql result-set-ref)
| false |
39c0966ac5cafb864a4db95780fb2bd554a84fec | 000dbfe5d1df2f18e29a76ea7e2a9556cff5e866 | /sitelib/rfc/tls/socket.scm | afb3a6004240a52e890d9a3ccbf890b7d7273202 | [
"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 | 13,094 | scm | socket.scm | ;;; -*- Scheme -*-
;;;
;;; rfc/tls/socket.scm - TLS 1.0 - 1.2 protocol library.
;;;
;;; Copyright (c) 2010-2013 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.
;;;
;; Caution this library is not well tested and not well secure yet.
#!nounbound
(library (rfc tls socket)
(export make-client-tls-socket
make-server-tls-socket
tls-socket?
tls-socket-send tls-socket-send/range
tls-socket-recv
tls-socket-recv!
tls-socket-shutdown
tls-socket-close
tls-socket-closed?
tls-socket-accept
tls-socket-peer
tls-socket-name
tls-socket-node
tls-socket-service
tls-socket-info
tls-socket-info-values
call-with-tls-socket
tls-socket-peer-certificate
tls-socket-selected-alpn
<tls-socket>
;; blocking
tls-socket-nonblocking!
tls-socket-blocking!
tls-socket-set-read-timeout!
nonblocking-tls-socket?
tls-socket-client-certificate-callback-set!
;; for the user who wants to specify TSL version
*tls-version-1.2*
*tls-version-1.1*
*tls-version-1.0*
socket-close
socket-closed?
socket-shutdown
socket-send socket-send/range
socket-recv
socket-recv!
socket-accept
call-with-socket
socket-peer
socket-name
socket-node
socket-service
socket-info
socket-info-values
socket-nonblocking!
socket-blocking!
nonblocking-socket?
socket-set-read-timeout!
socket-read-select
socket-write-select
socket-error-select
;; to send handshake explicitly
tls-server-handshake
tls-client-handshake
;; socket conversion
socket->tls-socket
;; hello extension helper
make-hello-extension
make-server-name-indication
make-protocol-name-list
tls-socket-raw-socket ;; don't use this casually
)
(import (rnrs)
(rfc tls constant)
(rfc tls types)
(sagittarius)
(rename (sagittarius tls-socket)
(socket->tls-socket tls:socket->tls-socket)
(tls-server-socket-handshake tls-server-handshake)
(tls-socket-peer-certificate %tls-socket-peer-certificate)
(tls-socket-client-certificate-callback-set!
tls:tls-socket-client-certificate-callback-set!))
(sagittarius socket)
(prefix (only (sagittarius socket)
socket-read-select
socket-write-select
socket-error-select
socket-accept) socket:)
(sagittarius control)
(sagittarius object)
(clos user)
(rename (sagittarius crypto keys)
(*key:rsa* RSA)
(key-pair-private keypair-private))
(sagittarius crypto random)
(srfi :1)
(srfi :19)
(rfc x.509))
(define (make-server-tls-socket port certificates :key
(private-key #f)
(authorities '()) ;; trust store i guess.
(client-certificate-required? #f)
(certificate-verifier #f)
:allow-other-keys opt)
(let ((s (apply make-server-socket port opt)))
(socket->tls-socket s :certificates certificates
:private-key private-key
:client-socket #f
:authorities authorities
:peer-certificate-required? client-certificate-required?
:certificate-verifier certificate-verifier)))
(define (make-client-tls-socket server service :key
(handshake #t)
(certificates '())
(private-key #f)
(hello-extensions '())
(certificate-verifier #f)
:allow-other-keys opt)
(let ((s (apply make-client-socket server service opt)))
(socket->tls-socket s :certificates certificates
:private-key private-key
:handshake handshake
:client-socket #t
:hello-extensions hello-extensions
:peer-certificate-required? #t
:certificate-verifier certificate-verifier)))
(define (make-hello-extension type data)
(make-tls-extension type (make-variable-vector 2 data)))
(define (make-server-name-indication names)
(let1 names (map (^n (make-tls-server-name *host-name* n)) names)
(make-tls-extension *server-name* (make-tls-server-name-list names))))
(define (make-protocol-name-list names)
(let1 names (map (^n (make-tls-protocol-name n)) names)
(make-tls-extension *application-layer-protocol-negotiation*
(make-tls-protocol-name-list names))))
(define 1year (make-time time-duration 0 (* 1 60 60 24 365)))
(define system-prng (pseudo-random-generator *prng:system*))
(define (read-sys-random bits)
(let ((size (div (+ bits 7) 8)))
(random-generator-read-random-bytes system-prng size)))
(define (socket->tls-socket socket
:key (client-socket #t)
(handshake #t)
(hello-extensions '())
(certificates '())
(private-key #f)
(authorities '())
(peer-certificate-required? #t)
(certificate-verifier #f)
:allow-other-keys opt)
(define (certificates->bytevector certificates)
(map x509-certificate->bytevector certificates))
(define (backward-compatiblity pkey certs)
(if (or pkey client-socket)
(values pkey certs)
;; once upon a time, I misunderstood the requirement of the
;; certificates and private key. thus, some of the TLS server
;; doesn't have private key. such TLS servers (must) never be
;; in real world other than testing, so we generates self signed
;; certificates here
(let* ((ks (generate-key-pair RSA))
(cert (make-x509-basic-certificate ks
(bytevector->uinteger (read-sys-random 32))
(make-x509-issuer '((C . "NL")))
(make-validity (current-date)
(time-utc->date
(add-duration! (current-time) 1year)))
(make-x509-issuer '((C . "NL"))))))
;; TODO show warning message
(values (keypair-private ks) (list cert)))))
(let-values (((pkey certs)
(backward-compatiblity private-key certificates)))
(let ((r (tls:socket->tls-socket socket
:certificates (certificates->bytevector certs)
:private-key (and pkey (export-private-key pkey)))))
(tls-socket-authorities-set! r
(map x509-certificate->bytevector authorities))
(tls-socket-peer-certificate-verifier-set! r
peer-certificate-required? certificate-verifier)
(if (and client-socket handshake)
(tls-client-handshake r :hello-extensions hello-extensions)
r))))
(define (tls-client-handshake socket :key (hello-extensions '()))
(define (parse-extension hello-extensions)
(define (retrieve-sni snil)
;; supports only one server for now...
(let ((lis (filter-map (lambda (s)
(and (eqv? *host-name* (slot-ref s 'name-type))
(utf8->string
(slot-ref (slot-ref s 'name) 'value))))
(slot-ref snil 'server-name-list))))
(car lis)))
(define (retrieve-alpn alpn)
(let-values (((out e) (open-bytevector-output-port)))
(write-tls-packet alpn out)
(e)))
(let loop ((extensions hello-extensions)
(sni #f) (alpn #f))
(if (null? extensions)
`(,@(if sni `(:domain-name ,sni) '())
,@(if alpn `(:alpn ,alpn) '()))
(let* ((e (car extensions))
(t (slot-ref e 'type))
(d (slot-ref e 'data)))
(cond ((eqv? *server-name* t)
(loop (cdr extensions) (retrieve-sni d) alpn))
((eqv? *application-layer-protocol-negotiation* t)
(loop (cdr extensions) sni (retrieve-alpn d)))
(else (loop (cdr extensions) sni alpn)))))))
(let ((opts (parse-extension hello-extensions)))
(and (apply tls-socket-connect! socket opts)
socket)))
(define (tls-socket-peer-certificate socket)
(let ((bv (%tls-socket-peer-certificate socket)))
(and bv (make-x509-certificate bv))))
(define (tls-socket-client-certificate-callback-set! socket callback)
(tls:tls-socket-client-certificate-callback-set! socket
(lambda (socket)
(let ((r (callback socket)))
(and (pair? r) (private-key? (car r))
(pair? (cdr r)) (for-all x509-certificate? (cdr r))
(cons (export-private-key (car r))
(map x509-certificate->bytevector (cdr r))))))))
(define (call-with-tls-socket socket proc)
(let-values ((args (proc socket)))
(tls-socket-close socket)
(apply values args)))
(define (tls-socket-peer socket)
(socket-peer (~ socket 'raw-socket)))
(define (tls-socket-name socket)
(socket-name (~ socket 'raw-socket)))
(define (tls-socket-node socket)
(socket-node (~ socket 'raw-socket)))
(define (tls-socket-service socket)
(socket-service (~ socket 'raw-socket)))
(define (tls-socket-info socket)
(socket-info (~ socket 'raw-socket)))
(define (tls-socket-info-values socket :key (type 'peer))
(socket-info-values (~ socket 'raw-socket) :type type))
(define (tls-socket-nonblocking! socket)
(socket-nonblocking! (~ socket 'raw-socket)))
(define (tls-socket-blocking! socket)
(socket-blocking! (~ socket 'raw-socket)))
(define (nonblocking-tls-socket? socket)
(nonblocking-socket? (~ socket 'raw-socket)))
(define (tls-socket-set-read-timeout! tls-socket timeout)
(socket-set-read-timeout! (slot-ref tls-socket 'raw-socket) timeout))
;; to make call-with-socket available for tls-socket
(define-method socket-close ((o <tls-socket>))
(tls-socket-close o))
(define-method socket-closed? ((o <tls-socket>))
(tls-socket-closed? o))
(define-method socket-shutdown ((o <tls-socket>) how)
(tls-socket-shutdown o how))
(define-method socket-send ((o <tls-socket>) data :optional (flags 0))
(tls-socket-send o data flags))
(define-method socket-send/range ((o <tls-socket>) data . args)
(apply tls-socket-send/range o data args))
(define-method socket-recv ((o <tls-socket>) size :optional (flags 0))
(tls-socket-recv o size flags))
(define-method socket-recv! ((o <tls-socket>) bv start len
:optional (flags 0))
(tls-socket-recv! o bv start len flags))
(define-method socket-accept ((o <tls-socket>) . opt)
(apply tls-socket-accept o opt))
;; To avoid no-next-method error
(define-method socket-accept ((o <socket>) (key <keyword>) . dummy)
(socket:socket-accept o))
(define-method call-with-socket ((o <tls-socket>) proc)
(call-with-tls-socket o proc))
(define-method socket-peer ((o <tls-socket>))
(tls-socket-peer o))
(define-method socket-name ((o <tls-socket>))
(tls-socket-name o))
(define-method socket-node ((o <tls-socket>))
(tls-socket-node o))
(define-method socket-service ((o <tls-socket>))
(tls-socket-service o))
(define-method socket-info ((o <tls-socket>))
(tls-socket-info o))
(define-method socket-info-values ((o <tls-socket>) . opt)
(apply tls-socket-info-values o opt))
(define-method socket-nonblocking! ((o <tls-socket>))
(tls-socket-nonblocking! o))
(define-method socket-blocking! ((o <tls-socket>))
(tls-socket-blocking! o))
(define-method nonblocking-socket? ((o <tls-socket>))
(nonblocking-tls-socket? o))
(define-method socket-set-read-timeout! ((o <tls-socket>) timeout)
(tls-socket-set-read-timeout! o timeout))
(define (select-sockets selector timeout sockets)
(define mapping (make-eq-hashtable))
(for-each (lambda (s)
(hashtable-set! mapping
(if (tls-socket? s) (slot-ref s 'raw-socket) s) s)) sockets)
(let ((raw-sockets (apply selector timeout
(hashtable-keys-list mapping))))
(filter-map (lambda (s) (hashtable-ref mapping s #f)) raw-sockets)))
(define-method socket-read-select (timeout . rest)
(select-sockets socket:socket-read-select timeout rest))
(define-method socket-write-select (timeout . rest)
(select-sockets socket:socket-write-select timeout rest))
(define-method socket-error-select (timeout . rest)
(select-sockets socket:socket-error-select timeout rest))
)
| false |
1df82216adfc6a4be93cd67d3e36e59fcb4bad3d | 614f19affc17608380f8c9306b1b9abc2639bae4 | /packages/gxjs-tests/fail-gsc.ss | c37f585035c291ff6aa02a49a1856308df937f10 | [
"Apache-2.0"
]
| permissive | drewc/gxjs | 04e744310b79fef437c7ca76deedf67a25fb067a | 4987bc66bb301b2d1d006a433888c5ad04e3f978 | refs/heads/main | 2023-04-21T01:09:10.810675 | 2021-05-09T18:48:31 | 2021-05-09T18:48:31 | 324,202,474 | 16 | 2 | null | null | null | null | UTF-8 | Scheme | false | false | 34 | ss | fail-gsc.ss | (##inline-host-statement "(@1@)")
| false |
ffaeb0c382a41ff3ad67581509b66618643d2b69 | 000dbfe5d1df2f18e29a76ea7e2a9556cff5e866 | /test/tests/net/server.scm | db082219db25e987730d22ddaef327f5c28f75c7 | [
"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 | 6,311 | scm | server.scm | (import (rnrs)
(net server)
(sagittarius)
(sagittarius socket)
(util concurrent)
(rfc tls)
(rfc x.509)
(crypto)
(srfi :18)
(srfi :19)
(srfi :64))
(define (print . args) (for-each display args) (newline))
(test-begin "Simple server framework")
(define-constant +shutdown-port+ "7500")
;; use default config
;; no IPv6, no shutdown port and signel thread
(let ()
(define (handler server socket)
(let ((bv (socket-recv socket 255)))
(socket-send socket bv)))
(define server (make-simple-server "0" handler))
(test-assert "server?" (server? server))
(server-start! server :background #t)
;; wait until it's started
(thread-sleep! 0.1)
(let ((sock (make-client-socket "localhost" (server-port server))))
(socket-send sock (string->utf8 "hello"))
(test-equal "echo back" (string->utf8 "hello") (socket-recv sock 255))
(socket-close sock))
(test-assert "stop server" (server-stop! server))
)
;; multi threading server
(let ()
(define config (make-server-config :shutdown-port +shutdown-port+
:exception-handler
(lambda (sr s e) (print e))
:max-thread 5
:use-ipv6? #t))
(define (handler server socket)
(let ((bv (socket-recv socket 255)))
(socket-send socket bv)))
(define server (make-simple-server "0" handler :config config))
(define (test ai-family)
(let ((t* (map (lambda (_)
(make-thread
(lambda ()
;; IPv6 may not be supported
(guard (e (else "hello"))
(define sock
(make-client-socket "localhost" (server-port server)
ai-family))
(thread-sleep! 0.2)
(socket-send sock (string->utf8 "hello"))
(let ((r (utf8->string (socket-recv sock 255))))
(socket-close sock)
r)))))
;; more than max thread
'(1 2 3 4 5 6 7 8 9 10))))
(test-equal "multi threaded server"
'("hello" "hello" "hello" "hello" "hello"
"hello" "hello" "hello" "hello" "hello")
(map thread-join! (map thread-start! t*)))))
(test-assert "config?" (server-config? config))
(test-assert "server-config" (eq? config (server-config server)))
(server-start! server :background #t)
(thread-sleep! 0.1)
;; test both sockets
(test AF_INET6)
(test AF_INET)
(test-assert "stop server" (server-stop! server))
(test-assert "server-stopped?" (server-stopped? server))
)
(let ()
(define keypair (generate-key-pair RSA))
(define cert (make-x509-basic-certificate keypair 1
(make-x509-issuer '((C . "NL")))
(make-validity (current-date)
(current-date))
(make-x509-issuer '((C . "NL")))))
(define config (make-server-config :shutdown-port +shutdown-port+
:secure? #t
:use-ipv6? #t
:certificates (list cert)
:private-key (keypair-private keypair)))
(define (handler server socket)
(let ((bv (socket-recv socket 255)))
(socket-send socket bv)))
(define server (make-simple-server "0" handler :config config))
(define (test ai-family)
;; IPv6 may not be supported
(guard (e (else #t))
(let ((sock (make-client-tls-socket "localhost" (server-port server)
ai-family)))
(socket-send sock (string->utf8 "hello"))
(test-equal "TLS echo back"
(string->utf8 "hello") (socket-recv sock 255))
(socket-close sock))))
(server-start! server :background #t)
(thread-sleep! 0.1)
;; test both socket
(test AF_INET)
(test AF_INET6)
;; stop server by accessing shutdown port
(make-client-socket "localhost" +shutdown-port+)
(test-assert "finish simple server (2)" (wait-server-stop! server))
(test-assert "finish simple server (3)" (wait-server-stop! server))
)
;; call #135
(let ()
(define server (make-simple-server "12345" (lambda (s sock) #t)))
(test-assert "socket not created"
(let ((s (make-server-socket "12345")))
(socket-close s))))
(let ((server (make-simple-server "12345" (lambda (s sock) #t)
:context 'context)))
(test-equal 'context (server-context server))
(test-error (server-status server)))
(let ()
;; the thread management is done outside of our threads
;; thus there's no way to guarantee. let's hope...
(define (hope-it-works)
(thread-yield!)
(thread-sleep! 1))
(define detached-actor
(make-shared-queue-channel-actor
(lambda (input-receiver output-sender)
(define socket (input-receiver))
(output-sender 'ready)
(hope-it-works)
(let ((msg (input-receiver)))
(socket-send socket msg))
(output-sender 'done)
(input-receiver)
(socket-shutdown socket SHUT_RDWR)
(socket-close socket))))
(define config (make-server-config
:non-blocking? #t :max-thread 5
:exception-handler print))
(define server (make-simple-server
"12345" (lambda (s sock)
(server-detach-socket! s sock)
(actor-send-message! detached-actor sock))
:config config))
(define (check-status server)
(let ((status (server-status server)))
(test-assert (server-status? status))
(test-equal 5 (server-status-thread-count status))
(test-equal server (server-status-target-server status))
(test-equal 5 (length (server-status-thread-statuses status)))
(for-each (lambda (ts)
(test-assert (number? (thread-status-thread-id ts)))
(test-assert (string? (thread-status-thread-info ts)))
(test-equal 0 (thread-status-active-socket-count ts)))
(server-status-thread-statuses status))
(test-assert
(call-with-string-output-port
(lambda (out) (report-server-status status out))))))
(server-start! server :background #t)
(test-assert (server-status server))
(check-status server)
(let ((sock (make-client-socket "localhost" "12345")))
(socket-send sock #vu8(0))
(test-equal 'ready (actor-receive-message! detached-actor))
(actor-send-message! detached-actor #vu8(1 2 3 4 5))
(test-equal 'done (actor-receive-message! detached-actor))
(hope-it-works)
;; it should have 0 active socket on the server, it's detached
;; and server socket is not closed
(check-status server)
(actor-send-message! detached-actor 'finish)
(let ((bv (socket-recv sock 5)))
(test-equal #vu8(1 2 3 4 5) bv))
(socket-shutdown sock SHUT_RDWR)
(socket-close sock))
(server-stop! server))
(test-end)
| false |
d02aecbeb72b9400511c8087e49c838bd267f3a6 | 6c6cf6e4b77640825c2457e54052a56d5de6f4d2 | /ch2/2_40-prime-sum-pairs.scm | 057f6b33aec96f6f415f9f32c1cb10396487c197 | []
| no_license | leonacwa/sicp | a469c7bc96e0c47e4658dccd7c5309350090a746 | d880b482d8027b7111678eff8d1c848e156d5374 | refs/heads/master | 2018-12-28T07:20:30.118868 | 2015-02-07T16:40:10 | 2015-02-07T16:40:10 | 11,738,761 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 455 | scm | 2_40-prime-sum-pairs.scm |
(load "2_40-unique-pairs.scm")
(define (prime? n)
(define (iter x up)
(cond ((> x up) #t)
((= 0 (remainder n x)) #f)
(else (iter (+ x 1) up))))
(let ((up (+ (sqrt n) 0.001)))
(iter 2 up)))
(define (prime-sum? pair)
(prime? (+ (car pair) (cadr pair))))
(define (make-pair-sum pair)
(list (car pair) (cadr pair) (+ (car pair) (cadr pair))))
(define (prime-sum-pairs n)
(map make-pair-sum
(filter prime-sum? (unique-pairs n))))
| false |
7cfdb14a96d27052482caa3175183638c38bee90 | a450dce2e163cf37264ea33f941184e9a0cfa6de | /bad-r7rs-lint/tools.scm | 080683fb1c08567548aaa52e8d56e481a2a13ac2 | [
"MIT"
]
| permissive | BernardTatin/Bad-Tools-For-The-Good-R7RS | 78976717095d88e5a0eb252aee081057958bf981 | 9af346ef09516a1f4f025106956c2c2d30146eb3 | refs/heads/master | 2021-01-09T05:57:27.464008 | 2017-02-15T23:39:24 | 2017-02-15T23:39:24 | 80,849,103 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 511 | scm | tools.scm | ;; ======================================================================
;; tools.scm
;; ======================================================================
(module tools racket
(provide tprintln file-loader on-error)
(define tprintln
(lambda args
(for-each display args)))
(define on-error
(lambda args
(let ((exit-code (car args))
(_args (cdr args)))
(for-each (lambda(e) (display e (current-error-port))) _args)
(exit exit-code))))
) | false |
e61504848c158daa01740df5b2909e00cec93fa5 | 6cf2e78840970768168f583716e8826b1902dafa | /learning-functional/work-in-university/home-practice/scheme-practice/part-5-data-structures/my-cons.scm | ab7448f90646080ffd30d1b6587164aace0ae9cd | []
| no_license | dianvaltodorov/learning-code | e4b3e5034c68cdf9d1e38f8b6a12af1d51d2e167 | a92605345829e051c0b2420de6f3dfc1fe5eb65a | refs/heads/master | 2021-01-17T12:24:58.618311 | 2016-02-02T17:48:55 | 2018-06-21T06:53:16 | 49,488,021 | 2 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 244 | scm | my-cons.scm | (define (mcons a b)
(lambda (f)
(if(eq? f "car")
a
b)))
(define (mcar pair) (pair "car"))
(define (mcdr pair) (pair "cdr"))
(define yolo (mcons 2 (mcons 3 (mcons 4 5))))
((mcdr yolo) "car")
(mcdr yolo)
(mcar (mcdr yolo))
| false |
195f11dbbfd2552238da4fdd50df54fa3c450fc3 | e82d67e647096e56cb6bf1daef08552429284737 | /data-directed-programming/generic_operations.scm | 1d19a007ac72885149ea7a53388aa48fa0f406e2 | []
| no_license | ashishmax31/sicp-exercises | 97dfe101dd5c91208763dcc4eaac2c17977d1dc1 | 097f76a5637ccb1fba055839d389541a1a103e0f | refs/heads/master | 2020-03-28T11:16:28.197294 | 2019-06-30T20:25:18 | 2019-06-30T20:25:18 | 148,195,859 | 6 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 925 | scm | generic_operations.scm | (define (real-part z)
(apply-generic 'real-part z))
(define (imag-part z)
(apply-generic 'imag-part z))
(define (magnitude z)
(apply-generic 'magnitude z))
(define (angle z)
(apply-generic 'angle z))
(define (make-from-real-imag x y)
((get 'make-from-real-imag 'complex ) x y))
(define (make-from-mag-angle r A)
((get 'make-from-magnitude-angle 'complex ) r A))
(define (make-rational-number x y)
((get 'make-rat 'rational) x y))
(define (make-scheme-number n)
((get 'make 'scheme-number) n))
(define (make-real-number n)
((get 'make 'real-number) n))
(define (raise item)
(apply-generic 'raise item))
(define (add z1 z2)
(apply-generic 'add z1 z2))
(define (div z1 z2)
(apply-generic 'div z1 z2))
(define (sub z1 z2)
(apply-generic 'sub z1 z2))
(define (mul z1 z2)
(apply-generic 'mul z1 z2))
(define (addd z1 z2 z3)
(apply-generic 'add-3 z1 z2 z3))
| false |
7d6648ed2967a0c7585c30d6dabbd9fcfac72541 | ac2a3544b88444eabf12b68a9bce08941cd62581 | /lib/_prim-string#.scm | a78b242fb8dd7e9414617d520d947e605ce7bc0a | [
"Apache-2.0",
"LGPL-2.1-only"
]
| permissive | tomelam/gambit | 2fd664cf6ea68859d4549fdda62d31a25b2d6c6f | d60fdeb136b2ed89b75da5bfa8011aa334b29020 | refs/heads/master | 2020-11-27T06:39:26.718179 | 2019-12-15T16:56:31 | 2019-12-15T16:56:31 | 229,341,552 | 1 | 0 | Apache-2.0 | 2019-12-20T21:52:26 | 2019-12-20T21:52:26 | null | UTF-8 | Scheme | false | false | 495 | scm | _prim-string#.scm | ;;;============================================================================
;;; File: "_prim-string#.scm"
;;; Copyright (c) 1994-2019 by Marc Feeley, All Rights Reserved.
;;;============================================================================
;;; String operations.
(##include "~~lib/_prim-string-r4rs#.scm")
(##include "~~lib/_prim-string-r7rs#.scm")
(##include "~~lib/_prim-string-gambit#.scm")
;;;============================================================================
| false |
34f8143cb8360142cb52d127c60efae804d3e848 | 3508dcd12d0d69fec4d30c50334f8deb24f376eb | /v8/src/compiler/machines/spectrum/instr2.scm | e9d0601c3c3952f320132869d45120ed1241235c | []
| no_license | barak/mit-scheme | be625081e92c2c74590f6b5502f5ae6bc95aa492 | 56e1a12439628e4424b8c3ce2a3118449db509ab | refs/heads/master | 2023-01-24T11:03:23.447076 | 2022-09-11T06:10:46 | 2022-09-11T06:10:46 | 12,487,054 | 12 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 19,563 | scm | instr2.scm | #| -*-Scheme-*-
Copyright (c) 1987-1999 Massachusetts Institute of Technology
This program 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.
This program 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 this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|#
;;;; HP Spectrum Instruction Set Description
;;; Originally from Walt Hill, who did the hard part.
;;; package: (compiler lap-syntaxer)
(declare (usual-integrations))
;;;; Memory and offset operations
;;; The long forms of many of the following instructions use register
;;; 1 -- this may be inappropriate for assembly-language programs, but
;;; is OK for the output of the compiler.
(let-syntax ((long-load
(macro (keyword opcode)
`(define-instruction ,keyword
((() (OFFSET (? offset) (? space) (? base)) (? reg))
(VARIABLE-WIDTH (disp offset)
((#x-2000 #x1FFF)
(LONG (6 ,opcode)
(5 base)
(5 reg)
(2 space)
(14 disp RIGHT-SIGNED)))
((() ())
(LONG
;; (ADDIL () L$,offset ,base)
(6 #x0A)
(5 base)
(21 (quotient disp #x800) ASSEMBLE21:X)
;; (LDW () (OFFSET R$,offset ,space 1) ,reg)
(6 ,opcode)
(5 1)
(5 reg)
(2 space)
(14 (remainder disp #x800) RIGHT-SIGNED))))))))
(long-store
(macro (keyword opcode)
`(define-instruction ,keyword
((() (? reg) (OFFSET (? offset) (? space) (? base)))
(VARIABLE-WIDTH (disp offset)
((#x-2000 #x1FFF)
(LONG (6 ,opcode)
(5 base)
(5 reg)
(2 space)
(14 disp RIGHT-SIGNED)))
((() ())
(LONG
;; (ADDIL () L$,offset ,base)
(6 #x0A)
(5 base)
(21 (quotient disp #x800) ASSEMBLE21:X)
;; (STW () ,reg (OFFSET R$,offset ,space 1))
(6 ,opcode)
(5 1)
(5 reg)
(2 space)
(14 (remainder disp #x800) RIGHT-SIGNED))))))))
(load-offset
(macro (keyword opcode)
`(define-instruction ,keyword
((() (OFFSET (? offset) 0 (? base)) (? reg))
(VARIABLE-WIDTH (disp offset)
((#x-2000 #x1FFF)
(LONG (6 ,opcode)
(5 base)
(5 reg)
(2 #b00)
(14 disp RIGHT-SIGNED)))
((() ())
(LONG
;; (ADDIL () L$,offset ,base)
(6 #x0A)
(5 base)
(21 (quotient disp #x800) ASSEMBLE21:X)
;; (LDO () (OFFSET R$,offset 0 1) ,reg)
(6 ,opcode)
(5 1)
(5 reg)
(2 #b00)
(14 (remainder disp #x800) RIGHT-SIGNED))))))))
(load-immediate
(macro (keyword opcode)
`(define-instruction ,keyword
((() (? offset) (? reg))
(VARIABLE-WIDTH (disp offset)
((#x-2000 #x1FFF)
(LONG (6 ,opcode)
(5 0)
(5 reg)
(2 #b00)
(14 disp RIGHT-SIGNED)))
((() ())
(LONG
;; (LDIL () L$,offset ,base)
(6 #x08)
(5 reg)
(21 (quotient disp #x800) ASSEMBLE21:X)
;; (LDO () (OFFSET R$,offset 0 ,reg) ,reg)
(6 ,opcode)
(5 reg)
(5 reg)
(2 #b00)
(14 (remainder disp #x800) RIGHT-SIGNED))))))))
(left-immediate
(macro (keyword opcode)
`(define-instruction ,keyword
((() (? immed-21) (? reg))
(LONG (6 ,opcode)
(5 reg)
(21 immed-21 ASSEMBLE21:X)))))))
(long-load LDW #x12)
(long-load LDWM #x13)
(long-load LDH #x11)
(long-load LDB #x10)
(long-store STW #x1a)
(long-store STWM #x1b)
(long-store STH #x19)
(long-store STB #x18)
(load-offset LDO #x0d)
(load-immediate LDI #x0d) ; pseudo-op (LDO complt (OFFSET displ 0) reg)
(left-immediate LDIL #x08)
(left-immediate ADDIL #x0a))
;; In the following, the middle completer field (2 bits) appears to be zero,
;; according to the hardware. Also, the u-bit seems not to exist in the
;; cache instructions.
(let-syntax ((indexed-load
(macro (keyword opcode extn)
`(define-instruction ,keyword
(((? compl complx) (INDEX (? index-reg) (? space) (? base))
(? reg))
(LONG (6 ,opcode)
(5 base)
(5 index-reg)
(2 space)
(1 (vector-ref compl 0))
(1 #b0)
(2 (vector-ref compl 1))
(4 ,extn)
(1 (vector-ref compl 2))
(5 reg))))))
(indexed-store
(macro (keyword opcode extn)
`(define-instruction ,keyword
(((? compl complx) (? reg)
(INDEX (? index-reg) (? space) (? base)))
(LONG (6 ,opcode)
(5 base)
(5 index-reg)
(2 space)
(1 (vector-ref compl 0))
(1 #b0)
(2 (vector-ref compl 1))
(4 ,extn)
(1 (vector-ref compl 2))
(5 reg))))))
(indexed-d-cache
(macro (keyword extn)
`(define-instruction ,keyword
(((? compl m-val) (INDEX (? index-reg) (? space) (? base)))
(LONG (6 #x01)
(5 base)
(5 index-reg)
(2 space)
(8 ,extn)
(1 compl)
(5 #x0))))))
(indexed-i-cache
(macro (keyword extn)
`(define-instruction ,keyword
(((? compl m-val)
(INDEX (? index-reg) (? space sr3) (? base)))
(LONG (6 #x01)
(5 base)
(5 index-reg)
(3 space)
(7 ,extn)
(1 compl)
(5 #x0)))))))
(indexed-load LDWX #x03 #x2)
(indexed-load LDHX #x03 #x1)
(indexed-load LDBX #x03 #x0)
(indexed-load LDCWX #x03 #x7)
(indexed-load FLDWX #x09 #x0)
(indexed-load FLDDX #x0B #x0)
(indexed-store FSTWX #x09 #x8)
(indexed-store FSTDX #x0b #x8)
(indexed-d-cache PDC #x4e)
(indexed-d-cache FDC #x4a)
(indexed-i-cache FIC #x0a)
(indexed-d-cache FDCE #x4b)
(indexed-i-cache FICE #x0b))
(let-syntax ((scalr-short-load
(macro (keyword extn)
`(define-instruction ,keyword
(((? compl compls) (OFFSET (? offset) (? space) (? base))
(? reg))
(LONG (6 #x03)
(5 base)
(5 offset RIGHT-SIGNED)
(2 space)
(1 (vector-ref compl 0))
(1 #b1)
(2 (vector-ref compl 1))
(4 ,extn)
(1 (vector-ref compl 2))
(5 reg))))))
(scalr-short-store
(macro (keyword extn)
`(define-instruction ,keyword
(((? compl compls) (? reg)
(OFFSET (? offset) (? space) (? base)))
(LONG (6 #x03)
(5 base)
(5 reg)
(2 space)
(1 (vector-ref compl 0))
(1 #b1)
(2 (vector-ref compl 1))
(4 ,extn)
(1 (vector-ref compl 2))
(5 offset RIGHT-SIGNED))))))
(float-short-load
(macro (keyword opcode extn)
`(define-instruction ,keyword
(((? compl compls) (OFFSET (? offset) (? space) (? base))
(? reg))
(LONG (6 ,opcode)
(5 base)
(5 offset RIGHT-SIGNED)
(2 space)
(1 (vector-ref compl 0))
(1 #b1)
(2 (vector-ref compl 1))
(4 ,extn)
(1 (vector-ref compl 2))
(5 reg))))))
(float-short-store
(macro (keyword opcode extn)
`(define-instruction ,keyword
(((? compl compls) (? reg)
(OFFSET (? offset) (? space) (? base)))
(LONG (6 ,opcode)
(5 base)
(5 offset RIGHT-SIGNED)
(2 space)
(1 (vector-ref compl 0))
(1 #b1)
(2 (vector-ref compl 1))
(4 ,extn)
(1 (vector-ref compl 2))
(5 reg)))))))
(scalr-short-load LDWS #x02)
(scalr-short-load LDHS #x01)
(scalr-short-load LDBS #x00)
(scalr-short-load LDCWS #x07)
(scalr-short-store STWS #x0a)
(scalr-short-store STHS #x09)
(scalr-short-store STBS #x08)
(scalr-short-store STBYS #x0c)
(float-short-load FLDWS #x09 #x00)
(float-short-load FLDDS #x0b #x00)
(float-short-store FSTWS #x09 #x08)
(float-short-store FSTDS #x0b #x08))
;;;; Control transfer instructions
;;; Note: For the time being the unconditionaly branch instructions are not
;;; branch tensioned since their range is pretty large (1/2 Mbyte).
;;; They should be eventually (by using an LDIL,LDI,BLR sequence, for example).
(let-syntax ((branch&link
(macro (keyword extn)
`(define-instruction ,keyword
((() (? reg) (@PCR (? label)))
(LONG (6 #x3a)
(5 reg)
(5 label PC-REL ASSEMBLE17:X)
(3 ,extn)
(11 label PC-REL ASSEMBLE17:Y)
(1 0)
(1 label PC-REL ASSEMBLE17:Z)))
(((N) (? reg) (@PCR (? label)))
(LONG (6 #x3a)
(5 reg)
(5 label PC-REL ASSEMBLE17:X)
(3 ,extn)
(11 label PC-REL ASSEMBLE17:Y)
(1 1)
(1 label PC-REL ASSEMBLE17:Z)))
((() (? reg) (@PCO (? offset)))
(LONG (6 #x3a)
(5 reg)
(5 offset ASSEMBLE17:X)
(3 ,extn)
(11 offset ASSEMBLE17:Y)
(1 0)
(1 offset ASSEMBLE17:Z)))
(((N) (? reg) (@PCO (? offset)))
(LONG (6 #x3a)
(5 reg)
(5 offset ASSEMBLE17:X)
(3 ,extn)
(11 offset ASSEMBLE17:Y)
(1 1)
(1 offset ASSEMBLE17:Z))))))
(branch
(macro (keyword extn)
`(define-instruction ,keyword
((() (@PCR (? l)))
(LONG (6 #x3a)
(5 #b00000)
(5 l PC-REL ASSEMBLE17:X)
(3 #b000)
(11 l PC-REL ASSEMBLE17:Y)
(1 0)
(1 l PC-REL ASSEMBLE17:Z)))
(((N) (@PCR (? l)))
(LONG (6 #x3a)
(5 #b00000)
(5 l PC-REL ASSEMBLE17:X)
(3 #b000)
(11 l PC-REL ASSEMBLE17:Y)
(1 1)
(1 l PC-REL ASSEMBLE17:Z)))
((() (@PCO (? offset)))
(LONG (6 #x3a)
(5 #b00000)
(5 offset ASSEMBLE17:X)
(3 #b000)
(11 offset ASSEMBLE17:Y)
(1 0)
(1 offset ASSEMBLE17:Z)))
(((N) (@PCO (? offset)))
(LONG (6 #x3a)
(5 #b00000)
(5 offset ASSEMBLE17:X)
(3 #b000)
(11 offset ASSEMBLE17:Y)
(1 1)
(1 offset ASSEMBLE17:Z)))))))
(branch B 0) ; pseudo-op (BL complt 0 displ)
(branch&link BL 0)
(branch&link GATE 1))
(let-syntax ((BV&BLR
(macro (keyword extn)
`(define-instruction ,keyword
((() (? offset-reg) (? reg))
(LONG (6 #x3a)
(5 reg)
(5 offset-reg)
(3 ,extn)
(11 #b00000000000)
(1 0)
(1 #b0)))
(((N) (? offset-reg) (? reg))
(LONG (6 #x3a)
(5 reg)
(5 offset-reg)
(3 ,extn)
(11 #b00000000000)
(1 1)
(1 #b0))))))
(BE&BLE
(macro (keyword opcode)
`(define-instruction ,keyword
((() (OFFSET (? offset) (? space sr3) (? base)))
(LONG (6 ,opcode)
(5 base)
(5 offset ASSEMBLE17:X)
(3 space)
(11 offset ASSEMBLE17:Y)
(1 0)
(1 offset ASSEMBLE17:Z)))
(((N) (OFFSET (? offset) (? space sr3) (? base)))
(LONG (6 ,opcode)
(5 base)
(5 offset ASSEMBLE17:X)
(3 space)
(11 offset ASSEMBLE17:Y)
(1 1)
(1 offset ASSEMBLE17:Z)))))))
(BV&BLR BLR 2)
(BV&BLR BV 6)
(BE&BLE BE #x38)
(BE&BLE BLE #x39))
;;;; Conditional branch instructions
#|
Branch tensioning notes for the conditional branch instructions:
The sequence
combt,cc r1,r2,label
instr1
instr2
becomes
combf,cc,n r1,r2,tlabel ; pco = 0
b label ; no nullification
tlabel instr1
instr2
The sequence
combt,cc,n r1,r2,label
instr1
instr2
becomes either
combf,cc,n r1,r2,tlabel ; pco = 0
b,n label ; nullification
tlabel instr1
instr2
when label is downstream (a forwards branch)
or
combf,cc,n r1,r2,tlabel ; pco = 4
b label ; no nullification
instr1
tlabel instr2
when label is upstream (a backwards branch).
This adjusting of the nullify bits, the pc offset, etc. for tlabel are
performed by the utilities branch-extend-pco, branch-extend-disp, and
branch-extend-nullify in instr1.
|#
;;;; Compare/compute and branch.
(let-syntax
((defccbranch
(macro (keyword completer opcode1 opcode2 opr1)
`(define-instruction ,keyword
(((? compl ,completer) (? ,(car opr1)) (? reg-2) (@PCO (? offset)))
(LONG (6 ,opcode1)
(5 reg-2)
(5 ,@opr1)
(3 (cadr compl))
(11 offset ASSEMBLE12:X)
(1 (car compl))
(1 offset ASSEMBLE12:Y)))
(((? compl ,completer) (? ,(car opr1)) (? reg-2) (@PCR (? l)))
(VARIABLE-WIDTH
(disp `(- ,l (+ *PC* 8)))
((#x-2000 #x1FFF)
(LONG (6 ,opcode1)
(5 reg-2)
(5 ,@opr1)
(3 (cadr compl))
(11 disp ASSEMBLE12:X)
(1 (car compl))
(1 disp ASSEMBLE12:Y)))
((() ())
;; See page comment above.
(LONG (6 ,opcode2) ; COMBF
(5 reg-2)
(5 ,@opr1)
(3 (cadr compl))
(11 (branch-extend-pco disp (car compl)) ASSEMBLE12:X)
(1 1)
(1 (branch-extend-pco disp (car compl)) ASSEMBLE12:Y)
(6 #x3a) ; B
(5 0)
(5 (branch-extend-disp disp) ASSEMBLE17:X)
(3 0)
(11 (branch-extend-disp disp) ASSEMBLE17:Y)
(1 (branch-extend-nullify disp (car compl)))
(1 (branch-extend-disp disp) ASSEMBLE17:Z)))))))))
(define-macro (defcond name opcode1 opcode2 opr1)
`(defccbranch ,name complaltfb ,opcode1 ,opcode2 ,opr1))
(define-macro (defpseudo name opcode opr1)
`(defccbranch ,name complalb
(TF-adjust ,opcode (cdr compl))
(TF-adjust-inverted ,opcode (cdr compl))
,opr1))
(defcond COMBT #x20 #x22 (reg-1))
(defcond COMBF #x22 #x20 (reg-1))
(defcond ADDBT #x28 #x2a (reg-1))
(defcond ADDBF #x2a #x28 (reg-1))
(defcond COMIBT #x21 #x23 (immed-5 right-signed))
(defcond COMIBF #x23 #x21 (immed-5 right-signed))
(defcond ADDIBT #x29 #x2b (immed-5 right-signed))
(defcond ADDIBF #x2b #x29 (immed-5 right-signed))
(defpseudo COMB #x20 (reg-1))
(defpseudo ADDB #x28 (reg-1))
(defpseudo COMIB #x21 (immed-5 right-signed))
(defpseudo ADDIB #x29 (immed-5 right-signed)))
;;;; Pseudo branch instructions.
#|
These nullify the following instruction when the branch is taken.
irrelevant of the sign of the displacement (unlike the real instructions).
If the displacement is positive, they use the nullify bit.
If the displacement is negative, they use a NOP.
combn,cc r1,r2,label
becomes either
comb,cc,n r1,r2,label
if label is downstream (forward branch)
or
comb,cc r1,r2,label
nop
if label is upstream (backward branch)
If the displacement is too large, it becomes
comb,!cc,n r1,r2,tlabel ; pco = 0
b,n label
tlabel
Note: Only those currently used by the code generator are implemented.
|#
(let-syntax
((defccbranch
(macro (keyword completer opcode1 opcode2 opr1)
`(define-instruction ,keyword
;; No @PCO form.
;; This is a pseudo-instruction used by the code-generator
(((? compl ,completer) (? ,(car opr1)) (? reg-2) (@PCR (? l)))
(VARIABLE-WIDTH
(disp `(- ,l (+ *PC* 8)))
((0 #x1FFF)
;; Forward branch. Nullify.
(LONG (6 ,opcode1) ; COMB,cc,n
(5 reg-2)
(5 ,@opr1)
(3 (car compl))
(11 disp ASSEMBLE12:X)
(1 1)
(1 disp ASSEMBLE12:Y)))
((#x-2000 -1)
;; Backward branch. No nullification, insert NOP.
(LONG (6 ,opcode1) ; COMB,cc
(5 reg-2)
(5 ,@opr1)
(3 (car compl))
(11 disp ASSEMBLE12:X)
(1 0)
(1 disp ASSEMBLE12:Y)
(6 #x02) ; NOP (OR 0 0 0)
(10 #b0000000000)
(3 0)
(1 0)
(7 #x12)
(5 #b00000)))
((() ())
(LONG (6 ,opcode2) ; COMB!,n
(5 reg-2)
(5 ,@opr1)
(3 (car compl))
(11 0 ASSEMBLE12:X)
(1 1)
(1 0 ASSEMBLE12:Y)
(6 #x3a) ; B,n
(5 0)
(5 (branch-extend-disp disp) ASSEMBLE17:X)
(3 0)
(11 (branch-extend-disp disp) ASSEMBLE17:Y)
(1 1)
(1 (branch-extend-disp disp) ASSEMBLE17:Z)))))))))
(define-macro (defcond name opcode1 opcode2 opr1)
`(defccbranch ,name complaltf ,opcode1 ,opcode2 ,opr1))
(define-macro (defpseudo name opcode opr1)
`(defccbranch ,name complal
(TF-adjust ,opcode compl)
(TF-adjust-inverted ,opcode compl)
,opr1))
(defcond COMIBTN #x21 #x23 (immed-5 right-signed))
(defcond COMIBFN #x23 #x21 (immed-5 right-signed))
(defpseudo COMIBN #x21 (immed-5 right-signed))
(defpseudo COMBN #x20 (reg-1)))
;;;; Miscellaneous control
(let-syntax
((defmovb&bb
(macro (name opcode opr1 opr2 field2)
`(define-instruction ,name
(((? compl compledb) (? ,(car opr1)) ,@opr2 (@PCO (? offset)))
(LONG (6 ,opcode)
(5 ,field2)
(5 ,@opr1)
(3 (cdr compl))
(11 offset ASSEMBLE12:X)
(1 (car compl))
(1 offset ASSEMBLE12:Y)))
(((? compl compledb) (? ,(car opr1)) ,@opr2 (@PCR (? l)))
(VARIABLE-WIDTH
(disp `(- ,l (+ *PC* 8)))
((#x-2000 #x1FFF)
(LONG (6 ,opcode)
(5 ,field2)
(5 ,@opr1)
(3 (cdr compl))
(11 l PC-REL ASSEMBLE12:X)
(1 (car compl))
(1 l PC-REL ASSEMBLE12:Y)))
((() ())
;; See page comment above.
(LONG (6 ,opcode) ; MOVB
(5 ,field2)
(5 ,@opr1)
(3 (branch-extend-edcc (cdr compl)))
(11 (branch-extend-pco disp (car compl)) ASSEMBLE12:X)
(1 1)
(1 (branch-extend-pco disp (car compl)) ASSEMBLE12:Y)
(6 #x3a) ; B
(5 0)
(5 (branch-extend-disp disp) ASSEMBLE17:X)
(3 0)
(11 (branch-extend-disp disp) ASSEMBLE17:Y)
(1 (branch-extend-nullify disp (car compl)))
(1 (branch-extend-disp disp) ASSEMBLE17:Z)))))))))
(defmovb&bb BVB #x30 (reg) () #b00000)
(defmovb&bb BB #x31 (reg) ((? pos)) pos)
(defmovb&bb MOVB #x32 (reg-1) ((? reg-2)) reg-2)
(defmovb&bb MOVIB #x33 (immed-5 right-signed) ((? reg-2)) reg-2))
;;;; Assembler pseudo-ops
(define-instruction USHORT
((() (? high) (? low))
(LONG (16 high UNSIGNED)
(16 low UNSIGNED))))
(define-instruction WORD
((() (? expression))
(LONG (32 expression SIGNED))))
(define-instruction UWORD
((() (? expression))
(LONG (32 expression UNSIGNED))))
(define-instruction EXTERNAL-LABEL
((() (? format-word) (@PCR (? label)))
(LONG (16 format-word UNSIGNED)
(16 label BLOCK-OFFSET)))
((() (? format-word) (@PCO (? offset)))
(LONG (16 format-word UNSIGNED)
(16 offset UNSIGNED))))
(define-instruction PCR-HOOK
((() (? target)
(OFFSET (? offset) (? space sr3) (? base))
(@PCR (? label)))
(VARIABLE-WIDTH
(disp `(- ,label (+ *PC* 8)))
((#x-2000 #x1FFF)
(LONG
;; (BLE () (OFFSET ,offset ,space ,base))
(6 #x39)
(5 base)
(5 offset ASSEMBLE17:X)
(3 space)
(11 offset ASSEMBLE17:Y)
(1 0)
(1 offset ASSEMBLE17:Z)
;; (LDO () (OFFSET ,disp 0 31) ,target)
(6 #x0D)
(5 31)
(5 target)
(2 #b00)
(14 disp RIGHT-SIGNED)))
((() ())
(LONG
;; (LDIL () L$disp-8 target)
(6 #x08)
(5 1)
(21 (quotient (- disp 8) #x800) ASSEMBLE21:X)
;; (LDO () (OFFSET R$disp-4 0 1) target)
(6 #x0D)
(5 1)
(5 1)
(2 #b00)
(14 (remainder (- disp 8) #x800) RIGHT-SIGNED)
;; (BLE () (OFFSET ,offset ,space ,base))
(6 #x39)
(5 base)
(5 offset ASSEMBLE17:X)
(3 space)
(11 offset ASSEMBLE17:Y)
(1 0)
(1 offset ASSEMBLE17:Z)
;; (ADD () 31 1 target)
(6 #x02)
(5 31)
(5 1)
(3 0)
(1 0)
(7 #x30)
(5 target)))))) | false |
47052456b42195bcd5f26f9615373ac5f266039b | 30395eb9edba529c044bb13c8fd3f5ebae29be3b | /examples/sch2scheme/sch2scheme.scm | 23d2e4175a3408444398ec98cab0f00adc704701 | []
| no_license | vzh/gschem-goodies | 604b4fdcea1fe979cd0726953c8d5811aa202c54 | d47620ae5dc00820c1332665cc86657f86d85d12 | refs/heads/master | 2021-01-19T03:02:41.262204 | 2019-04-12T08:55:12 | 2019-04-12T08:55:12 | 52,795,722 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 9,160 | scm | sch2scheme.scm | ; Script for converting gschem schematic/symbol into Guile script, suitable
; for generating code which can be used to generate sets of symbols
(use-modules (geda page)
(geda object)
(geda file io))
(define scale 1)
(define (scale-number number)
(/ number scale))
(define (scale-coord pair)
(cons (scale-number (car pair)) (scale-number (cdr pair))))
(define (scale-two l)
(apply list (scale-coord (car l)) (scale-coord (cadr l)) (cddr l)))
(define (scale-one-and-num l)
(apply list (scale-coord (car l)) (scale-number (cadr l)) (cddr l)))
(define (scale-one l)
(cons (scale-coord (car l)) (cdr l)))
; Redefine info functions
(define old-line-info line-info)
(define (line-info obj) (scale-two (old-line-info obj)))
(define old-box-info box-info)
(define (box-info obj) (scale-two (old-box-info obj)))
(define old-picture-info picture-info)
(define (picture-info obj)
(cons
(car (old-picture-info obj))
(scale-two (cdr (old-picture-info obj)))))
(define old-arc-info arc-info)
(define (arc-info obj) (scale-one-and-num (old-arc-info obj)))
(define old-circle-info circle-info)
(define (circle-info obj) (scale-one-and-num (old-circle-info obj)))
(define old-component-info component-info)
(define (component-info obj)
(cons
(car (old-component-info obj))
(scale-one (cdr (old-component-info obj)))))
(define old-text-info text-info)
(define (text-info obj) (scale-one (old-text-info obj)))
(define old-path-ref path-ref)
(define (path-ref obj N)
(map (lambda (elem) (if (pair? elem) (scale-coord elem) elem)) (old-path-ref obj N)))
(define (get-dash-string dash)
(case (car dash)
((solid) (apply format #f "'~A" dash))
((dotted) (apply format #f "'~A ~A" dash))
; others (dashed, center, phantom) take two parameters
(else (apply format #f "'~A ~A ~A" dash)))
)
(define (get-fill-string fill)
(case (car fill)
((hollow solid) (apply format #f "'~A" fill))
((hatch) (apply format #f "'~A ~A ~A ~A" fill))
; mesh takes five parameters
(else (apply format #f "'~A ~A ~A ~A ~A ~A" fill)))
)
(define (format-dash s obj)
(format #f "(set-object-stroke! ~A ~A '~6A ~A)"
s
(object-stroke-width obj)
(object-stroke-cap obj)
(get-dash-string (object-stroke-dash obj))))
(define (format-fill s obj)
(format #f "(set-object-fill! ~A ~A)"
s
(get-fill-string (object-fill obj))))
(define (output-arc obj)
(let ((arc-string (apply format #f "(make-arc '~15A ~A ~A ~A ~A)" (arc-info obj))))
(format-dash arc-string obj)))
(define (output-box obj)
(let ((box-string (apply format #f "(make-box '~15A '~15A ~A)" (box-info obj))))
(format-fill
(format-dash box-string obj) obj)))
(define (output-bus obj)
(apply format #f "(make-bus '~15A '~15A ~A)" (line-info obj)))
(define (output-circle obj)
(let ((circle-string (apply format #f "(make-circle '~15A ~A ~A)" (circle-info obj))))
(format-fill
(format-dash circle-string obj) obj)))
(define (output-complex obj)
(apply format #f "(make-component/library ~S '~15A ~A ~A ~A)" (component-info obj)))
(define (output-line obj)
(let ((line-string (apply format #f "(make-line '~15A '~15A ~A)" (line-info obj))))
(format-dash line-string obj)))
(define (output-net obj)
(apply format #f "(make-net '~15A '~15A ~A)" (line-info obj)))
(define (output-path obj)
(format-fill
(format-dash
(let ((s (format #f "\n(let ((P (make-path ~A)))\n" (object-color obj)))
(a "")
(K (path-length obj))
(N 0))
(while (< N K)
(case (car (path-ref obj N))
((moveto lineto)
(set! a (apply format #f " (path-insert! P -1 '~8A '~15A)" (path-ref obj N))))
((curveto) (set! a (apply format #f " (path-insert! P -1 '~8A '~A '~A '~A)" (path-ref obj N))))
((closepath) (set! a " (path-insert! P -1 'closepath)" ))
)
(set! s (string-append s a "\n"))
(set! N (1+ N)))
(set! s (string-append s ")"))
s)
obj)
obj))
(define (output-picture obj)
(apply format #f "(make-picture/vector (bytevector->sint-list (get-bytevector-all (open-file ~S \"rb\")) (native-endianness) 1) ~S '~15A '~15A ~A ~A)" (picture-filename obj) (picture-info obj)))
(define (output-pin obj)
(if (net-pin? obj)
(apply format #f "(make-net-pin '~15A '~15A ~A)" (line-info obj))
(apply format #f "(make-bus-pin '~15A '~15A ~A)" (line-info obj))
))
(define (output-text obj)
(apply format #f "(make-text '~15A '~15A ~A ~S ~A ~A '~A ~A)" (text-info obj)))
(define (output-scheme-string obj)
(begin
(display " ")
(display
(case (object-type obj)
; all output-* functions must return strings
('arc (output-arc obj))
('box (output-box obj))
('bus (output-bus obj))
('circle (output-circle obj))
('complex (output-complex obj))
('line (output-line obj))
('net (output-net obj))
('path (output-path obj))
('picture (output-picture obj))
('pin (output-pin obj))
('text (output-text obj))
))
(newline)))
(define (main)
(if (< (length (command-line)) 3)
(error "You must give at least 2 file names"))
(let ((input (cadr (command-line)))
(output (caddr (command-line))))
(set! scale (or (and (eq? (length (command-line)) 4)
(string->number (list-ref (command-line) 3)))
1))
(with-output-to-file output
(lambda ()
;header
(display "(use-modules (geda page))\n")
(display "(use-modules (geda object))\n")
(display "(use-modules (rnrs io ports))\n")
(display "(use-modules (rnrs bytevectors))\n")
(newline)
(if scale
(format #t
"
; Redefine some procedures to support scale (points/mm)
; default scale is 1
(define scale ~A)
(define (scale-number number)
(* number scale))
(define (scale-coord pair)
(cons (scale-number (car pair)) (scale-number (cdr pair))))
(define (scale-two l)
(apply list (scale-coord (car l)) (scale-coord (cadr l)) (cddr l)))
(define (scale-one l)
(cons (scale-coord (car l)) (cdr l)))
; Redefine info functions
(define old-make-line make-line)
(define (make-line line-start line-end color)
(old-make-line (scale-coord line-start) (scale-coord line-end) color))
(define old-make-net make-net)
(define (make-net net-start net-end color)
(old-make-net (scale-coord net-start) (scale-coord net-end) color))
(define old-make-net-pin make-net-pin)
(define (make-net-pin net-pin-start net-pin-end color)
(old-make-net-pin (scale-coord net-pin-start) (scale-coord net-pin-end) color))
(define old-make-bus make-bus)
(define (make-bus bus-start bus-end color)
(old-make-bus (scale-coord bus-start) (scale-coord bus-end) color))
(define old-make-bus-pin make-bus-pin)
(define (make-bus-pin bus-pin-start bus-pin-end color)
(old-make-bus-pin (scale-coord bus-pin-start) (scale-coord bus-pin-end) color))
(define old-make-box make-box)
(define (make-box top-left bottom-right color)
(old-make-box (scale-coord top-left) (scale-coord bottom-right) color))
(define old-make-picture/vector make-picture/vector)
(define (make-picture/vector vector filename top-left bottom-right angle mirror)
(old-make-picture/vector vector filename (scale-coord top-left) (scale-coord bottom-right) angle mirror))
(define old-make-arc make-arc)
(define (make-arc center radius start-angle end-angle color)
(old-make-arc (scale-coord center) (scale-number radius) start-angle end-angle color))
(define old-make-circle make-circle)
(define (make-circle center radius color)
(old-make-circle (scale-coord center) (scale-number radius) color))
(define old-make-component make-component)
(define (make-component basename position angle mirror locked)
(old-make-component basename (scale-coord position) angle mirror locked))
(define old-make-component/library make-component/library)
(define (make-component/library basename position angle mirror locked)
(old-make-component/library basename (scale-coord position) angle mirror locked))
(define old-make-text make-text)
(define (make-text anchor align angle string size visible show color)
(old-make-text (scale-coord anchor) align angle string size visible show color))
(define old-path-insert! path-insert!)
(define (path-insert! p idx type . points)
(apply old-path-insert! p idx type (map (lambda (point) (scale-coord point)) points)))
"
scale))
(display "(define page (make-page \"new\"))\n")
;; object list begin
(display "(define object-list (list\n")
;body
(for-each output-scheme-string (page-contents (file->page input)))
;footer
;;object list end
(display "))\n\n")
(display "(apply page-append! page object-list)\n")
(display "(with-output-to-file \"tmp.sym\" (lambda () (display (page->string page))))")
))))
(main)
| false |
148851eb96c9ca8e7bb90736b30ff0653b9f648d | 2a4d841aa312e1759f6cea6d66b4eaae81d67f99 | /test.scm | a71ce70c23949f2dbe1341e83b724480f69090dc | []
| no_license | amit-k-s-pundir/computing-programming | 9f8e136658322bb9a61e7160301c1a780cec84ca | 9104f371fe97c9cd3c9f9bcd4a06038b936500a4 | refs/heads/master | 2021-07-12T22:46:09.849331 | 2017-10-16T08:50:48 | 2017-10-16T08:50:48 | 106,879,266 | 1 | 2 | null | null | null | null | UTF-8 | Scheme | false | false | 876 | scm | test.scm | (define test (lambda (p)
(let loop ((s (get-line p)))
(if (not s)
#f
(let ((m (string-match s-regex s)))
(if m
(match:substring m)
(loop (get-line p))))))))
(define test1 (lambda (p)
(let ((s (get-line p)))
(if (not s)
#f
(let ((m (string-match s-regex s)))
(if m
(match:substring m)
(test1 p )))))))
(define test2 (lambda (p)
(letrec ((s (get-line p))
(m (string-match s-regex s)))
(if m
(match:substring m)
(test2 p)))))
(define test1 (lambda (p)
))
| false |
8ad8678a40138af240a0f1fced82dbf6e6297635 | 81788f723d53fa098f2fce87d4d022dc78aaa68c | /chap-3/3-32.scm | 7120b1a80b7d53a1527fdbd7cef609e44fbfab93 | []
| no_license | docmatrix/sicp | 01ef2028b1fde0c035e4fa49106d2e07b4baf42d | c7f1214bdd6da23ef8edb0670b61cdb222147674 | refs/heads/master | 2020-12-24T06:44:10.783386 | 2017-11-28T17:03:09 | 2017-11-28T17:03:09 | 58,923,881 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 300 | scm | 3-32.scm | ; If you do not maintain the order of operations, then nested
; components make run on stale inputs. You cannot garauntee that
; the components you're using are ultimate primitives, so you need
; to ensure that any nested component gets called immediately after
; its inputs are triggered.
; CORRECT
| false |
2fbc86971a86dd1744501e43e369e4c9ae20feb6 | 000dbfe5d1df2f18e29a76ea7e2a9556cff5e866 | /test/tests/srfi/%3a132.scm | 92f7449e70b6d1f8467bfa94b928ef5dd91bcd1f | [
"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 | 46,772 | scm | %3a132.scm | ;;; 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.)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(import (except (scheme base) vector-copy or)
(rename (scheme base)
(vector-copy r7rs-vector-copy))
(scheme write)
(scheme process-context)
(scheme time)
(only (srfi 27) random-integer)
(srfi 132)
(srfi 64)
)
(test-begin "SRFI-132")
(define-syntax or
(syntax-rules (fail)
((_ expr (fail who))
(test-assert who expr))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; 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 (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 (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))
(test-end)
| true |
958077678480171113934d73fe9689f9c399cfe5 | f0916dac3f6f73d721db09e137ce6201efd027d2 | /ext/crypto/crypto/eddsa.scm | 56a1ab227fcd6294739043e06935aceb37ee6cf7 | [
"BSD-3-Clause",
"LicenseRef-scancode-other-permissive",
"MIT",
"BSD-2-Clause"
]
| permissive | christoff-buerger/sagittarius-scheme | b8b9289650b4245c1f4d8d92d03d6d8e8e0faacf | f2ac5bbc48a65ca89f036000e5a658a429e0a8b9 | refs/heads/master | 2021-11-12T12:26:17.738912 | 2021-10-28T10:06:47 | 2021-10-28T10:06:47 | 243,363,196 | 0 | 0 | NOASSERTION | 2020-02-26T20:52:02 | 2020-02-26T20:52:01 | null | UTF-8 | Scheme | false | false | 31,421 | scm | eddsa.scm | ;;; -*- mode:scheme; coding:utf-8; -*-
;;;
;;; crypto/key/eddsa.scm - EdDSA cipher
;;;
;;; Copyright (c) 2021 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:
;; - [RFC 8032](https://datatracker.ietf.org/doc/html/rfc8032)
#!nounbound
#!read-macro=sagittarius/bv-string
(library (crypto eddsa)
(export EdDSA
Ed25519 Ed25519ctx Ed25519ph
Ed448 Ed448ph
<eddsa-key> eddsa-key?
eddsa-key-parameter
<eddsa-private-key> eddsa-private-key?
eddsa-private-key-random eddsa-private-key-public-key
<eddsa-public-key> eddsa-public-key?
eddsa-public-key-data
ed25519-key? ed448-key?
;; low level APIs?
make-eddsa-signer make-eddsa-verifier
ed25519-scheme ed25519ctx-scheme ed25519ph-scheme
ed448-scheme ed448ph-scheme
)
(import (rnrs)
(clos user)
(math)
(math ec)
(math modular)
(crypto key pair)
(sagittarius crypto)
(sagittarius) ;; for bytevector->integer/endian
(core misc) ;; for define-vector-type;
(util bytevector)
(srfi :2 and-let*)
)
;;; Interfaces
(define EdDSA :eddsa)
(define Ed25519 :ed25519)
(define Ed25519ctx :ed25519ctx)
(define Ed25519ph :ed25519ph)
(define Ed448 :ed448)
(define Ed448ph :ed448ph)
(define-class <eddsa-key> ()
((parameter :init-keyword :parameter :reader eddsa-key-parameter)))
(define (eddsa-key? o) (is-a? o <eddsa-key>))
(define-class <eddsa-private-key> (<private-key> <eddsa-key>)
((random :init-keyword :random :reader eddsa-private-key-random)
(public-key :init-keyword :public-key :reader eddsa-private-key-public-key)))
(define (eddsa-private-key? o) (is-a? o <eddsa-private-key>))
(define-class <eddsa-public-key> (<public-key> <eddsa-key>)
((data :init-keyword :data :reader eddsa-public-key-data)))
(define (eddsa-public-key? o) (is-a? o <eddsa-public-key>))
(define (ed25519-key? key)
(eq? 'ed25519 (eddsa-parameter-name (eddsa-key-parameter key))))
(define (ed448-key? key)
(eq? 'ed448 (eddsa-parameter-name (eddsa-key-parameter key))))
(define-class <eddsa-cipher-spi> (<cipher-spi>) ())
(define-method initialize ((o <eddsa-cipher-spi>) initargs)
(define (check-ed25519 key)
(unless (ed25519-key? key)
(assertion-violation 'eddsa-cipher "Wrong type for the key")))
(define (check-ed448 key)
(unless (ed448-key? key)
(assertion-violation 'eddsa-cipher "Wrong type for the key")))
(define (type->scheme type key)
(cond ((eq? type Ed25519) (check-ed25519 key) ed25519-scheme)
((eq? type Ed25519ctx) (check-ed25519 key) ed25519ctx-scheme)
((eq? type Ed25519ph) (check-ed25519 key) ed25519ph-scheme)
((eq? type Ed448) (check-ed448 key) ed448-scheme)
((eq? type Ed448ph) (check-ed448 key) ed448ph-scheme)
(else (if (ed25519-key? key) ed25519-scheme ed448-scheme))))
(let ((key (car initargs)))
(let-keywords (cdr initargs)
((type #f) . ignore)
(let ((scheme (type->scheme type key)))
(slot-set! o 'name 'EdDSA)
(slot-set! o 'key key)
(slot-set! o 'encrypt
(lambda ignore (error 'encrypt "not supported in EdDSA")))
(slot-set! o 'decrypt
(lambda ignore (error 'decrypt "not supported in EdDSA")))
(slot-set! o 'padder #f)
(slot-set! o 'signer (make-eddsa-signer scheme))
(slot-set! o 'verifier (make-eddsa-verifier scheme))
(slot-set! o 'keysize #f)))))
(register-spi EdDSA <eddsa-cipher-spi>)
;; this is super generic ;)
(define-method export-public-key ((key <eddsa-public-key>))
(eddsa-public-key-data key))
(define-method export-private-key ((key <eddsa-private-key>))
(eddsa-private-key-random key))
;;; Ed25519 Framework
(define-method generate-public-key ((m (eql Ed25519)) data)
(generate-ed25519-public-key data))
(define-method import-public-key ((m (eql Ed25519)) data)
(generate-ed25519-public-key data))
(define-method export-public-key ((m (eql Ed25519)) (key <eddsa-public-key>))
(eddsa-public-key-data key))
(define-method generate-private-key ((m (eql Ed25519)) random)
(generate-ed25519-private-key random))
(define-method import-private-key ((m (eql Ed25519)) random)
(generate-ed25519-private-key random))
(define-method export-private-key ((m (eql Ed25519)) (key <eddsa-private-key>))
(eddsa-private-key-random key))
(define-method generate-key-pair ((m (eql Ed25519))
;; should we start using ChaCha20?
:key (prng (secure-random RC4)))
(generate-ed25519-key-pair prng))
(define-class <ed25519-cipher-spi> (<cipher-spi>) ())
(define-method initialize ((o <ed25519-cipher-spi>) initargs)
(let ((key (car initargs)))
(slot-set! o 'name 'Ed25519)
(slot-set! o 'key key)
(slot-set! o 'encrypt
(lambda ignore (error 'encrypt "not supported in Ed25519")))
(slot-set! o 'decrypt
(lambda ignore (error 'decrypt "not supported in Ed25519")))
(slot-set! o 'padder #f)
(slot-set! o 'signer (make-eddsa-signer ed25519-scheme))
(slot-set! o 'verifier (make-eddsa-verifier ed25519-scheme))
(slot-set! o 'keysize #f)))
(register-spi Ed25519 <ed25519-cipher-spi>)
;;; Ed25519ctx Framework
(define-method generate-public-key ((m (eql Ed25519ctx)) data)
(generate-ed25519-public-key data))
(define-method import-public-key ((m (eql Ed25519ctx)) data)
(generate-ed25519-public-key data))
(define-method export-public-key ((m (eql Ed25519ctx)) (key <eddsa-public-key>))
(eddsa-public-key-data key))
(define-method generate-private-key ((m (eql Ed25519ctx)) random)
(generate-ed25519-private-key random))
(define-method import-private-key ((m (eql Ed25519ctx)) random)
(generate-ed25519-private-key random))
(define-method export-private-key ((m (eql Ed25519ctx)) (key <eddsa-private-key>))
(eddsa-private-key-random key))
(define-method generate-key-pair ((m (eql Ed25519ctx))
:key (prng (secure-random RC4)))
(generate-ed25519-key-pair prng))
(define-class <ed25519ctx-cipher-spi> (<cipher-spi>) ())
(define-method initialize ((o <ed25519ctx-cipher-spi>) initargs)
(let ((key (car initargs)))
(slot-set! o 'name 'Ed25519)
(slot-set! o 'key key)
(slot-set! o 'encrypt
(lambda ignore (error 'encrypt "not supported in Ed25519ctx")))
(slot-set! o 'decrypt
(lambda ignore (error 'decrypt "not supported in Ed25519ctx")))
(slot-set! o 'padder #f)
(slot-set! o 'signer (make-eddsa-signer ed25519ctx-scheme))
(slot-set! o 'verifier (make-eddsa-verifier ed25519ctx-scheme))
(slot-set! o 'keysize #f)))
(register-spi Ed25519ctx <ed25519ctx-cipher-spi>)
;;; Ed25519ph Framework
(define-method generate-public-key ((m (eql Ed25519ph)) data)
(generate-ed25519-public-key data))
(define-method import-public-key ((m (eql Ed25519ph)) data)
(generate-ed25519-public-key data))
(define-method export-public-key ((m (eql Ed25519ph)) (key <eddsa-public-key>))
(eddsa-public-key-data key))
(define-method generate-private-key ((m (eql Ed25519ph)) random)
(generate-ed25519-private-key random))
(define-method import-private-key ((m (eql Ed25519ph)) random)
(generate-ed25519-private-key random))
(define-method export-private-key ((m (eql Ed25519ph)) (key <eddsa-private-key>))
(eddsa-private-key-random key))
(define-method generate-key-pair ((m (eql Ed25519ph))
:key (prng (secure-random RC4)))
(generate-ed25519-key-pair prng))
(define-class <ed25519ph-cipher-spi> (<cipher-spi>) ())
(define-method initialize ((o <ed25519ph-cipher-spi>) initargs)
(let ((key (car initargs)))
(slot-set! o 'name 'Ed25519)
(slot-set! o 'key key)
(slot-set! o 'encrypt
(lambda ignore (error 'encrypt "not supported in Ed25519ph")))
(slot-set! o 'decrypt
(lambda ignore (error 'decrypt "not supported in Ed25519ph")))
(slot-set! o 'padder #f)
(slot-set! o 'signer (make-eddsa-signer ed25519ph-scheme))
(slot-set! o 'verifier (make-eddsa-verifier ed25519ph-scheme))
(slot-set! o 'keysize #f)))
(register-spi Ed25519ph <ed25519ph-cipher-spi>)
;; Ed448 Framework
(define-method generate-public-key ((m (eql Ed448)) data)
(generate-ed448-public-key data))
(define-method import-public-key ((m (eql Ed448)) data)
(generate-ed448-public-key data))
(define-method export-public-key ((m (eql Ed448)) (key <eddsa-public-key>))
(eddsa-public-key-data key))
(define-method generate-private-key ((m (eql Ed448)) random)
(generate-ed448-private-key random))
(define-method import-private-key ((m (eql Ed448)) random)
(generate-ed448-private-key random))
(define-method export-private-key ((m (eql Ed448)) (key <eddsa-private-key>))
(eddsa-private-key-random key))
(define-method generate-key-pair ((m (eql Ed448))
;; should we start using ChaCha20?
:key (prng (secure-random RC4)))
(generate-ed448-key-pair prng))
(define-class <ed448-cipher-spi> (<cipher-spi>) ())
(define-method initialize ((o <ed448-cipher-spi>) initargs)
(let ((key (car initargs)))
(slot-set! o 'name 'Ed25519)
(slot-set! o 'key key)
(slot-set! o 'encrypt
(lambda ignore (error 'encrypt "not supported in Ed448")))
(slot-set! o 'decrypt
(lambda ignore (error 'decrypt "not supported in Ed448")))
(slot-set! o 'padder #f)
(slot-set! o 'signer (make-eddsa-signer ed448-scheme))
(slot-set! o 'verifier (make-eddsa-verifier ed448-scheme))
(slot-set! o 'keysize #f)))
(register-spi Ed448 <ed448-cipher-spi>)
;; Ed448ph Framework
(define-method generate-public-key ((m (eql Ed448ph)) data)
(generate-ed448-public-key data))
(define-method import-public-key ((m (eql Ed448ph)) data)
(generate-ed448-public-key data))
(define-method export-public-key ((m (eql Ed448ph)) (key <eddsa-public-key>))
(eddsa-public-key-data key))
(define-method generate-private-key ((m (eql Ed448ph)) random)
(generate-ed448-private-key random))
(define-method import-private-key ((m (eql Ed448ph)) random)
(generate-ed448-private-key random))
(define-method export-private-key ((m (eql Ed448ph)) (key <eddsa-private-key>))
(eddsa-private-key-random key))
(define-method generate-key-pair ((m (eql Ed448ph))
;; should we start using ChaCha20?
:key (prng (secure-random RC4)))
(generate-ed448-key-pair prng))
(define-class <ed448ph-cipher-spi> (<cipher-spi>) ())
(define-method initialize ((o <ed448ph-cipher-spi>) initargs)
(let ((key (car initargs)))
(slot-set! o 'name 'Ed448)
(slot-set! o 'key key)
(slot-set! o 'encrypt
(lambda ignore (error 'encrypt "not supported in Ed448ph")))
(slot-set! o 'decrypt
(lambda ignore (error 'decrypt "not supported in Ed448ph")))
(slot-set! o 'padder #f)
(slot-set! o 'signer (make-eddsa-signer ed448ph-scheme))
(slot-set! o 'verifier (make-eddsa-verifier ed448ph-scheme))
(slot-set! o 'keysize #f)))
(register-spi Ed448ph <ed448ph-cipher-spi>)
;;; Ed25519 implementations
(define (generate-ed25519-key-pair prng)
(let* ((random (read-random-bytes prng 32))
(private-key (generate-ed25519-private-key random)))
(make-keypair private-key
(eddsa-private-key-public-key private-key))))
(define (generate-ed25519-public-key data)
(make <eddsa-public-key> :data data :parameter ed25519-parameter))
(define (generate-ed25519-private-key random)
#|
5.1.5. Key Generation
The private key is 32 octets (256 bits, corresponding to b) of
cryptographically secure random data. See [RFC4086] for a discussion
about randomness.
The 32-byte public key is generated by the following steps.
1. Hash the 32-byte private key using SHA-512, storing the digest in
a 64-octet large buffer, denoted h. Only the lower 32 bytes are
used for generating the public key.
2. Prune the buffer: The lowest three bits of the first octet are
cleared, the highest bit of the last octet is cleared, and the
second highest bit of the last octet is set.
3. Interpret the buffer as the little-endian integer, forming a
secret scalar s. Perform a fixed-base scalar multiplication
[s]B.
4. The public key A is the encoding of the point [s]B. First,
encode the y-coordinate (in the range 0 <= y < p) as a little-
endian string of 32 octets. The most significant bit of the
final octet is always zero. To form the encoding of the point
[s]B, copy the least significant bit of the x coordinate to the
most significant bit of the final octet. The result is the
public key.
|#
(define (generate-public-key random)
(let ((h (hash SHA-512 random))
(l (make-bytevector 32)))
;; 1
(bytevector-copy! h 0 l 0 32)
;; 2
(eddsa-clamp! l 3 254 256)
;; 3
(let* ((s (bytevector->integer/endian l (endianness little)))
(sB (ed-point-mul ed25519-parameter
(eddsa-parameter-B ed25519-parameter)
s)))
;; 4
(ed-point-encode-base ed25519-parameter sB
(eddsa-parameter-b ed25519-parameter)))))
(unless (= (bytevector-length random) 32)
(assertion-violation 'generate-ed25519-private-key "Invalid key size"))
(let ((pub (generate-ed25519-public-key (generate-public-key random))))
(make <eddsa-private-key> :parameter ed25519-parameter
:random random :public-key pub)))
(define (generate-ed448-key-pair prng)
(let* ((random (read-random-bytes prng 57))
(private-key (generate-ed448-private-key random)))
(make-keypair private-key
(eddsa-private-key-public-key private-key))))
(define (generate-ed448-public-key data)
(make <eddsa-public-key> :data data :parameter ed448-parameter))
(define (generate-ed448-private-key random)
#|
5.2.5. Key Generation
The private key is 57 octets (456 bits, corresponding to b) of
cryptographically secure random data. See [RFC4086] for a discussion
about randomness.
The 57-byte public key is generated by the following steps:
1. Hash the 57-byte private key using SHAKE256(x, 114), storing the
digest in a 114-octet large buffer, denoted h. Only the lower 57
bytes are used for generating the public key.
2. Prune the buffer: The two least significant bits of the first
octet are cleared, all eight bits the last octet are cleared, and
the highest bit of the second to last octet is set.
3. Interpret the buffer as the little-endian integer, forming a
secret scalar s. Perform a known-base-point scalar
multiplication [s]B.
4. The public key A is the encoding of the point [s]B. First encode
the y-coordinate (in the range 0 <= y < p) as a little-endian
string of 57 octets. The most significant bit of the final octet
is always zero. To form the encoding of the point [s]B, copy the
least significant bit of the x coordinate to the most significant
bit of the final octet. The result is the public key.
|#
(define (generate-public-key random)
(let ((h (hash SHAKE256 random :size 114))
(l (make-bytevector 57)))
;; 1
(bytevector-copy! h 0 l 0 57)
;; 2
(eddsa-clamp! l 2 447 456)
;; 3
(let* ((s (bytevector->integer/endian l (endianness little)))
(sB (ed-point-mul ed448-parameter
(eddsa-parameter-B ed448-parameter)
s)))
;; 4
(ed-point-encode-base ed448-parameter sB
(eddsa-parameter-b ed448-parameter)))))
(unless (= (bytevector-length random) 57)
(assertion-violation 'generate-ed448-private-key "Invalid key size"))
(let ((pub (generate-ed448-public-key (generate-public-key random))))
(make <eddsa-private-key> :parameter ed448-parameter
:random random :public-key pub)))
(define (eddsa-clamp! a c n b)
(do ((i 0 (+ i 1)))
((= i c))
(bytevector-u8-set! a (div i 8)
(bitwise-and (bytevector-u8-ref a (div i 8))
(bitwise-not (bitwise-arithmetic-shift-left 1 (mod i 8))))))
(bytevector-u8-set! a (div n 8)
(bitwise-ior (bytevector-u8-ref a (div n 8))
(bitwise-arithmetic-shift-left 1 (mod n 8))))
(do ((i (+ n 1) (+ i 1)))
((= i b) a)
(bytevector-u8-set! a (div i 8)
(bitwise-and (bytevector-u8-ref a (div i 8))
(bitwise-not (bitwise-arithmetic-shift-left 1 (mod i 8)))))))
;;; Ed25519 parameters
(define-vector-type eddsa-parameter
(make-eddsa-parameter name p b c n d a B L) eddsa-parameter?
(name eddsa-parameter-name)
(p eddsa-parameter-p)
(b eddsa-parameter-b)
(c eddsa-parameter-c)
(n eddsa-parameter-n)
(d eddsa-parameter-d)
(a eddsa-parameter-a)
(B eddsa-parameter-B)
(L eddsa-parameter-L))
;; 5.1 Ed25519ph, Ed25519ctx, and Ed25519
(define ed25519-parameter
(let ((xb #x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a)
(yb #x6666666666666666666666666666666666666666666666666666666666666658)
(p (ec-field-fp-p
(elliptic-curve-field (ec-parameter-curve curve25519))))
(d #x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3))
(make-eddsa-parameter
'ed25519
p ;; p = 2^255 - 19
256 ;; b
3 ;; c
254 ;; n
d ;; d
-1 ;; a
(make-ed-point xb yb 1 (mod (* xb yb) p)) ;; B (x y z t)
(ec-parameter-n curve25519) ;; L (ec-parameter-n = order)
)))
;; once we have short Weierstrass form in (math ec), do like above
(define ed448-parameter
(let ((p (- (expt 2 448) (expt 2 224) 1))
(xb #x4f1970c66bed0ded221d15a622bf36da9e146570470f1767ea6de324a3d3a46412ae1af72ab66511433b80e18b00938e2626a82bc70cc05e)
(yb #x693f46716eb6bc248876203756c9c7624bea73736ca3984087789c1e05a0c2d73ad3ff1ce67c39c4fdbd132c4ed7c8ad9808795bf230fa14)
(L (- (expt 2 446) #x8335dc163bb124b65129c96fde933d8d723a70aadc873d6d54a7bb0d)))
(make-eddsa-parameter
'ed448
p ;; p
456 ;; b
2 ;; c
447 ;; n
-39081 ;; d
1 ;; a
(make-ed-point xb yb 1 0) ;; B (x y z t) note: t isn't used
L ;; L
)))
(define-vector-type eddsa-scheme
(make-eddsa-scheme parameter prehash inithash) eddsa-scheme?
(parameter eddsa-scheme-parameter)
(prehash eddsa-scheme-prehash)
(inithash eddsa-scheme-inithash))
(define ed25519-scheme
(make-eddsa-scheme ed25519-parameter
#f (lambda (data ctx hflag)
(when (or hflag (and ctx (> (bytevector-length ctx) 0)))
(assertion-violation 'ed25519 "Context/hashes not supported"))
(hash SHA-512 data))))
(define (ed25519ctx-inithash data ctx hflag)
(let ((dom-prefix (if ctx
(if (< (bytevector-length ctx) 256)
(bytevector-append
#*"SigEd25519 no Ed25519 collisions"
(if hflag #vu8(1) #vu8(0))
(make-bytevector 1 (bytevector-length ctx))
ctx)
(assertion-violation 'Ed25519
"Context too big"))
#vu8())))
(hash SHA-512 (bytevector-append dom-prefix data))))
(define ed25519ctx-scheme
(make-eddsa-scheme ed25519-parameter #f ed25519ctx-inithash))
(define ed25519ph-scheme
(make-eddsa-scheme ed25519-parameter
(lambda (x y) (hash SHA-512 x))
ed25519ctx-inithash))
(define (ed448-inithash data ctx hflag)
(let ((dom-prefix (if ctx
(if (< (bytevector-length ctx) 256)
(bytevector-append
#*"SigEd448"
(if hflag #vu8(1) #vu8(0))
(make-bytevector 1 (bytevector-length ctx))
ctx)
(assertion-violation 'Ed448
"Context too big"))
#vu8())))
(hash SHAKE256 (bytevector-append dom-prefix data) :size 114)))
(define ed448-scheme
(make-eddsa-scheme ed448-parameter #f ed448-inithash))
(define ed448ph-scheme
(make-eddsa-scheme ed448-parameter
(lambda (data ctx) (hash SHAKE256 data :size 64))
ed448-inithash))
(define (make-eddsa-signer scheme)
(lambda (bv key :key (context #f))
(define prehash (eddsa-scheme-prehash scheme))
(define (sign msg key ctx scheme)
(define prehash (eddsa-scheme-prehash scheme))
(define inithash (eddsa-scheme-inithash scheme))
(define parameter (eddsa-scheme-parameter scheme))
(define l (eddsa-parameter-L parameter))
(define c (eddsa-parameter-c parameter))
(define n (eddsa-parameter-n parameter))
(define b (eddsa-parameter-b parameter))
(define B (eddsa-parameter-B parameter))
(define pub-key
(eddsa-public-key-data (eddsa-private-key-public-key key)))
(let* ((khash (inithash (eddsa-private-key-random key) #f prehash))
(a (bytevector->integer/endian
(eddsa-clamp! (bytevector-copy khash 0 (div b 8)) c n b)
(endianness little)))
(seed (bytevector-copy khash (div b 8)))
(r (bytevector->integer/endian
(inithash (bytevector-append seed msg) ctx prehash)
(endianness little)))
(R (ed-point-encode-base parameter (ed-point-mul parameter B r) b))
(h (mod (bytevector->integer/endian
(inithash (bytevector-append R pub-key msg) ctx prehash)
(endianness little))
l))
(S (integer->bytevector/endian (mod (+ r (* h a)) l)
(endianness little)
(div b 8))))
(bytevector-append R S)))
(let ((ctx (or context #vu8())))
(sign (or (and prehash (prehash bv ctx)) bv) key ctx scheme))))
(define (make-eddsa-verifier scheme)
(lambda (msg sig key :key (context #f))
(define prehash (eddsa-scheme-prehash scheme))
(define (verify msg sig key ctx scheme)
(define prehash (eddsa-scheme-prehash scheme))
(define inithash (eddsa-scheme-inithash scheme))
(define parameter (eddsa-scheme-parameter scheme))
(define l (eddsa-parameter-L parameter))
(define c (eddsa-parameter-c parameter))
(define n (eddsa-parameter-n parameter))
(define b (eddsa-parameter-b parameter))
(define B (eddsa-parameter-B parameter))
(define pub-key (eddsa-public-key-data key))
(define b/8 (div b 8))
;; sanity check
(unless (and (= (bytevector-length sig) (div b 4))
(= (bytevector-length pub-key) b/8))
(error 'eddsa-verifier "inconsistent"))
(let* ((r-raw (bytevector-copy sig 0 b/8))
(s-raw (bytevector-copy sig b/8))
(R (ed-point-decode-base parameter r-raw b))
(S (bytevector->integer/endian s-raw (endianness little)))
(A (ed-point-decode-base parameter pub-key b)))
(unless (and R A (< S l))
(error 'eddsa-verifier "inconsistent"))
(let* ((h (mod (bytevector->integer/endian
(inithash (bytevector-append r-raw pub-key msg)
ctx prehash)
(endianness little))
l))
(rhs (ed-point-add parameter R (ed-point-mul parameter A h)))
(lhs (ed-point-mul parameter B S)))
(do ((i 0 (+ i 1))
(lhs lhs (ed-point-double parameter lhs))
(rhs rhs (ed-point-double parameter rhs)))
((= i c) (or (ed-point=? parameter lhs rhs)
(error 'eddsa-verifier "inconsistent")))))))
(let ((ctx (or context #vu8())))
(verify (or (and prehash (prehash msg ctx)) msg) sig key ctx scheme))))
;;; Twisted Edwards curve computation
;;; TODO should we make (math ed) and export them from there
(define-vector-type ed-point
(make-ed-point x y z t) ed-point?
(x ed-point-x)
(y ed-point-y)
(z ed-point-z)
(t ed-point-t))
;; Based on RFC 8032 Appendix A
;; field calculation (modular arith)
(define (ed-field-add p x y) (mod-add x y p))
(define (ed-field-sub p x y) (mod-sub x y p))
(define (ed-field-mul p x y) (mod-mul x y p))
;;(define (ed-field-inv p x) (mod (mod-expt x (- p 2) p) p))
(define (ed-field-inv p x) (mod-inverse x p))
(define (ed-field-div p x y) (mod-div x y p))
;; (ed-field-mul p x (ed-field-inv p y)))
(define (ed-field-zero? p x) (zero? x))
(define (ed-field-sign p x) (mod x 2))
(define (ed-field-negate p x) (mod-negate x p))
(define (ed-field-sqrt p x) (mod-sqrt x p))
(define (bytevector->ed-field p bv b)
(let ((rv (mod (bytevector->integer/endian bv (endianness little))
(expt 2 (- b 1)))))
(and (< rv p) rv)))
;; Ed point calculation
(define ed-point-zero
(let ((zero (make-ed-point 0 1 1 0)))
(lambda (parameter)
zero)))
(define (ed-point-add parameter x y)
(case (eddsa-parameter-name parameter)
((ed25519) (ed25519-point-add parameter x y))
((ed448) (ed448-point-add parameter x y))
(else (assertion-violation 'ed-point-add "Not supported"
(eddsa-parameter-name parameter)))))
(define (ed25519-point-add parameter x y)
(define p (eddsa-parameter-p parameter))
(define d (eddsa-parameter-d parameter))
(define xx (ed-point-x x))
(define xy (ed-point-y x))
(define xt (ed-point-t x))
(define xz (ed-point-z x))
(define yx (ed-point-x y))
(define yy (ed-point-y y))
(define yt (ed-point-t y))
(define yz (ed-point-z y))
(let* ((zcp (ed-field-mul p xz yz))
(A (ed-field-mul p (ed-field-sub p xy xx) (ed-field-sub p yy yx)))
(B (ed-field-mul p (ed-field-add p xy xx) (ed-field-add p yy yx)))
(C (ed-field-mul p (ed-field-add p d d) (ed-field-mul p xt yt)))
(D (ed-field-add p zcp zcp))
(E (ed-field-sub p B A))
(H (ed-field-add p B A))
(F (ed-field-sub p D C))
(G (ed-field-add p D C)))
(make-ed-point (ed-field-mul p E F) (ed-field-mul p G H)
(ed-field-mul p F G) (ed-field-mul p E H))))
(define (ed448-point-add parameter x y)
(define p (eddsa-parameter-p parameter))
(define d (eddsa-parameter-d parameter))
(define xx (ed-point-x x))
(define xy (ed-point-y x))
(define xz (ed-point-z x))
(define yx (ed-point-x y))
(define yy (ed-point-y y))
(define yz (ed-point-z y))
(let* ((xcp (ed-field-mul p xx yx))
(ycp (ed-field-mul p xy yy))
(zcp (ed-field-mul p xz yz))
(B (ed-field-mul p zcp zcp))
(E (ed-field-mul p d (ed-field-mul p xcp ycp)))
(F (ed-field-sub p B E))
(G (ed-field-add p B E)))
(make-ed-point (ed-field-mul p
(ed-field-mul p zcp F)
(ed-field-sub p
(ed-field-mul p
(ed-field-add p xx xy)
(ed-field-add p yx yy))
(ed-field-add p xcp ycp)))
(ed-field-mul p
(ed-field-mul p zcp G) (ed-field-sub p ycp xcp))
(ed-field-mul p F G)
0)))
(define (ed-point-double parameter p)
(case (eddsa-parameter-name parameter)
((ed25519) (ed25519-point-double parameter p))
((ed448) (ed448-point-double parameter p))
(else (assertion-violation 'ed-point-double "Not supported"
(eddsa-parameter-name parameter)))))
(define (ed25519-point-double parameter e)
(define p (eddsa-parameter-p parameter))
(define x (ed-point-x e))
(define y (ed-point-y e))
(define z (ed-point-z e))
(let* ((A (ed-field-mul p x x))
(B (ed-field-mul p y y))
(Ch (ed-field-mul p z z))
(C (ed-field-add p Ch Ch))
(H (ed-field-add p A B))
(xys (ed-field-add p x y))
(E (ed-field-sub p H (ed-field-mul p xys xys)))
(G (ed-field-sub p A B))
(F (ed-field-add p C G)))
(make-ed-point (ed-field-mul p E F) (ed-field-mul p G H)
(ed-field-mul p F G) (ed-field-mul p E H))))
(define (ed448-point-double parameter e)
(define p (eddsa-parameter-p parameter))
(define x (ed-point-x e))
(define y (ed-point-y e))
(define z (ed-point-z e))
(let* ((x1s (ed-field-mul p x x))
(y1s (ed-field-mul p y y))
(z1s (ed-field-mul p z z))
(xys (ed-field-add p x y))
(F (ed-field-add p x1s y1s))
(J (ed-field-sub p F (ed-field-add p z1s z1s))))
(make-ed-point (ed-field-mul p
(ed-field-sub p
(ed-field-sub p (ed-field-mul p xys xys) x1s) y1s) J)
(ed-field-mul p F (ed-field-sub p x1s y1s))
(ed-field-mul p F J)
0)))
;; scalar multiplication
(define (ed-point-mul parameter p k)
(unless (integer? k)
(assertion-violation 'ed-point-mul "integer required for k" k))
(do ((r (ed-point-zero parameter)
(if (odd? k) (ed-point-add parameter r s) r))
(s p (ed-point-double parameter s))
(k k (bitwise-arithmetic-shift-right k 1)))
((<= k 0) r)))
(define (ed-point=? parameter x y)
(define p (eddsa-parameter-p parameter))
(define xx (ed-point-x x))
(define xy (ed-point-y x))
(define xz (ed-point-z x))
(define yx (ed-point-x y))
(define yy (ed-point-y y))
(define yz (ed-point-z y))
(let ((xn1 (ed-field-mul p xx yz))
(xn2 (ed-field-mul p yx xz))
(yn1 (ed-field-mul p xy yz))
(yn2 (ed-field-mul p yy xz)))
(and (= xn1 xn2) (= yn1 yn2))))
(define (ed-point-solve-x2 parameter x y)
(case (eddsa-parameter-name parameter)
((ed25519) (ed25519-point-solve-x2 parameter x y))
((ed448) (ed448-point-solve-x2 parameter x y))
(else (assertion-violation 'ed-point-solve-x2 "Not supported"
(eddsa-parameter-name parameter)))))
(define (ed25519-point-solve-x2 parameter x y)
(define p (eddsa-parameter-p parameter))
(define d (eddsa-parameter-d parameter))
(ed-field-div p
(ed-field-sub p (ed-field-mul p y y) 1)
(ed-field-add p (ed-field-mul p (ed-field-mul p d y) y) 1)))
(define (ed448-point-solve-x2 parameter x y)
(define p (eddsa-parameter-p parameter))
(define d (eddsa-parameter-d parameter))
(ed-field-div p
(ed-field-sub p (ed-field-mul p y y) 1)
(ed-field-sub p (ed-field-mul p (ed-field-mul p d y) y) 1)))
;; encode
(define (ed-point-encode-base parameter point b)
(define p (eddsa-parameter-p parameter))
(define x (ed-point-x point))
(define y (ed-point-y point))
(define z (ed-point-z point))
(let ((xp (ed-field-div p x z))
(yp (ed-field-div p y z)))
(let ((s (integer->bytevector/endian yp (endianness little) (div b 8))))
(when (odd? xp)
(bytevector-u8-set! s (div (- b 1) 8)
(bitwise-ior
(bytevector-u8-ref s (div (- b 1) 8))
(bitwise-arithmetic-shift-left 1 (mod (- b 1) 8)))))
s)))
;; decode
(define (ed-point-decode-base parameter s b)
(define p (eddsa-parameter-p parameter))
(and-let* (( (= (bytevector-length s) (div b 8)) )
(xs (bitwise-arithmetic-shift-right
(bytevector-u8-ref s (div (- b 1) 8))
(bitwise-and (- b 1) 7)))
(y (bytevector->ed-field p s b))
(x (ed-field-sqrt p (ed-point-solve-x2 parameter s y)))
( (not (and (ed-field-zero? p x)
(not (= xs (ed-field-sign p x))))) )
(x (if (= (ed-field-sign p x) xs) x (ed-field-negate p x))))
;; NOTE: t is only used on Ed25519, Ed448 doesn't use it
(make-ed-point x y 1 (ed-field-mul p x y))))
)
| false |
02270d200ce50b222dbaa7190413d280072e4a0f | 2bcf33718a53f5a938fd82bd0d484a423ff308d3 | /programming/sicp/ch2/ex-2.71.scm | 0952d4dc9fc6822de9c67adefb74002194ab50c7 | []
| 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 | 1,101 | scm | ex-2.71.scm | #lang scheme
;; https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book-Z-H-16.html#%_thm_2.71
;; For an alphabet of n symbols with relative frequency 1, 2, 4, ..., 2^(n-1):
;; Since successive more frequent symbol has double the frequency of the
;; previous, when combining least frequent symbols during tree construction,
;; the sum of the two least frequent remaining is always less than the third.
;; This results in each successive combination producing a new sibling of the
;; less frequent symbols, and so every node in the tree has a right leaf.
;;
;; Consequently the most frequent symbol is encoded with 1 bit (from the topmost
;; right child), and the least frequent symbols require n - 1 bits since the
;; tree has depth n - 1.
;; Tree from the [Scheme Community Wiki](http://community.schemewiki.org/?sicp-ex-2.71)
;; {a b c d e} 31
;; / \
;; {a b c d} 15 e 16
;; / \
;; {a b c} 7 d 8
;; / \
;; {a b} 3 c 4
;; / \
;; a 1 b 2
| false |
64b30329b901c382f0f689bfde17b4c5fd55eea4 | a2d8b4843847507b02085bb8adabd818f57dd09f | /scheme/sicp/ch_3/arithmetic-pkg/rational.scm | 2cdc4562906fc9a1ef50a1e944c0fd7f143b80da | []
| no_license | tcharding/self_learning | df911b018fc86bd5f918394b79d2456bf51f35a8 | f6bb5c6f74092177aa1b71da2ce87ca1bfc5ef3c | refs/heads/master | 2022-05-13T05:09:32.284093 | 2022-05-02T08:25:18 | 2022-05-02T08:25:18 | 41,029,057 | 13 | 2 | null | null | null | null | UTF-8 | Scheme | false | false | 2,636 | scm | rational.scm | ;;;; Rational Number Package
(load-from-path "lib.scm")
(define (rational? x)
(eq? (type-tag x) 'rational))
(define (install-rational-package)
;; internal procedures
(define (numer x) (car x))
(define (denom x) (cdr x))
(define (make-rat n d)
(let ((r (reduce n d)))
; (debug "make-rat: let" r)
(cons (car r) (cadr r))))
#!
;; We can't use this when using rational functions
(define (make-rat-pos n d)
(let ((g (gcd n d)))
(cons (/ n g) (/ d g))))
(let ((rat (make-rat-pos (abs n) (abs d))))
(cond ((and (negative? n) (negative? d)) rat)
((or (negative? n) (negative? d))
(set-car! rat (sub 0 (car rat)))
rat)
(else rat))))po
!#
(define (add-rat x y)
(make-rat (add (mul (numer x) (denom y))
(mul (numer y) (denom x)))
(mul (denom x) (denom y))))
(define (sub-rat x y)
(make-rat (sub (mul (numer x) (denom y))
(mul (numer y) (denom x)))
(mul (denom x) (denom y))))
(define (mul-rat x y)
(make-rat (mul (numer x) (numer y))
(mul (denom x) (denom y))))
(define (div-rat x y)
(make-rat (mul (numer x) (denom y))
(mul (denom x) (numer y))))
(define (equal-rat? x y)
(num-eq? (mul (numer x) (denom y))
(mul (numer y) (denom x))))
(define (zero-rat? x)
(num-eq? (numer x) 0))
(define (print-rat x)
(display (numer x))
(display "/")
(display (denom x))
(newline))
(define (negate-rat x)
(make-rat (sub 0 (numer x)) (denom x)))
(define (negative-rat? x)
(cond ((and (negative? (numer x)) (negative? (denom x))) #f)
((or (negative? (numer x)) (negative? (denom x))) #t)
(else #f)))
;; interface to rest of system
(define (tag x) (attach-tag 'rational x))
(put 'denom
'(rational)
(lambda (x)
(denom (contents x))))
(put 'numer
'(rational)
(lambda (x)
(numer (contents x))))
(put 'add
'(rational rational)
(lambda (x y)
(tag (add-rat x y))))
(put 'sub
'(rational rational)
(lambda (x y)
(tag (sub-rat x y))))
(put 'mul
'(rational rational)
(lambda (x y)
(tag (mul-rat x y))))
(put 'div
'(rational rational)
(lambda (x y)
(tag (div-rat x y))))
(put 'num-eq?
'(rational rational)
(lambda (x y) (equal-rat? x y)))
(put 'make
'rational
(lambda (n d)
(tag (make-rat n d))))
(put '=zero? '(rational) zero-rat?)
'done)
| false |
76de9c7d881ffe2c548e544a501246beece08216 | c74dcb1facbd920d762017345171f47f8e41d0c5 | /chapter_3/3.23.scm | 7a91d604662f789602657f75e9502dcdb2ed051e | []
| 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 | 3,951 | scm | 3.23.scm | #lang sicp
(#%require "utils.scm")
;; Exercise 3.23: A deque (“double-ended queue”) is a sequence in
;; which items can be inserted and deleted at either the front or the
;; rear. Operations on deques are the constructor make-deque, the
;; predicate empty-deque?, selectors front-deque and rear-deque, and
;; mutators front-insert-deque!, rear-insert-deque!,
;; front-delete-deque!, rear-delete-deque!. Show how to represent
;; deques using pairs, and give implementations of the operations.151
;; All operations should be accomplished in Θ ( 1 ) steps.
;; doubly linked lists
(define (make-entry data left right)
(list data left right))
(define (set-left! entry left)
(set-car! (cdr entry) left))
(define (set-right! entry right)
(set-car! (cddr entry) right))
(define (data entry) (car entry))
(define (left entry) (cadr entry))
(define (right entry) (caddr entry))
(define (make-deque)
(let ((front-ptr nil)
(rear-ptr nil))
(define (set-front-ptr! item)
(set! front-ptr item))
(define (set-rear-ptr! item)
(set! rear-ptr item))
(define (empty-queue?)
(null? front-ptr))
(define (front-insert-deque! element)
(let ((entry (make-entry element nil nil)))
(cond ((empty-queue?)
(set-front-ptr! entry)
(set-rear-ptr! entry))
(else
(set-right! entry front-ptr)
(set-left! front-ptr entry)
(set-front-ptr! entry)))))
(define (rear-insert-deque! element)
(let ((entry (make-entry element nil nil)))
(cond ((empty-queue?)
(set-front-ptr! entry)
(set-rear-ptr! entry))
(else
(set-right! rear-ptr entry)
(set-left! entry rear-ptr)
(set-rear-ptr! entry)))))
(define (front-delete-deque!)
(cond ((empty-queue?)
(error "DELETE! called with empty deque"))
(else
(set-left! (right front-ptr) nil)
(set-front-ptr! (right front-ptr)))))
(define (rear-delete-deque!)
(cond ((empty-queue?)
(error "DELETE! called with empty deque"))
(else
(set-right! (left rear-ptr) nil)
(set-rear-ptr! (left rear-ptr)))))
(define (front-deque)
(if (empty-queue?)
nil
(data front-ptr)))
(define (rear-deque)
(if (empty-queue?)
nil
(data rear-ptr)))
(define (print-deque)
(define (iter entry)
(cond ((null? entry)
(newline))
(else
(display (data entry))
(display " ")
(iter (right entry)))))
(newline)
(iter front-ptr))
(define (dispatch m)
(cond
((eq? 'insert-front m) front-insert-deque!)
((eq? 'insert-rear m) rear-insert-deque!)
((eq? 'delete-front m) front-delete-deque!)
((eq? 'delete-rear m) rear-delete-deque!)
((eq? 'rear-deque m) rear-deque)
((eq? 'front-deque m) front-deque)
((eq? 'print-deque m) print-deque)
(else
(error "Invalid option!" m))))
dispatch))
(define (insert-front q elem) ((q 'insert-front) elem))
(define (insert-rear q elem) ((q 'insert-rear) elem))
(define (delete-front q) ((q 'delete-front)))
(define (delete-rear q) ((q 'delete-rear)))
(define (rear-deque q) ((q 'rear-deque)))
(define (front-deque q) ((q 'front-deque)))
(define (print-deque q) ((q 'print-deque)))
;; test
(define (run-test)
(define q1 (make-deque))
(insert-front q1 'a)
(insert-front q1 'b)
(insert-front q1 'c)
(insert-rear q1 'd)
(display "Deque: ")
(print-deque q1)
(test-equal (front-deque q1) 'c)
(test-equal (rear-deque q1) 'd)
(delete-front q1)
(test-equal (front-deque q1) 'b)
(delete-rear q1)
(test-equal (rear-deque q1) 'a)
(insert-front q1 'e)
(insert-rear q1 'f)
(print-deque q1))
| false |
ee36b40de9f3dac6095561e6753114f43b5fb7d9 | eef5f68873f7d5658c7c500846ce7752a6f45f69 | /spheres/string/fmt.sld | 08acd5e7c7dfc9eaac04e6bc77139384e223642c | [
"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 | 899 | sld | fmt.sld | ;;!!! FMT: formatting library
;; .author Alex Shinn, 2006-2009
;; .version 0.8.4
;; Copyright (c) 2006-2009 Alex Shinn. All rights reserved.
;; BSD-style license: http://synthcode.com/license.txt
(define-library (spheres/string fmt)
(export <TODO>)
(import (spheres/algorithm list)
(spheres/structure hash-table)
(spheres/string string))
(include "fmt/let-optionals.scm") ; if you don't have LET-OPTIONALS*
(include "fmt/make-eq-table.scm")
(include "fmt/mantissa.scm")
(include "fmt/fmt.scm")
(include "fmt/fmt-pretty.scm") ; optional pretty printing
(include "fmt/fmt-column.scm") ; optional columnar output
(include "fmt/fmt-c.scm") ; optional C formatting utilities
(include "fmt/fmt-js.scm") ; optional C formatting utilities
(include "fmt/fmt-color.scm") ; optional color utilities
(include "fmt/fmt-unicode.scm"))
| false |
335c4753efc582173d527c5613e8ef96b33a8ebb | de5d387aa834f85a1df3bd47bc324b01130f21fb | /ps2/code/generic-tests.scm | 7e183a54982429ed455153fdaca8047ff57c3238 | []
| no_license | chuchao333/6.945 | 5ae15980a952bed5c868be03d1a71b1878ddd53d | c50bb28aadf0c3fcda3c8e56b4a61b9a2d582552 | refs/heads/master | 2020-05-30T20:23:23.501175 | 2013-05-05T19:59:53 | 2013-05-05T19:59:53 | 24,237,118 | 5 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 6,765 | scm | generic-tests.scm | ;;; Unit tests for generic-sequences, based on descriptions from generic-specs
;;; Author Owen Derby ([email protected])
(load "load")
(define (assert pred #!optional msg)
(if pred
pred
(if (default-object? msg)
(error "assertion failed")
(error msg))))
;;; Constructors
(define v1 (sequence:construct vector? 'a 'b 'c))
(define s1 (sequence:construct string? 'a 'b 'c))
;(define s1 (sequence:construct string? #\a #\b #\c))
(define l1 (sequence:construct list? 'a 'b 'c))
(assert (equal? v1 #(a b c)) "vector construction failed")
(assert (string=? s1 "abc") "string construction failed")
(assert (equal? l1 (list 'a 'b 'c)) "list construction failed")
(assert (equal? (sequence:null vector?) #()) "non null vector")
(assert (equal? (sequence:null string?) "") "non null string")
(assert (equal? (sequence:null list?) '()) "non null list")
;;; Selecting
(assert (equal? (sequence:ref v1 1) 'b) "wrong vector element")
(assert (equal? (sequence:ref s1 1) #\b) "wrong string element")
(assert (equal? (sequence:ref l1 1) 'b) "wrong list element")
(assert (= 3 (sequence:size v1)) "wrong vector size")
(assert (= 3 (sequence:size s1)) "wrong string size")
(assert (= 3 (sequence:size l1)) "wrong list size")
(assert (eq? (sequence:type v1) vector?) "wrong vector predicate")
(assert (eq? (sequence:type s1) string?) "wrong string predicate")
(assert (eq? (sequence:type l1) list?) "wrong list predicate")
;;; Testing
(assert (sequence:null? (sequence:null vector?)) "bad null vector check")
(assert (sequence:null? (sequence:null string?)) "bad null string check")
(assert (sequence:null? (sequence:null list?)) "bad null list check")
(assert (sequence:equal? v1 #(a b c)) "vector comparison failed")
(assert (not (sequence:equal? v1 #(a a c))) "vector bad comparison failed")
(assert (sequence:equal? s1 "abc") "string comparison failed")
(assert (not (sequence:equal? s1 "aaa")) "string bad comparison failed")
(assert (sequence:equal? l1 (list 'a 'b 'c)) "list comparison failed")
(assert (not (sequence:equal? l1 '(a a c))) "vector bad comparison failed")
;;; Mutation
(let ((v2 (sequence:construct vector? 'a 'a 'c)))
(sequence:set! v2 1 'b)
(assert (sequence:equal? v1 v2) "vector mutation failed"))
(let ((s2 (sequence:construct string? 'a 'a 'c)))
(sequence:set! s2 1 #\b)
(assert (sequence:equal? s1 s2) "string mutation failed"))
(let ((l2 (sequence:construct list? 'a 'a 'c)))
(sequence:set! l2 1 'b)
(assert (sequence:equal? l1 l2) "list mutation failed"))
;;; Cutting and Pasting
(assert (sequence:equal? (sequence:subsequence v1 0 3)
v1) "vector complete subsequence failed")
(assert (sequence:equal? (sequence:subsequence v1 0 2)
#(a b)) "vector subsequence failed")
(assert (sequence:null? (sequence:subsequence v1 0 0))
"vector empty subsequence failed")
(assert (sequence:equal? (sequence:subsequence s1 0 3) s1)
"string complete subsequence failed")
(assert (sequence:equal? (sequence:subsequence s1 0 2) "ab")
"string subsequence failed")
(assert (sequence:null? (sequence:subsequence s1 0 0))
"string empty subsequence failed")
(assert (sequence:equal? (sequence:subsequence l1 0 3) l1)
"list complete subsequence failed")
(assert (sequence:equal? (sequence:subsequence l1 0 2) '(a b))
"list subsequence failed")
(assert (sequence:null? (sequence:subsequence l1 0 0))
"list empty subsequence failed")
(assert (sequence:equal? (sequence:append v1 v1) #(a b c a b c))
"vector append failed")
(assert (sequence:equal? (sequence:append s1 s1) "abcabc")
"string append failed")
(assert (sequence:equal? (sequence:append l1 l1) '(a b c a b c))
"list append failed")
;;; Iterators
(assert (sequence:equal? (sequence:generate vector? 3 (lambda (x) x))
#(0 1 2)) "vector:generate failed")
(assert (sequence:equal? (sequence:generate string? 3 (lambda (x) x))
"012") "string:generate failed")
(assert (sequence:equal? (sequence:generate list? 3 (lambda (x) x))
'(0 1 2)) "list:generate failed")
(assert (sequence:equal? (sequence:map (lambda (x y z) (+ x y z))
#(1 2) #(1 2) #(1 2))
#(3 6))
"vector:map failed")
(assert (sequence:equal? (sequence:map (lambda (x y z) (string x y z))
"ab" " " "cd")
"a cb d")
"string:map filed")
(assert (sequence:equal? (let ((v #(1 2 3)))
(sequence:for-each (lambda (i j k)
(sequence:set! v i (* j j)))
#(0 1 2) #(3 2 1) #(3 2 1))
v)
#(9 4 1))
"vector:for-each failed")
;;; Filtration and Search
(assert (sequence:equal? (sequence:filter #(1 2 3) odd?)
#(1 3)) "filtering failed")
(assert (= (sequence:get-index #(1 2 3) odd?) 0) "get-index failed")
(assert (= (sequence:get-element #(1 2 3) odd?) 1) "get-element failed")
;;; Accumulation
(assert (sequence:equal? (sequence:fold-right
list 'end '(1 2 3))
'(1 (2 (3 end)))) "fold-right failed")
(assert (sequence:equal? (sequence:fold-left
list 'start '(1 2 3))
'(((start 1) 2) 3)) "fold-right failed")
; Problem 2.2 - generalizations
;;; generalized equal?
(assert (sequence:equal-ta? #(1 2 3) '(1 2 3)) "equal-ta_1 failed")
;(assert (sequence:equal-ta? #(#\1 #\2 #\3) "123") "equal-ta_1b failed")
;(assert (sequence:equal-ta? '(#\1 #\2 #\3) "123") "equal-ta_1c failed")
(assert (sequence:equal-ta? '(1 #(2 3) 4) #(1 (2 3) 4)) "equal-ta_2 failed")
(assert (not
(sequence:equal-ta? '(1 #(2 3) 4) #(1 (3 2) 4))) "equal-ta_2b failed")
;(assert (not
; (sequence:equal-ta? '(1 #(2 3) 4) '(1 "23" 4))) "equal-ta_3 failed")
;(assert (sequence:equal-ta? '(1 #(#\2 #\3) 4) '(1 "23" 4)) "equal-ta_3b failed")
;;; generalized append
(define v2 (sequence:construct vector? 1 2 3))
;(define s2 (sequence:construct string? 1 2 3))
(define l2 (sequence:construct list? ))
(assert (sequence:equal? (sequence:append v1 l1)
#(a b c a b c)) "vector-general append failed")
;(assert (sequence:equal? (sequence:append s2 l2 v2)
; "abcabcabc") "string-general append failed")
(assert (sequence:equal? (sequence:append l1 v1)
'(a b c a b c)) "list-general append failed")
;;; generalized map
(assert (sequence:equal? (sequence:map (lambda (x y z) (+ x y z))
#(1 2) '(1 2) #(1 2))
#(3 6))
"general map failed")
;;; generalized for-each
(assert (sequence:equal? (let ((v #(1 2 3)))
(sequence:for-each (lambda (i j k)
(sequence:set! v i (* j j)))
#(0 1 2) '(3 2 1) "321")
v)
#(9 4 1))
"general for-each failed")
; problem 2.3
; problem 2.5.C
; since '() is a list?, nothing is null....
(assert (generic:less? #f #t) "generic:less bool failed")
(assert (not (generic:less? #t #f)) "generic:less bool failed")
(assert (not (generic:less? '(1 2 3) #t)) "generic:less_null2 failed")
(assert (generic:less? #t '(1 2 3)) "generic:less_null2 failed")
| false |
7923ed1183ba1f5fc82b597fc37e6c09a430537f | a9d1a0e915293c3e6101e598b3f8fc1d8b8647a9 | /scheme/raytrace/test-material.scm | b1097c633bcbf2300fb2a0030eb0599ba31248a2 | []
| no_license | mbillingr/raytracing | a3b5b988007536a7065e51ef2fc17e6b5ac44d43 | 9c786e5818080cba488d3795bc6777270c505e5e | refs/heads/master | 2021-04-16T17:10:40.435285 | 2020-11-11T07:02:18 | 2020-11-11T07:02:18 | 249,372,261 | 2 | 4 | null | null | null | null | UTF-8 | Scheme | false | false | 2,578 | scm | test-material.scm | (import (scheme base) (scheme write)
(raytrace testing)
(raytrace ray)
(raytrace tuple)
(raytrace matrix)
(raytrace lights)
(raytrace constants)
(raytrace material)
(raytrace shapes))
(let ((m (default-material))
(pos (point 0 0 0)))
(test "Lighting with the eye between light and surface"
(given (eyev <- (vec 0 0 -1))
(normalv <- (vec 0 0 -1))
(light <- (point-light (point 0 0 -10) (color 1 1 1))))
(when (result <- (lighting m (sphere) light pos eyev normalv #f)))
(then (result == (color 1.9 1.9 1.9))))
(test "Lighting with the eye between light and surface, eye offset 45 deg"
(given (eyev <- (vec 0 SQRT2/2 (- SQRT2/2)))
(normalv <- (vec 0 0 -1))
(light <- (point-light (point 0 0 -10) (color 1 1 1))))
(when (result <- (lighting m (sphere) light pos eyev normalv #f)))
(then (result == (color 1.0 1.0 1.0))))
(test "Lighting with eye opposite surface, light offset 45 deg"
(given (eyev <- (vec 0 0 -1))
(normalv <- (vec 0 0 -1))
(light <- (point-light (point 0 10 -10) (color 1 1 1))))
(when (result <- (lighting m (sphere) light pos eyev normalv #f)))
(then (result == (color 0.7364 0.7364 0.7364))))
(test "Lighting with eye in the path of the reflection vector"
(given (eyev <- (vec 0 (- SQRT2/2) (- SQRT2/2)))
(normalv <- (vec 0 0 -1))
(light <- (point-light (point 0 10 -10) (color 1 1 1))))
(when (result <- (lighting m (sphere) light pos eyev normalv #f)))
(then (result == (color 1.6364 1.6364 1.6364))))
(test "Lighting with the light behind the surface"
(given (eyev <- (vec 0 0 -1))
(normalv <- (vec 0 0 -1))
(light <- (point-light (point 0 0 10) (color 1 1 1))))
(when (result <- (lighting m (sphere) light pos eyev normalv #f)))
(then (result == (color 0.1 0.1 0.1))))
(test "Lighting with the surface in shadow"
(given (eyev <- (vec 0 0 -1))
(normalv <- (vec 0 0 -1))
(light <- (point-light (point 0 0 -10) (color 1 1 1))))
(when (result <- (lighting m (sphere) light pos eyev normalv #t)))
(then (result == (color 0.1 0.1 0.1))))
(test "Reflectivity for the default material"
(given (m <- (default-material)))
(then ((material-reflective m) == 0)))
(test "Transparency and Refractive Index for the default material"
(given (m <- (default-material)))
(then ((material-transparency m) == 0)
((material-refractive-index m) == 1))))
| false |
5f5deb127b25e51717bf49a0f8e501d52dfab730 | 358b0f0efbdb9f081245b536c673648abbb6dc41 | /srfi-27-lognormals.scm | 05bc42d346c02be43b088d75688e87aaaf9c9471 | [
"MIT"
]
| permissive | diamond-lizard/srfi-27 | edb34a5ab850bfdf342acab61f1b49b87875116a | d54fcd1916ddef175df1d3dda107b149737ce1ca | refs/heads/main | 2023-01-13T00:50:41.260636 | 2020-11-16T17:18:46 | 2020-11-16T17:18:46 | 312,747,512 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,556 | scm | srfi-27-lognormals.scm | ;;;; srfi-27-lognormals.scm
;;;; Kon Lovett, Dec '17
;;;; Kon Lovett, Jun '17
;;;; Kon Lovett, May '06
; Chicken Generic Arithmetic! (would use fp routines, except for the "real" constraint)
(module srfi-27-lognormals
(;export
*make-random-lognormals
make-random-lognormals)
(import scheme)
(import (chicken base))
(import (chicken type))
(import
(only type-errors error-argument-type)
(only type-checks
define-check+error-type
check-procedure
check-natural-integer
check-real
check-open-interval
check-closed-interval)
srfi-27
srfi-27-distributions-support
srfi-27-normals)
;;;
(include "srfi-27-common-types")
;;; Lognormal distribution
(: *make-random-lognormals (number number random-real-function --> number-function))
;
(define (*make-random-lognormals mu sigma randoms)
(let (
(normals (*make-random-normals 0.0 1.0 randoms) )
(nmu (log (* mu (/ mu (sqrt (+ (* sigma sigma) (* mu mu)))))) )
(nsigma (sqrt (log (+ 1.0 (* sigma (/ sigma mu mu))))) ) )
;
(lambda ()
(exp (+ nmu (* (normals) nsigma))))) )
(: make-random-lognormals (#!rest --> number-function procedure))
;
(define (make-random-lognormals #!key (mu 1.0) (sigma 1.0) (randoms (current-random-real)))
(check-nonzero-real 'make-random-lognormals mu 'mu)
(check-nonnegative-real 'make-random-lognormals sigma 'sigma)
(check-procedure 'make-random-lognormals randoms 'randoms)
(values
(*make-random-lognormals mu sigma randoms)
(lambda () (values mu sigma randoms))) )
) ;module srfi-27-lognormals
| false |
ee435657dbb7668217bcb096f3ee4df84e1b4691 | c51f6a2ddfedc49313106d935141286eb0a13256 | /PAPR2/maze/way-out/test.scm | bc64511fbd335d3620a516fa39dff7e57576bfb9 | []
| no_license | Emp3r/School | 395970f68238cf4e1723241d578b17113f0412b8 | 0814b06931939f3d745713c16c64e5d8adc783f6 | refs/heads/master | 2021-01-14T08:04:25.875803 | 2017-03-26T13:47:13 | 2017-03-26T13:47:13 | 17,414,260 | 0 | 1 | null | 2017-03-26T13:47:13 | 2014-03-04T19:35:00 | Scheme | UTF-8 | Scheme | false | false | 2,054 | scm | test.scm | (load "way-out.scm")
(define test-maze
(lambda (filename)
(load filename)
(let* ((maze #f)
(boy-pos #f) (boy-x #f) (boy-y #f)
(trs-pos #f) (trs-x #f) (trs-y #f))
(define set-maze
(lambda ()
(set! boy-pos (car setting))
(set! boy-x (car boy-pos))
(set! boy-y (cdr boy-pos))
(set! trs-pos (cadr setting))
(set! trs-x (car trs-pos))
(set! trs-y (cdr trs-pos))
(set! maze (caddr setting))))
(define run-loop
(lambda (i)
(let* ((directions (get-directions maze boy-x boy-y))
(treasure (get-inc-directions (- trs-x boy-x)
(- trs-y boy-y)))
(move (eval `(navigator ',directions ',treasure))))
(if (and (not move))
(begin
(display "Halt: ")
(display i)
(newline)
i)
(begin
(set! boy-pos (make-move maze boy-pos move))
(if (not boy-pos)
(begin
(display "Suicide: ")
(display i)
(newline)
i)
(begin
(set! boy-x (car boy-pos))
(set! boy-y (cdr boy-pos))
;; vypis tahu
(if (= (modulo i 50) 0)
(begin
(display i)
(display " ")
))
(if (equal? boy-pos trs-pos)
(begin
(display "Moves: ")
(display i)
(newline)
i)
(run-loop (+ i 1))))))))))
(set-maze)
(run-loop 0))))
(define start-time 0)
(set! start-time (current-seconds))
(apply +
(build-list 1000 (lambda (i)
(load "solution.scm")
(test-maze
(string-append "maze"
(number->string i)
".scm")))))
(newline)
(display "time in seconds: ")
(display (- (current-seconds) start-time))
| false |
25df2d7def2c4d528b908f0e5fa5e926deeb78e0 | 7301b8e6fbd4ac510d5e8cb1a3dfe5be61762107 | /ex-3.75.scm | 9976312de1db13e943e24974b10453d28fc01da0 | []
| no_license | jiakai0419/sicp-1 | 75ec0c6c8fe39038d6f2f3c4c6dd647a39be6216 | 974391622443c07259ea13ec0c19b80ac04b2760 | refs/heads/master | 2021-01-12T02:48:12.327718 | 2017-01-11T12:54:38 | 2017-01-11T12:54:38 | 78,108,302 | 0 | 0 | null | 2017-01-05T11:44:44 | 2017-01-05T11:44:44 | null | UTF-8 | Scheme | false | false | 1,902 | scm | ex-3.75.scm | ;;; Exercise 3.75. Unfortunately, Alyssa's zero-crossing detector in exercise
;;; 3.74 proves to be insufficient, because the noisy signal from the sensor
;;; leads to spurious zero crossings. Lem E. Tweakit, a hardware specialist,
;;; suggests that Alyssa smooth the signal to filter out the noise before
;;; extracting the zero crossings. Alyssa takes his advice and decides to
;;; extract the zero crossings from the signal constructed by averaging each
;;; value of the sense data with the previous value. She explains the problem
;;; to her assistant, Louis Reasoner, who attempts to implement the idea,
;;; altering Alyssa's program as follows:
;;;
;;; (define (make-zero-crossings input-stream last-value)
;;; (let ((avpt (/ (+ (stream-car input-stream) last-value) 2)))
;;; (cons-stream (sign-change-detector avpt last-value)
;;; (make-zero-crossings (stream-cdr input-stream)
;;; avpt))))
;;;
;;; This does not correctly implement Alyssa's plan. Find the bug that Louis
;;; has installed and fix it without changing the structure of the program.
;;; (Hint: You will need to increase the number of arguments to
;;; make-zero-crossings.)
; Let's denote
;
; * S = (S_i) as the sense data, and
; * A = (A_i) as the average values calculated from S,
; where A_i = (S_i + S_{i-1}) / 2.
;
; Alyssa's plan is to extract zero crossings from A.
; But Louis's implementation does not correctly calculate A.
; It calculates A_i by (S_i + A_{i-1}) / 2.
(define (make-zero-crossings input-stream last-raw-value last-average-value)
(let ((avpt (/ (+ (stream-car input-stream) last-raw-value) 2)))
(cons-stream (sign-change-detector avpt last-average-value)
(make-zero-crossings (stream-cdr input-stream)
(stream-car input-stream)
avpt))))
| false |
30d1e3fe7bf283cf1f2f5f03c3210c2f888719ac | ac2a3544b88444eabf12b68a9bce08941cd62581 | /tests/unit-tests/13-modules/prim_boolean.scm | 915201ca6fd84a6144b00849de4a9533349fdd40 | [
"Apache-2.0",
"LGPL-2.1-only"
]
| permissive | tomelam/gambit | 2fd664cf6ea68859d4549fdda62d31a25b2d6c6f | d60fdeb136b2ed89b75da5bfa8011aa334b29020 | refs/heads/master | 2020-11-27T06:39:26.718179 | 2019-12-15T16:56:31 | 2019-12-15T16:56:31 | 229,341,552 | 1 | 0 | Apache-2.0 | 2019-12-20T21:52:26 | 2019-12-20T21:52:26 | null | UTF-8 | Scheme | false | false | 255 | scm | prim_boolean.scm | (include "#.scm")
(check-same-behavior ("" "##" "~~lib/_prim-boolean#.scm")
;; R4RS
(boolean? #f) (boolean? #t) (boolean? 123)
(not #f) (not #t) (not 123)
;; R7RS
(boolean=?) (boolean=? #f) (boolean=? #f #f) (boolean=? #f #t) (boolean=? #f #f #f)
)
| false |
5e2bd1ff0e286ae76a422f00a220078d2b85b4e2 | 932c31c2eeb3b9f6efba945e0d3634e8f0081c89 | /lib/nnex/os.nmosh.sls | 911ea3662cd308fbcf1d97afdb19200f3d53e1e8 | []
| no_license | okuoku/nnex | 13a989c732390d16ddf5a8b245aed8c109f83ae5 | e4cf50b3040becd1cf7df4eb5129e03ba40cc0ae | refs/heads/master | 2020-05-17T20:53:30.101288 | 2012-05-13T22:06:17 | 2012-05-13T22:19:17 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 114 | sls | os.nmosh.sls | (library (nnex os)
(export host-os
current-directory)
(import (mosh)(system)))
| false |
524bc6c8d7127f6ab68e8c3b58ed539070cdb5af | 9046fb7fa896d41aecd0f98c8cdd26447ccf9a1a | /11.ss | 12c4e1418f501356199c45064db884637f7439bd | []
| no_license | Joycexuy2/CSSE304 | 25743e01c1fb7e743ba0a83145872517229617b5 | 6e405e5a277ad14228d031d9fcbdc54325e9a88a | refs/heads/master | 2021-01-11T06:59:53.372832 | 2016-10-25T22:27:11 | 2016-10-25T22:27:11 | 71,944,384 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 10,104 | ss | 11.ss | ;; Assignment 11a
;;Joyce Xu
;; #1a
(define-syntax my-let
(syntax-rules ()
[(_ ((x v) ...) e1 e2 ...)
((lambda (x ...) e1 e2 ...) v ...)]
[(_ n ((x v) ...) exp)
(letrec ([n (lambda (x ...) exp)])
(n v ...))]))
;; #1b
(define-syntax my-or
(syntax-rules ()
[(_) #f]
[(_ e1) e1]
;;[(_ exp e1 e2) e1]
[(_ e1 e2 ...)
(let ((x e1))
(if x x (my-or e2 ...)))]))
;; #1c
(define-syntax +=
(syntax-rules ()
[(_) #f]
[(_ e1 e2)
(begin
(set! e1 (+ e1 e2))
e1)]))
;; #1d
(define-syntax return-first
(syntax-rules ()
[(_ e1) e1]
[(_ e1 e2 ...)
(let ((val e1))
(begin e2 ... val))]))
;; #2
(load "chez-init.ss")
(define-datatype bintree bintree? ;;defined in EOPL page 50
(leaf-node
(num integer?))
(interior-node
(key symbol?)
(left-tree bintree?)
(right-tree bintree?)))
(define bintree-to-list (lambda (bt) bt))
;; #3
(define leaf-sum
(lambda (T)
(cases bintree T
[leaf-node (datum) datum]
[interior-node (key left-tree right-tree) (+ (leaf-sum right-tree) (leaf-sum left-tree))])))
(define isleaf?
(lambda (T)
(cases bintree T
[leaf-node (datum) #t]
[interior-node (key left-tree right-tree) #f])))
(define max-interior-helper
(lambda (T)
(cases bintree T
[leaf-node (datum) #f]
[interior-node (key left-tree right-tree)
(cond
[(and (isleaf? left-tree) (isleaf? right-tree))
(let ((s (leaf-sum T)))
(cons
(cons
key
s)
s))]
[(isleaf? right-tree);;if the right-tree is not leaf, and left-tree is leaf
(let* ((left-max (max-interior-helper left-tree))
[max-lsum (cdar left-max)]
[lsum (cdr left-max)]
[total-sum (+ lsum (leaf-sum right-tree))])
(if (< max-lsum total-sum)
(cons
(cons key total-sum)
total-sum)
(cons
(car left-max)
total-sum)))]
[(isleaf? left-tree) ;;if the left-tree is not leaf, and right-tree is leaf
(let* ((right-max (max-interior-helper right-tree))
[max-rsum (cdar right-max)]
[rsum (cdr right-max)]
[total-sum (+ rsum (leaf-sum left-tree))])
(if (< max-rsum total-sum)
(cons
(cons key total-sum)
total-sum)
(cons
(car right-max)
total-sum)))]
[else;;both left and right not leaf
(let*
([right (max-interior-helper right-tree)] ;;get right tree max
[left (max-interior-helper left-tree)];;get left tree max
[max-rsum (cdr (car right))] ;;max of right sum
[rsum (cdr right)] ;;get right tree sum
[max-lsum (cdr (car left))] ;;max of left sum
[lsum (cdr left)] ;;sum of left sum
[total-sum (+ lsum rsum)])
(if [< max-rsum max-lsum]
(if [< max-lsum total-sum]
(cons
(cons key total-sum)
total-sum)
(cons
(car left)
total-sum))
(if [< max-rsum total-sum]
(cons
(cons key total-sum)
total-sum)
(cons
(car right)
total-sum))))])])))
(define max-interior
(lambda (T)
(car (car (max-interior-helper T)))))
;;4a
(load "chez-init.ss"); This is a parser for simple Scheme expressions, such as those in EOPL, 3.1 thru 3.3.
; You will want to replace this with your parser that includes more expression types, more options for these types, and error-checking.
; Procedures to make the parser a little bit saner.
(define 1st car)
(define 2nd cadr)
(define 3rd caddr)
(define 4th cadddr)
;;helper, check whether the list are all symbol
(define all-symbol?
(lambda (ls)
(if (null? ls)
#t
(if (symbol? (car ls))
(all-symbol (cdr ls))
#f))))
(define list-of-expression?
[lambda (e)
(if (list? e) (andmap expression? e) #f)])
(define lambda-var?
[lambda (e)
(cond
[(symbol? e) #t]
[(pair? e)
(let helper ([rest e])
(cond
[(null? rest) #t]
[(symbol? rest) #t]
[else
(and (symbol? (car rest)) (helper (cdr rest)))]))]
[else #f])])
(define-datatype expression expression?
[var-exp (id symbol?)]
[lit-exp (id lit?)]
[lambda-exp (var (lambda (v) (or (symbol? v) (list-of-expression? v))))
(body list-of-expression?)]
[lambda-var-exp (var lambda-var?)]
[set!-exp (id symbol?) (r-val-exp expression)]
[if-else-exp (condition-exp expression?)
(true-exp expression?) (false-exp expression?)]
[if-exp (condition-exp expression?)
(true-exp expression?)]
[let-exp (ls list-of-expression?)
(body list-of-expression?)]
[single-let-exp (var expression?)
(body expression?)]
[named-let-exp (name expression?)
(ls list-of-expression?) (body list-of-expression?)]
[let*-exp (ls list-of-expression?)
(body list-of-expression?)]
[letrec-exp (ls list-of-expression?)
(body list-of-expression?)]
[app-exp (rator expression?)
(rand list-of-expression?)])
(define lit?
(lambda (e)
(or (number? e)
(string? e)
(symbol? e)
(boolean? e)
(char? e)
(vector? e)
(null? e)
(and (list? e)
(list? (cdr e))
(eq? 'quote (car e))))))
(define parse-exp
(lambda (datum)
(cond
[(lit? datum) (lit-exp datum)]
;;set! expression
[(eqv? (1st datum) 'set!)
(cond
[(> (length datum) 3)
(eopl:error 'parse-exp "Too many parts: ~s" datum)]
[(= (length datum) 3)
(if (symbol? (2nd datum))
(set!-exp (parse-exp (2nd datum)) (parse-exp (3rd datum)))
(eopl:error 'parse-exp "declaration in set-expression ~s must take a symbol" (2nd datum)))]
[else (eopl:error 'parse-exp "set expression ~s has incorrect arguments" datum)]
)]
[(pair? datum)
(cond
[(not (list? datum))
(eopl:error 'parse-exp "expression ~s is an improper list" datum)]
;;lambda expression
[(eqv? (car datum) 'lambda)
(cond
[(< (length datum) 3)
(eopl:error 'parse-exp "lambda expression: ~s" datum)]
[(symbol? (2nd datum))
(lambda-exp (2nd datum) (map parse-exp (cddr datum)))]
[(list? (2nd datum))
(if (andmap (lambda (v) (symbol? v)) (cadr datum))
(lambda-exp (map parse-exp (2nd datum)) (map parse-exp (cddr datum)))
(eopl:error 'parse-exp "lambda argument list: formals must be symbols: ~s" datum))]
[else (eopl:error 'parse-exp "Incorrect lambda syntax: ~s" datum)])]
;;if expression
[(eqv? 'if (1st datum))
(cond
[(= 2 (length datum))
(eopl:error 'parse-exp "missing then and else parts: ~s" datum)]
[(= 3 (length datum))
(if-exp (parse-exp (2nd datum)) (parse-exp (3rd datum)))]
[(= 4 (length datum))
(if-else-exp (parse-exp (2nd datum))
(parse-exp (3rd datum))
(parse-exp (4th datum)))]
[else
(eopl:error 'parse-exp "if-expression: ~s does not have the right format: condition, then, else" datum)])]
;;let expression
[(or (eqv? 'let (1st datum)) (eqv? 'letrec (1st datum)) (eqv? 'let* (1st datum)));;check whether the 1st datum meeet any let type
(cond
[(< (length datum) 3) (eopl:error 'parse-exp "let-expression has incorrect length")]
[else
(letrec ([parse-let
(lambda (ls)
(let helper ((rest ls))
(cond
[(null? rest) (list)]
[(not (list? rest)) (eopl:error 'parse-exp "~s-list is not a proper list" (1st datum) rest)]
[(not (list? (car rest))) (eopl:error 'parse-exp "declaration in ~s-list is not a proper list" (1st datum) (car rest))]
[(not (= 2 (length (car rest)))) (eopl:error 'parse-exp "declaration in ~s-list must be in length of two ~s" (1st datum) (car rest))]
[(not (symbol? (caar rest))) (eopl:error 'parse-exp "variable in ~s must be a symbol ~s" (1st datum) (caar rest))]
[else
(cons (single-let-exp (parse-exp (caar rest))
(parse-exp (cadar rest)))
(helper (cdr rest)))])))])
(cond
[(symbol? (2nd datum))
(cond
[(= 3 (length datum)) (eopl:error 'parse-exp "named-let-exp has incorrect length ~s" datum)]
[(not (eqv? 'let (1st datum))) (eopl:error 'parse-exp "declaration in ~s must be a proper list ~s" (1st datum) (2nd datum))]
[else (named-let-exp (var-exp (2nd datum))
(parse-let (3rd datum))
(map parse-exp (cdddr datum)))])]
[(eqv? 'let (1st datum))
(let-exp (parse-let (2nd datum)) (map parse-exp (cddr datum)))]
[(eqv? 'let* (1st datum))
(let*-exp (parse-let (2nd datum)) (map parse-exp (cddr datum)))]
[else
(letrec-exp (parse-let (2nd datum)) (map parse-exp (cddr datum)))]))])]
[else (app-exp (parse-exp (1st datum))
(map parse-exp (cdr datum)))])]
[else (eopl:error 'parse-exp "bad expression: ~s" datum)])))
;;#4b
(define unparse-exp
(lambda (e)
(cases expression e
[var-exp (id) id]
[lit-exp (id) id]
[lambda-var-exp (var) var]
[lambda-exp (var body)
(cons 'lambda (cons (if (symbol? var) var (map unparse-exp var))
(map unparse-exp body)))]
[set!-exp (id r-val-exp)
(list 'set! (unparse-exp id) (unparse-exp r-val-exp))]
[if-exp (condition-exp true-exp)
(list 'if (unparse-exp condition-exp) (unparse-exp true-exp))]
[if-else-exp (condition-exp true-exp false-exp)
(list 'if (unparse-exp condition-exp) (unparse-exp true-exp) (unparse-exp false-exp))]
[let-exp (ls body)
(cons* 'let (map unparse-exp ls) (map unparse-exp body))]
[single-let-exp (var body)
(list (unparse-exp var) (unparse-exp body))]
[named-let-exp (name ls body) (cons 'let
(cons (unparse-exp name) (cons (map unparse-exp ls) (map unparse-exp body))))]
[let*-exp (ls body) (cons* 'let*
(cons (map unparse-exp ls) (map unparse-exp body)))]
[letrec-exp (ls body) (cons* 'letrec
(cons (map unparse-exp ls) (map unparse-exp body)))]
[app-exp (rator rand) (cons (unparse-exp rator) (map unparse-exp rand))])))
| true |
4daa16de7c818f6a6c7cc825ac7c4d1c79516030 | c44a2ead2d7905965b9ff621f81c48077de04b0b | /lab05-scheme-procedures/procedures.ss | 63939a9af8fcf05d2b9440823c6f763edb531c1d | []
| no_license | CaMapLenBo/prog-langs-4003 | 597af770a763b0a87d8a413642671107a82d74f6 | aa275fb3a3647691d024c3f4890e776098bcd924 | refs/heads/master | 2020-07-31T04:17:18.654636 | 2017-11-07T01:35:41 | 2017-11-07T01:35:41 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 960 | ss | procedures.ss | ; Prime number generation lab
; Completed by Kristian Snyder
(define (nlist n m acc) ; Create a list from n to m, inclusive.
(if (< m n)
acc
(nlist n (- m 1) (cons m acc))
)
)
(define (rangelist n m) ; Nice wrapper for nlist that provides the accumulator
(nlist n m '())
)
(define (splice-mults-of n lst) ; remove multiples of n from the list
(if (pair? lst)
(if (= (modulo (car lst) n) 0)
(splice-mults-of n (cdr lst))
(cons (car lst) (splice-mults-of n (cdr lst)))
)
'()
)
)
(define (primes n lst acc) ; Return the first n primes in a list of integers
(if (pair? lst)
(if (zero? n)
acc
(primes (- n 1) (splice-mults-of (car lst) (cdr lst)) (append acc (list (car lst))))
)
(write "Failed: not enough integers")
)
)
; the final procedure to generate primes.
(define (stol n) (primes n (rangelist 2 (* n 10)) '()))
| false |
aff21dcef9cd66efea7bea5ff3edefede83f485c | 784dc416df1855cfc41e9efb69637c19a08dca68 | /src/std/text/base64.scm | 4cadaf43c976ce35e890046294c051af4da20e67 | [
"LGPL-2.1-only",
"Apache-2.0",
"LGPL-2.1-or-later"
]
| permissive | danielsz/gerbil | 3597284aa0905b35fe17f105cde04cbb79f1eec1 | e20e839e22746175f0473e7414135cec927e10b2 | refs/heads/master | 2021-01-25T09:44:28.876814 | 2018-03-26T21:59:32 | 2018-03-26T21:59:32 | 123,315,616 | 0 | 0 | Apache-2.0 | 2018-02-28T17:02:28 | 2018-02-28T17:02:28 | null | UTF-8 | Scheme | false | false | 17,005 | scm | base64.scm | ;;
;; U8vector <-> Base64-encoded string coding module
;;
;; Copyright (C) 2005-2007 by Marc Feeley, All Rights Reserved.
;; Copyright (C) 2012 Mikael More
;; Copyright (C) 2016 vyzo at hackzen.org
;;
;; ## Base64 coding support notes
;; * Support for urlsafe coding
;; In this mode, #\- instead of #\+ and #\_ is used instead of #\/. For this coding to work,
;; the padding should be turned off during encoding (so there's no #\=:s in the output).
;; Also known as the "Base64 with URL and Filename Safe Alphabet" aka base64url of RFC 4648.
;;
;; * Support for presence and absence of end padding
;; Supports both the older encoding with padding, and the unpadded form that's slightly smaller, that
;; is gaining popularity in decoders currently, currently implemented in decoders such as that of
;; Ecmascript 5 and the apache-commons Java library. We imitate this functionality, while offering
;; the option of not outputting padding on encoding, as well as requiring padding on decoding.
;;
;; ## Exports
;; (base64-string->u8vector str #!key (nopadding-ok? #t) (urlsafe? #f)) => u8vector
;;
;; (base64-substring->u8vector str start end #!key (nopadding-ok? #t) (urlsafe? #f)) => u8vector
;;
;; (u8vector->base64-string u8vect #!key (width 0) (padding? #t) (urlsafe? #f)) => string
;;
;; (subu8vector->base64-string u8vect start end #!key (width 0) (padding? #t) (urlsafe? #f)) => string
;;
;; ## History
;; 2012-11-29: Added support for not producing padding in /sub/u8vector->base64-string ,
;; and for not requirind padding in base64-string->/sub/u8vector .
;;
;; Basically the requirement for padding on base64encoded was motivated by the
;; scarce nature of computing resources in the 1980:s. Today there's a move
;; toward not requiring the padding, as reflected for instance in Ecmascript 5's
;; spec to produce the badding on encode but not to require it on decode.
;; For some more references see:
;; Description of JS5 btoa() at https://en.wikipedia.org/wiki/Base64#HTML
;; http://stackoverflow.com/questions/4080988/why-does-base64-encoding-requires-padding-if-the-input-length-is-not-divisible-b
;; http://stackoverflow.com/questions/4322507/why-padding-is-used-in-base64-encoding
;; http://stackoverflow.com/questions/4492426/remove-trailing-when-base64-encoding
;; https://code.google.com/p/go/issues/detail?id=4237
;; 2012-12-04: Added support for "Base64 with URL and Filename Safe Alphabet" aka base64url of RFC 4648.
;; If there'd be any need for it, the decoder can be made to accept both urlsafe and ordinary
;; coding instead of either.
;; 2016-01-28: [vyzo] namespaced for gerbil, comment cosmetics for emacs indendation whims.
;;
;;
;; ## TODO
;; * There's a variant of base64 encoding called "URL base64 encoding", where + and some
;; other char is replaced by something else. May be a nice idea for us to support it.
(declare (standard-bindings)
(extended-bindings)
(block)
(safe)
(fixnum)
; (not interrupts-enabled)
)
;;==============================================================================
;; Representation of fifos.
(define-macro (macro-make-fifo)
`(let ((fifo (##cons '() '())))
(macro-fifo-tail-set! fifo fifo)
fifo))
(define-macro (macro-fifo-next fifo) `(##cdr ,fifo))
(define-macro (macro-fifo-next-set! fifo x) `(##set-cdr! ,fifo ,x))
(define-macro (macro-fifo-tail fifo) `(##car ,fifo))
(define-macro (macro-fifo-tail-set! fifo x) `(##set-car! ,fifo ,x))
(define-macro (macro-fifo-elem fifo) `(##car ,fifo))
(define-macro (macro-fifo-elem-set! fifo x) `(##set-car! ,fifo ,x))
(define-macro (macro-fifo->list fifo)
`(macro-fifo-next ,fifo))
(define-macro (macro-fifo-remove-all! fifo)
`(let ((fifo ,fifo))
(##declare (not interrupts-enabled))
(let ((head (macro-fifo-next fifo)))
(macro-fifo-tail-set! fifo fifo)
(macro-fifo-next-set! fifo '())
head)))
(define-macro (macro-fifo-remove-head! fifo)
`(let ((fifo ,fifo))
(##declare (not interrupts-enabled))
(let ((head (macro-fifo-next fifo)))
(if (##pair? head)
(let ((next (macro-fifo-next head)))
(if (##null? next)
(macro-fifo-tail-set! fifo fifo))
(macro-fifo-next-set! fifo next)
(macro-fifo-next-set! head '())))
head)))
(define-macro (macro-fifo-insert-at-tail! fifo elem)
`(let ((fifo ,fifo) (elem ,elem))
(let ((x (##cons elem '())))
(##declare (not interrupts-enabled))
(let ((tail (macro-fifo-tail fifo)))
(macro-fifo-next-set! tail x)
(macro-fifo-tail-set! fifo x)
(##void)))))
(define-macro (macro-fifo-insert-at-head! fifo elem)
`(let ((fifo ,fifo) (elem ,elem))
(let ((x (##cons elem '())))
(##declare (not interrupts-enabled))
;; To obtain an atomic update of the fifo, we must force a
;; garbage-collection to occur right away if needed by the
;; ##cons, so that any finalization that might mutate this fifo
;; will be done before updating the fifo.
(##check-heap-limit)
(let ((head (macro-fifo-next fifo)))
(if (##null? head)
(macro-fifo-tail-set! fifo x))
(macro-fifo-next-set! fifo x)
(macro-fifo-next-set! x head)
(##void)))))
(define-macro (macro-fifo-advance-to-tail! fifo)
`(let ((fifo ,fifo))
;; It is assumed that the fifo contains at least one element
;; (i.e. the fifo's tail does not change).
(let ((new-head (macro-fifo-tail fifo)))
(macro-fifo-next-set! fifo new-head)
(macro-fifo-elem new-head))))
(define-macro (macro-fifo-advance! fifo)
`(let ((fifo ,fifo))
;; It is assumed that the fifo contains at least two elements
;; (i.e. the fifo's tail does not change).
(let* ((head (macro-fifo-next fifo))
(new-head (macro-fifo-next head)))
(macro-fifo-next-set! fifo new-head)
(macro-fifo-elem new-head))))
(define-macro (fifo->u8vector fifo start end)
`(##fifo->u8vector ,fifo ,start ,end))
(define-macro (u8vector-shrink! u8vect len)
`(##u8vector-shrink! ,u8vect ,len))
(define-macro (fifo->string fifo start end)
`(##fifo->string ,fifo ,start ,end))
(define-macro (string-shrink! str len)
`(##string-shrink! ,str ,len))
;;==============================================================================
(##namespace ("std/text/base64#"
base64-string->u8vector
base64-substring->u8vector
u8vector->base64-string
subu8vector->base64-string
))
(define base64-string->u8vector
(lambda (str #!key (nopadding-ok? #t) (urlsafe? #f))
(base64-substring->u8vector str 0 (string-length str) nopadding-ok?: nopadding-ok? urlsafe?: urlsafe?)))
(define base64-substring->u8vector
(lambda (str start end #!key (nopadding-ok? #t) (urlsafe? #f))
(define padding-required? (not nopadding-ok?))
(define index-62-char (if urlsafe? #\- #\+))
(define index-63-char (if urlsafe? #\_ #\/))
(define err
(lambda (str-location code-location)
(error "base64 decoding error" str-location code-location)
;; (void) - If uncommented, keeps variables on the stack during the exception
))
(define chunk-len 64) ; must be a power of 2
(define state
(vector 0
(macro-make-fifo)))
(define (wr-u8 x)
(let ((ptr (vector-ref state 0)))
(vector-set! state 0 (+ ptr 1))
(let ((fifo (vector-ref state 1))
(i (bitwise-and ptr (- chunk-len 1))))
(u8vector-set!
(if (= i 0)
(let ((chunk (make-u8vector chunk-len)))
(macro-fifo-insert-at-tail! fifo chunk)
chunk)
(macro-fifo-elem (macro-fifo-tail fifo)))
i
x))))
(define (get-output-u8vector)
(let ((ptr (vector-ref state 0))
(fifo (vector-ref state 1)))
(if (and (< 0 ptr) (<= ptr chunk-len))
(let ((u8vect (macro-fifo-elem (macro-fifo-tail fifo))))
(u8vector-shrink! u8vect ptr)
u8vect)
(fifo->u8vector fifo 0 ptr))))
(define decode
(lambda (c)
(cond ((and (char>=? c #\A) (char<=? c #\Z))
(- (char->integer c) (char->integer #\A)))
((and (char>=? c #\a) (char<=? c #\z))
(+ 26 (- (char->integer c) (char->integer #\a))))
((and (char>=? c #\0) (char<=? c #\9))
(+ 52 (- (char->integer c) (char->integer #\0))))
((char=? c (if urlsafe? #\- #\+))
62)
((char=? c (if urlsafe? #\_ #\/))
63)
(else
#f))))
(define done
(lambda ()
(get-output-u8vector)))
(define add1
(lambda (x0 x1)
(add (+ (arithmetic-shift x0 2)
(arithmetic-shift x1 -4)))))
(define add2
(lambda (x0 x1 x2)
(add1 x0 x1)
(add (bitwise-and #xff
(+ (arithmetic-shift x1 4)
(arithmetic-shift x2 -2))))))
(define add3
(lambda (x0 x1 x2 x3)
(add2 x0 x1 x2)
(add (bitwise-and #xff
(+ (arithmetic-shift x2 6)
x3)))))
(define add
(lambda (x)
(wr-u8 x)))
(let loop0 ((i start))
(if (>= i end)
(done)
(let* ((c0 (string-ref str i))
(x0 (decode c0)))
(if x0
(let loop1 ((i (+ i 1)))
(if (>= i end)
(err i '@a)
(let* ((c1 (string-ref str i))
(x1 (decode c1)))
(if x1
(let loop2 ((i (+ i 1)))
(if (and padding-required? (>= i end))
(err i '@b)
(let* ((c2 (if (and nopadding-ok? (>= i end))
#\=
(string-ref str i)))
(x2 (decode c2)))
(if x2
(let loop3 ((i (+ i 1)))
(if (and padding-required? (>= i end))
(err i '@c)
(let* ((c3 (if (and nopadding-ok? (>= i end))
#\=
(string-ref str i)))
(x3 (decode c3)))
(if x3
(begin
(add3 x0 x1 x2 x3)
(loop0 (+ i 1)))
(if (char=? c3 #\=)
(begin
(add2 x0 x1 x2)
(done))
(loop3 (+ i 1)))))))
(if (char=? c2 #\=)
(begin
(add1 x0 x1)
(done))
(loop2 (+ i 1)))))))
(if (char=? c1 #\=)
(err i '@e)
(loop1 (+ i 1)))))))
(if (char=? c0 #\=)
(err i '@f)
(loop0 (+ i 1)))))))))
(define u8vector->base64-string
(lambda (u8vect #!key (width 0) (padding? #t) (urlsafe? #f))
(subu8vector->base64-string u8vect 0 (u8vector-length u8vect) width: width padding?: padding? urlsafe?: urlsafe?)))
(define subu8vector->base64-string
(lambda (u8vect start end #!key (width 0) (padding? #t) (urlsafe? #f))
(define index-62-char (if urlsafe? #\- #\+))
(define index-63-char (if urlsafe? #\_ #\/))
(define chunk-len 64) ; must be a power of 2
(define state
(vector 0
(macro-make-fifo)))
(define (wr-char c)
(let ((ptr (vector-ref state 0)))
(vector-set! state 0 (+ ptr 1))
(let ((fifo (vector-ref state 1))
(i (bitwise-and ptr (- chunk-len 1))))
(string-set!
(if (= i 0)
(let ((chunk (make-string chunk-len)))
(macro-fifo-insert-at-tail! fifo chunk)
chunk)
(macro-fifo-elem (macro-fifo-tail fifo)))
i
c))))
(define (get-output-string)
(let ((ptr (vector-ref state 0))
(fifo (vector-ref state 1)))
(if (and (< 0 ptr) (<= ptr chunk-len))
(let ((str (macro-fifo-elem (macro-fifo-tail fifo))))
(string-shrink! str ptr)
str)
(fifo->string fifo 0 ptr))))
(define add
(lambda (c)
(wr-char c)))
(define out
(lambda (x n)
(let* ((add-char (cond ((<= x 25)
(integer->char (+ x (char->integer #\A))))
((<= x 51)
(integer->char (+ (- x 26) (char->integer #\a))))
((<= x 61)
(integer->char (+ (- x 52) (char->integer #\0))))
((= x 62)
index-62-char)
((= x 63)
index-63-char)
(else
(and padding? #\=))))
(new-n
(if (or add-char padding?) ; If we have a character to add, or if we don't have a character to add but we do have padding
; enabled, then count n down one. Otherwise, just return n unmodified.
(cond ((= -1 n)
n)
((= 0 n)
(add #\newline)
(- width 1))
(else
(- n 1)))
n)))
(if add-char (add add-char))
new-n)))
(let loop ((i start)
(n (if (> width 0) width -1)))
(if (<= (+ i 3) end)
(let ((b0 (u8vector-ref u8vect i))
(b1 (u8vector-ref u8vect (+ i 1)))
(b2 (u8vector-ref u8vect (+ i 2))))
(let ((x0
(arithmetic-shift b0 -2))
(x1
(bitwise-and #x3f
(+ (arithmetic-shift b0 4)
(arithmetic-shift b1 -4))))
(x2
(bitwise-and #x3f
(+ (arithmetic-shift b1 2)
(arithmetic-shift b2 -6))))
(x3
(bitwise-and #x3f b2)))
(loop (+ i 3)
(out x3 (out x2 (out x1 (out x0 n)))))))
(let ((rest (- end i)))
(cond ((= rest 2)
(let ((b0 (u8vector-ref u8vect i))
(b1 (u8vector-ref u8vect (+ i 1))))
(let ((x0
(arithmetic-shift b0 -2))
(x1
(bitwise-and #x3f
(+ (arithmetic-shift b0 4)
(arithmetic-shift b1 -4))))
(x2
(bitwise-and #x3f
(arithmetic-shift b1 2)))
(x3
64))
(out x3 (out x2 (out x1 (out x0 n)))))))
((= rest 1)
(let ((b0 (u8vector-ref u8vect i)))
(let ((x0
(arithmetic-shift b0 -2))
(x1
(bitwise-and #x3f
(arithmetic-shift b0 4)))
(x2
64)
(x3
64))
(out x3 (out x2 (out x1 (out x0 n))))))))
(get-output-string))))))
;;==============================================================================
| false |
9ad5b4a56213a299834354940be5b48b4f6468e6 | 4fd95c081ccef6afc8845c94fedbe19699b115b6 | /chapter_1/1.46.scm | 7ef68f7e7ff9adde80733298461183f2bb24ad86 | [
"MIT"
]
| permissive | ceoro9/sicp | 61ff130e655e705bafb39b4d336057bd3996195d | 7c0000f4ec4adc713f399dc12a0596c770bd2783 | refs/heads/master | 2020-05-03T09:41:04.531521 | 2019-08-08T12:14:35 | 2019-08-08T12:14:35 | 178,560,765 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 885 | scm | 1.46.scm | (define (iterative-improve is-good-enough? improve)
(define (cal-iter current-value)
(if (is-good-enough? current-value)
current-value
(cal-iter (improve current-value))))
(lambda (start-value) (cal-iter start-value)))
(define (average a b)
(/ (+ a b) 2.0))
(define (square x)
(* x x))
(define (sqrt x)
(define inflecity 0.0001)
(define (improve guess)
(average guess (/ x guess)))
(define (is-good-enough? guess)
(< (abs (- (square guess) x)) inflecity))
((iterative-improve is-good-enough? improve) 1))
(define (fixed-point f)
(define inflecity 0.0001)
(define (is-good-enough? guess)
(< (abs (- guess (f guess))) inflecity))
(define (improve x) (f x))
((iterative-improve is-good-enough? improve) 1))
(display (sqrt 36))
(newline)
(display (fixed-point cos))
| false |
5cadcc3e51e48d10921005deced0e17aed4cd7b6 | ee10242f047e9b4082a720c48abc7d94fe2b64a8 | /readline.sch | f716cfc6a3d28abee6e3906fbd0727e263be3534 | [
"Apache-2.0"
]
| permissive | netguy204/brianscheme | 168c20139c31d5e7494e55033c78f59741c81eb9 | 1b7d7b35485ffdec3b76113064191062e3874efa | refs/heads/master | 2021-01-19T08:43:43.682516 | 2012-07-21T18:30:39 | 2012-07-21T18:30:39 | 1,121,869 | 5 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 604 | sch | readline.sch | (require 'ffi)
(with-library (rl "libreadline")
(let ((ffi-readline (ffi:dlsym rl "readline"))
(ffi-add-history (ffi:dlsym rl "add_history")))
(define (readline prompt)
(let ((astr (ffi:funcall ffi-readline 'ffi-pointer prompt)))
(if (= (ffi:alien-to-int astr) 0)
""
(let ((str (ffi:alien-to-string astr)))
(ffi:funcall ffi-add-history 'ffi-void astr)
(ffi:free astr)
str))))))
(define (readline-repl)
"Provide a REPL with readline."
(display (eval (read-string (readline "bs+> "))))
(readline-repl))
| false |
24a10a45166c1a42da3e7e320b74e8856771ccae | 1ed47579ca9136f3f2b25bda1610c834ab12a386 | /sec4/q4.55.scm | d439480ad1354f0b2b0ab8a1eb8e7565ab4de420 | []
| no_license | thash/sicp | 7e89cf020e2bf5ca50543d10fa89eb1440f700fb | 3fc7a87d06eccbe4dcd634406e3b400d9405e9c4 | refs/heads/master | 2021-05-28T16:29:26.617617 | 2014-09-15T21:19:23 | 2014-09-15T21:19:23 | 3,238,591 | 0 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 1,148 | scm | q4.55.scm | ;; データベースから, 次の情報を検索する単純質問を示せ.
;; (a). Ben Bitdiddleに監督されているひとすべて
;; (b). 経理部門(accounting division) のすべての人の名前と担当
;; (c). Slumervilleに住む人すべての名前と住所
;;; answer ;;;
;; first, exec sec4.4-Logic-Programming.scm
;; (a). Ben Bitdiddleに監督されているひとすべて
;;; Query input:
(supervisor ?x (Bitdiddle Ben))
;;; Query results:
(supervisor (Tweakit Lem E) (Bitdiddle Ben))
(supervisor (Fect Cy D) (Bitdiddle Ben))
(supervisor (Hacker Alyssa P) (Bitdiddle Ben))
;; (b). 経理部門(accounting division) のすべての人の名前と担当
;;; Query input:
(job ?x (accounting . ?type))
;;; Query results:
(job (Cratchet Robert) (accounting scrivener))
(job (Scrooge Eben) (accounting chief accountant))
;; (c). Slumervilleに住む人すべての名前と住所
;;; Query input:
(address ?x (Slumerville . ?type))
;;; Query results:
(address (Aull DeWitt) (Slumerville (Onion Square) 5))
(address (Reasoner Louis) (Slumerville (Pine Tree Road) 80))
(address (Bitdiddle Ben) (Slumerville (Ridge Road) 10))
| false |
9784f8b12b3f4a43d92d212e1e8faee653eb213a | 6bd63be924173b3cf53a903f182e50a1150b60a8 | /chapter_2/2.17.scm | 8727357fb9be03c172f3dec9114c03905cfb81a7 | []
| no_license | lf2013/SICP-answer | d29ee3095f0d018de1d30507e66b12ff890907a5 | 2712b67edc6df8ccef3156f4ef08a2b58dcfdf81 | refs/heads/master | 2020-04-06T13:13:51.086818 | 2019-09-11T11:39:45 | 2019-09-11T11:39:45 | 8,695,137 | 0 | 1 | null | 2016-03-17T13:19:21 | 2013-03-11T02:24:41 | Scheme | UTF-8 | Scheme | false | false | 142 | scm | 2.17.scm | ; 2.17
(define (last-pair l)
(if (null? (cdr l))
l
(last-pair (cdr l))))
(define (try)
(last-pair (list 23 52 143 34)))
| false |
3a017a22615411a381d96d2064d28ae5cb9a5650 | defeada37d39bca09ef76f66f38683754c0a6aa0 | /UnityEngine/unity-engine/networking/host-topology-internal.sls | 2035bf299fd19e5a5058255fdd6712a3c38e62c4 | []
| 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 | 1,758 | sls | host-topology-internal.sls | (library (unity-engine networking host-topology-internal)
(export new
is?
host-topology-internal?
init-received-pool-size
dispose
init-wrapper
add-special-connection-config-wrapper
init-message-pool-size-growth-factor
init-sent-message-pool-size)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new
UnityEngine.Networking.HostTopologyInternal
a
...)))))
(define (is? a)
(clr-is UnityEngine.Networking.HostTopologyInternal a))
(define (host-topology-internal? a)
(clr-is UnityEngine.Networking.HostTopologyInternal a))
(define-method-port
init-received-pool-size
UnityEngine.Networking.HostTopologyInternal
InitReceivedPoolSize
(System.Void System.UInt16))
(define-method-port
dispose
UnityEngine.Networking.HostTopologyInternal
Dispose
(System.Void))
(define-method-port
init-wrapper
UnityEngine.Networking.HostTopologyInternal
InitWrapper
(System.Void
UnityEngine.Networking.ConnectionConfigInternal
System.Int32))
(define-method-port
add-special-connection-config-wrapper
UnityEngine.Networking.HostTopologyInternal
AddSpecialConnectionConfigWrapper
(System.Int32 UnityEngine.Networking.ConnectionConfigInternal))
(define-method-port
init-message-pool-size-growth-factor
UnityEngine.Networking.HostTopologyInternal
InitMessagePoolSizeGrowthFactor
(System.Void System.Single))
(define-method-port
init-sent-message-pool-size
UnityEngine.Networking.HostTopologyInternal
InitSentMessagePoolSize
(System.Void System.UInt16)))
| true |
1cff92947a8d646b7d80bbfd1d8f78dc7f33d348 | 84bd214ba2422524b8d7738fb82dd1b3e2951f73 | /chapter_1/exercises/1.07/newton_method_root.scm | b6aad7a88c48f483678d261e80b2ea0b854c1357 | []
| no_license | aequanimitas/sicp-redux | e5ef32529fa727de0353da973425a326e152c388 | 560b2bd40a12df245a8532de5d76b0bd2e033a64 | refs/heads/master | 2020-04-10T06:49:13.302600 | 2016-03-15T00:59:24 | 2016-03-15T00:59:24 | 21,434,389 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 668 | scm | newton_method_root.scm | (define (average x y)
(abs (/ (+ x y) 2.0)))
(define (better-approximation x y)
; x is the radicant
; y is the guess
(average y (/ x y)))
(define (newton-sqrt-find x guess previous-guess)
(if (approximation-threshold? guess previous-guess)
guess
(newton-sqrt-find x (better-approximation x guess) guess)))
(define (approximation-threshold? guess previous-guess)
; 0.001 is our threshold
; 'watch guess in each iteration until the difference between two guesses are smaller than the threshold value
(newline)
(display (- guess previous-guess))
(newline)
(< (abs (- guess previous-guess)) 0.001))
(newton-sqrt-find 9 1.0 0.0)
| false |
d5df2497ff1c051edd43c2829dd5c99dbe0cee0f | 382706a62fae6f24855ab689b8b2d87c6a059fb6 | /0.3/interpreter/src/types-records.scm | 3cfc0fb7ba5d783f955134fd1eba5f2fc7bee599 | [
"Apache-2.0"
]
| permissive | mstram/bard | ddb1e72a78059617403bea1842840bb9e979198e | 340d6919603a30c7944fb66e04df0562180bc0bb | refs/heads/master | 2021-01-21T00:12:27.174597 | 2014-07-10T13:20:39 | 2014-07-10T13:20:39 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,686 | scm | types-records.scm | ;;;; ***********************************************************************
;;;; FILE IDENTIFICATION
;;;;
;;;; Name: types-records.scm
;;;; Project: Bard
;;;; Purpose: representing Bard records
;;;; Author: mikel evins
;;;; Copyright: 2013 by mikel evins
;;;;
;;;; ***********************************************************************
;;; =====================================================================
;;; record schemas
;;; =====================================================================
(define tags:$bard-record (%next-bard-type-number))
(define tags:$bard-record-instance (%next-bard-type-number))
(define (%parse-record-slot-spec slot-spec)
(let* ((sname (car slot-spec))
(attrs (cdr slot-spec))
(default (getf default: attrs default: '()))
(type (getf type: attrs test: eq? default: Anything)))
`(,sname default: ,default type: ,type)))
(define (%parse-record-slot-specs slot-specs)
(map (lambda (spec)
(cond
((symbol? spec) `(,spec default: () type: ,Anything))
((pair? spec) (%parse-record-slot-spec spec))
(else: (error (str "Invalid record-slot specification: " spec)))))
slot-specs))
(define (make-record name slot-specs)
(let* ((tag tags:$bard-record)
(slot-templates (%parse-record-slot-specs slot-specs)))
(make-record-schema name tag slot-templates)))
;;; instance constructor
(define (initialize-record record-instance . initargs)
(let* ((inits (plist->alist initargs))
(initslots (map (lambda (slot)
(cons (string->symbol (keyword->string (car slot)))
(cdr slot)))
inits)))
(let ((slots (record-instance-slots record-instance)))
(for-each (lambda (init)
(let* ((sname (car init))
(val (cdr init))
(slot (alist-get slots sname test: eq?)))
(if slot
(set-cdr! slot val)
(error (str "No such slot: " sname)))))
initslots))
record-instance))
;;; TODO: slot templates contain type information.
;;; currently it's not used, but later
;;; we can enforce it
(define (%make-record-slot template)
(let* ((sname (car template))
(attrs (cdr template))
(val (getf default: attrs default: '())))
(cons sname val)))
(define (instantiate-record schema initargs)
(let* ((slot-templates (record-schema-slots schema))
(slots (map %make-record-slot slot-templates))
(instance (make-record-instance schema slots)))
(apply initialize-record instance initargs)))
;;; instance accessors
;;; TODO: add support for marking slots immutable
(define (record-ref record-instance slot-name #!key (default '()))
(alist-ref (record-instance-slots record-instance) slot-name default: default))
(define (record-set! record-instance slot-name val)
(alist-set! (record-instance-slots record-instance) slot-name val test: eq?))
(define (record-put record-instance slot-name val)
(let* ((slots (record-instance-slots record-instance))
(snames (map car slots))
(new-slots (alist-put (record-instance-slots record-instance) slot-name val test: eq?)))
(if (member slot-name snames)
;; we're putting an existing slot, so the result can be of the same record type
(make-record-instance (instance-schema record-instance) new-slots)
;; we're putting a new slot, so the result cannot be the same record tpye; we return a table instead
(%make-alist-table new-slots))))
| false |
be9cd7d5e3f77b1d8cba81c7d99ba5123aa523f2 | defeada37d39bca09ef76f66f38683754c0a6aa0 | /mscorlib/system/security/policy/policy-statement.sls | cd70390ec7fab9f6b095b690f181d8dbfc85efee | []
| 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 | 2,119 | sls | policy-statement.sls | (library (system security policy policy-statement)
(export new
is?
policy-statement?
get-hash-code
from-xml
to-xml
copy
equals?
permission-set-get
permission-set-set!
permission-set-update!
attributes-get
attributes-set!
attributes-update!
attribute-string)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new System.Security.Policy.PolicyStatement a ...)))))
(define (is? a) (clr-is System.Security.Policy.PolicyStatement a))
(define (policy-statement? a)
(clr-is System.Security.Policy.PolicyStatement a))
(define-method-port
get-hash-code
System.Security.Policy.PolicyStatement
GetHashCode
(System.Int32))
(define-method-port
from-xml
System.Security.Policy.PolicyStatement
FromXml
(System.Void
System.Security.SecurityElement
System.Security.Policy.PolicyLevel)
(System.Void System.Security.SecurityElement))
(define-method-port
to-xml
System.Security.Policy.PolicyStatement
ToXml
(System.Security.SecurityElement System.Security.Policy.PolicyLevel)
(System.Security.SecurityElement))
(define-method-port
copy
System.Security.Policy.PolicyStatement
Copy
(System.Security.Policy.PolicyStatement))
(define-method-port
equals?
System.Security.Policy.PolicyStatement
Equals
(System.Boolean System.Object))
(define-field-port
permission-set-get
permission-set-set!
permission-set-update!
(property:)
System.Security.Policy.PolicyStatement
PermissionSet
System.Security.PermissionSet)
(define-field-port
attributes-get
attributes-set!
attributes-update!
(property:)
System.Security.Policy.PolicyStatement
Attributes
System.Security.Policy.PolicyStatementAttribute)
(define-field-port
attribute-string
#f
#f
(property:)
System.Security.Policy.PolicyStatement
AttributeString
System.String))
| true |
87243d9ec59c876a6fdbe6bdbcc793b5ee0f9a53 | ac2a3544b88444eabf12b68a9bce08941cd62581 | /gsc/tests/14-keyword/str2key.scm | 536ae2d04c5aad5a84912fc1ff6f650a1093c65c | [
"Apache-2.0",
"LGPL-2.1-only"
]
| permissive | tomelam/gambit | 2fd664cf6ea68859d4549fdda62d31a25b2d6c6f | d60fdeb136b2ed89b75da5bfa8011aa334b29020 | refs/heads/master | 2020-11-27T06:39:26.718179 | 2019-12-15T16:56:31 | 2019-12-15T16:56:31 | 229,341,552 | 1 | 0 | Apache-2.0 | 2019-12-20T21:52:26 | 2019-12-20T21:52:26 | null | UTF-8 | Scheme | false | false | 343 | scm | str2key.scm | (declare (extended-bindings) (not constant-fold) (not safe))
(define k1 'hello:)
(define k2 '||:)
(define k3 '|a b c|:)
(define (test x)
(let ((k (##string->keyword x)))
(println k)
(println (##keyword? k))
(println (##eq? k k1))
(println (##eq? k k2))
(println (##eq? k k3))))
(test "hello")
(test "")
(test "a b c")
| false |
11fca0fb912004127216cb5803858d9c6b80f87f | fb6c8976daedad7dc2c5230c6927d6c2ee067b64 | /src/err.scm | d35c24999b3a38776dfcb32dbd3ded4a597206a6 | []
| no_license | Smirnoff/WireMap | e24e497325fb228ff5c91f0042855d92767515e6 | d523ab311a516f7ae950698f543a3fc9e22a1c92 | refs/heads/master | 2020-05-25T19:54:06.377565 | 2012-06-13T02:31:18 | 2012-06-13T02:31:18 | 4,343,379 | 0 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 154 | scm | err.scm |
(define (condition-message x)
(get-condition-property x 'exn 'message))
(define (condition-arguments x)
(get-condition-property x 'exn 'arguments))
| false |
bc860d5f676357574d1ffa48a926ab0fa0992f5c | a8216d80b80e4cb429086f0f9ac62f91e09498d3 | /lib/srfi/128/comparators.scm | ab5a282e753f075f825599f1dead20c085d4f43e | [
"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 | 7,980 | scm | comparators.scm |
(define-record-type Comparator
(%make-comparator% type-test equality ordering hash)
comparator?
(type-test comparator-type-test-predicate)
(equality comparator-equality-predicate)
(ordering comparator-ordering-predicate)
(hash comparator-hash-function))
(define (make-comparator type-test equality ordering hash)
(%make-comparator%
type-test
equality
ordering
(if (or (opcode? hash)
(not (procedure? hash))
(procedure-variadic? hash)
(> (procedure-arity hash) 1))
hash
(lambda (x . o) (hash x)))))
(define-syntax hash-bound
(er-macro-transformer
(lambda (expr rename compare)
(if (fixnum? (- (expt 2 62) 1))
(- (expt 2 62) 1)
(- (expt 2 30) 1)))))
(define-syntax hash-salt
(er-macro-transformer
(let ((salt (or (string->number
(or (get-environment-variable "CHIBI_HASH_SALT") ""))
(random-integer (hash-bound)))))
(lambda (expr rename compare)
salt))))
(define-syntax comparator-if<=>
(syntax-rules ()
((comparator-if<=> comparator obj1 obj2 less equal greater)
(let ((cmp comparator)
(o1 obj1)
(o2 obj2))
(cond
(((comparator-equality-predicate cmp) o1 o2) equal)
(((comparator-ordering-predicate cmp) o1 o2) less)
(else greater))))
((comparator-if<=> obj1 obj2 less equal greater)
(comparator-if<=> (make-default-comparator) obj1 obj2 less equal greater))))
(define (comparator-ordered? comparator)
(and (comparator-ordering-predicate comparator) #t))
(define (comparator-hashable? comparator)
(and (comparator-hash-function comparator) #t))
(define (comparator-test-type comparator obj)
((comparator-type-test-predicate comparator) obj))
(define (comparator-check-type comparator obj)
(or (comparator-test-type comparator obj)
(error "not an object of the comparator type" comparator obj)))
(define (comparator-hash comparator obj)
((comparator-hash-function comparator) obj))
(define default-comparators
(make-parameter '()))
(define (comparator-register-default! comparator)
(default-comparators (cons comparator (default-comparators))))
(define (make-pair-comparator car-comparator cdr-comparator)
(make-comparator
(lambda (x)
(and (pair? x)
((comparator-type-test-predicate car-comparator) (car x))
((comparator-type-test-predicate cdr-comparator) (cdr x))))
(lambda (x y)
(and ((comparator-equality-predicate car-comparator) (car x) (car y))
((comparator-equality-predicate cdr-comparator) (cdr x) (cdr y))))
(lambda (x y)
(if ((comparator-equality-predicate car-comparator) (car x) (car y))
((comparator-ordering-predicate cdr-comparator) (cdr x) (cdr y))
((comparator-ordering-predicate car-comparator) (car x) (car y))))
(lambda (x)
(bitwise-xor ((comparator-hash-function car-comparator) (car x))
((comparator-hash-function cdr-comparator) (cdr x))))))
(define (make-list-comparator element-comparator type-test empty? head tail)
(make-comparator
(lambda (x)
(and (type-test x)
(let lp ((ls x))
(or (empty? ls)
(and ((comparator-type-test-predicate element-comparator) (head ls))
(lp (tail ls)))))))
(lambda (x y)
(let lp ((ls1 x) (ls2 y))
(cond
((empty? ls1) (empty? ls2))
((empty? ls2) #f)
(else
(and ((comparator-equality-predicate element-comparator) (head ls1) (head ls2))
(lp (tail ls1) (tail ls2)))))))
(lambda (x y)
(let lp ((ls1 x) (ls2 y))
(cond
((empty? ls1) (not (empty? ls2)))
((empty? ls2) #f)
(else
(let ((a (head ls1)) (b (head ls2)))
(if ((comparator-equality-predicate element-comparator) a b)
(lp (tail ls1) (tail ls2))
((comparator-ordering-predicate element-comparator) a b)))))))
(lambda (x)
(let lp ((ls x) (acc 0))
(if (empty? ls)
acc
(lp (tail ls)
(bitwise-xor ((comparator-hash-function element-comparator) (head ls))
acc)))))
))
(define (make-vector-comparator element-comparator type-test length ref)
(make-comparator
(lambda (x)
(and (type-test x)
(let ((len (length x)))
(let lp ((i 0))
(or (>= i len)
(and ((comparator-type-test-predicate element-comparator) (ref x i))
(lp (+ i 1))))))))
(lambda (x y)
(let ((lenx (length x)) (leny (length y)))
(and
(= lenx leny)
(let lp ((i 0))
(or (>= i lenx)
(let ((a (ref x i)) (b (ref y i)))
(and ((comparator-equality-predicate element-comparator) a b)
(lp (+ i 1)))))))))
(lambda (x y)
(let ((lenx (length x)) (leny (length y)))
(cond
((< lenx leny) #t)
((> lenx leny) #f)
(else
(let lp ((i 0))
(and (< i lenx)
(let ((a (ref x i)) (b (ref y i)))
(if ((comparator-equality-predicate element-comparator) a b)
(lp (+ i 1))
((comparator-ordering-predicate element-comparator) a b)))))))))
(lambda (x)
(let ((len (length x)))
(let lp ((i 0) (acc 0))
(if (>= i len)
acc
(lp (+ i 1)
(bitwise-xor ((comparator-hash-function element-comparator) (ref x i))
acc))))))
))
(define (make-eq-comparator)
(make-comparator (lambda (x) #t) eq? object-cmp hash-by-identity))
(define (make-eqv-comparator)
(make-comparator (lambda (x) #t) eqv? object-cmp hash))
(define (make-equal-comparator)
(make-comparator (lambda (x) #t) equal? object-cmp hash))
(define boolean-hash hash)
(define char-hash hash)
(define (char-ci-hash ch)
(hash (char-foldcase ch)))
(define symbol-hash hash)
(define number-hash hash)
(define (default-hash x . o)
(if (string? x) (string-hash x) (hash x)))
(define default-comparator
(make-comparator
(lambda (x) #t)
(lambda (x y)
(let lp ((ls (default-comparators)))
(cond ((null? ls)
(if (number? x)
(and (number? y) (= x y))
(equal? x y)))
((and (comparator-test-type (car ls) x)
(comparator-test-type (car ls) y))
((comparator-equality-predicate (car ls)) x y))
(else
(lp (cdr ls))))))
(lambda (x y)
(let lp ((ls (default-comparators)))
(cond ((null? ls)
(negative? (object-cmp x y)))
((and (comparator-test-type (car ls) x)
(comparator-test-type (car ls) y))
((comparator-ordering-predicate (car ls)) x y))
(else
(lp (cdr ls))))))
default-hash))
(define (make-default-comparator)
default-comparator)
(define (=? comparator o1 o2 . o)
(let ((eq (comparator-equality-predicate comparator)))
(and (eq o1 o2)
(let lp ((ls o))
(or (null? ls)
(and (eq o1 (car ls))
(lp (cdr ls))))))))
(define (<? comparator o1 o2 . o)
(let ((less (comparator-ordering-predicate comparator)))
(and (less o1 o2)
(let lp ((prev o2) (ls o))
(or (null? ls)
(and (less prev (car ls))
(lp (car ls) (cdr ls))))))))
(define (<=? comparator o1 o2 . o)
(let ((less (comparator-ordering-predicate comparator)))
(and (not (less o2 o1))
(let lp ((prev o2) (ls o))
(or (null? ls)
(and (not (less (car ls) prev))
(lp (car ls) (cdr ls))))))))
(define (>? comparator . o)
(apply <? comparator (reverse o)))
(define (>=? comparator . o)
(apply <=? comparator (reverse o)))
| true |
e2daeb280d4da009e93b367fa4dc921cf74f807d | 53d4e640e1f666f3005653e7b4ab8a26fa3bd2fc | /guix/systems/syst-geek.scm | e4b41b17d9313b10fd3663f50e7cddd19bb126f9 | []
| no_license | Bost/dotfiles | fe64c8c032658306b5ff1815e50c3d39d6246274 | c5f2a8d465d203e98a45b41fb9dc02b54e591471 | refs/heads/master | 2023-08-29T06:55:49.676142 | 2023-08-10T09:29:26 | 2023-08-10T11:22:27 | 5,963,855 | 4 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 6,208 | scm | syst-geek.scm | #|
## Initially:
## 1. From another host:
scp ~/.config/guix/channels.scm geek:~/.config/guix/
cd $dev/dotfiles/guix/systems && scp signing-key.pub geek.scm geek:/tmp
## 2. From the geek machine:
chmod +rw ~/.config/guix/channels.scm
vi ~/.config/guix/channels.scm # remove all other channels except 'nonguix'
guix pull
sudo guix system --fallback reconfigure geek.scm
## Run this file by (the `~' doesn't work as a value of --load-path):
# --fallback fall back to building when the substituter fails
# -L --load-path
sudo guix system --fallback -L $dotf/guix/systems reconfigure $dotf/guix/systems/geek.scm
|#
(define-module (syst-geek)
#:use-module (settings)
#:use-module (utils) ; for partial
#:use-module (memo)
#:use-module (gnu)
#:use-module (gnu system shadow) ; for user-group; user-account-shell
#:use-module (nongnu packages linux)
#:use-module (nongnu system linux-initrd)
#:use-module (guix) ; for package-version
#:export (
syst-config
))
;; no need to write: #:use-module (gnu services <module>)
(use-service-modules cups desktop networking ssh xorg)
;; no need to write: #:use-module (gnu packages <module>)
(use-package-modules
android ; android-udev-rules - access smartphone via mtp://
bash
libusb ; libmtp
shells ; login shell
)
(define m (module-name-for-logging))
;; (format #t "~a evaluating module ...\n" m)
(define syst-config
(operating-system
(kernel linux)
(initrd microcode-initrd)
(firmware (list linux-firmware))
(locale "en_US.utf8")
(timezone "Europe/Berlin")
(keyboard-layout ; keyboard-layout for the console
(keyboard-layout
"us,de,sk,fr" "altgr-intl,,qwerty,"
#:options '("compose:menu,grp:ctrls_toggle")))
(host-name host-geek)
;; The list of user accounts ('root' is implicit).
(users (cons*
(user-account
(name "bost")
(comment
(begin
;; (format #t "~a user-full-name: ~a\n" m user-full-name)
user-full-name))
(group "users")
(home-directory "/home/bost")
;; list of group names that this user-account belongs to
(supplementary-groups
;; grant access to:
'("wheel" #| sudo etc.; See polkit-wheel-service for administrative tasks for non-root users |#
"netdev" #| network devices |#
"audio" #| sound card |#
"video" #| video devices, e.g. webcams |#
"lp" #| control bluetooth devices |#
;; "kvm"
;; "tty"
;; "input"
;; "docker"
;; "realtime" #| Enable realtime scheduling |#
)))
%base-user-accounts))
;;; Packages installed system-wide. Users can also install packages under their
;;; own account: use 'guix search KEYWORD' to search for packages and 'guix
;;; install PACKAGE' to install a package.
(packages
(append
(map specification->package
(list
"brightnessctl" #| backlight and LED brightness control |#
"git"
;; "gparted" #| disk partition |#
"nss-certs" #| HTTPS access |#
;; "rsync" #| 'scp' is preinstalled |#
;; "vim" #| 'vi' is preinstalled |#
))
%base-packages))
;;; Below is the list of system services. To search for available services, run
;;; 'guix system search KEYWORD' in a terminal.
(services
(append (list
(service xfce-desktop-service-type)
;; ntp-service-type for system clock sync is in the
;; %desktop-services by default
;; To configure OpenSSH, pass an 'openssh-configuration'
;; record as a second argument to 'service' below.
(service openssh-service-type)
(set-xorg-configuration
(xorg-configuration (keyboard-layout keyboard-layout)))
(udev-rules-service 'mtp libmtp) ;; mtp - Media Transfer Protocol
(udev-rules-service 'android android-udev-rules
#:groups '("adbusers")))
;; This is the default list of services we are appending to.
(modify-services %desktop-services
(guix-service-type
config => (guix-configuration
(inherit config)
(substitute-urls
(append (list "https://substitutes.nonguix.org")
%default-substitute-urls))
(authorized-keys
;;; The signing-key.pub should be obtained by
;;; wget https://substitutes.nonguix.org/signing-key.pub
(append (list (local-file "./signing-key.pub"))
%default-authorized-guix-keys)))))))
(bootloader
(bootloader-configuration
(bootloader grub-efi-bootloader)
(targets (list "/boot/efi"))
(keyboard-layout keyboard-layout)))
(mapped-devices (list (mapped-device
(source (uuid
"fe8beac5-240d-4850-b67c-347b8cf4dc7e"))
(target "encrypted")
(type luks-device-mapping))))
;; The list of file systems that get "mounted". The unique
;; file system identifiers there ("UUIDs") can be obtained
;; by running 'blkid' in a terminal.
(file-systems (cons* (file-system
(mount-point "/")
(device "/dev/mapper/encrypted")
(type "ext4")
(dependencies mapped-devices))
(file-system
(mount-point "/boot/efi")
(device (uuid "FC73-7111"
'fat32))
(type "vfat")) %base-file-systems))))
;; (format #t "~a module evaluated\n" m)
;; operating-system (or image) must be returned
syst-config
| false |
afa92be542dc6eeb44a96b040409a7c58604447d | ae4938300d7eea07cbcb32ea4a7b0ead9ac18e82 | /parser/parser.sls | 6b517211ff297a3f42e590ec8764a2e058a20a2f | []
| no_license | keenbug/imi-libs | 05eb294190be6f612d5020d510e194392e268421 | b78a238f03f31e10420ea27c3ea67c077ea951bc | refs/heads/master | 2021-01-01T19:19:45.036035 | 2012-03-04T21:46:28 | 2012-03-04T21:46:28 | 1,900,111 | 0 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 10,678 | sls | parser.sls | #!r6rs
(import (rnrs)
(match)
(srfi :64)
(imi io string)
(imi parser lexer)
(only (imi parser lexer-syntax) lexer))
(define (rule-tester rule)
(elim-newline)
(let ([input (get-line (current-input-port))])
(with-input-from-string
input
(lambda ()
(parse rule)))))
(define (elim-newline)
(when (char=? #\newline (peek-char))
(read-char)
(elim-newline)))
(define (readfile file)
(with-input-from-file
file
(lambda ()
(let loop ()
(if (eof-object? (peek-char))
(list (lex lex-sexpr))
(cons (lex lex-sexpr)
(loop)))))))
(define (stdreadfile file)
(with-input-from-file file read))
(define (readfile* file)
(with-input-from-file
file
read-sexpr
#;
(lambda ()
(let loop ()
(if (eof-object? (peek-char))
(list (read-sexpr))
(cons (read-sexpr)
(loop)))))))
(define (mute . sth) '())
(define (test* . files)
(time (map readfile* files)))
(define (stdtest . files)
(time (map stdreadfile files)))
(define read-sexpr
(lexer parse-all
(delimiter
list-begin
list-end
string-delim
special-begin
comment-begin
whitespace
%eof)
(parse-all
%eof
#(parse-main parse-all))
(parse-main
#(`whitespace 'elim-whitespace parse-main)
',@(comment 'simple-comment)
special
quotation-form
,@(list list)
,@(string string)
,@(number number)
,@(symbol symbol)
%eof
)
(whitespace
#\space #\newline #\tab)
(elim-whitespace
#(whitespace elim-whitespace)
#())
(comment-begin . #\;)
(comment-end #\newline %eof)
(simple-comment
#(comment-begin 'simple-comment-main))
(simple-comment-main
'comment-end
#(%any 'simple-comment-main))
(block-comment
#(#\# block-comment-inner block-comment)
#(#\| block-comment-end)
#(%any block-comment))
(block-comment-inner
#(#\| block-comment)
#(%any))
(block-comment-end
#(#\#)
#(%any block-comment))
(special-begin . #\#)
(special
#('special-begin special-main))
(special-main
;#('comment-begin ,@(comment parse-main))
'#('comment-begin ,@(comment 'parse-main))
#('char-begin ,@(char char))
,@(vector list)
'#(#\! ,@(reader-special symbol))
;#(#\| ,@(block-comment block-comment))
'#('#\| ,@(comment 'block-comment))
,@(boolean boolean)
,@(syntax quotation-form)
(%error special "invalid special" %any))
(boolean
(#\t `delimiter)
(#\f `delimiter))
(char-begin . #\\)
(char delimiter symbol)
(digit #\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
(number-special #\. #\+ #\-)
(number
number-sign
number-main)
(number-main
#(#\. number-comma)
#(digit number-main)
`delimiter
(%error 'read-number "invalid character in number" %any))
(number-comma
#(digit number-comma)
`delimiter
(%error 'read-number "invalid character in number" %any))
(symbol-plus ,@(plus `delimiter))
(symbol-minus ,@(minus `delimiter))
(number-sign
#(#\+ (symbol-plus number-main))
#(#\- (symbol-minus number-main)))
(quotation-form
#('#\' ,@(quote parse-main))
#('#\` ,@(quasiquote parse-main))
#('#\, unquote-form))
(unquote-form
#('#\@ ,@(unquote-splicing parse-main))
,@(unquote parse-main))
(list-begin #\( #\[)
(list-end #\) #\])
(list
#('list-begin 'elim-whitespace list-main))
(list-main
#('list-end)
#(%eof (%error parse-list "eof while reading list"))
#(dot 'elim-whitespace list-main)
#(parse-main 'elim-whitespace list-main))
(dot
,@(dot dot-main0))
(dot-main0
#(#\. (`delimiter dot-elipsis)))
(dot-elipsis
#(#\. dot-elipsis-end)
(%error 'elipsis "invalid character in elipsis" %any))
(dot-elipsis-end
#(#\. (`delimiter
(%error 'elipsis "invalid character after elipsis" %any)))
#(`delimiter (%error 'elipsis "unexpected end of elipsis" %any))
(%error 'elipsis "invalid character in elipsis" %any))
(string-delim . #\")
(string-escape . #\\)
(string
#('string-delim string-main))
(string-main
#(string-escape string-main-escape)
#('string-delim)
#(%eof (%error parse-string "eof while reading string"))
#(%any string-main))
(string-main-escape
#(%any string-main))
(symbol-delim . #\|)
(symbol
#('symbol-delim symbol-special)
#((%not delimiter) symbol-main))
(symbol-main
`delimiter
#(%any symbol-main))
(symbol-special
'symbol-delim
#(%eof (%error parse-symbol "eof while reading escaped symbol"))
#(%any symbol-special))
)
)
(define lex-sexpr
'(parse-main
(whitespace
#\space #\newline #\tab)
(comment-begin . #\;)
(special-begin . #\#)
(char-begin . #\\)
(symbol-delim . #\|)
(string-delim . #\")
(string-escape . #\\)
(list-begin . #\()
(list-end . #\))
(delimiter
list-begin
list-end
string-delim
special-begin
comment-begin
whitespace
%eof)
(parse-main
#('whitespace parse-main)
,@(comment elim-comment)
,@(special special)
quotation-form
,@(list list)
,@(string string)
,@(symbol symbol)
%eof
)
(elim-whitespace
#(whitespace elim-whitespace)
#())
(elim-comment
#(comment-begin elim-comment-main))
(elim-comment-main
'(#\newline %eof)
#(%any elim-comment-main))
(special
#('special-begin special-main))
(special-main
#('comment-begin ,@(comment parse-main))
#('char-begin ,@(char char))
,@(vector list)
#(#\! ,@(reader-special symbol))
,@(boolean boolean)
)
(boolean
(#\t `delimiter)
(#\f `delimiter))
(char
delimiter
symbol)
(quotation-form
#('#\' ,@(quote parse-main))
#('#\` ,@(quasiquote parse-main))
#('#\, unquote-form))
(unquote-form
#('#\@ ,@(unquote-splicing parse-main))
,@(unquote parse-main))
(list
#('list-begin 'elim-whitespace list-main))
(list-main
#('list-end)
#(%eof (%error parse-list "eof while reading list"))
#(dot 'elim-whitespace list-main)
#(parse-main 'elim-whitespace list-main))
(dot
,@(dot dot-main0))
(dot-main0
#(#\. (`delimiter dot-elipsis)))
(dot-elipsis
#(#\. dot-elipsis-end)
(%error 'elipsis "invalid character in elipsis" %any))
(dot-elipsis-end
#(#\. (`delimiter
(%error 'elipsis "invalid character after elipsis" %any)))
#(`delimiter (%error 'elipsis "unexpected end of elipsis" %any))
(%error 'elipsis "invalid character in elipsis" %any))
(string
#('string-delim string-main))
(string-main
#(string-escape string-main-escape)
#('string-delim)
#(%eof (%error parse-string "eof while reading string"))
#(%any string-main))
(string-main-escape
#(%any string-main))
(symbol
#('symbol-delim symbol-special)
#((%not delimiter) symbol-main))
(symbol-main
`delimiter
#(%any symbol-main))
(symbol-special
'symbol-delim
#(%eof (%error parse-symbol "eof while reading escaped symbol"))
#(%any symbol-special))
))
(define lex-comment
'(#('elim-whitespace ,@simple-comment)
(whitespace
#\space #\newline #\tab)
(simple-comment-begin . #\;)
(simple-comment-end #\newline %eof)
(simple-comment
#(simple-comment-begin simple-comment-main))
(simple-comment-main
'simple-comment-end
#(%any simple-comment-main))
(elim-whitespace
#(whitespace elim-whitespace)
#())
))
(define (test-rule rule str)
(with-input-from-string
str
(lambda ()
(lex rule))))
(define (res-stringify res)
(cond
[(position? res)
(match res
[(,name ,start ,end ,cont)
(list name start end (res-stringify cont))]
[(,start ,end ,cont)
(list start end (res-stringify cont))]
[,invalid
(error 'res-stringify
"unknown position form"
invalid)])]
[(list? res)
(if (for-all char? res)
(list->string res)
(map res-stringify res))]
[(char? res)
(string res)]
[(eof-object? res) res]
[else (error 'res-stringify
"invalid result"
res)]))
(define (test-rule* rule str)
(res-stringify (test-rule rule str)))
(test-begin "lexer")
(test-equal 'char "a" (test-rule* '(#\a) "acbkvaje"))
(test-equal 'bare-char "d" (test-rule* '(#\d) "d"))
(test-equal 'any "l" (test-rule* '(%any) "lasd"))
(test-equal 'list0 "r" (test-rule* '((#\r #\x #\y)) "r"))
(test-equal 'list1 "x" (test-rule* '((#\r #\x #\y)) "x"))
(test-equal 'list2 "y" (test-rule* '((#\r #\x #\y)) "y"))
(test-equal 'list-in-list "a" (test-rule* '(((#\r #\a) #\x #\y)) "a"))
(test-equal 'eof (eof-object) (test-rule* '(%eof) ""))
(test-equal 'empty-vector "" (test-rule* '(#()) "asd"))
(test-equal 'bare-empty-vector "" (test-rule* '(#()) ""))
(test-equal 'vector "abc" (test-rule* '(#(#\a #\b #\c)) "abcd"))
(let ([lex-elim-space '(elim-space
(elim-space
#(#\space elim-space)
#()))])
(test-equal 'symbol-elim-space " " (test-rule* lex-elim-space " abc"))
(test-equal 'symbol-elim-space-bare " " (test-rule* lex-elim-space " "))
(test-equal 'symbol-elim-space-none "" (test-rule* lex-elim-space "a"))
)
(test-end "lexer")
| false |
a61c867e2afa1781e1f35153fd92ef0a704c2b14 | a09ad3e3cf64bc87282dea3902770afac90568a7 | /1/44.scm | ca7252551869f72a764f6d8a0a9afd4d2acfc3b7 | []
| no_license | lockie/sicp-exercises | aae07378034505bf2e825c96c56cf8eb2d8a06ae | 011b37387fddb02e59e05a70fa3946335a0b5b1d | refs/heads/master | 2021-01-01T10:35:59.759525 | 2018-11-30T09:35:35 | 2018-11-30T09:35:35 | 35,365,351 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 354 | scm | 44.scm | #lang sicp
(define dx 0.00001)
(define (smooth f)
(lambda (x) (/ (+ (f (- x dx)) (f x) (f (+ x dx))) 3)))
(define (repeated f n)
(define (compose f g)
(lambda (x) (f (g x))))
(cond ((= n 1) f)
(else (compose f (repeated f (- n 1))))))
(define (square x) (* x x))
((smooth square) 2)
(((repeated smooth 10) square) 2)
| false |
e1a4c4d03752bfd574a4b4838166683e207457fb | 3c9983e012653583841b51ddfd82879fe82706fb | /experiments/transactions/old-splay.scm | 8ce752e358ba8136a37fcb17ef7c0137ef121cf4 | []
| no_license | spdegabrielle/smalltalk-tng | 3c3d4cffa09541b75524fb1f102c7c543a84a807 | 545343190f556edd659f6050b98036266a270763 | refs/heads/master | 2020-04-16T17:06:51.884611 | 2018-08-07T16:18:20 | 2018-08-07T16:18:20 | 165,763,183 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,395 | scm | old-splay.scm | ;; Splay tree partitioning, from Okasaki's book:
(define (splay-tree-partition cmp-pivot t k)
(let walk ((t t)
(k k))
(if (null? t)
(k '() '())
(let ((element (bst-node-element t))
(left (bst-node-left t))
(right (bst-node-right t)))
(if (negative? (cmp-pivot element))
(if (null? left)
(k '() t)
(let ((le (bst-node-element left))
(ll (bst-node-left left))
(lr (bst-node-right left)))
(if (negative? (cmp-pivot le))
(walk ll (lambda (small big)
(k small
(make-bst-node le big (make-bst-node element lr right)))))
(walk lr (lambda (small big)
(k (make-bst-node le ll small)
(make-bst-node element big right)))))))
(if (null? right)
(k t '())
(let ((re (bst-node-element right))
(rl (bst-node-left right))
(rr (bst-node-right right)))
(if (negative? (cmp-pivot re))
(walk rl (lambda (small big)
(k (make-bst-node element left small)
(make-bst-node re big rr))))
(walk rr (lambda (small big)
(k (make-bst-node re (make-bst-node element left rl) small)
big)))))))))))
(define (splay-tree-insert cmp t x)
(splay-tree-partition (binary-curry cmp x)
t
(lambda (smaller bigger)
(make-bst-node x smaller bigger))))
(define (splay-tree-find predcmp t)
(splay-tree-partition predcmp
t
(lambda (smaller bigger)
(
| false |
d5f693c05dc82212dbe6a55b6760fcb5e1bbc9ae | 665da87f9fefd8678b0635e31df3f3ff28a1d48c | /tests/benchmarks/lattice-csc-cps.scm | e1db128b0f9f6e62d824815f43197f669340fce5 | [
"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 | 304,250 | scm | lattice-csc-cps.scm | [cps]
(lambda (k598)
(let ((k599 (##core#lambda
(r600)
(let ((t326 r600))
(let ((k602 (##core#lambda
(r603)
(let ((t327 r603))
(let ((k605 (##core#lambda
(r606)
(let ((t328 r606))
(let ((k608 (##core#lambda
(r609)
(let ((t329 r609))
(let ((k611 (##core#lambda
(r612)
(let ((t15 r612))
(let ((t16 (##core#undefined)))
(let ((t330 (##core#undefined)))
(let ((t614 (set! flush-output-port #f flush-output)))
(let ((t331 t614))
(let ((t615 (set! current-jiffy #f current-milliseconds)))
(let ((t332 t615))
(let ((t616 (set! jiffies-per-second
#f
(lambda (k618) (k618 1000)))))
(let ((t333 t616))
(let ((t619 (set! current-second #f current-seconds)))
(let ((t334 t619))
(let ((t620 (set! inexact #f exact->inexact)))
(let ((t335 t620))
(let ((t621 (set! exact #f inexact->exact)))
(let ((t336 t621))
(let ((t622 (set! square
#f
(lambda (k624 x61)
(let ((k625 (##core#lambda (r626) (k624 r626))))
(* k625 x61 x61))))))
(let ((t337 t622))
(let ((t628 (set! exact-integer? #f integer?)))
(let ((t338 t628))
(let ((t629 (set! this-scheme-implementation-name
#f
(lambda (k631)
(let ((k632 (##core#lambda (r633) (k631 r633))))
(let ((k636 (##core#lambda
(r637)
(let ((a635 r637))
(string-append k632 "chicken-" a635)))))
(chicken-version k636)))))))
(let ((t339 t629))
(let ((t639 (set! lexico
#f
(lambda (k641 base66)
(let ((lex-fixed67 (##core#undefined)))
(let ((lex-first68 (##core#undefined)))
(let ((t642 (set! lex-fixed67
#f
(lambda (k644 fixed69 lhs70 rhs71)
(let ((check72 (##core#undefined)))
(let ((t645 (set! check72
#f
(lambda (k647 lhs73 rhs74)
(let ((k648 (##core#lambda (r649) (k647 r649))))
(let ((k651 (##core#lambda
(r652)
(if r652
(k648 fixed69)
(let ((k654 (##core#lambda
(r655)
(let ((probe75 r655))
(let ((k657 (##core#lambda (r658) (k648 r658))))
(let ((k660 (##core#lambda
(r661)
(let ((tmp7678 r661))
(let ((k663 (##core#lambda
(r664)
(if r664
(let ((k666 (##core#lambda (r667) (k657 r667))))
(let ((k670 (##core#lambda
(r671)
(let ((a669 r671))
(let ((k674 (##core#lambda
(r675)
(let ((a673 r675)) (check72 k666 a669 a673)))))
(cdr k674 rhs74))))))
(cdr k670 lhs73)))
(k657 'uncomparable)))))
(if tmp7678
(k663 tmp7678)
(let ((k677 (##core#lambda (r678) (k663 r678))))
(eq? k677 probe75 fixed69))))))))
(eq? k660 probe75 'equal)))))))
(let ((k681 (##core#lambda
(r682)
(let ((a680 r682))
(let ((k685 (##core#lambda
(r686)
(let ((a684 r686)) (base66 k654 a680 a684)))))
(car k685 rhs74))))))
(car k681 lhs73)))))))
(null? k651 lhs73)))))))
(let ((t79 t645))
(let ((k688 (##core#lambda (r689) (k644 r689))))
(check72 k688 lhs70 rhs71)))))))))
(let ((t92 t642))
(let ((t691 (set! lex-first68
#f
(lambda (k693 lhs80 rhs81)
(let ((k694 (##core#lambda (r695) (k693 r695))))
(let ((k697 (##core#lambda
(r698)
(if r698
(k694 'equal)
(let ((k700 (##core#lambda
(r701)
(let ((probe82 r701))
(let ((tmp8388 probe82))
(let ((k703 (##core#lambda (r704) (k694 r704))))
(let ((k706 (##core#lambda
(r707)
(let ((tmp8991 r707))
(let ((k709 (##core#lambda
(r710)
(if r710
(let ((k712 (##core#lambda (r713) (k703 r713))))
(let ((k716 (##core#lambda
(r717)
(let ((a715 r717))
(let ((k720 (##core#lambda
(r721)
(let ((a719 r721))
(lex-fixed67 k712 probe82 a715 a719)))))
(cdr k720 rhs81))))))
(cdr k716 lhs80)))
(let ((k723 (##core#lambda (r724) (k703 r724))))
(let ((k726 (##core#lambda
(r727)
(if r727
(let ((k729 (##core#lambda (r730) (k723 r730))))
(let ((k733 (##core#lambda
(r734)
(let ((a732 r734))
(let ((k737 (##core#lambda
(r738)
(let ((a736 r738)) (lex-first68 k729 a732 a736)))))
(cdr k737 rhs81))))))
(cdr k733 lhs80)))
(let ((k740 (##core#lambda (r741) (k723 r741))))
(let ((k743 (##core#lambda
(r744)
(if r744
(k740 'uncomparable)
(k740 (##core#undefined))))))
(eqv? k743 tmp8388 'uncomparable)))))))
(eqv? k726 tmp8388 'equal)))))))
(if tmp8991
(k709 tmp8991)
(let ((k746 (##core#lambda (r747) (k709 r747))))
(eqv? k746 tmp8388 'more))))))))
(eqv? k706 tmp8388 'less))))))))
(let ((k750 (##core#lambda
(r751)
(let ((a749 r751))
(let ((k754 (##core#lambda
(r755)
(let ((a753 r755)) (base66 k700 a749 a753)))))
(car k754 rhs81))))))
(car k750 lhs80)))))))
(null? k697 lhs80)))))))
(let ((t93 t691)) (k641 lex-first68)))))))))))
(let ((t340 t639))
(let ((t757 (set! make-lattice
#f
(lambda (k759 elem-list95 cmp-func96)
(let ((k760 (##core#lambda (r761) (k759 r761))))
(cons k760 elem-list95 cmp-func96))))))
(let ((t341 t757))
(let ((t763 (set! lattice->elements #f car)))
(let ((t342 t763))
(let ((t764 (set! lattice->cmp #f cdr)))
(let ((t343 t764))
(let ((t765 (set! zulu-select
#f
(lambda (k767 test100 lst101)
(let ((select-a102 (##core#undefined)))
(let ((t768 (set! select-a102
#f
(lambda (k770 ac103 lst104)
(let ((k771 (##core#lambda (r772) (k770 r772))))
(let ((k774 (##core#lambda
(r775)
(if r775
(let ((k777 (##core#lambda (r778) (k771 r778))))
(xreverse! k777 ac103))
(let ((k780 (##core#lambda (r781) (k771 r781))))
(let ((k784 (##core#lambda
(r785)
(let ((head105 r785))
(let ((k787 (##core#lambda
(r788)
(let ((a783 r788))
(let ((k791 (##core#lambda
(r792)
(let ((a790 r792)) (select-a102 k780 a783 a790)))))
(cdr k791 lst104))))))
(let ((k794 (##core#lambda
(r795)
(if r795
(let ((k797 (##core#lambda (r798) (k787 r798))))
(cons k797 head105 ac103))
(k787 ac103)))))
(test100 k794 head105)))))))
(car k784 lst104)))))))
(null? k774 lst104)))))))
(let ((t106 t768))
(let ((k800 (##core#lambda (r801) (k767 r801))))
(select-a102 k800 '() lst101)))))))))
(let ((t344 t765))
(let ((rotate109 (##core#undefined)))
(let ((rotate108110
(lambda (k805 fo111 fum112)
(let ((k806 (##core#lambda
(r807)
(let ((next113 r807))
(let ((k809 (##core#lambda
(r810)
(let ((t114 r810))
(let ((k812 (##core#lambda (r813) (k805 r813))))
(let ((k815 (##core#lambda
(r816)
(if r816
(k812 fo111)
(let ((k818 (##core#lambda (r819) (k812 r819))))
(rotate109 k818 next113 fo111))))))
(null? k815 next113)))))))
(set-cdr! k809 fo111 fum112))))))
(cdr k806 fo111)))))
(let ((t821 (set! rotate109 #f rotate108110)))
(let ((t116 t821))
(let ((t803 (set! xreverse!
#f
(lambda (k823 lst115)
(let ((k824 (##core#lambda (r825) (k823 r825))))
(let ((k827 (##core#lambda
(r828)
(if r828
(k824 '())
(let ((k830 (##core#lambda (r831) (k824 r831))))
(rotate109 k830 lst115 '()))))))
(null? k827 lst115)))))))
(let ((t345 t803))
(let ((t833 (set! select-map
#f
(lambda (k835 test118 func119 lst120)
(let ((select-a121 (##core#undefined)))
(let ((t836 (set! select-a121
#f
(lambda (k838 ac122 lst123)
(let ((k839 (##core#lambda (r840) (k838 r840))))
(let ((k842 (##core#lambda
(r843)
(if r843
(let ((k845 (##core#lambda (r846) (k839 r846))))
(xreverse! k845 ac122))
(let ((k848 (##core#lambda (r849) (k839 r849))))
(let ((k852 (##core#lambda
(r853)
(let ((head124 r853))
(let ((k855 (##core#lambda
(r856)
(let ((a851 r856))
(let ((k859 (##core#lambda
(r860)
(let ((a858 r860)) (select-a121 k848 a851 a858)))))
(cdr k859 lst123))))))
(let ((k862 (##core#lambda
(r863)
(if r863
(let ((k865 (##core#lambda (r866) (k855 r866))))
(let ((k869 (##core#lambda
(r870)
(let ((a868 r870)) (cons k865 a868 ac122)))))
(func119 k869 head124)))
(k855 ac122)))))
(test118 k862 head124)))))))
(car k852 lst123)))))))
(null? k842 lst123)))))))
(let ((t125 t836))
(let ((k872 (##core#lambda (r873) (k835 r873))))
(select-a121 k872 '() lst120)))))))))
(let ((t346 t833))
(let ((t875 (set! map-and
#f
(lambda (k877 proc127 lst128)
(let ((k878 (##core#lambda (r879) (k877 r879))))
(let ((k881 (##core#lambda
(r882)
(if r882
(k878 #t)
(let ((drudge130 (##core#undefined)))
(let ((drudge129131
(lambda (k885 lst132)
(let ((k886 (##core#lambda
(r887)
(let ((rest133 r887))
(let ((k889 (##core#lambda (r890) (k885 r890))))
(let ((k892 (##core#lambda
(r893)
(if r893
(let ((k895 (##core#lambda (r896) (k889 r896))))
(let ((k899 (##core#lambda
(r900)
(let ((a898 r900)) (proc127 k895 a898)))))
(car k899 lst132)))
(let ((k902 (##core#lambda (r903) (k889 r903))))
(let ((k905 (##core#lambda
(r906)
(if r906
(let ((k908 (##core#lambda (r909) (k902 r909))))
(drudge130 k908 rest133))
(k902 #f)))))
(let ((k912 (##core#lambda
(r913)
(let ((a911 r913)) (proc127 k905 a911)))))
(car k912 lst132))))))))
(null? k892 rest133)))))))
(cdr k886 lst132)))))
(let ((t915 (set! drudge130 #f drudge129131)))
(let ((t135 t915))
(let ((k916 (##core#lambda (r917) (k878 r917))))
(drudge130 k916 lst128))))))))))
(null? k881 lst128)))))))
(let ((t347 t875))
(let ((t919 (set! maps-1
#f
(lambda (k921 source137 target138 pas139 new140)
(let ((k922 (##core#lambda
(r923)
(let ((scmp141 r923))
(let ((k925 (##core#lambda
(r926)
(let ((tcmp142 r926))
(let ((k928 (##core#lambda
(r929)
(let ((less143 r929))
(let ((k931 (##core#lambda
(r932)
(let ((more144 r932))
(let ((k934 (##core#lambda (r935) (k921 r935))))
(let ((a937 (lambda (k939 t147)
(let ((k940 (##core#lambda (r941) (k939 r941))))
(let ((k943 (##core#lambda
(r944)
(if r944
(let ((k946 (##core#lambda (r947) (k940 r947))))
(let ((a949 (lambda (k951 t2150)
(let ((k952 (##core#lambda (r953) (k951 r953))))
(let ((k956 (##core#lambda
(r957)
(let ((a955 r957))
(memq k952 a955 '(more equal))))))
(tcmp142 k956 t2150 t147))))))
(map-and k946 a949 more144)))
(k940 #f)))))
(let ((a959 (lambda (k961 t2149)
(let ((k962 (##core#lambda (r963) (k961 r963))))
(let ((k966 (##core#lambda
(r967)
(let ((a965 r967))
(memq k962 a965 '(less equal))))))
(tcmp142 k966 t2149 t147))))))
(map-and k943 a959 less143)))))))
(let ((k970 (##core#lambda
(r971)
(let ((a969 r971)) (zulu-select k934 a937 a969)))))
(lattice->elements k970 target138))))))))
(let ((a973 (lambda (k975 p146)
(let ((k976 (##core#lambda (r977) (k975 r977))))
(let ((k980 (##core#lambda
(r981)
(let ((a979 r981)) (eq? k976 'more a979)))))
(let ((k984 (##core#lambda
(r985)
(let ((a983 r985)) (scmp141 k980 a983 new140)))))
(car k984 p146)))))))
(select-map k931 a973 cdr pas139)))))))
(let ((a987 (lambda (k989 p145)
(let ((k990 (##core#lambda (r991) (k989 r991))))
(let ((k994 (##core#lambda
(r995)
(let ((a993 r995)) (eq? k990 'less a993)))))
(let ((k998 (##core#lambda
(r999)
(let ((a997 r999)) (scmp141 k994 a997 new140)))))
(car k998 p145)))))))
(select-map k928 a987 cdr pas139)))))))
(lattice->cmp k925 target138))))))
(lattice->cmp k922 source137))))))
(let ((t348 t919))
(let ((t1001 (set! maps-rest
#f
(lambda (k1003
source152
target153
pas154
rest155
to-1156
to-collect157)
(let ((k1004 (##core#lambda (r1005) (k1003 r1005))))
(let ((k1007 (##core#lambda
(r1008)
(if r1008
(let ((k1010 (##core#lambda (r1011) (k1004 r1011))))
(to-1156 k1010 pas154))
(let ((k1013 (##core#lambda
(r1014)
(let ((next158 r1014))
(let ((k1016 (##core#lambda
(r1017)
(let ((rest159 r1017))
(let ((k1019 (##core#lambda (r1020) (k1004 r1020))))
(let ((k1023 (##core#lambda
(r1024)
(let ((g167175 r1024))
(let ((g166176 g167175))
(let ((g168177
(lambda (k1027 x179)
(let ((k1028 (##core#lambda (r1029) (k1027 r1029))))
(let ((k1032 (##core#lambda
(r1033)
(let ((a1031 r1033))
(maps-rest
k1028
source152
target153
a1031
rest159
to-1156
to-collect157)))))
(let ((k1036 (##core#lambda
(r1037)
(let ((a1035 r1037)) (cons k1032 a1035 pas154)))))
(cons k1036 next158 x179)))))))
(let ((k1039 (##core#lambda
(r1040)
(let ((g174178 r1040))
(let ((k1042 (##core#lambda
(r1043)
(let ((t186 r1043))
(let ((k1045 (##core#lambda
(r1046)
(let ((a1022 r1046)) (to-collect157 k1019 a1022)))))
(let ((map-loop162180 (##core#undefined)))
(let ((t1048 (set! map-loop162180
#f
(lambda (k1050 g174181)
(let ((k1051 (##core#lambda (r1052) (k1050 r1052))))
(let ((k1054 (##core#lambda
(r1055)
(if r1055
(let ((k1057 (##core#lambda
(r1058)
(let ((g163182 r1058))
(let ((k1060 (##core#lambda
(r1061)
(let ((t183 r1061))
(let ((t1063 (set! g167175 #f g163182)))
(let ((t184 t1063))
(let ((k1064 (##core#lambda (r1065) (k1051 r1065))))
(let ((k1068 (##core#lambda
(r1069)
(let ((a1067 r1069))
(map-loop162180 k1064 a1067)))))
(##sys#slot k1068 g174181 1)))))))))
(##sys#setslot k1060 g167175 1 g163182))))))
(let ((k1072 (##core#lambda
(r1073)
(let ((a1071 r1073)) (cons k1057 a1071 '())))))
(let ((k1076 (##core#lambda
(r1077)
(let ((a1075 r1077)) (g168177 k1072 a1075)))))
(##sys#slot k1076 g174181 0))))
(let ((k1079 (##core#lambda (r1080) (k1051 r1080))))
(##sys#slot k1079 g166176 1))))))
(pair? k1054 g174181)))))))
(let ((t185 t1048))
(map-loop162180 k1045 g174178)))))))))
(##sys#check-list k1042 g174178 'map))))))
(maps-1 k1039 source152 target153 pas154 next158))))))))
(cons k1023 (##core#undefined) '())))))))
(cdr k1016 rest155))))))
(car k1013 rest155))))))
(null? k1007 rest155)))))))
(let ((t349 t1001))
(let ((t1082 (set! maps
#f
(lambda (k1084 source188 target189)
(let ((k1085 (##core#lambda (r1086) (k1084 r1086))))
(let ((k1089 (##core#lambda
(r1090)
(let ((a1088 r1090))
(let ((k1093 (##core#lambda
(r1094)
(let ((a1092 r1094))
(make-lattice k1085 a1088 a1092)))))
(let ((k1097 (##core#lambda
(r1098)
(let ((a1096 r1098)) (lexico k1093 a1096)))))
(lattice->cmp k1097 target189)))))))
(let ((k1101 (##core#lambda
(r1102)
(let ((a1100 r1102))
(let ((a1104 (lambda (k1106 x190)
(let ((k1107 (##core#lambda (r1108) (k1106 r1108))))
(let ((k1111 (##core#lambda
(r1112)
(let ((g198206 r1112))
(let ((g197207 g198206))
(let ((g199208 cdr))
(let ((g205209 x190))
(let ((k1114 (##core#lambda
(r1115)
(let ((t216 r1115))
(let ((k1117 (##core#lambda
(r1118)
(let ((a1110 r1118)) (list k1107 a1110)))))
(let ((map-loop193210 (##core#undefined)))
(let ((t1120 (set! map-loop193210
#f
(lambda (k1122 g205211)
(let ((k1123 (##core#lambda (r1124) (k1122 r1124))))
(let ((k1126 (##core#lambda
(r1127)
(if r1127
(let ((k1129 (##core#lambda
(r1130)
(let ((g194212 r1130))
(let ((k1132 (##core#lambda
(r1133)
(let ((t213 r1133))
(let ((t1135 (set! g198206 #f g194212)))
(let ((t214 t1135))
(let ((k1136 (##core#lambda (r1137) (k1123 r1137))))
(let ((k1140 (##core#lambda
(r1141)
(let ((a1139 r1141))
(map-loop193210 k1136 a1139)))))
(##sys#slot k1140 g205211 1)))))))))
(##sys#setslot k1132 g198206 1 g194212))))))
(let ((k1144 (##core#lambda
(r1145)
(let ((a1143 r1145)) (cons k1129 a1143 '())))))
(let ((k1148 (##core#lambda
(r1149)
(let ((a1147 r1149)) (g199208 k1144 a1147)))))
(##sys#slot k1148 g205211 0))))
(let ((k1151 (##core#lambda (r1152) (k1123 r1152))))
(##sys#slot k1151 g197207 1))))))
(pair? k1126 g205211)))))))
(let ((t215 t1120))
(map-loop193210 k1117 g205209)))))))))
(##sys#check-list k1114 g205209 'map)))))))))
(cons k1111 (##core#undefined) '()))))))
(let ((a1154 (lambda (k1156 x217)
(let ((k1157 (##core#lambda (r1158) (k1156 r1158))))
(apply k1157 append x217)))))
(maps-rest
k1089
source188
target189
'()
a1100
a1104
a1154)))))))
(lattice->elements k1101 source188))))))))
(let ((t350 t1082))
(let ((t1160 (set! count-maps
#f
(lambda (k1162 source219 target220)
(let ((k1163 (##core#lambda (r1164) (k1162 r1164))))
(let ((k1167 (##core#lambda
(r1168)
(let ((a1166 r1168))
(let ((a1170 (lambda (k1172 x221) (k1172 1))))
(maps-rest
k1163
source219
target220
'()
a1166
a1170
sum))))))
(lattice->elements k1167 source219)))))))
(let ((t351 t1160))
(let ((t1173 (set! sum
#f
(lambda (k1175 lst223)
(let ((k1176 (##core#lambda (r1177) (k1175 r1177))))
(let ((k1179 (##core#lambda
(r1180)
(if r1180
(k1176 0)
(let ((k1182 (##core#lambda (r1183) (k1176 r1183))))
(let ((k1186 (##core#lambda
(r1187)
(let ((a1185 r1187))
(let ((k1190 (##core#lambda
(r1191)
(let ((a1189 r1191)) (+ k1182 a1185 a1189)))))
(let ((k1194 (##core#lambda
(r1195)
(let ((a1193 r1195)) (sum k1190 a1193)))))
(cdr k1194 lst223)))))))
(car k1186 lst223)))))))
(null? k1179 lst223)))))))
(let ((t352 t1173))
(let ((t1197 (set! run
#f
(lambda (k1199 k225)
(let ((k1200 (##core#lambda
(r1201)
(let ((l2226 r1201))
(let ((k1203 (##core#lambda
(r1204)
(let ((l3247 r1204))
(let ((k1206 (##core#lambda
(r1207)
(let ((l4248 r1207))
(let ((k1209 (##core#lambda
(r1210)
(let ((t258 r1210))
(let ((k1212 (##core#lambda
(r1213)
(let ((t259 r1213))
(let ((k1215 (##core#lambda
(r1216)
(let ((t260 r1216))
(let ((k1218 (##core#lambda
(r1219)
(let ((t261 r1219))
(let ((tmp249254 k225))
(let ((k1221 (##core#lambda (r1222) (k1199 r1222))))
(let ((k1224 (##core#lambda
(r1225)
(if r1225
(let ((k1227 (##core#lambda (r1228) (k1221 r1228))))
(count-maps k1227 l3247 l3247))
(let ((k1230 (##core#lambda (r1231) (k1221 r1231))))
(let ((k1233 (##core#lambda
(r1234)
(if r1234
(let ((k1236 (##core#lambda (r1237) (k1230 r1237))))
(count-maps k1236 l4248 l4248))
(let ((k1239 (##core#lambda (r1240) (k1230 r1240))))
(let ((k1242 (##core#lambda
(r1243)
(if r1243
(let ((k1245 (##core#lambda
(r1246)
(let ((l5255 r1246))
(let ((k1248 (##core#lambda (r1249) (k1239 r1249))))
(count-maps k1248 l4248 l5255))))))
(maps k1245 l4248 l4248))
(let ((k1251 (##core#lambda (r1252) (k1239 r1252))))
(let ((k1254 (##core#lambda
(r1255)
(if r1255
(let ((k1257 (##core#lambda
(r1258)
(let ((l5256 r1258))
(let ((k1260 (##core#lambda (r1261) (k1251 r1261))))
(count-maps k1260 l5256 l4248))))))
(maps k1257 l4248 l4248))
(let ((k1263 (##core#lambda (r1264) (k1251 r1264))))
(let ((k1266 (##core#lambda
(r1267)
(if r1267
(let ((k1269 (##core#lambda
(r1270)
(let ((l5257 r1270))
(let ((k1272 (##core#lambda (r1273) (k1263 r1273))))
(count-maps k1272 l5257 l5257))))))
(maps k1269 l4248 l4248))
(let ((k1275 (##core#lambda (r1276) (k1263 r1276))))
(error k1275
"run: unanticipated problem size"
k225))))))
(eqv? k1266 tmp249254 55)))))))
(eqv? k1254 tmp249254 54)))))))
(eqv? k1242 tmp249254 45)))))))
(eqv? k1233 tmp249254 44)))))))
(eqv? k1224 tmp249254 33))))))))
(count-maps k1218 l3247 l2226))))))
(count-maps k1215 l2226 l3247))))))
(count-maps k1212 l3247 l3247))))))
(count-maps k1209 l2226 l2226))))))
(maps k1206 l3247 l3247))))))
(maps k1203 l2226 l2226))))))
(let ((a1278 (lambda (k1280 lhs227 rhs228)
(let ((tmp229234 lhs227))
(let ((k1281 (##core#lambda (r1282) (k1280 r1282))))
(let ((k1284 (##core#lambda
(r1285)
(if r1285
(let ((tmp235240 rhs228))
(let ((k1287 (##core#lambda (r1288) (k1281 r1288))))
(let ((k1290 (##core#lambda
(r1291)
(if r1291
(k1287 'equal)
(let ((k1293 (##core#lambda (r1294) (k1287 r1294))))
(let ((k1296 (##core#lambda
(r1297)
(if r1297
(k1293 'less)
(let ((k1299 (##core#lambda (r1300) (k1293 r1300))))
(error k1299 'make-lattice "base" rhs228))))))
(eqv? k1296 tmp235240 'high)))))))
(eqv? k1290 tmp235240 'low))))
(let ((k1302 (##core#lambda (r1303) (k1281 r1303))))
(let ((k1305 (##core#lambda
(r1306)
(if r1306
(let ((tmp241246 rhs228))
(let ((k1308 (##core#lambda (r1309) (k1302 r1309))))
(let ((k1311 (##core#lambda
(r1312)
(if r1312
(k1308 'more)
(let ((k1314 (##core#lambda (r1315) (k1308 r1315))))
(let ((k1317 (##core#lambda
(r1318)
(if r1318
(k1314 'equal)
(let ((k1320 (##core#lambda (r1321) (k1314 r1321))))
(error k1320 'make-lattice "base" rhs228))))))
(eqv? k1317 tmp241246 'high)))))))
(eqv? k1311 tmp241246 'low))))
(let ((k1323 (##core#lambda (r1324) (k1302 r1324))))
(error k1323 'make-lattice "base" lhs227))))))
(eqv? k1305 tmp229234 'high)))))))
(eqv? k1284 tmp229234 'low)))))))
(make-lattice k1200 '(low high) a1278)))))))
(let ((t353 t1197))
(let ((t1326 (set! main
#f
(lambda (k1328)
(let ((k1329 (##core#lambda
(r1330)
(let ((count263 r1330))
(let ((k1332 (##core#lambda
(r1333)
(let ((input1264 r1333))
(let ((k1335 (##core#lambda
(r1336)
(let ((output265 r1336))
(let ((k1338 (##core#lambda
(r1339)
(let ((s2266 r1339))
(let ((k1341 (##core#lambda
(r1342)
(let ((s1267 r1342))
(let ((name268 "lattice"))
(let ((k1344 (##core#lambda (r1345) (k1328 r1345))))
(let ((k1348 (##core#lambda
(r1349)
(let ((a1347 r1349))
(let ((a1351 (lambda (k1353)
(let ((k1354 (##core#lambda (r1355) (k1353 r1355))))
(let ((k1358 (##core#lambda
(r1359)
(let ((a1357 r1359)) (run k1354 a1357)))))
(hide k1358 count263 input1264))))))
(let ((a1361 (lambda (k1363 result269)
(let ((k1364 (##core#lambda (r1365) (k1363 r1365))))
(= k1364 result269 output265)))))
(run-r7rs-benchmark
k1344
a1347
count263
a1351
a1361)))))))
(string-append k1348 name268 ":" s1267 ":" s2266))))))))
(number->string k1341 input1264))))))
(number->string k1338 count263))))))
(read k1335))))))
(read k1332))))))
(read k1329))))))
(let ((t354 t1326))
(let ((t1367 (set! hide
#f
(lambda (k1369 r271 x272)
(let ((k1370 (##core#lambda (r1371) (k1369 r1371))))
(let ((a1373 (lambda (k1375)
(let ((k1376 (##core#lambda (r1377) (k1375 r1377))))
(let ((k1380 (##core#lambda
(r1381)
(let ((a1379 r1381))
(let ((k1384 (##core#lambda
(r1385)
(let ((a1383 r1385)) (values k1376 a1379 a1383)))))
(let ((k1387 (##core#lambda
(r1388)
(if r1388 (k1384 0) (k1384 1)))))
(< k1387 r271 100)))))))
(let ((a1390 (lambda (k1392 x273) (k1392 x273))))
(vector k1380 values a1390)))))))
(let ((a1393 (lambda (k1395 v274 i275)
(let ((k1396 (##core#lambda
(r1397)
(let ((g276277 r1397))
(let ((k1399 (##core#lambda (r1400) (k1395 r1400))))
(g276277 k1399 x272))))))
(vector-ref k1396 v274 i275)))))
(call-with-values k1370 a1373 a1393))))))))
(let ((t355 t1367))
(let ((t1402 (set! run-r7rs-benchmark
#f
(lambda (k1404 name279 count280 thunk281 ok?282)
(let ((rounded283 (##core#undefined)))
(let ((t1405 (set! rounded283
#f
(lambda (k1407 x284)
(let ((k1408 (##core#lambda (r1409) (k1407 r1409))))
(let ((k1412 (##core#lambda
(r1413)
(let ((a1411 r1413)) (/ k1408 a1411 1000)))))
(let ((k1416 (##core#lambda
(r1417)
(let ((a1415 r1417)) (round k1412 a1415)))))
(* k1416 1000 x284))))))))
(let ((t320 t1405))
(let ((k1419 (##core#lambda
(r1420)
(let ((t321 r1420))
(let ((k1422 (##core#lambda
(r1423)
(let ((t322 r1423))
(let ((k1425 (##core#lambda
(r1426)
(let ((t323 r1426))
(let ((k1428 (##core#lambda
(r1429)
(let ((t324 r1429))
(let ((k1431 (##core#lambda
(r1432)
(let ((j/s285 r1432))
(let ((k1434 (##core#lambda
(r1435)
(let ((t0286 r1435))
(let ((k1437 (##core#lambda
(r1438)
(let ((j0287 r1438))
(let ((k1440 (##core#lambda (r1441) (k1404 r1441))))
(let ((loop288 (##core#undefined)))
(let ((t1443 (set! loop288
#f
(lambda (k1445 i289 result290)
(let ((k1446 (##core#lambda (r1447) (k1445 r1447))))
(let ((k1449 (##core#lambda
(r1450)
(if r1450
(let ((k1452 (##core#lambda (r1453) (k1446 r1453))))
(let ((k1456 (##core#lambda
(r1457)
(let ((a1455 r1457))
(let ((k1460 (##core#lambda
(r1461)
(let ((a1459 r1461)) (loop288 k1452 a1455 a1459)))))
(thunk281 k1460))))))
(+ k1456 i289 1)))
(let ((k1463 (##core#lambda (r1464) (k1446 r1464))))
(let ((k1466 (##core#lambda
(r1467)
(if r1467
(let ((k1469 (##core#lambda
(r1470)
(let ((j1295 r1470))
(let ((k1472 (##core#lambda
(r1473)
(let ((t1296 r1473))
(let ((k1475 (##core#lambda
(r1476)
(let ((jifs297 r1476))
(let ((k1478 (##core#lambda
(r1479)
(let ((secs298 r1479))
(let ((k1481 (##core#lambda
(r1482)
(let ((secs2299 r1482))
(let ((k1484 (##core#lambda
(r1485)
(let ((t300 r1485))
(let ((k1487 (##core#lambda
(r1488)
(let ((t301 r1488))
(let ((k1490 (##core#lambda
(r1491)
(let ((t302 r1491))
(let ((k1493 (##core#lambda
(r1494)
(let ((t303 r1494))
(let ((k1496 (##core#lambda
(r1497)
(let ((t304 r1497))
(let ((k1499 (##core#lambda
(r1500)
(let ((t305 r1500))
(let ((k1502 (##core#lambda
(r1503)
(let ((t306 r1503))
(let ((k1505 (##core#lambda
(r1506)
(let ((t307 r1506))
(let ((k1508 (##core#lambda
(r1509)
(let ((t308 r1509))
(let ((k1511 (##core#lambda
(r1512)
(let ((t309 r1512))
(let ((k1514 (##core#lambda
(r1515)
(let ((t310 r1515))
(let ((k1517 (##core#lambda
(r1518)
(let ((t311 r1518))
(let ((k1520 (##core#lambda
(r1521)
(let ((t312 r1521))
(let ((k1523 (##core#lambda
(r1524)
(let ((t313 r1524))
(let ((k1526 (##core#lambda
(r1527)
(let ((t314 r1527)) (k1463 result290)))))
(let ((k1530 (##core#lambda
(r1531)
(let ((a1529 r1531))
(flush-output-port k1526 a1529)))))
(current-output-port k1530)))))))
(newline k1523))))))
(display k1520 secs298))))))
(display k1517 ","))))))
(display k1514 name279))))))
(display k1511 ","))))))
(let ((k1534 (##core#lambda
(r1535)
(let ((a1533 r1535)) (display k1508 a1533)))))
(this-scheme-implementation-name k1534)))))))
(display k1505 "+!CSVLINE!+"))))))
(newline k1502))))))
(display k1499 name279))))))
(display k1496 ") for "))))))
(write k1493 secs2299))))))
(display k1490 " seconds ("))))))
(write k1487 secs298))))))
(display k1484 "Elapsed time: "))))))
(let ((k1538 (##core#lambda
(r1539)
(let ((a1537 r1539)) (rounded283 k1481 a1537)))))
(- k1538 t1296 t0286)))))))
(let ((k1542 (##core#lambda
(r1543)
(let ((a1541 r1543)) (inexact k1478 a1541)))))
(/ k1542 jifs297 j/s285)))))))
(- k1475 j1295 j0287))))))
(current-second k1472))))))
(current-jiffy k1469))
(let ((k1545 (##core#lambda
(r1546)
(let ((t315 r1546))
(let ((k1548 (##core#lambda
(r1549)
(let ((t316 r1549))
(let ((k1551 (##core#lambda
(r1552)
(let ((t317 r1552))
(let ((k1554 (##core#lambda
(r1555)
(let ((t318 r1555)) (k1463 result290)))))
(let ((k1558 (##core#lambda
(r1559)
(let ((a1557 r1559))
(flush-output-port k1554 a1557)))))
(current-output-port k1558)))))))
(newline k1551))))))
(write k1548 result290))))))
(display
k1545
"ERROR: returned incorrect result: "))))))
(ok?282 k1466 result290)))))))
(< k1449 i289 count280)))))))
(let ((t319 t1443)) (loop288 k1440 0 #f)))))))))
(current-jiffy k1437))))))
(current-second k1434))))))
(jiffies-per-second k1431))))))
(let ((k1562 (##core#lambda
(r1563)
(let ((a1561 r1563))
(flush-output-port k1428 a1561)))))
(current-output-port k1562)))))))
(newline k1425))))))
(display k1422 name279))))))
(display k1419 "Running ")))))))))
(let ((t356 t1402))
(let ((k1565 (##core#lambda
(r1566)
(let ((t357 r1566))
(let ((k1568 (##core#lambda
(r1569)
(let ((t358 r1569)) (k598 (##core#undefined))))))
(let ((k1571 (##core#lambda (r1572) (r1572 k1568))))
(##sys#implicit-exit-handler k1571)))))))
(main k1565))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
(##sys#require k611 'vector-lib))))))
(##core#callunit "extras" k608))))))
(##core#callunit "chicken_2dsyntax" k605))))))
(##core#callunit "eval" k602))))))
(##core#callunit "library" k599)))
| false |
dc567cd3db74b7c2068c7ea24bd3a8c5b5f802be | a91a7ee596af92774f98b34d4c3c402d9049e779 | /pyani-lib/function-ops-tests.ss | 4839e9d9f5da938e1f436a7386286f447aa637c2 | []
| no_license | dzhus/scheme-pyani-lib | 9b9ffb4804071678b8a04eaf295835d5ef6b874c | c5eaab32142ae73f4d54cfbfc0f6ffeed210b53e | refs/heads/master | 2021-01-01T15:59:13.107209 | 2018-02-17T23:46:05 | 2018-02-17T23:47:29 | 22,468,803 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 2,614 | ss | function-ops-tests.ss | #lang scheme
(require (planet schematics/schemeunit:3)
(planet schematics/schemeunit:3/text-ui)
(planet wmfarr/simple-matrix:1:0/matrix))
(require srfi/43
"function-ops.ss")
(provide function-ops-tests)
(define test-epsilon 1e-2)
;; Check that vectors of the same length have equal components
(define-check (check-vectors v1 v2 epsilon)
(vector= (lambda (x y) (check-= x y epsilon)) v1 v2))
;; Check that two matrices of the same dimensions have equal
;; components
(define-check (matrix-= m1 m2 epsilon)
(for/matrix (matrix-cols m1)
(matrix-rows m1)
((x (in-matrix m1))
(y (in-matrix m2)))
(check-= x y epsilon)))
;; Check numbers or vectors of numbers or matrices of numbers for
;; equality
(define-check (mcheck-= v1 v2)
(cond ((and (vector? v1) (vector? v2))
(check-vectors v1 v2 test-epsilon))
((and (matrix? v1) (matrix? v2))
(matrix-= v1 v2 test-epsilon))
(else (check-= v1 v2 test-epsilon))))
(define-test-suite function-ops-tests
(let ((v '#(1 2 3 4))
(g (lambda (x y) (* (sqr x) (sqrt y))))
(f (lambda (x y z t) (+ (* z (sqr x)) (sqrt y) (- (exp z) (* x (expt t 3)))))))
(test-case
"at-vector"
(check-equal? (@ + '#(1 2 3)) (+ 1 2 3))
(check-equal? (@ f '#(-1 3.4 2 3/6)) (f -1 3.4 2 3/6))
(check-equal? (@ f '#(0 0.4 22222 3/6)) (f 0 0.4 22222 3/6)))
(test-case
"Derivative"
(mcheck-= ((deriv sin) 0) 1)
(mcheck-= ((deriv cos) (/ pi 2)) -1)
(mcheck-= ((deriv sqr) -5) -10)
(mcheck-= ((deriv (compose sqr sqr)) 7) 1372)
(mcheck-= ((deriv (compose sqr sin)) (/ pi 4)) 1))
(test-case
"Partial derivative"
(mcheck-= ((deriv sin 0) 0) 1)
(mcheck-= ((deriv sqr 0) 7) 14)
(mcheck-= (@ (deriv f 0) v) -58)
(mcheck-= (@ (deriv f 1) v) (/ 1 (* 2 (sqrt 2))))
(mcheck-= (@ (deriv f 2) v) (+ 1 (exp 3)))
(mcheck-= (@ (deriv f 3) v) -48))
(test-case
"Gradient"
(mcheck-= (@ (gradient f) v)
(vector -58 (/ 1 (* 2 (sqrt 2))) (+ 1 (exp 3)) -48))
(mcheck-= (@ (gradient (lambda (x y) (+ (sqr x) (sqr y)))) '#(5 -7.5))
'#(10 -15)))
(test-case
"Hessian"
(mcheck-= (@ (hessian f 1e-6) '#(2 1 0 3))
(matrix* 4 4
0 0 4 -27
0 -1/4 0 0
4 0 1 0
-27 0 0 -36))
(mcheck-= (@ (hessian g) '#(1 4))
(matrix* 2 2
4 1/2
1/2 -1/32)))))
| false |
09a0b61ef5ffbe553ad12a13c12ceadb588cb65e | f0747cba9d52d5e82772fd5a1caefbc074237e77 | /plat/nitro-ami-x86_64.scm | a7b17d7199d3983f24a81a6d1fde7e58bb45a61e | []
| no_license | philhofer/distill | a3b024de260dca13d90e23ecbab4a8781fa47340 | 152cb447cf9eef3cabe18ccf7645eb597414f484 | refs/heads/master | 2023-08-27T21:44:28.214377 | 2023-04-20T03:20:55 | 2023-04-20T03:20:55 | 267,761,972 | 3 | 0 | null | 2021-10-13T19:06:55 | 2020-05-29T04:06:55 | Scheme | UTF-8 | Scheme | false | false | 4,219 | scm | nitro-ami-x86_64.scm | (import
scheme
(only (chicken port) with-output-to-string)
(only (chicken module) export)
(distill base)
(distill plan)
(distill execline)
(distill fs)
(distill image)
(distill service)
(distill execline)
(distill system)
(pkg ip-wait)
(pkg wget)
(svc getty)
(svc acpid))
;; Amazon EC2 Nitro-based platform
;;
;; Images that use the nitro-ami-* platform
;; can be imported as EBS snapshots and then
;; converted to AMIs. The disk partitions will
;; automatically be updated on the first boot
;; to reflect the size of the volume.
;; the disk layout is
;; partition 1: kernel
;; partition 2: root
;; partition 3 (doesn't exist on first boot): /var
(define rootdev "/dev/nvme0n1")
(define (rootpart n)
(string-append rootdev "p" (number->string n)))
;; ami-preboot formats the root device
;; so that the tail contains the /var mount
(define ami-preboot
(interned
"/sbin/preboot" #o700
(lambda ()
(write-exexpr
`(if (test -b ,(rootpart 2)) ; sanity
if -t -n (test -b ,(rootpart 3))
foreground (echo "re-partitioning root device")
if (dosextend -n3 -k ,rootdev)
test -b ,(rootpart 3))))))
;; default kernel image; can be overridden
;; either by manipulating the nitro-ami-* platform
;; object or with a (set! linux-ami-x86_64 ...)
(export linux-ami-x86_64)
(define linux-ami-x86_64
(linux/config-static
"ami-x86_64"
(cdn-artifact "DqJkb_vWTMFFmqHAi72-TozfhoeU1Rmptca9c8pCvjM=" ".config" #o644)))
;; write a script called ec2-meta
;; which is invoked like
;; ec2-meta public-keys/0/openssh-key
;; in order to deduplicate code that needs to
;; access ec2 metadata
(define bin/ec2-meta
(interned "/bin/ec2-meta" #o755
(with-output-to-string
(lambda ()
(write-exexpr
`(foreground
;; block until the default route is available
(redirfd -w 1 /dev/null ip-wait route "^default")
backtick -E token
(wget -q --method=PUT -O "-"
"--header=X-aws-ec2-metadata-token-ttl-seconds: 21600"
http://169.254.169.254/latest/api/token)
wget -q -O "-" "--header=X-aws-ec2-metadata-token: ${token}"
"http://169.254.169.254/latest/meta-data/${1}")
shebang: "#!/bin/execlineb -s1")))))
;; ec2-ssh-keys extracts ssh keys from
;; the ec2 metadata service and sticks them
;; into /run/ec2-authorized-keys, which is what
;; the /root/.ssh/authorized_keys will point
;; to (as a symlink)
;;
;; BUGS: only fetches key 0
(define ec2-ssh-keys
(make-service
name: 'ec2-ssh-keys
inputs: (list
wget
ip-wait
bin/ec2-meta
(interned-symlink "/root/.ssh/authorized_keys" "/run/ec2-authorized-keys"))
spec: (oneshot*
up: `(/bin/umask
"077"
redirfd -w 1 /run/ec2-authorized-keys
s6-setuidgid nobody
ec2-meta public-keys/0/openssh-key))))
;; ec2-hostname sets the hostname based
;; on the metadata service "local-hostname" variable
(define ec2-hostname
(make-service
name: 'ec2-hostname
inputs: (list wget ip-wait bin/ec2-meta)
spec: (oneshot*
up: `(backtick
-E hostname
(s6-setuidgid nobody ec2-meta local-hostname)
hostname "$hostname"))))
;; nitro-ami-x86_64 is a basic AMI platform
;; for amazon EC2 images that will run
;; on any Nitro-backed x86_64 instance type
(define nitro-ami-x86_64
(make-platform
config: (default-config 'x86_64)
kernel: linux-ami-x86_64
cmdline: `(,(string-append "root=" (rootpart 2))
"rootfstype=squashfs" "console=ttyS0")
services: (list
ec2-hostname
ec2-ssh-keys
;; EC2 termination begins with
;; an ACPI poweroff event
acpid
(var-mount "/dev/nvme0n1p3")
;; ttyS0 is the EC2 console
(console-root-shell speed: 115200 tty: 'ttyS0))
packages: (list ami-preboot imgtools)
mkimage: (mbr-image "ami-x86_64")))
| false |
2d86b6b1101d40302f9f66825c8f06abe5259f35 | 61226ac514ed266ef11eb72b97215c8963c0c833 | /bootstrap/syntax.scm | a690a9a02401d90f014ba7cbde8887600c9eb277 | [
"MIT"
]
| permissive | uz3rname/cons | 1d4165dde97afdc7452fab2e284496104311a26a | e8e61af910cf8df7491cbf1f36a2d8c1023281e4 | refs/heads/master | 2022-12-15T19:08:35.174491 | 2020-09-02T07:15:35 | 2020-09-02T07:15:35 | 292,188,820 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 27,942 | scm | syntax.scm | ;-unit syntax -uses prelude -uses lex -uses posix
(include "inc/macro.scm")
(import (chicken file))
(define (syntax-error expr . fmt)
(apply expr-error 'syntax-error expr fmt))
(define (invalid-expr e)
(syntax-error e "Invalid expression"))
(define (expr-error type expr . fmt)
(make-error type
"{} (expression: {}, {}, line: {}, col: {})"
(apply format-str fmt)
(expr-repr expr)
(expr-file expr)
(expr-line expr)
(expr-col expr)))
(define (c-ify-name name)
(string->symbol
(translate-str
'(("->" "_to_")
("-" "_")
("!" "_1_")
("." "__")
("?" "_q_")
("%" "_ps_")
("+" "_p_")
("*" "_a_")
("/" "_s_")
("=" "_eq_")
(">" "_gt_")
("<" "_lt_"))
(let* ((s (symbol->string name))
(l (string-length s)))
(if (char=? (string-ref s (- l 1))
#\?)
(concat "is_" (substr s 0 (- l 1)))
s)))))
(define (token-data x) (cadr x))
(define (token-tag x) (car x))
(define (token-line x) (caddr x))
(define (token-col x) (cadddr x))
(define (parser-error msg)
(do
((: line col) <- (get-state))
(throw 'parser-error
"{} (line: {}, col: {})" msg line col)))
(define (next-token)
(do
((: tokens) <- (get-state))
(if (null? tokens)
(return #f)
(do
(set-state 'tokens (cdr tokens))
(set-state 'line (list-ref (car tokens) 2))
(set-state 'col (list-ref (car tokens) 3))
(return (car tokens))))))
(define (peek-token)
(do
((: tokens) <- (get-state))
(if (null? tokens)
(return #f)
(return (car tokens)))))
(define (parse-list end-tag)
(do
((: stack) <- (get-state))
(set-state 'stack
(cons '() stack))
(letrec
((loop (lambda ()
(do
(token <- (peek-token))
(if token
(let+ (tag data) token
(if (eqv? tag end-tag)
(do
(next-token)
((: stack result) <- (get-state))
(set-state 'stack
(cdr stack))
(return (reverse (car stack))))
(do
(e <- (next-expr))
((: stack) <- (get-state))
(set-state 'stack
(cons (cons e (car stack))
(cdr stack)))
(loop))))
(parser-error "Unexpected EOF"))))))
(loop))))
(define (make-expr file line col tag value sub . rest)
(append
`((tag . ,tag)
(file . ,file)
(line . ,line)
(col . ,col)
(value . ,value)
(sub . ,sub))
(map* cons (group 2 rest))))
(define (make-expr-at e tag value sub . rest)
(apply make-expr
(expr-file e)
(expr-line e)
(expr-col e)
tag
value
sub
rest))
(define (update-expr e . rest)
(foldl (lambda (e x)
(let+ (k v) x
(set k v e)))
e
(group 2 rest)))
(define (expr tag value sub)
(do
((: line col file) <- (get-state))
(return (make-expr file line col tag value sub))))
(define (expr-tag e)
(get 'tag e))
(define (expr-is? e tag)
(cond
((symbol? tag)
(eqv? (expr-tag e) tag))
((pair? tag)
(in? (expr-tag e) tag))
(else #f)))
(define (expr-list-is? e sym)
(and (expr-list? e)
(expr? (car e))
(let+ (: tag value) (car e)
(and (eqv? tag 'symbol)
(eqv? value sym)))))
(define (expr-file e)
(if (expr-list? e)
(expr-file (car e))
(get 'file e)))
(define (expr-line e)
(if (expr-list? e)
(expr-line (car e))
(get 'line e)))
(define (expr-col e)
(if (expr-list? e)
(expr-col (car e))
(get 'col e)))
(define (expr-value e)
(get 'value e))
(define (sub-expr e)
(get 'sub e))
(define (set-sub-expr e sub)
(set 'sub sub e))
(define (next-expr)
(define (parse-int s r)
(let ((x (string->int (substr s 1 (string-length s)) r)))
(if x (expr 'int x '())
(lexical-error "Invalid number representation."))))
(do
(token <- (next-token))
(if (not token)
(return (void))
(do
(let+ (tag data line col) token
(case tag
((number)
(expr (if (string-search "." data)
'real
'int)
(string->number data)
'()))
((char)
(expr 'char data '()))
((symbol)
(scase data
(("$")
(do
(n <- (peek-token))
(if (and n (eqv? (token-tag n) 'string))
(do
(next-token)
(h <- (expr 'symbol
'$cstring
'()))
(s <- (expr 'string
(token-data n)
'()))
(return (list h s)))
(expr 'symbol (string->symbol data) '()))))
(else (expr 'symbol (string->symbol data) '()))))
((string)
(expr 'string data '()))
((open-par)
(parse-list 'close-par))
((open-br)
(do
(e <- (parse-list 'close-br))
(expr 'list '() e)))
((close-par close-br)
(parser-error "Unmatched parens"))
((quote)
(do
(e <- (next-expr))
(expr 'quoted #t (list e))))
((hash)
(do
(n <- (next-token))
(let+ (tag data) n
(case tag
((symbol)
(scase data
(("t") (expr 'bool #t '()))
(("f") (expr 'bool #f '()))
(("$") (>>=
(expr 'symbol 'declare '())
(lambda (e)
(return
(set 'preproc #t e)))))
(else
(case (string-ref data 0)
((#\x) (parse-int data 16))
((#\b) (parse-int data 2))
((#\0) (parse-int data 8))
(else (lexical-error "Unrecognized token"))))))
((open-par)
(do
(e <- (parse-list 'close-par))
(expr 'struct '() e)))
((open-br)
(do
(e <- (parse-list 'close-br))
(expr 'array '() e)))
(else (lexical-error "Unrecognized token."))))))
(else
(lexical-error "Unrecognized token"))))))))
(define (parse)
(do
(e <- (next-expr))
((: result) <- (get-state))
(if (void? e)
(return (reverse result))
(do
(set-state 'result (cons e result))
(parse)))))
(define (parser-state lst filename)
(table (tokens lst)
(file filename)
(stack '())
(result '())))
(define (parse-tokens lst filename)
(let-values (e _) ((parse) (parser-state lst
filename))
e))
(define (expr? e)
(and (list? e)
(alist? e)
(let+ (: tag) e
(in? tag
'(bool int real string char null void closure
symbol array list c-array struct type
call num-expr cmp-expr bool-expr function
fn def extern let typedef is decl
if cast sequence macrodef ref set field
deref offset)))))
(define (expr-list? e)
(and (pair? e)
(or (expr? (car e))
(expr-list? (car e)))))
(define (valid-lambda-list? lst)
(or (null? lst)
(and (expr-list? lst)
(all (cut expr-is? <> 'symbol)
lst))))
(define (transform-lambda-list lst)
(map expr-value
(accept valid-lambda-list?
lst
(syntax-error lst "Invalid lambda list."))))
(define (make-fn-expr file line col arg-list head tail)
(let* ((arg-list (transform-lambda-list arg-list))
(head (transform-expr head))
(tail (transform-sub-expr tail))
(type (if (expr-is? head 'type)
(expr-value head)
(make-template-function (length arg-list))))
(body (if (expr-is? head 'type)
tail
(cons head tail))))
(make-expr file line col 'fn (list arg-list type) body)))
(define (transform-fn e)
(let+ (sym arg-list head . tail) e
(make-fn-expr (expr-file sym)
(expr-line sym)
(expr-col sym)
arg-list
head
tail)))
(define (transform-if e)
(and (assert (= (length e) 4)
(syntax-error
e
"Invalid conditional expression"))
(make-expr
(expr-file e)
(expr-line e)
(expr-col e)
'if
'()
(transform-sub-expr (cdr e)))))
(define (transform-def e)
(let+ (sym name . rest) e
(let+ (: line col file) sym
(and (assert (expr-is? name 'symbol)
(syntax-error
name
"Expected symbol"))
(if (= (length e) 3)
(make-expr
file
line
col
'def
(expr-value name)
(list (transform-expr (car rest))))
(if (valid-lambda-list? (car rest))
(let+ (arg-list head . tail) rest
(make-expr
file
line
col
'def
(expr-value name)
(list (make-fn-expr file
line
col
arg-list
head
tail))))
(map (lambda (x)
(let+ (arg-list head . tail) x
(make-expr file
line
col
'def
(expr-value name)
(list (make-fn-expr
file
line
col
arg-list
head
tail)))))
rest)))))))
(define (transform-extern e)
(let+ (sym name . funcs) e
(make-expr
(expr-file sym)
(expr-line sym)
(expr-col sym)
'extern
(cons (expr-value name)
(map (lambda (x)
(let ((x (map transform-expr x)))
(and (assert (>= (length x) 1)
(syntax-error x "Invalid declaration"))
(let+ (type . f-name) x
(and (assert (expr-is? type 'type)
(syntax-error
type
"Expected type"))
(assert (or (null? f-name)
(expr-is? (car f-name) 'string))
(syntax-error
(car f-name)
"Expected string"))
(list (expr-value type)
(if (null? f-name)
(symbol->string
(c-ify-name
(expr-value name)))
(expr-value (car f-name)))))))))
funcs))
'())))
(define (transform-sequence e lst)
(if (null? lst)
(make-expr-at e 'void '() '())
(make-expr-at
e
'sequence
#t
(transform-sub-expr lst))))
(define (transform-type e)
(define (transform-type e)
(cond ((pair? e)
(if (expr-list? e)
(map transform-type e)
(case (expr-tag e)
((list array)
`(|:| ,(expr-tag e) . ,(transform-type
(sub-expr e))))
((struct)
(transform-type (sub-expr e)))
(else (transform-type
(expr-value e))))))
((and (symbol? e)
(eqv? (string-ref (symbol->string e) 0)
#\*))
(list '|:| 'ptr
(string->symbol
(substr (symbol->string e) 1))))
(else e)))
(make-expr
(expr-file e)
(expr-line e)
(expr-col e)
'type
(unlist (transform-type (cdr e)))
'()))
(define (transform-typedef e)
(let+ (sym name . t) e
(let ((type (transform-expr (cons (make-expr
(expr-file name)
(expr-line name)
(expr-col name)
'symbol
'|::|
'())
t))))
(and
(assert (or (expr-is? name 'symbol)
(and (expr-list? name)
(all (cut expr-is? <> 'symbol)
name)))
(syntax-error name "Expected symbol"))
(assert (expr-is? type 'type)
(syntax-error type "Expected type"))
(make-expr
(expr-file e)
(expr-line e)
(expr-col e)
'typedef
(list
(if (expr-list? name)
(map expr-value name)
(expr-value name))
(expr-value type)
(eqv? (expr-value sym) 'alias))
'())))))
(define (transform-decl e)
(define (invalid-decl)
(syntax-error e "Invalid declaration"))
(define (tform-decl e)
(cond ((expr-list? e)
(map tform-decl e))
((expr-is? e '(symbol string))
(expr-value e))
(else (throw (invalid-decl)))))
(let+ (sym . tail) e
(make-expr
(expr-file e)
(expr-line sym)
(expr-col sym)
'decl
(let ((d (map tform-decl tail)))
(if (get 'preproc sym)
(list d)
d))
'())))
(define (transform-cast e)
(and (assert (> (length e) 3)
(invalid-expr e))
(let+ (sym what . type) e
(let ((type (transform-expr type)))
(and (assert (expr-is? type 'type)
(invalid-expr e))
(make-expr
(expr-file e)
(expr-line sym)
(expr-col sym)
'cast
(expr-value type)
(list (transform-expr what))))))))
(define (transform-ref e)
(and (assert (= (length e) 3)
(invalid-expr e))
(let+ (sym struct idx) e
(and (assert (and (expr-is? idx 'int)
(>= (expr-value idx) 0))
(syntax-error e "Invalid struct index"))
(make-expr
(expr-file e)
(expr-line sym)
(expr-col sym)
'ref
(expr-value idx)
(list (transform-expr struct)))))))
(define (transform-field e)
(and (assert (= (length e) 3)
(invalid-expr e))
(let+ (sym e field) e
(and (assert (or (expr-is? field 'symbol)
(expr-is? field 'int))
(syntax-error field
"Expected symbol"))
(make-expr
(expr-file e)
(expr-line sym)
(expr-col sym)
'field
(expr-value field)
(list (transform-expr e)))))))
(define (transform-is e)
(and (assert (= (length e) 3)
(invalid-expr e))
(let+ (sym value type) e
(let ((sym (transform-expr sym))
(value (transform-expr value))
(type (transform-expr type)))
(and (assert (and (expr-is? type 'symbol)
(field-sym? (expr-value type)))
(syntax-error type "Expected type"))
(make-expr
(expr-file e)
(expr-line sym)
(expr-col sym)
'is
(field-name (expr-value type))
(list value)))))))
(define (transform-set e)
(let+ (loc expr) (map transform-expr (cdr e))
(and (assert (expr-is? loc '(symbol field))
(syntax-error e "Expected symbol/field"))
(make-expr (expr-file e)
(expr-line e)
(expr-col e)
'set
#t
(list loc expr)))))
(define (transform-mov e)
(and (assert (= (length e) 3)
(syntax-error e "Expected two arguments"))
(make-expr-at
e
'mov
#t
(map transform-expr (cdr e)))))
(define (transform-deref e)
(and (assert (= (length e) 2)
(syntax-error e "Expected single argument"))
(make-expr (expr-file e)
(expr-line e)
(expr-col e)
'deref
#t
(list (transform-expr (cadr e))))))
(define (transform-offset e)
(and (assert (= (length e) 3)
(syntax-error e "Expected two arguments"))
(let+ (sym ptr o) e
(make-expr (expr-file sym)
(expr-line sym)
(expr-col sym)
'offset
(and (expr-is? o 'int)
(expr-value o))
(cons (transform-expr ptr)
(if (expr-is? o 'int)
'()
(list (transform-expr o))))))))
(define (special-forms-dispatch)
(list
'fn transform-fn
'begin (lambda (e)
(transform-sequence (car e) (cdr e)))
'if transform-if
'def transform-def
'extern transform-extern
'|::| transform-type
'type transform-typedef
'alias transform-typedef
'declare transform-decl
'-> transform-cast
(string->symbol ".") transform-field
'set! transform-set
'mov! transform-mov
'is transform-is
'deref transform-deref
'offset transform-offset))
(define (builtin-forms)
(map car (group 2 (special-forms-dispatch))))
(define (special-form? e)
(let+ (head . tail) e
(and (expr? head)
(expr-is? head 'symbol)
(and-let* ((x (memv (expr-value head)
(special-forms-dispatch))))
((cadr x) e)))))
(define (expr-predicate e tag valid-syms)
(let+ (head . tail) e
(and (expr? head)
(expr-is? head 'symbol)
(memv (expr-value head)
valid-syms)
(make-expr
(expr-file e)
(expr-line head)
(expr-col head)
tag
(expr-value head)
(transform-sub-expr tail)))))
(define (num-expr? e)
(expr-predicate e
'num-expr
`(+ - * / mod shl shr logand logor xor)))
(define (cmp-expr? e)
(expr-predicate e
'cmp-expr '(eq neq = /= < > <= >=)))
(define (bool-expr? e)
(expr-predicate e
'bool-expr '(and or not)))
(define (field-ref? e)
(and (expr-list? e)
(let+ (head . tail) e
(and (expr? head)
(expr-is? head 'symbol)
(field-sym? (expr-value head))
(transform-field
(cons (make-expr (expr-file head)
(expr-line head)
(expr-col head)
'symbol 'field '())
(append tail
(list (make-expr-at
e
'symbol
(field-name (expr-value head))
'())))))))))
(define (transform-expr e)
(if (or (null? e)
(expr-list? e))
(transform-list e)
(let+ (: file line col tag sub) e
(case tag
((array struct list)
(make-expr
file
line
col
tag
'()
(transform-sub-expr sub)))
(else e)))))
(define (transform-sub-expr args)
(foldr (lambda (x xs)
(if (expr-list? x)
(append x xs)
(cons x xs)))
'()
(map transform-expr args)))
(define (make-call-expr e)
(make-expr
(expr-file e)
(expr-line e)
(expr-col e)
'call
#t
(transform-sub-expr e)))
(define (make-void e)
(make-expr
(expr-file e)
(expr-line e)
(expr-col e)
'void
#t
'()))
(define (transform-list e)
(or (and (null? e)
(make-void e))
(special-form? e)
(num-expr? e)
(cmp-expr? e)
(bool-expr? e)
(field-ref? e)
(make-call-expr e)))
(define (parse-string s filename dirs)
(parse-tokens (tokenize s) filename))
(define (parse-file f dirs)
(and (assert (file-exists? f)
'error "Couldn't find {}" f)
(parse-string (file->string f)
f
(cons (file-directory f)
dirs))))
(define (expr-repr e)
(cond
((null? e) "()")
((expr-list? e)
(concat "(" (join-str " " (map expr-repr e)) ")"))
(else
(let+ (: tag value sub) e
(case tag
((unit)
(format-str
"File: {} \n {}"
value
(expr-repr sub)))
((int real bool function)
(repr value))
((closure)
(format-str
"(closure {} ({}))"
value
(expr-repr sub)))
((symbol)
(if (symbol? value)
(repr value)
(format-str "(ref {} {})"
(get '(ref ref) e)
(get '(ref value) e))))
((char)
(fmt #f "#\\x{}" (number->string (char->integer value) 16)))
((string)
(concat "\"" value "\""))
((num-expr cmp-expr bool-expr)
(format-str
"({} {})"
value
(join-str " " (map expr-repr sub))))
((sequence)
(format-str
"(begin {})"
(join-str " " (map expr-repr sub))))
((call)
(format-str
"({} {})"
(expr-repr (car sub))
(join-str " " (map expr-repr (cdr sub)))))
((extern)
(let+ (symbol type) value
(format-str
"(extern {})"
symbol)))
((def)
(format-str
"(def {} {})"
value
(join-str " " (map expr-repr sub))))
((fn)
(let+ (arg-list type) value
(format-str
"(fn ({}) (:: {}) {})"
(join-str " " (map repr arg-list))
(join-str " " (map type-repr type))
(join-str " " (map expr-repr sub)))))
((list)
(concat "["
(join-str " " (map expr-repr sub))
"]"))
((null) "[]")
((array)
(concat "#["
(join-str " " (map expr-repr sub))
"]"))
((struct)
(concat "#("
(join-str " " (map expr-repr sub))
")"))
((if)
(format-str
"(if {})"
(join-str " " (map expr-repr sub))))
((let)
(format-str
"(let ({}) {})"
(join-str
" "
(map (lambda (name body)
(format-str
"({} {})"
name
(join-str " " (map expr-repr (sub-expr body)))))
value
(list-head sub (length value))))
(join-str " " (map expr-repr (list-tail sub (length value))))))
((type)
(type-repr value))
((typedef)
(let+ (symbol type) value
(format-str
"(type {} {})"
symbol
(type-repr type))))
((cast)
(format-str
"(-> {} :: {})"
(expr-repr (car sub))
(type-repr value)))
((ref)
(format-str
"(ref {} {})"
(expr-repr (car sub))
value))
((void)
"()")
((set)
(format-str
"(set! {} {})"
(expr-repr (car sub))
(expr-repr (cadr sub))))
((field)
(format-str
"(. {} {})"
(expr-repr (car sub))
value))
((is)
(format-str
"(is {} .{})"
(expr-repr (car sub))
value))
((decl)
(format-str
"(declare {})"
value))
((deref)
(format-str
"(deref {})"
(expr-repr (car sub))))
((offset)
(format-str
"(offset {} {})"
(expr-repr (car sub))
(or value (expr-repr (cadr sub)))))
((mov)
(format-str
"(mov! {} {})"
(expr-repr (car sub))
(expr-repr (cadr sub))))
((c-array)
(format-str
"$[{}]"
(join-str " " (map expr-repr sub))))
(else (throw 'error "Invalid expression tag {}" e)))))))
(define (make-expr-from e file line col)
(define (tform x)
(cond ((list? x)
(if (null? x)
(make-expr file line col 'void #t '())
(case (car x)
((if)
(make-expr file line col
'if #t
(map tform (cdr x))))
(else
(make-expr file line col
'call
#t
(cons (tform (car x))
(map tform (cdr x))))))))
((symbol? x)
(make-expr file line col
'symbol
x
'()))
((string? x)
(make-expr file line col
'string
x
'()))
((integer? x)
(make-expr file line col
'int
x
'()))
((number? x)
(make-expr file line col
'real
x
'()))))
(tform e))
| false |
fe4b1b044f5f6adc9e5e2d40763298e4e7274652 | 57426a1b07914bae0e884ab1314310f38cc96b57 | /posix-shm.scm | 6f394e300bda78d9cf496e9b4e59f7f7f4463cb7 | [
"BSD-3-Clause"
]
| permissive | iraikov/chicken-posix-shm | 73a9f9a04cdc6e92efebc5b6375dd30ce9dce6a3 | f1a4ffa3f8475df738fda65a6f134e748f135b58 | refs/heads/master | 2021-06-08T20:44:30.696193 | 2021-05-03T14:05:09 | 2021-05-03T14:05:09 | 42,020,350 | 0 | 1 | BSD-3-Clause | 2021-03-31T00:29:57 | 2015-09-06T21:58:31 | Scheme | UTF-8 | Scheme | false | false | 6,543 | scm | posix-shm.scm |
;;
;; Chicken Scheme interface to the POSIX Shared Memory API.
;;
;; Copyright 2011-2020 Ivan Raikov.
;;
;; Based in part on code from the Ocamlnet library.
;;
;; 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 name of the copyright holders 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 THE
;; 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 THE
;; 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.
(module posix-shm
(posix-shm? shm-open shm-unlink)
(import scheme)
(cond-expand
(chicken-4
(import chicken foreign)
(require-library posix srfi-1)
(import (only srfi-1 filter)
(only posix perm/irwxu perm/irgrp perm/iroth
open/rdonly open/rdwr open/creat open/excl open/trunc)))
(chicken-5
(import scheme (chicken base) (chicken foreign) (chicken blob)
(only (chicken string) ->string)
(only srfi-1 filter)
(only (chicken file posix) perm/irwxu perm/irgrp perm/iroth
open/rdonly open/rdwr open/creat open/excl open/trunc)))
(else
(error "Unsupported CHICKEN version.")))
; Include into generated code, but don't parse:
#>
#include <errno.h>
#include <stdio.h>
static void chicken_panic (C_char *) C_noret;
static void chicken_panic (C_char *msg)
{
C_word *a = C_alloc (C_SIZEOF_STRING (strlen (msg)));
C_word scmmsg = C_string2 (&a, msg);
C_halt (scmmsg);
exit (5); /* should never get here */
}
static void chicken_throw_exception(C_word value, C_word loc) C_noret;
static void chicken_throw_exception(C_word value, C_word loc)
{
char *aborthook = C_text("\003syserror-hook");
C_word *a = C_alloc(C_SIZEOF_STRING(strlen(aborthook)));
C_word abort = C_intern2(&a, aborthook);
abort = C_block_item(abort, 0);
if (C_immediatep(abort))
chicken_panic(C_text("`##sys#error-hook' is not defined"));
#if defined(C_BINARY_VERSION) && (C_BINARY_VERSION >= 8)
C_word rval[4] = { abort, C_SCHEME_UNDEFINED, value, loc };
C_do_apply(4, rval);
#else
C_save(value);
C_do_apply(1, abort, C_SCHEME_UNDEFINED);
#endif
}
void chicken_error (char *msg, C_word obj, C_word loc)
{
size_t msglen;
C_word *a;
C_word scmmsg;
C_word list;
msglen = strlen (msg);
a = C_alloc (C_SIZEOF_STRING (msglen) + C_SIZEOF_LIST(2));
scmmsg = C_string2 (&a, (char *) msg);
list = C_list(&a, 2, scmmsg, obj);
chicken_throw_exception(list, loc);
}
/* Adapted from the Ocaml function convert_flag_list: */
int convert_flag_list (C_word list, int *flags)
{
C_word l; int res;
res = 0;
for (l = list; !(C_truep(C_i_null_list_p(l))); l = C_u_i_cdr(l))
{
res |= flags[C_unfix(C_u_i_car(l))];
}
return res;
}
#ifdef HAVE_POSIX_SHM
#include <sys/mman.h>
#include <sys/stat.h> /* For mode constants */
#include <fcntl.h> /* For O_* constants */
#endif
/**********************************************************************/
/* POSIX shared memory */
/**********************************************************************/
/* This is from the POSIX realtime extensions. Not every POSIX-type OS
* supports it.
*/
static C_word have_posix_shm =
#ifdef HAVE_POSIX_SHM
C_SCHEME_TRUE;
#else
C_SCHEME_FALSE;
#endif
#ifdef HAVE_POSIX_SHM
static int shm_open_flag_table[] = {
O_RDONLY, O_RDWR, O_CREAT, O_EXCL, O_TRUNC
};
#endif
C_word chicken_shm_open(char *path, int flags, int perm)
{
C_word result;
#ifdef HAVE_POSIX_SHM
int ret;
ret = shm_open(path, flags, perm);
if (ret == -1)
{
C_word *p; size_t pathlen;
pathlen = strlen(path);
p = C_alloc (C_SIZEOF_STRING (pathlen));
C_word *l; size_t loclen;
char *loc = "shm_open";
loclen = strlen(loc);
l = C_alloc (C_SIZEOF_STRING (loclen));
chicken_error ("Unable to shm_open", C_string(&p, pathlen, path), C_string(&l, loclen, loc));
} else
{
result = C_fix(ret);
}
#else
result = C_SCHEME_FALSE;
#endif
C_return(result);
}
C_word chicken_shm_unlink(char *path)
{
C_word result;
#ifdef HAVE_POSIX_SHM
int ret;
ret = shm_unlink(path);
if (ret == -1)
{
C_word *p; size_t pathlen;
pathlen = strlen(path);
p = C_alloc (C_SIZEOF_STRING (pathlen));
C_word *l; size_t loclen;
char *loc = "shm_unlink";
loclen = strlen(loc);
l = C_alloc (C_SIZEOF_STRING (loclen));
chicken_error ("Unable to shm_open", C_string(&p, pathlen, path), C_string(&l, loclen, loc));
} else
{
result = C_fix(ret);
}
result = C_fix(ret);
#else
result = C_SCHEME_FALSE;
#endif
C_return(result);
}
<#
(define posix-shm? (foreign-value "have_posix_shm" bool))
(define chicken_shm_open (foreign-safe-lambda scheme-object "chicken_shm_open" nonnull-c-string int int))
(define valid-flags (list open/rdonly open/rdwr open/creat open/excl open/trunc))
(define (shm-open path oflags #!key (mode (+ perm/irwxu perm/irgrp perm/iroth)))
(let ((oflags1 (apply + (filter (lambda (x) (member x valid-flags)) oflags))))
(chicken_shm_open path oflags1 mode)))
(define shm-unlink (foreign-safe-lambda scheme-object "chicken_shm_unlink" nonnull-c-string))
)
| false |
aeb6e5d4af5011aeb56ad3470c9f1f05fb3655c3 | ebf028b3a35ae1544bba1a1f9aa635135486ee6c | /tests/lunula/persistent-record.scm | 2412ecdf7e50c382e80231cc89431f8937c80740 | [
"BSD-2-Clause",
"BSD-3-Clause"
]
| permissive | tabe/lunula | b4b666151874271211744cce1346e58e3a56fa79 | b7699a850b9c9a64c1d3a52d50ce20050bd17475 | refs/heads/master | 2021-01-01T20:04:43.571993 | 2010-05-06T15:39:31 | 2010-05-06T15:39:31 | 334,916 | 2 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,442 | scm | persistent-record.scm | #!/usr/bin/env ypsilon
#!r6rs
(import (rnrs)
(lunula persistent-record)
(xunit))
(define-assert-predicate persistent-record?)
(define-persistent-record-type foo
(fields x y z)
(protocol
(persistent-protocol
(lambda (p)
(lambda (a b c)
(p a b c))))))
(assert-boolean=? #f (maybe-integer ""))
(assert-= 0 (maybe-integer 0))
(assert-= 0 (maybe-integer "0"))
(assert-= 100 (maybe-integer "100"))
(assert-boolean=? #f (maybe-integer "3.14"))
(let ((p (make-persistent-record 7 #f #f)))
(assert-persistent-record? p)
(assert-= 7 (id-of p))
(assert-boolean=? #f (created-at-of p))
(assert-boolean=? #f (updated-at-of p)))
(let ((q (make-persistent-record "100" "2009-10-16 19:20:00" "2009-10-16 19:30:00")))
(assert-persistent-record? q)
(assert-= 100 (id-of q))
(assert-string=? "2009-10-16 19:20:00" (created-at-of q))
(assert-string=? "2009-10-16 19:30:00" (updated-at-of q)))
(let ((f (make-foo 1 2 3)))
(assert-boolean=? #f (id-of f))
(assert-boolean=? #f (created-at-of f))
(assert-boolean=? #f (updated-at-of f))
(assert-= 1 (foo-x f))
(assert-= 2 (foo-y f))
(assert-= 3 (foo-z f))
(let ((id 12))
(id-set! f id)
(assert-= id (id-of f)))
(let ((t "2009-10-16 00:00:00"))
(created-at-set! f t)
(assert-string=? t (created-at-of f)))
(let ((t "2009-10-16 12:00:00"))
(updated-at-set! f t)
(assert-string=? t (updated-at-of f))))
(report)
| false |
958754f7d2131a8f9c3c672ce8ca8c52c9d27e65 | 53cb8287b8b44063adcfbd02f9736b109e54f001 | /flic/invariant.scm | c6c04869cfb1d1b9283375197764f5456531f1af | []
| no_license | fiddlerwoaroof/yale-haskell-reboot | 72aa8fcd2ab7346a4990795621b258651c6d6c39 | 339b7d85e940db0b8cb81759e44abbb254c54aad | refs/heads/master | 2021-06-22T10:32:25.076594 | 2020-10-30T00:00:31 | 2020-10-30T00:00:31 | 92,361,235 | 3 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 2,992 | scm | invariant.scm | ;;; invariant.scm -- look for invariant expressions
;;;
;;; author : Sandra Loosemore
;;; date : 12 Mar 1993
;;;
;;;
;;; The function flic-invariant? returns true if the expression is
;;; invariant with respect to a set of local variable bindings.
(define-flic-walker flic-invariant? (object local-bindings))
(define (flic-invariant-list? objects local-bindings)
(if (null objects)
'#t
(and (flic-invariant? (car objects) local-bindings)
(flic-invariant-list? (cdr objects) local-bindings))))
(define-flic-invariant? flic-lambda (object local-bindings)
(flic-invariant? (flic-lambda-body object)
(cons (flic-lambda-vars object) local-bindings)))
(define-flic-invariant? flic-let (object local-bindings)
(let* ((bindings (flic-let-bindings object))
(body (flic-let-body object))
(recursive? (flic-let-recursive? object))
(inner-stuff (cons bindings local-bindings)))
(and (flic-invariant-list? (map (function var-value) bindings)
(if recursive? inner-stuff local-bindings))
(flic-invariant? body inner-stuff))))
(define-flic-invariant? flic-app (object local-bindings)
(and (flic-invariant? (flic-app-fn object) local-bindings)
(flic-invariant-list? (flic-app-args object) local-bindings)))
(define-flic-invariant? flic-ref (object local-bindings)
(let ((var (flic-ref-var object)))
(or (var-toplevel? var)
(flic-local-var? var local-bindings))))
(define (flic-local-var? var local-bindings)
(cond ((null? local-bindings)
'#f)
((memq var (car local-bindings))
'#t)
(else
(flic-local-var? var (cdr local-bindings)))))
(define-flic-invariant? flic-const (object local-bindings)
(declare (ignore object local-bindings))
'#t)
(define-flic-invariant? flic-pack (object local-bindings)
(declare (ignore object local-bindings))
'#t)
(define-flic-invariant? flic-case-block (object local-bindings)
(flic-invariant-list? (flic-case-block-exps object) local-bindings))
(define-flic-invariant? flic-return-from (object local-bindings)
(flic-invariant? (flic-return-from-exp object) local-bindings))
(define-flic-invariant? flic-and (object local-bindings)
(flic-invariant-list? (flic-and-exps object) local-bindings))
(define-flic-invariant? flic-if (object local-bindings)
(and (flic-invariant? (flic-if-test-exp object) local-bindings)
(flic-invariant? (flic-if-then-exp object) local-bindings)
(flic-invariant? (flic-if-else-exp object) local-bindings)))
(define-flic-invariant? flic-sel (object local-bindings)
(flic-invariant? (flic-sel-exp object) local-bindings))
(define-flic-invariant? flic-is-constructor (object local-bindings)
(flic-invariant? (flic-is-constructor-exp object) local-bindings))
(define-flic-invariant? flic-con-number (object local-bindings)
(flic-invariant? (flic-con-number-exp object) local-bindings))
(define-flic-invariant? flic-void (object local-bindings)
(declare (ignore object local-bindings))
'#t)
| false |
57f873df108c5fef9ed0650aa12775e8f0238892 | eef5f68873f7d5658c7c500846ce7752a6f45f69 | /test/streams-lazy-seq.scm | 2c8865044470ff2a8cdc085815165c6309c258c4 | [
"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 | 6,149 | scm | streams-lazy-seq.scm | (load-relative "../lazy-seq")
(import lazy-seq)
(use test)
(test-group "custom lazy-seq"
(define calls 0)
(define natural-numbers
(case-lambda
(() (natural-numbers 0))
((n) (lazy-seq
(set! calls (+ calls 1))
(cons n (natural-numbers (+ n 1)))))))
(define numbers (natural-numbers))
(test '(0 1 2) (lazy-seq->list (lazy-take 3 numbers)))
(test '(0 1 2) (lazy-seq->list (lazy-take 3 numbers)))
(test calls 3))
(test-group "lazy-seq-realized?"
(define even-numbers (lazy-numbers step: 2))
(test-assert (not (lazy-seq-realized? even-numbers)))
(test 0 (lazy-head even-numbers))
(test-assert (lazy-seq-realized? even-numbers))
(test-assert (not (lazy-seq-realized? (lazy-tail even-numbers))))
(test 2 (lazy-head (lazy-tail even-numbers))))
(test-group "list->lazy-seq"
(define seq
(list->lazy-seq '("foo" "bar")))
(test-assert (lazy-seq? seq))
(test-assert (lazy-seq-realized? seq))
(test '("foo" "bar") (lazy-seq->list seq))
(test-assert (lazy-null? (lazy-tail (lazy-tail seq))))
(test "ok" (lazy-head (lazy-seq (list->lazy-seq '("ok"))))))
(test-group "lazy-length"
(test 10 (lazy-length (lazy-numbers count: 10))))
(test-group "lazy-map"
(test '(1 2 3 4 5)
(lazy-seq->list
(lazy-take 5 (lazy-map add1 (lazy-numbers)))))
(test '(10 12 14)
(lazy-seq->list
(lazy-take 3 (lazy-map +
(lazy-numbers start: 7)
(lazy-numbers start: 3))))))
(test-group "lazy-append-map"
(test '(1 2 3 4 5 6)
(lazy-seq->list
(lazy-append-map
(compose list->lazy-seq list)
(list->lazy-seq '(1 3 5))
(list->lazy-seq '(2 4 6 7))))))
(test-group "lazy-filter"
(test '(2 8 14 20 26)
(lazy-seq->list
(lazy-take 5 (lazy-filter
(lambda (x) (zero? (modulo x 2)))
(lazy-numbers start: 2 step: 3)))))
(test '(2) (lazy-seq->list
(lazy-filter (lambda (x) (= x 2))
(lazy-numbers count: 10)))))
(test-group "lazy-ref"
(test 3 (lazy-ref 3 (lazy-numbers))))
(test-group "input-port->lazy-seq"
(test '(b c d)
(lazy-seq->list
(lazy-take
3 (lazy-tail
(input-port->lazy-seq
(open-input-string "a b c d e")
read)))))
(test-assert
(lazy-null?
(input-port->lazy-seq
(open-input-string "")
read))))
(test-group "lazy-each"
(define sum 0)
(lazy-each (lambda (i)
(set! sum (+ i sum)))
(lazy-numbers count: 5))
(test sum (fold + 0 (iota 5))))
(test-group "lazy-repeat"
(test '(x x x x) (lazy-seq->list (lazy-take 4 (lazy-repeat 'x)))))
(test-group "lazy-repeatedly"
(test 10 (lazy-ref 9 (lazy-repeatedly
(let ((n 0))
(lambda () (set! n (+ n 1)) n))))))
(test-group "lazy-append"
(test 6 (lazy-ref 5 (lazy-append (lazy-numbers count: 2)
(lazy-numbers count: 2)
(lazy-numbers start: 5)))))
(test-group "lazy-iterate"
(test '(2 4 8 16)
(lazy-seq->list
(lazy-take 4 (lazy-iterate (lambda (x) (* x 2)) 2)))))
(test-group "lazy-take-while"
(test '(2 2 2 4)
(lazy-seq->list
(lazy-take-while even? (list->lazy-seq '(2 2 2 4 5 6))))))
(test-group "lazy-drop-while"
(test '(end)
(lazy-seq->list
(lazy-drop-while number? (list->lazy-seq '(1 2 3 4 end))))))
(test-group "lazy-reverse"
(test '() (lazy-seq->list (lazy-reverse (lazy-seq '()))))
(test '(3 2 1)
(lazy-seq->list
(lazy-reverse
(lazy-numbers count: 3 start: 1)))))
(test-group "lazy-cycle"
(test '(1 2 1 2 1 2)
(lazy-seq->list
(lazy-take 6 (lazy-cycle
(list->lazy-seq '(1 2))))))
(test '() (lazy-seq->list (lazy-cycle (list->lazy-seq '())))))
(test-group "lazy-fold"
(test 390 (lazy-fold + 0 (lazy-numbers start: 10 count: 20))))
(test-group "lazy-concatenate"
(test '(1 2 3 4)
(lazy-seq->list
(lazy-concatenate
(list->lazy-seq (list (list->lazy-seq '(1))
(list->lazy-seq '(2 3))
(list->lazy-seq '(4))))))))
(test-group "lazy-flatten"
(test "nothing to flatten"
'(1 2 3 4)
(lazy-seq->list (lazy-flatten (list->lazy-seq '(1 2 3 4)))))
(test "flatten one level deep"
'(1 2 3 4)
(lazy-seq->list
(lazy-flatten (list->lazy-seq
(map (lambda (x) (list->lazy-seq (list x)))
'(1 2 3 4))))))
(test "flatten multiple levels"
'(1 2 3 4 5 6)
(lazy-seq->list
(lazy-flatten
(list->lazy-seq
(list (list->lazy-seq '(1))
(list->lazy-seq
(list
(list->lazy-seq '(2 3))
(list->lazy-seq '(4))
5))
6)))))
(define depth1-calls 0)
(define depth2-calls 0)
(define seq
(lazy-map
(lambda (x)
(set! depth1-calls (+ depth1-calls 1))
(lazy-map
(lambda (y)
(set! depth2-calls (+ depth2-calls 1))
(* 2 y)) x))
(list->lazy-seq
(list (list->lazy-seq '(1))
(list->lazy-seq '(2))
(list->lazy-seq '(3))
(list->lazy-seq '(4))))))
(lazy-seq->list (lazy-take 2 (lazy-flatten seq)))
(test "lists are resolved lazily"
'(2 2) (list depth1-calls depth2-calls)))
(test-group "nested lazy-seq realizations are retained"
(define (realized-prefix seq)
(if (lazy-seq-realized? seq)
(cons (lazy-head seq)
(realized-prefix (lazy-tail seq)))
'()))
(let* ((q (lazy-numbers))
(r (lazy-seq q))
(s (lazy-seq r)))
(test '(0 1 2 3 4) (lazy-seq->list (lazy-take 5 s)))
(test '(0 1 2 3 4) (realized-prefix r))
(test '(0 1 2 3 4) (realized-prefix q))))
(test-exit)
| false |
f53558ff37c968c73a2dc177848b5bf9f0f39816 | 35d4b26f34243adacc41eadc985f9bd6f0739140 | /src/wander.scm | f2046412707c8dfd617589d57642a3fa9cd6fac6 | []
| no_license | holdenk/wanderinghobos | f6234856c69a44dcd984fc114c4a8fe80d4f7ba2 | 506087dda0063ec0dd15c5a2d0419a952ff14bed | refs/heads/master | 2021-01-10T19:03:25.920021 | 2012-07-16T10:24:00 | 2012-07-16T10:24:00 | 5,061,209 | 1 | 0 | null | 2012-07-16T02:23:33 | 2012-07-15T23:59:11 | Scheme | UTF-8 | Scheme | false | false | 3,502 | scm | wander.scm | ;; -*- indent-tabs-mode: nil -*- ;;
(declare (unit wander))
(declare (uses simulate parse-input dog))
(use list-utils)
(define (world-width world)
(board-width (world-board world)))
(define (world-height world)
(board-height (world-board world)))
(define (wander-compute-fw world)
(let* ((board (world-board world))
(fw-data (hobofloydwarshall board)))
(cons fw-data board)))
(define (wander-fw-distance fw-data a b)
(path-cost (car a) (cadr a)
(car b) (cadr b)
(car fw-data)
(cdr fw-data)))
;; Finds the closest point to the target in the provided list of points, and
;; places it at the head of the list (the rest may be re-ordered).
(define (point-closest-to-in points target fw-data)
(foldl (lambda (cur-m next)
(if (< (wander-fw-distance fw-data next target)
(wander-fw-distance fw-data (car cur-m) target))
(cons next cur-m)
(cons (car cur-m) (cons next (cdr cur-m)))))
(cons (car points) '())
(cdr points)))
(define (wander-hugs world)
(let* ((fw-data (wander-compute-fw world))
(hugs-locs (find-hugs world))
(robot-loc (find-robot world))
(lift-loc (find-lift world)))
'()))
(define (clusters-merge a b)
(list a b))
(define (contains-cluster? haystack needle)
(cond ((eq? haystack '()) #f)
((eq? needle (car haystack)) #t)
(else (contains-cluster? (cdr haystack) needle))))
(define (find-nearest-cluster fw-data clusters target)
(foldl (lambda (curr next)
(if (< (cluster-distance next target)
(cluster-distance curr target))
next
curr))
(car clusters)
(cdr clusters)))
(define (cluster-extract-points cluster)
(if (number? (car cluster))
cluster
(list (cluster-extract-points (car cluster))
(cluster-extract-points (cdr cluster)))))
(define (cluster-distance fw-data a b)
(let ((a-points (cluster-extract-points a))
(b-points (cluster-extract-points b)))
(apply min
(map (lambda (ap)
(apply min (map (lambda (bp)
(wander-fw-distance fw-data
ap
bp))
b-points)))))))
;; Execute one step in the nearest-neighbour-chain algorithm.
(define (nearest-neighbour-chain1 active-clusters
clusters-stack1
fw-data)
(if (> (length active-cluster) 1)
(apply nearest-neighbour-chain1
(let* ((clusters-stack (if (> (length clusters-stack) 0)
(list (car active-clusters))
(clusters-stack1)))
(c (car clusters-stack))
(d (find-nearest-cluster fw-data active-clusters c)))
(if (contains-cluster? clusters-stack d)
(list (cdr clusters-stack)
(cons (clusters-merge d (car clusters-stack))
(filter (lambda (x) (eq? d x) active-clusters)))
fw-data)
(list (cons d (clusters-stack)) active-clusters)) fw-data))
active-clusters))
(define (nearest-neighbour-chain points fw-data)
(nearest-neighbour-chain1 points '() fw-data))
| false |
d28684f51dc57d781ca5cf9602188c70d7c29241 | 0011048749c119b688ec878ec47dad7cd8dd00ec | /src/055/solution.scm | 1458a2e0e2167ee8fa42acf5e45f891e46a62995 | [
"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 | 563 | scm | solution.scm | (define (reverse-number n)
(let loop ((n n) (acc 0))
(if (= n 0)
acc
(loop (quotient n 10) (+ (* acc 10) (modulo n 10))))))
(define (valid? n)
(let loop ((n (+ n (reverse-number n))) (acc 1))
(if (> acc 50)
#t
(let ((r (reverse-number n)))
(if (= n r)
#f
(loop (+ n r) (+ acc 1)))))))
(define (solve n)
(let loop ((i 0) (acc 0))
(if (> i n)
acc
(loop (+ i 1)
(if (valid? i)
(+ acc 1)
acc)))))
(let ((_ (solve #e1e4)))
(print _) (assert (= _ 249)))
| false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.