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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
a05ebf7f1d45c1e91772351dd34661b92eba7d4c | d1beee618d659e47b2e401a651040de2d7ab982f | /dao/connection-pool.rkt | 66f68283d44e2a39f17d263f8f825fb8214d7b0b | []
| no_license | sindoc/metacima | 77cee62e71c7cdc0a4073f96cc87309938e7eb38 | ea07ac19e456b98c4d38b263888c6df9533b1464 | refs/heads/master | 2021-01-25T10:07:30.404313 | 2012-07-20T16:26:28 | 2012-07-20T16:28:38 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 696 | rkt | connection-pool.rkt | #lang racket
(require db
"../common/utils/debug.rkt")
(provide get-connection-pool
connection-pool-lease
disconnect)
(define metacima-home
(build-path
(find-system-path 'home-dir)
".metacima"))
(unless (directory-exists? metacima-home)
(make-directory metacima-home))
(define db-path
(path->string
(build-path
metacima-home
"database.sqlite")))
(define pool
(connection-pool
(λ ()
(dbg 'connection-pool db-path)
(displayln (format "Connecting to: ~a " db-path))
(sqlite3-connect
#:database db-path
#:mode 'create))
#:max-idle-connections 1
#:max-connections 100))
(define (get-connection-pool) pool) | false |
16c45e99a56e0e98040d182bd98b277e8c30a94f | 099418d7d7ca2211dfbecd0b879d84c703d1b964 | /whalesong/whalesong-helpers.rkt | d48d08083433cfb24a4a3e2c6a54b28cc2b16769 | []
| no_license | vishesh/whalesong | f6edd848fc666993d68983618f9941dd298c1edd | 507dad908d1f15bf8fe25dd98c2b47445df9cac5 | refs/heads/master | 2021-01-12T21:36:54.312489 | 2015-08-19T19:28:25 | 2015-08-19T20:34:55 | 34,933,778 | 3 | 0 | null | 2015-05-02T03:04:54 | 2015-05-02T03:04:54 | null | UTF-8 | Racket | false | false | 15,270 | rkt | whalesong-helpers.rkt | #lang racket/base
(require racket/match
racket/file
racket/path
racket/port
racket/date
racket/runtime-path
racket/pretty
json
"parser/parse-bytecode.rkt"
"parser/path-rewriter.rkt"
"compiler/compiler.rkt"
"compiler/compiler-structs.rkt"
"make/make-structs.rkt"
"js-assembler/package.rkt"
"resource/structs.rkt"
"logger.rkt"
"parameters.rkt"
"js-assembler/check-valid-module-source.rkt"
(for-syntax racket/base))
(provide (all-defined-out))
(define current-verbose? (make-parameter #f))
(define current-output-dir (make-parameter (build-path (current-directory))))
(define current-write-resources? (make-parameter #t))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; IE Compatbility stuff:
(define-runtime-paths (excanvas.js canvas-text.js optimer-normal-normal.js)
(values (build-path "ie-compat" "excanvas.js")
(build-path "ie-compat" "canvas.text.js")
(build-path "ie-compat" "optimer-normal-normal.js")))
(define ie-resources
(list (resource excanvas.js "excanvas.js" #"")
(resource canvas-text.js "canvas.text.js" #"")
(resource optimer-normal-normal.js "optimer-normal-normal.js" #"")))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (with-catchall-exception-handler thunk)
(with-handlers
([exn:invalid-module-source?
(lambda (exn)
(fprintf (current-report-port) "~a\n"
(exn-message exn))
(fprintf (current-report-port) "------------------\n")
(fprintf (current-report-port) "\nAborting compilation.\n"))]
[void (lambda (exn)
(fprintf (current-report-port) "ERROR: Whalesong has encountered an internal error.\n\n")
(fprintf (current-report-port) "Please send the following error report log to [email protected].\n\n")
(define op (open-output-string))
(parameterize ([current-error-port op])
((error-display-handler) (exn-message exn) exn))
(fprintf (current-report-port) "------------------\n")
(displayln (get-output-string op) (current-report-port))
(fprintf (current-report-port) "------------------\n")
(fprintf (current-report-port) "\nAborting compilation.\n"))])
(thunk)))
(define (same-file? p1 p2)
(or (equal? (normalize-path p1) (normalize-path p2))
(bytes=? (call-with-input-file p1 port->bytes)
(call-with-input-file p2 port->bytes))))
(define (turn-on-logger!)
(void (thread (lambda ()
(let ([receiver
(make-log-receiver whalesong-logger
(if (current-verbose?)
'debug
'info))])
(let loop ()
(let ([msg (sync receiver)])
(match msg
[(vector level msg data)
(fprintf (current-report-port)"~a: ~a\n" level msg)
(flush-output (current-report-port))]
[else
(fprintf (current-report-port)"~a\n" msg)
(flush-output (current-report-port))]))
(loop)))))))
(define (build-standalone-html f)
(with-catchall-exception-handler
(lambda ()
(turn-on-logger!)
(let-values ([(base filename dir?)
(split-path f)])
(let ([output-filename
(build-path
(regexp-replace #rx"[.](rkt|ss)$"
(path->string filename)
".html"))])
(unless (directory-exists? (current-output-dir))
(fprintf (current-report-port) "Creating destination directory ~s\n" (current-output-dir))
(make-directory* (current-output-dir)))
(parameterize ([current-on-resource
(lambda (r)
(cond
[(file-exists? (build-path (current-output-dir)
(resource-key r)))
(cond [(same-file? (build-path (current-output-dir)
(resource-key r))
(resource-path r))
(void)]
[else
(error 'whalesong "Unable to write resource ~s; this will overwrite a file that already exists."
(build-path (current-output-dir)
(resource-key r)))])]
[else
(fprintf (current-report-port)
(format "Writing resource ~s\n" (build-path (current-output-dir)
(resource-key r))))
(copy-file (resource-path r)
(build-path (current-output-dir)
(resource-key r)))]))])
(fprintf (current-report-port)
(format "Writing program ~s\n" (build-path (current-output-dir) output-filename)))
(call-with-output-file* (build-path (current-output-dir) output-filename)
(lambda (op)
(package-standalone-html
(make-MainModuleSource
(normalize-path (build-path f)))
op))
#:exists 'replace)))))))
(define (build-html-and-javascript f)
(with-catchall-exception-handler
(lambda ()
(turn-on-logger!)
(define written-js-paths '())
(define written-resources '())
(define module-mappings (make-hash))
(define make-output-js-filename
(let ([n 0])
(lambda (module-name)
(define result (build-path (current-output-dir)
(string-append
(regexp-replace #rx"[.](rkt|ss)$"
(path->string (file-name-from-path f))
"")
(if (= n 0)
".js"
(format "_~a.js" n)))))
(set! written-js-paths (cons result written-js-paths))
(set! n (add1 n))
(fprintf (current-report-port)
(format "Writing program ~s\n" result))
(when module-name
(hash-set! module-mappings module-name result))
result)))
(define (on-resource r)
(cond
[(file-exists? (build-path (current-output-dir) (resource-key r)))
(cond [(same-file? (build-path (current-output-dir)
(resource-key r))
(resource-path r))
(fprintf (current-report-port)
(format "Skipping writing resource ~s; already exists\n"
(build-path (current-output-dir)
(resource-key r))))
(void)]
[else
(error 'whalesong "Unable to write resource ~s; this will overwrite a file that already exists."
(build-path (current-output-dir)
(resource-key r)))])]
[else
(fprintf (current-report-port)
(format "Writing resource ~s\n" (build-path (current-output-dir)
(resource-key r))))
(copy-file (resource-path r)
(build-path (current-output-dir)
(resource-key r)))])
(set! written-resources (cons (resource-key r) written-resources)))
(define start-time (current-inexact-milliseconds))
(let ([title
(regexp-replace #rx"([.](rkt|ss))$"
(path->string (file-name-from-path f))
"")]
[output-html-filename
(build-path
(string-append (regexp-replace #rx"[.](rkt|ss)$"
(path->string (file-name-from-path f))
"")
".html"))]
[output-manifest-filename
(build-path
(string-append
(regexp-replace #rx"[.](rkt|ss)$"
(path->string (file-name-from-path f))
"")
".appcache"))]
[output-js-module-manifest-filename
(build-path
(string-append
(regexp-replace #rx"[.](rkt|ss)$"
(path->string (file-name-from-path f))
"")
"-module-manifest.js"))])
(unless (directory-exists? (current-output-dir))
(fprintf (current-report-port) "Creating destination directory ~s\n" (current-output-dir))
(make-directory* (current-output-dir)))
;; Write out the main module and its other module dependencies.
(parameterize ([current-on-resource on-resource])
(call-with-output-file* (make-output-js-filename #f)
(lambda (op)
(display (get-runtime) op))
#:exists 'replace)
(call-with-output-file* (make-output-js-filename #f)
(lambda (op)
(display (get-inert-code (make-MainModuleSource
(normalize-path (build-path f)))
make-output-js-filename)
op))
#:exists 'replace))
;; We want to get the symbolic name of the main module:
(define main-module-key (rewrite-path (normalize-path (build-path f))))
(when (current-with-legacy-ie-support?)
(for ([r ie-resources]) (on-resource r)))
(fprintf (current-report-port)
(format "Writing html ~s\n" (build-path (current-output-dir) output-html-filename)))
(define dynamically-loaded-modules
(for/list ([(key path) module-mappings]
#:unless (eq? key main-module-key))
(file-name-from-path path)))
(call-with-output-file* (build-path (current-output-dir) output-html-filename)
(lambda (op)
(display (get-html-template
(for*/list ([p (reverse written-js-paths)]
[name (in-value (file-name-from-path p))]
#:unless (member name dynamically-loaded-modules))
name)
#:title title
#:manifest output-manifest-filename
#:module-mappings (for/hash ([(key path) module-mappings])
(values key (path->string (file-name-from-path path)))))
op))
#:exists 'replace)
;; Write the manifest
(fprintf (current-report-port)
(format "Writing manifest ~s\n" (build-path (current-output-dir) output-manifest-filename)))
(call-with-output-file* (build-path (current-output-dir) output-manifest-filename)
(lambda (op)
(fprintf op "CACHE MANIFEST\n")
(fprintf op "## Timestamp: ~a\n" (date->string (current-date) #t))
(for [(js-name (map file-name-from-path (reverse written-js-paths)))]
(fprintf op "~a\n" js-name))
(for [(resource-name written-resources)]
(fprintf op "~a\n" resource-name))
(fprintf op "~a\n" output-js-module-manifest-filename)
(fprintf op "\n# All other resources (e.g. sites) require the user to be online.\nNETWORK:\n*\n"))
#:exists 'replace)
;; Write out the js module manifest:
(fprintf (current-report-port)
(format "Writing js module manifest ~s\n" (build-path (current-output-dir) output-js-module-manifest-filename)))
(call-with-output-file* (build-path (current-output-dir) output-js-module-manifest-filename)
(lambda (op)
(fprintf op "plt.runtime.currentModuleManifest=")
(write-json (for/hash ([(key path) module-mappings])
(values key (path->string (file-name-from-path path))))
op)
(fprintf op ";\n"))
#:exists 'replace)
(define stop-time (current-inexact-milliseconds))
(fprintf (current-timing-port) "Time taken: ~a milliseconds\n" (- stop-time start-time))))))
(define (print-the-runtime)
(with-catchall-exception-handler
(lambda ()
(turn-on-logger!)
(display (get-runtime) (current-output-port)))))
(define (get-javascript-code filename)
(with-catchall-exception-handler
(lambda ()
(turn-on-logger!)
(display (get-standalone-code
(make-MainModuleSource
(normalize-path (build-path filename))))
(current-output-port)))))
(define (print-bytecode filename)
(with-catchall-exception-handler
(lambda ()
(turn-on-logger!)
(define path (normalize-path (build-path filename)))
(define bytecode (parse-bytecode path))
(pretty-print bytecode))))
(define (print-il filename)
(with-catchall-exception-handler
(lambda ()
(turn-on-logger!)
(define path (normalize-path (build-path filename)))
(define bytecode (parse-bytecode path))
(define translation (compile bytecode 'val return-linkage))
(pretty-print translation))))
#;(define (print-version)
(fprintf (current-report-port) "~a\n" (this-package-version)))
| false |
105772a31dfbee87afab0f58efb1cec76ed1353e | 20a9cc2e1884f9e3e8f953ccd7b04e3e4c820f1a | /src/datafile.rkt | f47b2af4f196c6bbd2a077f1c6a343d7e4b04513 | [
"MIT"
]
| permissive | iCodeIN/herbie | 741c2b10b821041c1d234b4c4ee7b57af47a7a3a | d3249e9721223fd6acc70f4a0d21b37f8e2ecfdc | refs/heads/master | 2023-09-06T08:22:59.517664 | 2021-10-01T15:30:05 | 2021-10-01T15:30:05 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 5,330 | rkt | datafile.rkt | #lang racket
(require racket/date json)
(require "common.rkt" "interface.rkt" "preprocess.rkt")
(provide
(struct-out table-row) (struct-out report-info)
make-report-info read-datafile write-datafile)
(struct table-row
(name identifier status pre preprocess precision conversions vars
input output spec target-prog start result target
start-est result-est time bits link cost-accuracy) #:prefab)
(struct report-info
(date commit branch hostname seed flags points iterations note tests) #:prefab #:mutable)
(define (make-report-info tests #:note [note ""] #:seed [seed #f])
(report-info (current-date)
*herbie-commit*
*herbie-branch*
*hostname*
(or seed (get-seed))
(*flags*)
(*num-points*)
(*num-iterations*)
note
tests))
(define (write-datafile file info)
(define (simplify-test test)
(match test
[(table-row name identifier status pre preprocess prec conversions vars
input output spec target-prog
start-bits end-bits target-bits start-est end-est
time bits link cost-accuracy)
(define cost-accuracy*
(if (null? cost-accuracy)
'()
(list (first cost-accuracy)
(second cost-accuracy)
(for/list ([entry (third cost-accuracy)])
(list (first entry) (second entry) (~s (third entry)))))))
(make-hash
`((name . ,name)
(identifier . ,(~s identifier))
(pre . ,(~s pre))
(preprocess . ,(~s (map preprocess->sexp preprocess)))
(prec . ,(~s prec))
(conversions . ,(map (curry map ~s) conversions))
(status . ,status)
(start . ,start-bits)
(end . ,end-bits)
(target . ,target-bits)
(start-est . ,start-est)
(end-est . ,end-est)
(vars . ,(if vars (map symbol->string vars) #f))
(input . ,(~s input))
(output . ,(~s output))
(spec . ,(~s spec))
(target-prog . ,(~s target-prog))
(time . ,time)
(bits . ,bits)
(link . ,(~a link))
(cost-accuracy . ,(~a cost-accuracy*))))]))
(define data
(match info
[(report-info date commit branch hostname seed flags points iterations note tests)
(make-hash
`((date . ,(date->seconds date))
(commit . ,commit)
(branch . ,branch)
(hostname . ,hostname)
(seed . ,(~a seed))
(flags . ,(flags->list flags))
(points . ,points)
(iterations . ,iterations)
(note . ,note)
(tests . ,(map simplify-test tests))))]))
(call-with-output-file file (curry write-json data) #:exists 'replace))
(define (flags->list flags)
(for*/list ([rec (hash->list flags)] [fl (cdr rec)])
(format "~a:~a" (car rec) fl)))
(define (list->flags list)
(make-hash
(for/list ([part (group-by car (map (compose (curry map string->symbol) (curryr string-split ":")) list))])
(cons (car (first part)) (map cadr part)))))
(define (read-datafile file)
(define (parse-string s)
(if s
(call-with-input-string s read)
#f))
(let* ([json (call-with-input-file file read-json)]
[get (λ (field) (hash-ref json field))])
(report-info (seconds->date (get 'date)) (get 'commit) (get 'branch) (hash-ref json 'hostname "")
(parse-string (get 'seed))
(list->flags (get 'flags)) (get 'points)
(get 'iterations)
(hash-ref json 'note #f)
(for/list ([test (get 'tests)] #:when (hash-has-key? test 'vars))
(let ([get (λ (field) (hash-ref test field))])
(define vars
(match (hash-ref test 'vars)
[(list names ...) (map string->symbol names)]
[string-lst (parse-string string-lst)]))
(table-row (get 'name)
(parse-string (hash-ref test 'identifier "#f"))
(get 'status)
(parse-string (hash-ref test 'pre "TRUE"))
(map sexp->preprocess (parse-string (hash-ref test 'herbie-preprocess "()")))
(parse-string (hash-ref test 'prec "binary64"))
(let ([cs (hash-ref test 'conversions "()")])
(if (string? cs)
(parse-string cs)
(map (curry map parse-string) cs)))
vars (parse-string (get 'input)) (parse-string (get 'output))
(parse-string (hash-ref test 'spec "#f"))
(parse-string (hash-ref test 'target-prog "#f"))
(get 'start) (get 'end) (get 'target)
(hash-ref test 'start-est 0) (hash-ref test 'end-est 0)
(get 'time) (get 'bits) (get 'link)
(parse-string (hash-ref test 'cost-accuracy "()"))))))))
| false |
15ab5695c5189d1a8532eaa61d2e39a9b4abedc1 | bb6ddf239800c00988a29263947f9dc2b03b0a22 | /tests/exercise-4.29-test.rkt | c25158734cbf6e3a6a80003b4fa00ae858dc0ad7 | []
| no_license | aboots/EOPL-Exercises | f81b5965f3b17f52557ffe97c0e0a9e40ec7b5b0 | 11667f1e84a1a3e300c2182630b56db3e3d9246a | refs/heads/master | 2022-05-31T21:29:23.752438 | 2018-10-05T06:38:55 | 2018-10-05T06:38:55 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,855 | rkt | exercise-4.29-test.rkt | #lang racket/base
(require rackunit)
(require "../solutions/exercise-4.x-mutable-pairs-lang.rkt")
(check-equal? (run "let a = newarray(2, -99)
p = proc (x)
let v = arrayref(x, 1)
in arrayset(x, 1, -(v, -1))
in begin arrayset(a, 1, 0);
(p a);
(p a);
arrayref(a, 1)
end")
(num-val 2))
(check-equal? (run "arrayref(newarray(3, 2), 0)") (num-val 2))
(check-equal? (run "arrayref(newarray(3, 2), 1)") (num-val 2))
(check-equal? (run "arrayref(newarray(3, 2), 2)") (num-val 2))
(check-equal? (run "let a = newarray(3, 2)
in begin arrayset(a, 0, 4);
arrayref(a, 0)
end")
(num-val 4))
(check-equal? (run "let a = newarray(3, 2)
in begin arrayset(a, 1, 4);
arrayref(a, 0)
end")
(num-val 2))
(check-equal? (run "let a = newarray(3, 2)
in begin arrayset(a, 2, 4);
arrayref(a, 0)
end")
(num-val 2))
(check-equal? (run "let a = newarray(3, 2)
in begin arrayset(a, 0, 4);
arrayref(a, 1)
end")
(num-val 2))
(check-equal? (run "let a = newarray(3, 2)
in begin arrayset(a, 1, 4);
arrayref(a, 1)
end")
(num-val 4))
(check-equal? (run "let a = newarray(3, 2)
in begin arrayset(a, 2, 4);
arrayref(a, 1)
end")
(num-val 2))
| false |
0b445579cb8d6eb994bc3ddf92c4ff3d4ca0152f | 63a1f38e64b0604377fbfa0d10d48545c609cc86 | /cmarks/oopsla2010/sl-tests.rkt | a5bc95945bd1af5f72a6df0c35c0c7e3cf7cd586 | []
| no_license | jeapostrophe/redex | d02b96b441f27e3afa1ef92726741ec026160944 | 8e5810e452878a4ab5153d19725cfc4cf2b0bf46 | refs/heads/master | 2016-09-06T00:55:02.265152 | 2013-10-31T01:24:11 | 2013-10-31T01:24:11 | 618,062 | 2 | 1 | null | null | null | null | UTF-8 | Racket | false | false | 6,815 | rkt | sl-tests.rkt | #lang racket
(require redex
scheme/package
"sl.rkt"
"common.rkt")
;; Tests
;;; Values
(test-->> -->_sl
'(/ mt (λ (x) x))
'(/ mt (λ (x) x)))
(test-->> -->_sl
'(/ mt (unsafe-λ (x) x))
'(/ mt (unsafe-λ (x) x)))
(test-->> -->_sl
'(/ mt ("nil"))
'(/ mt ("nil")))
(test-->> -->_sl
'(/ mt ("S" ("0")))
'(/ mt ("S" ("0"))))
(test-->> -->_sl
'(/ mt (cont hole))
'(/ mt (cont hole)))
(test-->> -->_sl
'(/ mt (! "x"))
'(/ mt (! "x")))
;;; Applications
(test-->> -->_sl
'(/ mt ((λ (x) x) ("nil")))
'(/ mt ("nil")))
(test-->> -->_sl
'(/ mt ((unsafe-λ (x) x) ("nil")))
'(/ mt ("nil")))
;;; Store applications
(test-->> -->_sl
'(/ (snoc mt ["x" -> (λ (x) ("nil"))])
((! "x") ("0")))
'(/ (snoc mt ["x" -> (λ (x) ("nil"))])
("nil")))
;;; Letrec
(test-->> -->_sl
'(/ mt (letrec (["x" (λ (x) ("nil"))])
("foo")))
'(/ (snoc mt ["x" -> (λ (x) ("nil"))])
("foo")))
(test-->> -->_sl
'(/ mt (letrec (["x" (λ (x) ("nil"))])
((! "x") ("0"))))
'(/ (snoc mt ["x" -> (λ (x) ("nil"))])
("nil")))
(test-->> -->_sl
'(/ mt (letrec (["x" (unsafe-λ (x) ("nil"))])
("foo")))
'(/ (snoc mt ["x" -> (unsafe-λ (x) ("nil"))])
("foo")))
(test-->> -->_sl
'(/ mt (letrec (["x" (unsafe-λ (x) ("nil"))])
((! "x") ("0"))))
'(/ (snoc mt ["x" -> (unsafe-λ (x) ("nil"))])
("nil")))
;;; match
(test-->> -->_sl
'(/ mt (match ("S" ("0"))
[("0" n) => ("1")]
[("S" n) => n]))
'(/ mt ("0")))
(test-->> -->_sl
'(/ mt (match ("S" ("0"))
[("S" n) => n]
[("0") => ("1")]))
'(/ mt ("0")))
(test-->> -->_sl
'(/ mt (match ("S" ("0"))
[("0") => ("1")]
[("S" n) => n]))
'(/ mt ("0")))
(test-->> -->_sl
'(/ mt (match ("S" ("0"))
[("0") => ("0")]
[else => ("default")]))
'(/ mt ("default")))
(test-->> -->_sl
`(/ mt ,(:let 'x '(call/cc (λ (x) x))
`(match x
[("0") => ("0")]
[else => ("default")])))
'(/ mt ("default")))
; Store match
(test-->> -->_sl
'(/ mt (letrec (["x" ("S" ("0"))])
(match (! "x")
[("S" n) => n]
[("0") => ("0")])))
'(/ (snoc mt ["x" -> ("S" ("0"))])
("0")))
; Call/cc
(test-->> -->_sl
'(/ mt (call/cc (λ (x) x)))
(term (/ mt (cont hole))))
(test-->> -->_sl
'(/ mt (call/cc (λ (esc)
((λ (x) ("S" ("S" ("S" x))))
(call/cc (λ (k) (esc k)))))))
(term (/ mt (cont ((λ (x) ("S" ("S" ("S" x)))) hole)))))
;;; Continuation invocation
(test-->> -->_sl
(term (/ mt ((cont hole) ("0"))))
'(/ mt ("0")))
(test-->> -->_sl
(term (/ mt ((cont ((λ (x) ("S" x)) hole)) ("0"))))
'(/ mt ("S" ("0"))))
;; arith
(test-->> -->_sl
`(/ mt ,(:let 'x (num 1) 'x))
`(/ mt ,(num 1)))
(test-->> -->_sl
`(/ mt ,(with-arith (num 1)))
`(/ ,arith-store ,(num 1)))
(test-->> -->_sl
`(/ mt ,(with-arith `((! "+") ,(num 1) ,(num 1))))
`(/ ,arith-store ,(num 2)))
(test-->> -->_sl
`(/ mt ,(with-arith `((! "*") ,(num 2) ,(num 2))))
`(/ ,arith-store ,(num 4)))
(test-->> -->_sl
`(/ mt ,(with-arith `((! "=") ,(num 2) ,(num 2))))
`(/ ,arith-store ("#t")))
(test-->> -->_sl
`(/ mt ,(with-arith `((! "=") ,(num 2) ,(num 3))))
`(/ ,arith-store ("#f")))
(test-->> -->_sl
`(/ mt ,(with-arith `((! "-") ,(num 3) ,(num 2))))
`(/ ,arith-store ,(num 1)))
(test-->> -->_sl
`(/ mt ,(with-arith (:if '("#t") (num 1) (num 2))))
`(/ ,arith-store ,(num 1)))
(test-->> -->_sl
`(/ mt ,(with-arith (:if '("#f") (num 1) (num 2))))
`(/ ,arith-store ,(num 2)))
;; callcc puzzles
(test-->> -->_sl
`(/ ,arith-store ((λ (tmp) ((! "+") ,(num 1) tmp))
(call/cc (λ (k)
((λ (tmp) ((! "+") ,(num 2) tmp))
(k ,(num 3)))))))
`(/ ,arith-store ,(num 4)))
;; fact
(package-begin
(define fact-impl
`(λ (n)
,(:if `((! "=") n ,(num 0))
(num 1)
(:let 'sub1-fact
(:let 'sub1 `((! "-") n ,(num 1))
`((! "fact") sub1))
`((! "*") n sub1-fact)))))
(define fact-tr-impl
`(λ (n a)
,(:if `((! "=") n ,(num 0))
'a
(:let 'sub1 `((! "-") n ,(num 1))
(:let 'multa `((! "*") n a)
`((! "fact-tr") sub1 multa))))))
(define (test-fact n)
(test-->> -->_sl
`(/ mt ,(with-arith
`(letrec (["fact" ,fact-impl])
((! "fact") ,(num n)))))
`(/ (snoc ,arith-store ["fact" -> ,fact-impl]) ,(num (fact n)))))
(define (test-fact-tr n)
(test-->> -->_sl
`(/ mt ,(with-arith
`(letrec (["fact-tr" ,fact-tr-impl])
((! "fact-tr") ,(num n) ,(num 1)))))
`(/ (snoc ,arith-store ["fact-tr" -> ,fact-tr-impl]) ,(num (fact n)))))
(for ([i (in-range 0 4)]) (test-fact i))
(for ([i (in-range 0 4)]) (test-fact-tr i)))
(test-->> -->_sl
`(/ mt ,(with-safe
(:let 'l
`((! "unsafe-map")
(λ (x) (call/cc (λ (k) k)))
("cons" ,(num 1) ("cons" ,(num 2) ("nil"))))
`(match l
[("cons" k1 l1)
=>
(match l1
[("cons" k2 l2)
=>
(match k2
[("one") => ("done")]
[else =>
(match l2
[("nil")
=>
(k2 ("one"))])])])]))))
`(/ ,safe-store
("done")))
(test-results)
| false |
1999db74045e792989a27b9cef76a76bb086884e | 174072a16ff2cb2cd60a91153376eec6fe98e9d2 | /2-2-4-racket/2-45.rkt | ccf145070c6f79c8f74009fe0ce7a30e81f29806 | []
| 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 | Racket | false | false | 280 | rkt | 2-45.rkt | #lang racket
(require (planet "sicp.ss" ("soegaard" "sicp.plt" 2 1)))
(require "2-2-4.rkt")
(define e einstein)
(define indentity (lambda(x) x))
(define (split h1 h2)
(lambda (p) (h1 p (h2 p p))))
(define right-split (split beside below))
(define up-split (split below beside))
| false |
361c7435e225c374e80693d63a4e71b0067d6500 | 6c60c8d1303f357c2c3d137f15089230cb09479b | /compatibility-lib/net/pop3-unit.rkt | 3357b8aafdc35eaffb8cf497ec0c205fd012c9e3 | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/compatibility | 6f96569a3e98909e1e89260eeedf4166b5e26890 | 5b2509e30e3b93ca9d6c9d6d8286af93c662d9a8 | refs/heads/master | 2023-08-23T06:41:14.503854 | 2022-07-08T02:43:36 | 2022-07-14T18:00:20 | 27,431,360 | 6 | 10 | NOASSERTION | 2022-07-14T18:00:21 | 2014-12-02T12:23:20 | Racket | UTF-8 | Racket | false | false | 131 | rkt | pop3-unit.rkt | #lang racket/base
(require racket/unit
"pop3-sig.rkt" net/pop3)
(define-unit-from-context pop3@ pop3^)
(provide pop3@)
| false |
891aeaaa3d23f0586374792ed5de045a7ff65fd8 | 7e500549765a0bdc49d4fcf40158fb9bb5b07e3e | /tamer/cmdopt/scp.rkt | 15ffc93a2fd77caca0b8b14244106540f4b1f036 | []
| no_license | capfredf/digimon | 94f3b3946ce115e8ae4472fc757b5f548c519f04 | 1215bb3b1ab86fd115a6f2e393afa4d8530ed576 | refs/heads/master | 2023-04-05T01:27:59.773661 | 2021-04-14T05:32:44 | 2021-04-14T05:32:44 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,314 | rkt | scp.rkt | #lang typed/racket/base
(provide (all-defined-out))
(require digimon/cmdopt)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-cmdlet-option scp-flags #: SCP-Flags
#:program 'scp
#:args (src ... dest)
#:banner "secure copy (remote file copy program)"
#:ps "this cmdlet demonstrates optional arguments appearing before the last one"
#:ps "at least one optional argument is required"
#:once-each
[[(#\P port) port
"specifies the ~1 to connect to on the remote host"]
[(#\p) "preserves modification times, access times, and modes from the original file"]]
#:multi
[[(#\v verbose) "verbose mode"
"multiple -v options increase the verbosity"]]
#:once-any
[[(#\4) "use IPv4 addresses only"]
[(#\6) "use IPv6 addresses only"]])
(define-values (options λargv) (parse-scp-flags))
(define scp : (-> (Pairof String (Listof String)) String Void)
(lambda [srcs dest]
(displayln (list options srcs dest))))
(cond [(scp-flags-help? options) (display-scp-flags)]
[else (with-handlers ([exn:fail:user? (λ [[e : exn:fail:user]] (display-scp-flags #:user-error e #:exit 1))])
(let-values ([(srcs dest) (λargv)])
(scp srcs dest)))])
| false |
6b249a772e9e1b7c98f6d3b4718915195629f7b1 | 31173f24404ec7667aad9044fa868638130591f8 | /a4-Dynamic Scope.rkt | 223298fffe59c768ac63966e3a21d9b6019756a3 | []
| no_license | wang542/B521-Principles-of-Programming-Language | 3978d7f74ae1995cbd1873e4533d3abd36f6094f | ad487a89f574753ef1830e6d27b8d0e8e216ba2a | refs/heads/master | 2020-04-18T06:06:22.827547 | 2019-02-25T19:53:27 | 2019-02-25T19:53:27 | 167,306,278 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 7,828 | rkt | a4-Dynamic Scope.rkt | #lang racket
(define lex
(lambda (exp lst)
(match exp
[(? symbol?) (cons `var (list (index-of lst exp)))]
[`(lambda (,x) ,body) `(lambda ,(lex body (cons x lst)))]
[`,n #:when (number? n) `(const ,n)]
[`,b #:when (boolean? b) `(const ,b)]
[`(* ,a1 ,a2) `(* ,(lex a1 lst) ,(lex a2 lst))]
[`(sub1 ,body) `(sub1 ,(lex body lst))]
[`(zero? ,body) `(zero? ,(lex body lst))]
[`(if ,t ,c ,a) `(if ,(lex t lst) ,(lex c lst) ,(lex a lst))]
[`(,rator ,rand) (list (lex rator lst) (lex rand lst))]
[`(let (( ,var ,exp)) ,body) `(let ,(lex exp lst) ,(lex body (cons var lst)))])))
(define empty-env
(lambda ()
`(empty-env)))
(define extend-env
(lambda (x arg env)
`(extend-env ,x ,arg ,env)))
(define apply-env
(lambda (env var)
(match env
[`(empty-env) (error `value-of "unbound variables ~s" var)]
[`(extend-env, x ,arg ,env) (if (eqv? var x) arg
(apply-env env var))])))
(define closure-ds
(lambda (arg body env)
`(closure-ds ,arg ,body ,env)))
(define apply-closure-ds
(lambda (closure-exp x)
(match closure-exp
[`(closure-ds ,arg ,body ,env) (value-of-ds body (extend-env arg x env))])))
(define value-of-ds
(lambda (e env)
(match e
[`,n #:when (integer? n) n]
[`,y #:when (boolean? y) y]
[`,z #:when (symbol? z) (apply-env env z)]
[`(lambda (,arg),body) #:when (symbol? arg) (closure-ds arg body env)]
[`(zero?, ex) (zero? (value-of-ds ex env))]
[`(sub1 ,nexp) (sub1 (value-of-ds nexp env))]
[`(*, exp1, exp2) (* (value-of-ds exp1 env) (value-of-ds exp2 env))]
[`(if ,t ,c ,a) (if (value-of-ds t env)
(value-of-ds c env)
(value-of-ds a env))]
[`(let ([,var ,value]) ,body) (let ([l (value-of-ds value env)])
(value-of-ds body
(extend-env var l env)))]
[`(,rator ,rand) [apply-closure-ds (value-of-ds rator env)
(value-of-ds rand env)]]
)))
(define closure-fn
(lambda (arg body env)
(lambda (x)
(value-of-fn body (extend-env arg x env)))))
(define apply-closure-fn
(lambda (rator x)
(rator x)))
(define value-of-fn
(lambda (e env)
(match e
[`,n #:when (integer? n) n]
[`,y #:when (boolean? y) y]
[`,z #:when (symbol? z) (apply-env env z)]
[`(lambda (,arg),body) #:when (symbol? arg) (closure-fn arg body env) ]
[`(zero?, ex) (zero? (value-of-fn ex env))]
[`(sub1 ,nexp) (sub1 (value-of-fn nexp env))]
[`(*, exp1, exp2) (* (value-of-fn exp1 env) (value-of-fn exp2 env))]
[`(if ,t ,c ,a) (if (value-of-fn t env)
(value-of-fn c env)
(value-of-fn a env))]
[`(let ([,var ,value]) ,body) (let ([l (value-of-fn value env)])
(value-of-fn body
(extend-env var l env)))]
[`(,rator ,rand) [apply-closure-fn (value-of-fn rator env)
(value-of-fn rand env)]]
)))
(define value-of-dynamic
(lambda (exp env)
(match exp
;car
[`(car ,lst) (car (value-of-dynamic lst env))]
;cdr
[`(cdr ,lst) (cdr (value-of-dynamic lst env))]
;cons
[`(cons ,a ,b) (cons (value-of-dynamic a env) (value-of-dynamic b env))]
;null
[`(null? ,a) (null? (value-of-dynamic a env))]
;number
[`,n #:when (number? n) n]
;boolean
[`,b #:when (boolean? b) b]
;var
[`,v #:when (symbol? v) (apply-env env v)]
;lambda
[`(lambda (,x) ,body) `(lambda (,x) ,body)]
;zero
[`(zero? ,a) (zero? (value-of-dynamic a env))]
;sub1
[`(sub1 ,exp) (sub1 (value-of-dynamic exp env))]
;*
[`(* ,x1 ,x2) (* (value-of-dynamic x1 env)
(value-of-dynamic x2 env))]
;if
[`(if ,t ,c ,a) (if (value-of-dynamic t env)
(value-of-dynamic c env)
(value-of-dynamic a env))]
;let
[`(let ([,var ,exp]) ,body) (value-of-dynamic body (extend-env var (value-of-dynamic exp env) env))]
;quote
[`(quote ,v) v]
;ratorrand
[`(,rator ,rand) (match (value-of-dynamic rator env)
[`(lambda (,x) ,body) (match (value-of-dynamic rand env)
[`,a (value-of-dynamic body (extend-env x a env))])])]
)))
;Brain Teaser
(define empty-env-fn
(lambda ()
(lambda (y)
(error `value-of "unbound variable ~s" y))))
(define extend-env-fn
(lambda (x arg env)
(lambda (var)
(if (eqv? x var) arg (apply-env-fn env var)))))
(define apply-env-fn
(lambda (env var)
(env var)))
(define empty-env-ds
(lambda ()
`(empty-env-ds)))
(define extend-env-ds
(lambda (x var env)
`(extend-env-ds ,x ,var ,env)))
(define apply-env-ds
(lambda (env arg)
(match env
[`(empty-env-ds) (error `apply-env-ds "unbound variable ~s" arg)]
[`(extend-env-ds ,x ,var ,env) (if (eqv? arg x) var (apply-env-ds env arg))])))
(define closure-fn-ri
(lambda (x body env extend-env-ri value-of-ri)
(lambda (var)
((value-of-ri (extend-env-ri x var env))body))))
(define apply-closure-fn-ri
(lambda (lambdaexpression rand extend-env-ri value-of-ri)
(lambdaexpression rand)))
(define closure-ds-ri
(lambda (x body env extend-env-ri value-of-ri)
`(closure-ds-ri ,x ,body ,env)))
(define apply-closure-ds-ri
(lambda (exp rand extend-env-ri value-of-ri)
(match exp
[`(closure-ds-ri ,x ,body ,env)((value-of-ri (extend-env-ri x rand env)) body)])))
(define value-of-ri
(lambda (empty-env extend-env apply-env closure apply-closure)
(letrec ([value-of-ri-r (lambda (env)
(lambda (exp)
(match exp
;number
[`,x #:when (integer? x) x]
;boolean
[`,x #:when (boolean? x) x]
;var
[`,var #:when (symbol? var) (apply-env env var)]
;lambda
[`(lambda (,x) ,body) (closure x body env extend-env value-of-ri-r)]
;zero
[`(zero? ,a) (zero? ((value-of-ri-r env)a ))]
;sub1
[`(sub1 ,a) (sub1 ((value-of-ri-r env) a))]
;*
[`(* ,n1 ,n2) (* ((value-of-ri-r env) n1)
((value-of-ri-r env) n2))]
;if
[`(if ,t ,c ,a) (if ((value-of-ri-r env) t)
((value-of-ri-r env) c)
((value-of-ri-r env) a))]
;let
[`(let ([,var ,value]) ,body) (value-of-ri-r body (extend-env env var value))]
;ratorrand
[`(,rator ,rand) (apply-closure ((value-of-ri-r env) rator)
((value-of-ri-r env) rand) extend-env value-of-ri-r)])))])
(value-of-ri-r empty-env))))
| false |
013ad88d1d0445eb1543c5dc0475153cfd395ae2 | 925045585defcc1f71ee90cf04efb841d46e14ef | /racket/proverif/proverif.rkt | 9493b27476302ace8b02b7ec3a15d98e09c59239 | []
| no_license | rcherrueau/APE | db095c3b6fc43776d1421a16090937a49847bdd9 | a881df53edf84d93ec0a377c2ed02c0d754f7041 | refs/heads/master | 2022-07-19T18:01:41.848025 | 2021-12-19T17:30:23 | 2021-12-19T17:30:23 | 11,178,796 | 4 | 1 | null | 2022-07-07T21:11:07 | 2013-07-04T14:12:52 | Racket | UTF-8 | Racket | false | false | 2,177 | rkt | proverif.rkt | #! /usr/bin/env racket
#lang racket/base
(require (file "/home/rl3x-desktop/prog/APE/racket/proverif/fill-rastache/rastache/main.rkt")
racket/system
racket/cmdline)
(cond
;; Proverif is installed
[(system "hash proverif 2>/dev/null")
;; proverif evaluation namespace
(define proverif-ns (make-base-namespace))
;; Command line
(define color-mode (make-parameter #t))
(define debug-mode (make-parameter #f))
(define with-context (make-parameter #hash()))
(define file-to-compile
(command-line
#:usage-help "Cryptographic protocol verifier"
#:once-each
[("-t" "--test") "display a bit more information for debugging"
(debug-mode #t)]
[("--no-color") "do not use ANSI color codes"
(color-mode #f)]
[("-c" "--context") context
"set the context for mustache expansion"
(with-context
(eval (read (open-input-string context))
proverif-ns))]
#:args (filename)
filename))
(cond
;; The given file exists
[(file-exists? file-to-compile)
;; Compile option
(define options
(let ([opts ""])
(when (color-mode) (set! opts (string-append "-color " opts)))
(when (debug-mode) (set! opts (string-append "-test " opts)))
opts))
;; Expand rastache file
(define output-name "compiled-rastache.pv")
(define output (open-output-file output-name
#:exists 'replace))
(define tokens (rast-compile/open-file file-to-compile))
(rast-render tokens (with-context) output)
;; Call proverif on expanded file
(displayln (format "proverif ~a ~s" options output-name))
(void (system (format "proverif ~a ~s" options output-name)))]
;; The given file doesn't exist
[else
(error (format "File error: ~s: No such file or directory"
file-to-compile))])]
;; Proverif is not installed
[else (error "I require proverif but it's not installed. Aborting.")])
| false |
41512d89c95d3266b33603628420169d740a4a24 | fc90b5a3938850c61bdd83719a1d90270752c0bb | /web-server-lib/web-server/default-web-root/htdocs/servlets/examples/cookie.rkt | 2b6fe0ff29f02726b5fb5566c9c99574f2334c0e | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/web-server | cccdf9b26d7b908701d7d05568dc6ed3ae9e705b | e321f8425e539d22412d4f7763532b3f3a65c95e | refs/heads/master | 2023-08-21T18:55:50.892735 | 2023-07-11T02:53:24 | 2023-07-11T02:53:24 | 27,431,252 | 91 | 42 | NOASSERTION | 2023-09-02T15:19:40 | 2014-12-02T12:20:26 | Racket | UTF-8 | Racket | false | false | 583 | rkt | cookie.rkt | #lang web-server/insta
(require net/url)
(define (start req)
(define cookies (request-cookies req))
(define id-cookie
(findf (lambda (c)
(string=? "id" (client-cookie-name c)))
cookies))
(if id-cookie
(hello (client-cookie-value id-cookie))
(redirect-to
(url->string (request-uri req))
see-other
#:headers
(list
(cookie->header (make-cookie "id" "joseph"))))))
(define (hello who)
(response/xexpr
`(html (head (title "Hello!"))
(body
(h1 "Hello "
,who)))))
| false |
656c9ea2fa6eac2ae676bd8e84dc7ffdfb86631b | 25a6efe766d07c52c1994585af7d7f347553bf54 | /gui-lib/mrlib/cache-image-snip.rkt | 01582bc21d450d130365a1d84cac61b257a9c9ae | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/gui | 520ff8f4ae5704210822204aa7cd4b74dd4f3eef | d01d166149787e2d94176d3046764b35c7c0a876 | refs/heads/master | 2023-08-25T15:24:17.693905 | 2023-08-10T16:45:35 | 2023-08-10T16:45:35 | 27,413,435 | 72 | 96 | NOASSERTION | 2023-09-14T17:09:52 | 2014-12-02T03:35:22 | Racket | UTF-8 | Racket | false | false | 29,341 | rkt | cache-image-snip.rkt | #lang racket/base
(require racket/draw
racket/snip
racket/class
racket/contract
racket/promise
(for-syntax racket/base)
mzlib/string)
(provide cache-image-snip%
cache-image-snip-class%
snip-class
coerce-to-cache-image-snip
snip-size
bitmaps->cache-image-snip)
;; type argb = (make-argb (vectorof rational[between 0 & 255]) int int)
(define-struct argb (vector width height))
#|
The true meaning of an image is a vector of rationals,
between 0 & 255, representing color and alpha channel
information. The vector's contents are analogous to
the last argument to the get-argb-pixels method. That is,
there are (* 4 w h) entries in the vector for an image
of width w and height h, and the entries represent the
alpha, red, green, & blue channels, resp.
When drawn to the screen, the rationals are rounded to
their nearest integer, but the true meaning is kept inside
the image.
note to self:
mask of zero means this image dominates
mask of 255 means this image contributes nothing
black is 0
white is 255
a cleared out bitmap is full of 255s (white)
an alpha of 1 means the pixel value is 0
an alpha of 0 means the pixel value is 255
|#
(define cache-image-snip%
(class image-snip%
;; dc-proc : (union #f ((is-a?/c dc<%>) int[dx] int[dy] -> void))
;; used for direct drawing
(init-field dc-proc)
(define/public (get-dc-proc) dc-proc)
;; argb-proc : ((vectorof rational[0 <= x <= 255]) int[dx] int[dy] -> void)
;; used for drawing into a bitmap
(init-field argb-proc)
(define/public (get-argb-proc) argb-proc)
;; the pinhole's coordinates
(init-field px py)
(when (inexact? px)
(set! px (floor (inexact->exact px))))
(when (inexact? py)
(set! py (floor (inexact->exact py))))
(define/public (get-pinhole) (values px py))
(init-field (width #f)
(height #f))
(define/public (get-size)
(values width height))
;; argb : (union #f argb)
(init-field [argb #f])
;; bitmap : (union #f (is-a?/c bitmap%))
;; the way that this image is be drawn, on its own
(define bitmap #f)
(define/override (copy)
(new cache-image-snip%
(dc-proc dc-proc)
(argb-proc argb-proc)
(width width)
(height height)
(argb argb)
(px px)
(py py)))
;; get-bitmap : -> bitmap or false
;; returns a bitmap showing what the image would look like,
;; if it were drawn
(define/override (get-bitmap)
(cond
[(or (zero? width) (zero? height))
#f]
[else
(unless bitmap
(set! bitmap (argb->bitmap (get-argb))))
bitmap]))
;; get-argb : -> argb
(define/public (get-argb)
(unless argb
(set! argb (make-argb (make-vector (* 4 width height) 255) width height))
(argb-proc argb 0 0))
argb)
;; get-argb/no-compute : -> (union #f argb)
(define/public (get-argb/no-compute)
argb)
(define/override (get-extent dc x y w h descent space lspace rspace)
(set-box/f! w width)
(set-box/f! h height)
(set-box/f! descent 0)
(set-box/f! space 0)
(set-box/f! lspace 0)
(set-box/f! rspace 0))
(define/override (draw dc x y left top right bottom dx dy draw-caret)
(cond
[argb
(let ([bitmap (get-bitmap)])
(when bitmap
(send dc draw-bitmap bitmap x y 'solid
(send the-color-database find-color "black")
(send bitmap get-loaded-mask))))]
[dc-proc
(let ([smoothing (send dc get-smoothing)])
(send dc set-smoothing 'aligned)
(dc-proc dc x y)
(send dc set-smoothing smoothing))]
[else (void)]))
(define/override (write f)
(let ([str (string->bytes/utf-8
(format "~s"
(list (argb-vector (get-argb))
width
height
px
py)))])
(send f put str)))
(define/override (get-num-scroll-steps) (inexact->exact (+ (floor (/ height 20)) 1)))
(define/override (find-scroll-step y) (inexact->exact (floor (/ y 20))))
(define/override (get-scroll-step-offset offset) (* offset 20))
(define/override (equal-to? snip recur)
(if (snip . is-a? . cache-image-snip%)
;; Support extensions of cache-image-snip%:
(send snip other-equal-to? this recur)
;; Use ths object's extension:
(other-equal-to? snip recur)))
(define/override (other-equal-to? snip recur)
(image=? this snip))
(super-new)
(inherit set-snipclass)
(set-snipclass snip-class)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; snip-class
;;
(define cache-image-snip-class%
(class snip-class%
(define/override (read f)
(data->snip (read-from-string (send f get-bytes) (lambda () #f))))
(define/public (data->snip data)
(cond
[(not (list? data)) (make-null-cache-image-snip)]
[(= (length data) 4)
;; this is the case for old save files
;; if the width is zero, the height
;; will automatically also be zero
(let ([argb-vec (list-ref data 0)]
[width (list-ref data 1)]
[px (list-ref data 2)]
[py (list-ref data 3)])
(argb->cache-image-snip (make-argb argb-vec
width
(if (zero? width)
0
(/ (vector-length argb-vec) width 4)))
px
py))]
[(= (length data) 5)
;; this is the new saved data and it has the width and the height separately.
(let ([argb-vec (list-ref data 0)]
[width (list-ref data 1)]
[height (list-ref data 2)]
[px (list-ref data 3)]
[py (list-ref data 4)])
(argb->cache-image-snip (make-argb argb-vec width height) px py))]))
(super-new)))
(define snip-class (new cache-image-snip-class%))
(send snip-class set-version 1)
(send snip-class set-classname (format "~s" `(lib "cache-image-snip.ss" "mrlib")))
;; ***** WARNING: illegal activities **** -- MF
(define the-drscheme-snip-class (get-the-snip-class-list))
(send the-drscheme-snip-class add snip-class)
(provide the-drscheme-snip-class)
;; ***** WARNING: illegal activities ****
(define (make-null-cache-image-snip)
(define size 10)
(define (draw dc dx dy)
(with-pen/brush
dc
"black" 'solid
"black" 'transparent
(send dc draw-ellipse dx dy size size)
(send dc draw-line dx (+ dy size -1) (+ dx size -1) dy)))
(define bm (build-bitmap (lambda (dc) (draw dc 0 0))
size
size))
(new cache-image-snip%
(width size)
(height size)
(draw-proc draw)
(px (/ size 2))
(py (/ size 2))
(argb-proc
(lambda (argb dx dy)
(overlay-bitmap argb size size dx dy bm bm)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; image equality
;;
(define size-dc (delay (make-object bitmap-dc% (make-object bitmap% 1 1))))
(define (snip-size a)
(cond
[(is-a? a cache-image-snip%)
(send a get-size)]
[else
(let* ([dc (force size-dc)]
[wb (box 0)]
[hb (box 0)])
(send a get-extent dc 0 0 wb hb #f #f #f #f)
(values (unbox wb)
(unbox hb)))]))
(define (image=? a-raw b-raw)
(let ([a (coerce-to-cache-image-snip a-raw)]
[b (coerce-to-cache-image-snip b-raw)])
(let-values ([(aw ah) (snip-size a)]
[(bw bh) (snip-size b)]
[(apx apy) (send a get-pinhole)]
[(bpx bpy) (send b get-pinhole)])
(and (= aw bw)
(= ah bh)
(= apx bpx)
(= apy bpy)
(same/alpha? (argb-vector (send a get-argb))
(argb-vector (send b get-argb)))))))
(define (same/alpha? v1 v2)
(let loop ([i (vector-length v1)])
(or (zero? i)
(let ([a1 (vector-ref v1 (- i 4))]
[a2 (vector-ref v2 (- i 4))])
(and (or (= a1 a2 255)
(and (= a1 a2)
(= (vector-ref v1 (- i 3)) (vector-ref v2 (- i 3)))
(= (vector-ref v1 (- i 2)) (vector-ref v2 (- i 2)))
(= (vector-ref v1 (- i 1)) (vector-ref v2 (- i 1)))))
(loop (- i 4)))))))
(define image-snip-cache (make-weak-hasheq))
;; coerce-to-cache-image-snip : image -> (is-a?/c cache-image-snip%)
(define (coerce-to-cache-image-snip snp)
(cond
[(is-a? snp cache-image-snip%) snp]
[(hash-ref image-snip-cache snp (λ () #f)) => values]
[(is-a? snp image-snip%)
(let* ([bmp (send snp get-bitmap)]
[cis
(if bmp
(let ([bmp-mask (or (send bmp get-loaded-mask)
(send snp get-bitmap-mask)
(bitmap->mask bmp))])
(bitmaps->cache-image-snip (copy-bitmap bmp)
(copy-bitmap bmp-mask)
(floor (/ (send bmp get-width) 2))
(floor (/ (send bmp get-height) 2))))
(let-values ([(w h) (snip-size snp)])
(let* ([bmp (make-object bitmap%
(inexact->exact (floor w))
(inexact->exact (floor h)))]
[bdc (make-object bitmap-dc% bmp)])
(send bdc clear)
(send snp draw bdc 0 0 0 0 w h 0 0 'no-caret)
(send bdc set-bitmap #f)
(bitmaps->cache-image-snip bmp
(bitmap->mask bmp)
(floor (/ w 2))
(floor (/ h 2))))))])
(hash-set! image-snip-cache snp cis)
cis)]
[else snp]))
;; copy-bitmap : bitmap -> bitmap
;; does not copy the mask.
(define (copy-bitmap bitmap)
(let* ([w (send bitmap get-width)]
[h (send bitmap get-height)]
[copy (make-object bitmap% w h)]
[a-dc (make-object bitmap-dc% copy)])
(send a-dc clear)
(send a-dc draw-bitmap bitmap 0 0)
(send a-dc set-bitmap #f)
copy))
;; bitmap->mask : bitmap -> bitmap
(define (bitmap->mask bitmap)
(let* ([w (send bitmap get-width)]
[h (send bitmap get-height)]
[s (make-bytes (* 4 w h))]
[new-bitmap (make-object bitmap% w h)]
[dc (make-object bitmap-dc% new-bitmap)])
(send dc clear)
(send dc draw-bitmap bitmap 0 0)
(send dc get-argb-pixels 0 0 w h s)
(let loop ([i (* 4 w h)])
(unless (zero? i)
(let ([r (- i 3)]
[g (- i 2)]
[b (- i 1)])
(unless (and (eq? 255 (bytes-ref s r))
(eq? 255 (bytes-ref s g))
(eq? 255 (bytes-ref s b)))
(bytes-set! s r 0)
(bytes-set! s g 0)
(bytes-set! s b 0))
(loop (- i 4)))))
(send dc set-argb-pixels 0 0 w h s)
(begin0
(send dc get-bitmap)
(send dc set-bitmap #f))))
(define (bitmaps->cache-image-snip color mask px py)
(let ([w (send color get-width)]
[h (send color get-height)])
(new cache-image-snip%
[width w]
[height h]
[dc-proc
(lambda (dc dx dy)
(send dc draw-bitmap color dx dy 'solid
(send the-color-database find-color "black")
mask))]
[argb-proc
(lambda (argb-vector dx dy)
(overlay-bitmap argb-vector dx dy color mask))]
[px px]
[py py])))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; misc. utilities
;;
;; takes a bitmap with a mask and flattens the colors and the mask
;; drawing them as they would appear on the screen.
(define (flatten-bitmap bm)
(let* ([w (send bm get-width)]
[h (send bm get-height)]
[new-bm (make-object bitmap% w h)]
[bdc (make-object bitmap-dc% new-bm)])
(send bdc clear)
(send bdc draw-bitmap bm 0 0 'solid
(send the-color-database find-color "black")
(send bm get-loaded-mask))
(send bdc set-bitmap #f)
new-bm))
;; build-bitmap : (dc -> void) number number -> bitmap
(define (build-bitmap draw w h)
(let* ([bm (make-object bitmap% w h)]
[bdc (make-object bitmap-dc% bm)])
(send bdc clear)
; (send bdc set-smoothing 'aligned) ; causes image-inside? to fail in test suite.
(draw bdc)
(send bdc set-bitmap #f)
bm))
(define-syntax (with-pen/brush stx)
(syntax-case stx ()
[(_ dc pen-color pen-style brush-color brush-style code ...)
(syntax
(let ([old-pen (send dc get-pen)]
[old-brush (send dc get-brush)])
(send dc set-pen (send the-pen-list find-or-create-pen pen-color 1 pen-style))
(send dc set-brush (send the-brush-list find-or-create-brush brush-color brush-style))
code ...
(send dc set-pen old-pen)
(send dc set-brush old-brush)))]))
(define (set-box/f! b v) (when (box? b) (set-box! b v)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; argb vector utilties
;;
;; argb->cache-image-snip : argb number number -> cache-image-snip
(define (argb->cache-image-snip argb px py)
(let* ([width (argb-width argb)]
[height (argb-height argb)]
[argb-vector (argb-vector argb)]
[bitmap (argb->bitmap argb)]
[mask (and bitmap (send bitmap get-loaded-mask))])
(new cache-image-snip%
(width width)
(height height)
(argb argb)
(px px)
(py py)
(argb-proc (if (or (zero? width) (zero? height))
void
(lambda (argb dx dy) (overlay-bitmap argb dx dy bitmap mask))))
(dc-proc (if (or (zero? width) (zero? height))
void
(lambda (dc dx dy)
(send dc draw-bitmap bitmap dx dy 'solid
(send the-color-database find-color "black")
mask)))))))
;; argb-vector->bitmap : argb -> bitmap or false
;; flattens the argb vector into a bitmap
(define (argb->bitmap argb)
(let* ([argb-vector (argb-vector argb)]
[w (argb-width argb)]
[h (argb-height argb)])
(cond
[(or (zero? w) (zero? h)) #f]
[else
(let* ([bm (make-object bitmap% w h)]
[mask-bm (make-object bitmap% w h)]
[bdc (new bitmap-dc% (bitmap bm))]
[bytes (make-bytes (vector-length argb-vector) 255)]
[mask-bytes (make-bytes (vector-length argb-vector) 255)])
(let loop ([i (- (vector-length argb-vector) 1)])
(cond
[(zero? (modulo i 4))
(let ([av (round (vector-ref argb-vector i))])
(bytes-set! mask-bytes (+ i 1) av)
(bytes-set! mask-bytes (+ i 2) av)
(bytes-set! mask-bytes (+ i 3) av))]
[else
(bytes-set! bytes i (round (vector-ref argb-vector i)))])
(unless (zero? i)
(loop (- i 1))))
(send bdc set-argb-pixels 0 0 w h bytes)
(send bdc set-bitmap mask-bm)
(send bdc set-argb-pixels 0 0 w h mask-bytes)
(send bdc set-bitmap #f)
(send bm set-loaded-mask mask-bm)
bm)])))
;; overlay-bitmap : argb int int bitmap bitmap -> void
;; assumes that the mask bitmap only has greyscale in it
;; (ie, that looking at the red component of the mask is enough)
(define (overlay-bitmap argb dx dy color mask)
(let* ([argb-vector (argb-vector argb)]
[argb-w (argb-width argb)]
[w (send color get-width)]
[h (send color get-height)]
[color-bytes (make-bytes (* w h 4) 0)]
[mask-bytes (make-bytes (* w h 4) 0)]
[dc (make-object bitmap-dc%)])
(send dc set-bitmap color)
(send dc get-argb-pixels 0 0 w h color-bytes)
(send dc set-bitmap #f) ;; in case mask and color are the same bitmap....
(send dc set-bitmap mask)
(send dc get-argb-pixels 0 0 w h mask-bytes)
(send dc set-bitmap #f)
(let yloop ([y 0]
[str-i 0])
(unless (= y h)
(let xloop ([x 0]
[str-i str-i])
(if (= x w)
(yloop (add1 y) str-i)
(begin
(when (and (<= 0 (+ x dx))
(< (+ x dx) argb-w))
(let ([argb-i (* 4 (+ (+ dx x) (* (+ dy y) argb-w)))])
(when (and (<= 0 argb-i)
(< argb-i (vector-length argb-vector)))
(let* ([m1 (vector-ref argb-vector argb-i)]
[m2 (bytes-ref mask-bytes (+ str-i 1))] ;; get red coordinate
[m3 (build-m3 m1 m2)]
[bang (lambda (i v) (vector-set! argb-vector i (floor v)))]
[do-b
(lambda (off)
(bang (+ argb-i off)
(build-b3 m1
(vector-ref argb-vector (+ argb-i off))
m2
(bytes-ref color-bytes (+ str-i off))
m3)))])
(bang argb-i m3)
(do-b 1)
(do-b 2)
(do-b 3)))))
(xloop (+ x 1) (+ str-i 4)))))))))
#|
From Matthew's computation in PR 6930:
> m3 is (m1+m2-m1*m2) and
> b3 is (m1*b1*(1-m2) + m2*b2)/m3
but that's for values between 0 and 1 and we
need values between 0 and 255. Worse, the values
sense are reversed. That is,
1 above corresponds to 0 in pixel values and
0 above corresponds to 255.
;; the spec
(define (build-m3-0 big-m1 big-m2)
(let ([m1 (- 1 (/ big-m1 255))]
[m2 (- 1 (/ big-m2 255))])
(let ([m3 (+ m1 m2 (- (* m1 m2)))])
(* 255 (- 1 m3)))))
; = substitute in lets
(define (build-m3-1 m1 m2)
(* 255 (- 1 (+ (- 1 (/ m1 255))
(- 1 (/ m2 255))
(- (* (- 1 (/ m1 255))
(- 1 (/ m2 255))))))))
;= multiply out last product
(define (build-m3-2 m1 m2)
(* 255 (- 1 (+ (- 1 (/ m1 255))
(- 1 (/ m2 255))
(- (+ 1
(- (/ m1 255))
(- (/ m2 255))
(* (- (/ m1 255)) (- (/ m2 255)))))))))
; = lift out the neagtives into topmost sum
(define (build-m3-3 m1 m2)
(* 255 (- 1 (+ (- (/ m1 255))
1
(- (/ m2 255))
1
-1
(/ m1 255)
(/ m2 255)
(- (* (/ m1 255) (/ m2 255)))))))
; = push in topmost subtraction
(define (build-m3-4 m1 m2)
(* 255 (+ 1
(/ m1 255)
-1
(/ m2 255)
-1
1
(- (/ m1 255))
(- (/ m2 255))
(* (/ m1 255) (/ m2 255)))))
; = simplify sum:
(define (build-m3-5 m1 m2)
(* 255 (* (/ m1 255) (/ m2 255))))
; = distribute 255
(define (build-m3-6 m1 m2) (* m1 m2 1/255))
(define (test-m3 m1 m2)
(values (build-m3-0 m1 m2)
(build-m3-1 m1 m2)
(build-m3-2 m1 m2)
(build-m3-3 m1 m2)
(build-m3-4 m1 m2)
(build-m3-5 m1 m2)
(build-m3-6 m1 m2)))
(test-m3 0 0)
(test-m3 255 255)
(test-m3 100 200)
for b3, we have:
(define (build-m3-6 m1 m2) (* m1 m2 1/255))
;; the spec
(define (build-b3-0 big-m1 big-b1 big-m2 big-b2 big-m3)
(let ([m1 (- 1 (/ big-m1 255))]
[b1 (- 1 (/ big-b1 255))]
[m2 (- 1 (/ big-m2 255))]
[b2 (- 1 (/ big-b2 255))]
[m3 (- 1 (/ big-m3 255))])
(let ([ans (/ (+ (* m1 b1 (- 1 m2)) (* m2 b2)) m3)])
(* 255 (- 1 ans)))))
;; = substitute in for let.
(define (build-b3-1 m1 b1 m2 b2 m3)
(* 255 (- 1 (/ (+ (* (- 1 (/ m1 255)) (- 1 (/ b1 255)) (- 1 (- 1 (/ m2 255))))
(* (- 1 (/ m2 255)) (- 1 (/ b2 255))))
(- 1 (/ m3 255))))))
;; = simple substitution
(define (build-b3-2 m1 b1 m2 b2 m3)
(* 255 (- 1 (/ (+ (* (- 1 (/ m1 255)) (- 1 (/ b1 255)) (/ m2 255))
(* (- 1 (/ m2 255)) (- 1 (/ b2 255))))
(- 1 (/ m3 255))))))
;; = multiply out first part of first *
(define (build-b3-3 m1 b1 m2 b2 m3)
(* 255 (- 1 (/ (+ (* (+ 1
(- (/ m1 255))
(- (/ b1 255))
(* (/ m1 255) (/ b1 255)))
(/ m2 255))
(* (- 1 (/ m2 255)) (- 1 (/ b2 255))))
(- 1 (/ m3 255))))))
;; = distribute out newly created product
(define (build-b3-4 m1 b1 m2 b2 m3)
(* 255 (- 1 (/ (+ (/ m2 255)
(* (- (/ m1 255)) (/ m2 255))
(* (- (/ b1 255)) (/ m2 255))
(* (/ m1 255) (/ b1 255) (/ m2 255))
(* (- 1 (/ m2 255)) (- 1 (/ b2 255))))
(- 1 (/ m3 255))))))
;; = multiply out product of sum
(define (build-b3-5 m1 b1 m2 b2 m3)
(* 255 (- 1 (/ (+ (/ m2 255)
(* (- (/ m1 255)) (/ m2 255))
(* (- (/ b1 255)) (/ m2 255))
(* (/ m1 255) (/ b1 255) (/ m2 255))
(+ 1
(- (/ m2 255))
(- (/ b2 255))
(* (/ m2 255) (/ b2 255))))
(- 1 (/ m3 255))))))
;; = flatten out sum of sum & simplify
(define (build-b3-6 m1 b1 m2 b2 m3)
(* 255 (- 1 (/ (+ (* (- (/ m1 255)) (/ m2 255))
(* (- (/ b1 255)) (/ m2 255))
(* (/ m1 255) (/ b1 255) (/ m2 255))
1
(- (/ b2 255))
(* (/ m2 255) (/ b2 255)))
(- 1 (/ m3 255))))))
;; = rearrange denom
(define (build-b3-7 m1 b1 m2 b2 m3)
(* 255 (- 1 (/ (+ (* (- (/ m1 255)) (/ m2 255))
(* (- (/ b1 255)) (/ m2 255))
(* (/ m1 255) (/ b1 255) (/ m2 255))
1
(- (/ b2 255))
(* (/ m2 255) (/ b2 255)))
(/ (- 255 m3) 255)))))
;; = move 255 to numerator
(define (build-b3-8 m1 b1 m2 b2 m3)
(* 255 (- 1 (/ (* 255 (+ (* (- (/ m1 255)) (/ m2 255))
(* (- (/ b1 255)) (/ m2 255))
(* (/ m1 255) (/ b1 255) (/ m2 255))
1
(- (/ b2 255))
(* (/ m2 255) (/ b2 255))))
(- 255 m3)))))
;; cancel out 255s in numerator
(define (build-b3-9 m1 b1 m2 b2 m3)
(* 255 (- 1 (/ (+ (* (- m1) (/ m2 255))
(* (- b1) (/ m2 255))
(* m1 (/ b1 255) (/ m2 255))
255
(- b2)
(* m2 (/ b2 255)))
(- 255 m3)))))
;; rearrange numerator
(define (build-b3-10 m1 b1 m2 b2 m3)
(* 255 (- 1 (/ (+ (/ (* (- m1) m2) 255)
(/ (* (- b1) m2) 255)
(/ (* m1 b1 (/ m2 255)) 255)
(/ (* 255 255) 255)
(/ (* 255 (- b2)) 255)
(/ (* m2 b2) 255))
(- 255 m3)))))
;; pull out 255 in num
(define (build-b3-11 m1 b1 m2 b2 m3)
(* 255 (- 1 (/ (/ (+ (* (- m1) m2)
(* (- b1) m2)
(* m1 b1 (/ m2 255))
(* 255 255)
(* 255 (- b2))
(* m2 b2))
255)
(- 255 m3)))))
;; push 255 into denom
(define (build-b3-12 m1 b1 m2 b2 m3)
(* 255 (- 1 (/ (+ (* (- m1) m2)
(* (- b1) m2)
(* m1 b1 (/ m2 255))
(* 255 255)
(* 255 (- b2))
(* m2 b2))
(* 255 (- 255 m3))))))
;; turn 1 into (/ (* 255 (- 255 m3)) (* 255 (- 255 m3)))
;; and add into numerator
(define (build-b3-13 m1 b1 m2 b2 m3)
(* 255 (/ (- (* 255 (- 255 m3))
(+ (* (- m1) m2)
(* (- b1) m2)
(* m1 b1 (/ m2 255))
(* 255 255)
(* 255 (- b2))
(* m2 b2)))
(* 255 (- 255 m3)))))
;; cancel out outer 255
(define (build-b3-14 m1 b1 m2 b2 m3)
(/ (- (* 255 (- 255 m3))
(+ (* (- m1) m2)
(* (- b1) m2)
(* m1 b1 (/ m2 255))
(* 255 255)
(* 255 (- b2))
(* m2 b2)))
(- 255 m3)))
;; push negative thru to make big sum in numerator
(define (build-b3-15 m1 b1 m2 b2 m3)
(/ (+ (* 255 (- 255 m3))
(* m1 m2)
(* b1 m2)
(- (* m1 b1 (/ m2 255)))
(- (* 255 255))
(* 255 b2)
(- (* m2 b2)))
(- 255 m3)))
;; distribute 255 in first num term
(define (build-b3-16 m1 b1 m2 b2 m3)
(/ (+ (* 255 255)
(- (* 255 m3))
(* m1 m2)
(* b1 m2)
(- (* m1 b1 (/ m2 255)))
(- (* 255 255))
(* 255 b2)
(- (* m2 b2)))
(- 255 m3)))
;; simplify num
(define (build-b3-17 m1 b1 m2 b2 m3)
(/ (+ (* m1 m2)
(* b1 m2)
(- (* m2 b2))
(- (* m1 b1 m2 1/255))
(* 255 b2)
(- (* 255 m3)))
(- 255 m3)))
;; simplify num, some more
(define (build-b3-18 m1 b1 m2 b2 m3)
(/ (+ (* (+ m1 b1 (- b2)) m2)
(* m1 b1 m2 -1/255)
(* 255 b2)
(* -255 m3))
(- 255 m3)))
(define (test-b3 m1 b1 m2 b2)
(let ([m3 (build-m3-6 m1 m2)])
(values (build-b3-0 m1 b1 m2 b2 m3)
(build-b3-1 m1 b1 m2 b2 m3)
(build-b3-2 m1 b1 m2 b2 m3)
(build-b3-3 m1 b1 m2 b2 m3)
(build-b3-4 m1 b1 m2 b2 m3)
(build-b3-5 m1 b1 m2 b2 m3)
(build-b3-6 m1 b1 m2 b2 m3)
(build-b3-7 m1 b1 m2 b2 m3)
(build-b3-8 m1 b1 m2 b2 m3)
(build-b3-9 m1 b1 m2 b2 m3)
(build-b3-10 m1 b1 m2 b2 m3)
(build-b3-11 m1 b1 m2 b2 m3)
(build-b3-12 m1 b1 m2 b2 m3)
(build-b3-13 m1 b1 m2 b2 m3)
(build-b3-14 m1 b1 m2 b2 m3)
(build-b3-15 m1 b1 m2 b2 m3)
(build-b3-16 m1 b1 m2 b2 m3)
(build-b3-17 m1 b1 m2 b2 m3)
(build-b3-18 m1 b1 m2 b2 m3)
)))
(test-b3 255 100 0 250)
(test-b3 0 150 255 100)
(test-b3 100 200 75 150)
|#
(define (build-m3 m1 m2) (* m1 m2 1/255))
(define (build-b3 m1 b1 m2 b2 m3)
(if (= m3 255)
0
(/ (+ (* (+ m1 b1 (- b2)) m2)
(* m1 b1 m2 -1/255)
(* 255 b2)
(* -255 m3))
(- 255 m3))))
(define bitmap-size/c (and/c integer? exact? (between/c 1 10000)))
(provide/contract
[overlay-bitmap (argb? exact-integer?
exact-integer?
(is-a?/c bitmap%)
(is-a?/c bitmap%)
. -> .
any)]
[build-bitmap (((is-a?/c dc<%>) . -> . any) bitmap-size/c bitmap-size/c . -> . (is-a?/c bitmap%))]
[flatten-bitmap ((is-a?/c bitmap%) . -> . (is-a?/c bitmap%))]
[argb->cache-image-snip (argb? number? number? . -> . (is-a?/c cache-image-snip%))]
[argb->bitmap (argb? . -> . (or/c #f (is-a?/c bitmap%)))]
[argb? (any/c . -> . boolean?)]
[make-argb ((vectorof byte?) exact-nonnegative-integer? exact-nonnegative-integer? . -> . argb?)]
[argb-vector (argb? . -> . (vectorof byte?))]
[argb-width (argb? . -> . exact-nonnegative-integer?)]
[argb-height (argb? . -> . exact-nonnegative-integer?)])
| true |
bc7aa45b61bda3f6b9ac0bee2c3ae87df4a10f79 | 82c76c05fc8ca096f2744a7423d411561b25d9bd | /typed-racket-more/typed/xml/path.rkt | dcbcf81d686d4c92d7f4ec87c27ab12adec05135 | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/typed-racket | 2cde60da289399d74e945b8f86fbda662520e1ef | f3e42b3aba6ef84b01fc25d0a9ef48cd9d16a554 | refs/heads/master | 2023-09-01T23:26:03.765739 | 2023-08-09T01:22:36 | 2023-08-09T01:22:36 | 27,412,259 | 571 | 131 | NOASSERTION | 2023-08-09T01:22:41 | 2014-12-02T03:00:29 | Racket | UTF-8 | Racket | false | false | 268 | rkt | path.rkt | #lang typed/racket/base
(require (only-in "../xml.rkt" XExpr))
(provide (all-defined-out))
(define-type Se-Path
(Listof (U Symbol Keyword)))
(require/typed/provide xml/path
[se-path*/list (-> Se-Path XExpr (Listof Any))]
[se-path* (-> Se-Path XExpr Any)])
| false |
a4aae2e6b304545227585023418b21891975f543 | bf68f7b03459b2bc3748842f3184a75fc92ddf60 | /metapict/metapict.rkt | 0a8ad6c9f48d5bdef36ae0802b15017032835c0a | []
| no_license | stchang/metapict | 965c9781b28fa16e7d7078cfaac0e5adf6e7cc30 | 237ae35c7b26b86be5d472f0b7e110c438239af2 | refs/heads/master | 2020-12-07T15:16:56.411326 | 2014-02-10T23:27:56 | 2014-02-10T23:27:56 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,170 | rkt | metapict.rkt | #lang racket
(require racket/draw math/flonum
(except-in pict arrow)
(only-in srfi/1 zip unzip2)
"def.rkt" "dc.rkt" "bez.rkt" "window.rkt" "path.rkt" "curve.rkt"
"structs.rkt" "trig.rkt" "pt-vec.rkt" "angles.rkt" "trans.rkt"
"color.rkt" "pict.rkt" "device.rkt" "arrow.rkt" "shapes.rkt" "pen-and-brush.rkt"
"draw.rkt" "label.rkt" "shapes.rkt" "parameters.rkt" "grid.rkt")
(provide (all-from-out
pict
"def.rkt" "dc.rkt" "bez.rkt" "window.rkt" "path.rkt" "curve.rkt"
"structs.rkt" "trig.rkt" "pt-vec.rkt" "angles.rkt" "trans.rkt"
"color.rkt" "pict.rkt" "device.rkt" "arrow.rkt" "shapes.rkt" "pen-and-brush.rkt"
"draw.rkt" "label.rkt" "shapes.rkt" "parameters.rkt" "arrow.rkt" "grid.rkt")
; macros from draw.rkt
for/draw for*/draw
; macros from window.rkt
with-window
with-scaled-window
above
beside
~vec)
(define above vc-append)
(define beside hc-append)
(define (~vec v)
(define (t x) (text (~a x)))
(defm (vec x y) v)
(beside (t "(") (scale (above (t x) (t y)) 0.5) (t ")")))
| false |
e2ef750101900f0107a079b04f0b83bcadf47f91 | 28df383ef3d0cf36d4dd40c478b4c26f0d22bad6 | /2.65.rkt | b350077f5d94b341e323915b79417b1d24b8ad3d | []
| no_license | stefanruijsenaars/sicp-exercises | 2df9dc6f62b6701842490da7155da0d5c0230d02 | 7c6cf3f8ec38f6bd32a9bf120b23de0315ae6193 | refs/heads/master | 2021-01-21T22:15:06.088385 | 2017-10-11T17:48:37 | 2017-10-11T17:48:37 | 102,140,021 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 260 | rkt | 2.65.rkt | #lang sicp
; add previous definitions
(define (union-set-tree tree1 tree2)
(list->tree (union-set (tree->list tree1) (tree->list tree2))))
(define (intersection-set-tree tree1 tree2)
(list->tree (intersection-set (tree->list tree1) (tree->list tree2)))) | false |
016229ee2aa4c1b0a50c72c277b138a6e6be2028 | c5e9ad8c15b0a353f4d27bfdb95119f9cf4bd973 | /bitmap/tamer/composite/multiple-composite.rkt | 6f995b493d1372415d1ad3cf4b76709ddb42f1af | []
| no_license | wargrey/graphics | 807d18642df1d3e75456c92ed571038e50aee01e | ba858504ff361f7beba221455304eadf7c01edf0 | refs/heads/master | 2023-08-10T08:18:30.921815 | 2023-07-31T09:57:21 | 2023-07-31T09:57:21 | 99,306,277 | 7 | 4 | null | 2021-04-17T23:27:55 | 2017-08-04T05:27:06 | Racket | UTF-8 | Racket | false | false | 2,072 | rkt | multiple-composite.rkt | #lang typed/racket
(require "../../constructor.rkt")
(require "../../composite.rkt")
(require "../../font.rkt")
(require "../../color.rkt")
(require "../../paint.rkt")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define ring-thickness : Flonum 32.0)
(define ring-colors : (Listof Symbol) '(royalblue crimson lime purple chocolate khaki))
(define monospace : Font (desc-font #:family 'monospace #:size 16.0))
(bitmap-vl-append* #:gapsize -8.0
(build-list 16 (λ [[i : Index]]
(let ([rc (random #xFFFFFF)])
(bitmap-text #:color (rgb* rc)
(string-upcase (format "~a: ~x" (add1 i) rc))
monospace)))))
(bitmap-cc-superimpose
(bitmap-cc-superimpose*
(build-list 4 (λ [[i : Index]]
(let ([rc (random #xFFFFFF)]
[fs (* 8.0 (add1 i))])
(bitmap-text #:color (rgb* rc)
(string-upcase (format "~a" fs))
(desc-font #:family 'monospace #:size fs))))))
(bitmap-cc-superimpose*
(build-list (length ring-colors)
(λ [[i : Index]]
(let ([arclength (/ 360.0 (length ring-colors))])
(bitmap-arc #:stroke (desc-stroke #:width ring-thickness #:color (list-ref ring-colors i))
#:radian? #false
(* ring-thickness 4.0)
(* i arclength)
(* (+ i 1) arclength)))))))
(bitmap-cc-superimpose*
(build-list (length ring-colors)
(λ [[i : Index]]
(let ([arclength (/ 360.0 (length ring-colors))])
(bitmap-sector #:fill (list-ref ring-colors i) #:border 'ghostwhite
#:radian? #false
(* ring-thickness 4.0)
(* i arclength)
(* (+ i 1) arclength))))))
| false |
ec395f66f87d59a2fa36728931b525e7c872ddcc | 7f0653ac7c131520501524c8cac544fcbccca573 | /tests/misc/test-letrec.rkt | 80ecfdd5b086811270aa0e0b8cc7ab7de0815e19 | [
"BSD-2-Clause",
"MIT"
]
| permissive | nvgeele/Skive | 96c3bd0d3f654cd6dd7a109acfbe10facabd9919 | 1620167555a80456288c724a0decd879a1afdf93 | refs/heads/master | 2016-09-06T17:52:22.479861 | 2014-06-02T19:12:00 | 2014-06-02T19:12:00 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,387 | rkt | test-letrec.rkt | #lang racket
(require "../../src/expand.rkt")
(require "../../src/analyse.rkt")
(require "../../src/compile.rkt")
(require "../../src/skive.rkt")
(define prog
'(letrec ((fac (lambda (n)
(if (= n 0)
x
(* n (fac (- n 1))))))
(even? (lambda (n)
(if (= n 0)
#t
(odd? (- n 1)))))
(odd? (lambda (n)
(if (= n 0)
#f
(even? (- n 1)))))
(ok (lambda () "OK"))
(x 1))
(if (even? 20)
(fac 10)
(fac 5))))
(define-skive (test)
(letrec ((fac (lambda (n)
(if (= n 0)
x
(* n (fac (- n x))))))
(even? (lambda (n)
(if (= n 0)
#t
(odd? (- n x)))))
(odd? (lambda (n)
(if (= n 0)
#f
(even? (- n x)))))
(ok (lambda () "OK"))
(x 1))
(if (even? 20)
(fac 10)
(fac 5))))
(define (do-test prog)
(let* ((output (open-output-file "/tmp/code.if1" #:exists 'truncate)))
(display (compile-skive-to-if1 prog) output)
(close-output-port output)
(display "done!\n")))
| false |
b656cf015ea4c95c10698c1c16ccd74f0f720c8c | eeb788f85765d6ea5a495e1ece590f912bc8c657 | /profj/scribblings/intermediate-access.scrbl | 33292af7022c197696ffd6eb2255c1e91bbaf0dc | []
| no_license | mflatt/profj | f645aaae2b147a84b385e42f681de29535e13dd4 | bc30ab369ac92ef3859d57be5c13c9562948bb8a | refs/heads/master | 2023-08-28T14:13:17.153358 | 2023-08-08T13:08:04 | 2023-08-08T13:08:04 | 10,001,564 | 10 | 4 | null | 2020-12-01T18:41:00 | 2013-05-11T15:54:54 | Scheme | UTF-8 | Racket | false | false | 20,588 | scrbl | intermediate-access.scrbl | #lang scribble/doc
@(require scribble/manual "java-scribble.ss")
@title[#:style 'toc #:tag "intermediateAcc"]{ProfessorJ Intermediate + Access}
@javagrammar[Program [Import ... Def ...]]
@javagrammar[ #:literals(import *)
#:tag '(inta "import")
Import
[import Name (code:comment "")]
[import Name.* (code:comment "")]]
@javagrammar[#:literals(public)
Def [Class] [Interface]
[public Class] [public Interface]]
@javagrammar[#:literals (class implements extends abstract) #:tag '(inta "class") Class
[class Id { Member ... } ]
[class Id implements Id , Id ... { Member ... } ]
[class Id extends Id { Member ... } ]
[class Id extends Id implements Id , Id ... { Member ... } ]
[abstract class Id { Member ... }]
[abstract class Id implements Id , Id ... { Member ... } ]
[abstract class Id extends Id { Member ... } ]
[abstract class Id extends Id implements Id , Id ... { Member ... } ]]
@javagrammar[#:literals (interface extends) #:tag '(inta "iface") Interface
[interface Id { Signature ... } ]
[interface Id extends Id , Id ... { Signature ... } ]]
@javagrammar[#:literals (abstract) #:tag '(inta "sig")
Signature
[MethodReturn Id( Type Id , ... )(code:comment "")]
[abstract MethodReturn Id(Type Id , ...)(code:comment "")]]
@javagrammar[Member [Field][Modifier Field][Method][Modifier Method][Constructor][Modifier Constructor]]
@javagrammar[#:literals(public private protected) #:tag '(inta "mods")
Modifier
[public][private][protected]]
@javagrammar[#:literals(=) #:tag '(inta "field")
Field
[Type Id = Expression (code:comment "")]
[Type Id (code:comment "")]]
@javagrammar[#:literals (abstract) #:tag '(inta "method")
Method
[MethodReturn Id( Type Id , ...) { Statement ... } ]
[abstract MethodReturn Id(Type Id , ...) (code:comment "")]]
@javagrammar[#:literals(void)
MethodReturn
[void]
[Type]]
@javagrammar[#:tag '(inta "ctor")
Constructor [Id( Type Id , ...) { Statement ... } ]]
@javagrammar[#:literals(if else return super = this)
Statement
[#:tag '(inta "if") if (Expression) { Statement ...} else { Statement ...} ]
[#:tag '(inta "return") return Expression (code:comment "")]
[#:tag '(inta "return") return (code:comment "")]
[#:tag '(inta "block") { Statement ... }]
[#:tag '(inta "super") super(Expression , ...)(code:comment "")]
[#:tag '(inta "thisC") this(Expression , ...)(code:comment "")]
[#:tag '(inta "varDecl") Type Id (code:comment "")]
[#:tag '(inta "varDecl") Type Id = Expression (code:comment "")]
[#:tag '(inta "stmtExpr") StatementExpression (code:comment "")]]
@javagrammar[#:literals(super)
StatementExpression
[Id(Expression , ...)]
[Expression.Id(Expression , ...)]
[super.Id(Expression , ...)]]
@javagrammar[#:literals(- this ! new true false check expect within super instanceof)
Expression
[#:tag '(inta "op") Expression Op Expression]
[#:tag '(inta "op") - Expression]
[#:tag '(inta "op") ! Expression]
[#:tag '(inta "this") this]
[#:tag '(inta "call") Id.(expression , ...)]
[#:tag '(inta "call") Expression.Id(Expression , ...)]
[#:tag '(inta "supercall") super.Id(Expression , ...)]
[#:tag '(inta "acc") Expression.Id]
[#:tag '(inta "new") new Id(Expression , ...)]
[#:tag '(inta "cast") (Type) Expression]
[#:tag '(inta "instof") Expression instanceof Type]
[#:tag '(inta "check") check Expression expect Expression]
[#:tag '(inta "check") check Expression expect Expression within Expression]
[#:tag '(inta "misc") (Expression)]
[#:tag '(inta "misc") Id]
[#:tag '(inta "misc") Number]
[#:tag '(inta "misc") Character]
[#:tag '(inta "misc") String]
[#:tag '(inta "misc") null]
[#:tag '(inta "misc") true]
[#:tag '(inta "misc") false]]
@javagrammar[Name [ Id. ... Id]]
@javagrammar[Op [+][-][*][/][<][<=][==][>][>=][&&][||]]
@javagrammar[#:literals(int boolean float short double long byte char String)
Type
[Id] [boolean] [int] [char] [double] [float]
[long] [byte] [short]]
An @(scheme Id) is a sequence of alphanumeric characters, _, and $.
@section[#:tag "intermedAcc:import"]{@scheme[import]}
@elemtag['(inta "import")]
@itemize[
@item{@(scheme import Name (code:comment ""))
Imports a specified class to use within the program.}
@item{@(scheme import Name.* (code:comment ""))
Imports a group of classes that can all be used within the program.}
]
@section[#:tag "intermedAcc:class"]{@scheme[class]}
@elemtag['(inta "class")]
@itemize[
@item{@(scheme class Id { Member ...})
Creates a class named Id. If no constructor is present, one is generated that takes no arguments.
}
@item{@(scheme class Id implements Id , Id ... { Member ...})
Creates a class named Id that implements the listed @elemref['(inta "iface")]{interfaces}
named by (scheme implements). If no constructor is present, one is generated that takes no arguments.
Any @elemref['(inta "sig")]{method} defined by the listed interface must be a member of this class.
}
@item{@(scheme class Id extends Id { Member ... })
Creates a class named Id that inherits and expands the behavior of the extended class.
If no constructor is present, one is generated that takes no arguments. If the parent
class contains a constructor that requires arguments, then none can be generated and
the current class must contain a @elemref['(inta "ctor")]{constructor that contains @(scheme super)}.
}
@item{@(scheme class Id extends Id implements Id , Id ... { Member ... })
Creates a class named Id that inherits from the extended class and implements the listed interfaces.
}
@item{@(scheme abstract class Id { Member ... })
Creates a class named Id that cannot be instantiated. Members may contain @elemref['(inta "method")]{abstract methods}.
Non-abstract classes extending this class are required to implement all @(scheme abstract) methods.
}
@item{@(scheme abstract class Id implements Id , Id ... { Member ... })
Creates an abstract class named Id that implements the listed interfaces. Members can include abstract methods.
This class need not implement all methods in the interfaces, but all non-abstract subclasses must.
}
@item{@(scheme abstract class Id extends Id { Member ... })
Creates an abstract class named Id that inherits from the extended class. Members can include
abstract methods. If the parent is abstract, the current class does not need to implement all
inherited abstract methods, but all non-abstract subclasses must.
}
@item{@(scheme abstract class Id extends Id implements Id , Id ... { Member ... })
Creates an abstract class named Id, that inherits from the extended class and implements
the listed interfaces.
}
]
@section[#:tag "intermedAcc:iface"]{@scheme[interface]}
@elemtag['(inta "iface")]
@itemize[
@item{@(scheme interface Id { Signature ... })
Creates an interface named Id that specifies a set of method signatures for classes to implement.
}
@item{@(scheme interface Id extends Id , Id ... { Signature ... })
Creates an interface named Id that specifies a set of method signatures for classes to implement, and
inherits the method signatures of the interfaces specified in the extends list.
}
]
@elemtag['(inta "sig")]
@(scheme MethodReturn Id(Type Id , ...) (code:comment ""))
The signature specifies a method named Id, expecting the listed arguments. All @elemref['(inta "class")]{classes}
implementing the (scheme interface) must contain a @elemref['(inta "method")]{method} with the same name,
return type, and argument types. A method that does not return a value uses the @(scheme void) designation instead
of a Type.
@(scheme abstract MethodReturn Id(Type Id , ...)(code:comment ""))
A signature may be declared @(scheme abstract). This does not impact the method behavior;
all signatures are by default abstract.
@section[#:tag "intermedAcc:mods"]{@scheme[Modifiers]}
@elemtag['(inta "mods")]
The modifiers @(scheme public), @(scheme private), and @(scheme protected) controll access to the
modified member. A public member can be accessed by any class. A private member can only be accessed
by the containing class. A protected member can be accessed by the containing class and subclasses.
@section[#:tag "intermedAcc:field"]{@scheme[Field]}
@elemtag['(inta "field")]
@itemize[
@item{@(scheme Type Id (code:comment ""))
Creates a field, bound to Id, that can be used within the current class, or on instances of the
current class using an @elemref['(inta "acc")]{expression}.
This field will have the declared type and will contain a default value of this type if uninitialized.
}
@item{@(scheme Type Id = Expression (code:comment ""))
Creates a field, bound to Id, that can be used within the current class, or on instances of the
current class using an @elemref['(inta "acc")]{expression}.
This field will have the declared type and the value of the evaluated @(scheme Expression).
}
]
@section[#:tag "intermedAcc:method"]{@scheme[Method]}
@elemtag['(inta "method")]
@(scheme MethodReturn Id( Type Id , ...) { Statement ... })
Creates a method, bound to Id, that can be called on the current object, or instances of this class.
The body of the method, the @elemref['(inta "stmt")]{statements}, will be evaluated sequentially when the method is called.
The method name may not be the name of any classes defined in the same program or of any fields or methods in the same class.
A method that does not return a value uses the @(scheme void) designation instead of a Type for MethodReturn.
@(scheme abstract MethodReturn Id( Type Id , ...) (code:comment ""))
Creates a method, bount to Id, inside an @elemref['(inta "class")]{abstract class}. Like an @elemref['(inta "sig")]{interface signature},
non-abstract classes that inherit this method must provide an implementation.
@section[#:tag "intermedAcc:ctor"]{@scheme[Constructor]}
@elemtag['(inta "ctor")]
@(scheme Id( Type Id , ...) { Statement ... } )
Creates a constructor that is used in creating an @elemref['(inta "new")]{instance} of a @elemref['(inta "class")]{class} (called an object).
The arguments given when creating an instance must be of the same type, and in the same order, as that specified by the constructor.
The statements are executed in sequence in intializing the object. If the parent of the current class contains a constructor, that expects
parameters, then the first statement in the constructor must be a @elemref['(inta "super")]{@(scheme super) call}.
Multiple constructors can appear in a class body, provided that for each constructor the type of arguments or the number of arguments
us unique. Each constructor may set its own @elemref['(inta "mods")]{access}. A constructor in the same class can be called using a
@elemref['(inta "thisC")]{@(scheme this) call}. This must be the first statement.
@section[#:tag "intermedAcc:stmt"]{@scheme[Statement]}
@elemtag['(inta "stmt")]{}
@itemize[
@item{@elemtag['(inta "if")] @(scheme if (Expression) { Statement ... } else { Statement ...})
In this statement the expression should have a boolean type. It is evaluated first.
If the expression evaluates to @(scheme true), then the first group of statements (known as the then clause) are evaluated.
If the expression evaluates to @(scheme false), the group of statements following else (the else clause) are evaluated.
}
@item{@elemtag['(inta "return")] @(scheme return Expression (code:comment ""))
This form evaluates the expression, and then returns the value of the expression
as the result of the @elemref['(inta "method")]{method} in which it is contained.
}
@item{ @(scheme return (code:comment ""))
This form causes the method to cease evaluation, without producing a value. Should be used
in conjunction with @(scheme void) for the MethodReturn.}
@item{@elemtag['(inta "block")] @(scheme { Statement ... })
This statement groups the sequence of statements together, commonly called a block.
The statements evaluate sequentially.
}
@item{@elemtag['(inta "super")]@(scheme super(Expression , ...)(code:comment ""))
May only appear as the first statement of a @elemref['(inta "ctor")]{constructor}. Calls the
constructor for the parent class using the given expressions as arguments. Expressions
are evaluated left to right.
}
@item{@elemtag['(inta "thisC")]@(scheme this(Expression , ...)(code:comment ""))
May only appear as the first statement of a @elemref['(inta "ctor")]{constructor}. Calls
a different constructor from the same class, chosen by analyzing the given expressions.
}
@item{@elemtag['(inta "varDecl")] @(scheme Type Id (code:comment ""))
Creates a local variable Id within a method body or a block statement;
it is not visible outside the block or method, or to statements the preceed
the declaration. The variable must be initialized prior to use.
}
@item{@(scheme Type Id = Expression (code:comment ""))
Creates a local variable Id within a method body or a block statement.
}
@item{@elemtag['(inta "stmtExpr")]@(scheme StatementExpression (code:comment ""))
This set of expressions can be used in a statement position, provided they
are followed by ';'.
}
]
@section[#:tag "intermedAcc:expr"]{@scheme[Expression]}
@itemize[
@item{@elemtag['(inta "op")]@(scheme Expression Op Expression)
Performs the mathematical or logical operation Op on the value of the two expressions.
}
@item{@(scheme - Expression)}
@item{@(scheme ! Expression)
Performs logical negation on the value of the expression.
}
@item{ @elemtag['(inta "this")]@(scheme this)
Allows access to the current object. Within a class, fields and methods of the current
class can be accessed through @(scheme this).
}
@item{ @elemtag['(inta "call")]@(scheme Id(Expression , ...))
Id names a method of the current class to be called by the current expression.
The expressions following Id are
evaluated from left to right and passed in to the method as its arguments.
The number and types of the arguments must match the @elemref['(inta "method")]{method's declaration}.
These values replace the argument names in the body of the method, and the result of the body is the result of this expression.
}
@item{@(scheme Expression.Id(Expression , ...))
The first expression must evaluate to an object value. Id names a method of this
object to be called by the current expression. The expressions following Id are
evaluated from left to right and passed in to the method as its arguments.
The number and types of the arguments must match the @elemref['(inta "method")]{method's declaration}.
These values replace the argument names in the body of the method, and the result of the body is the result of this expression.
}
@item{@elemtag['(inta "supercall")] @(scheme super.Id (Expression , ...))
Evaluates the overridden method body using the provided expressions as its arguments.
}
@item{ @elemtag['(inta "acc")]@(scheme Expression.Id)
The first expression must evaluate to an object value. Id names a field of this
object, whose value is retrieved by this expression.
}
@item{ @elemtag['(inta "new")]@(scheme new Id(Expression , ...))
Evaluates to a new instance (object) of the Id class.
The class's @elemref['(inta "ctor")]{constructor} will be run with the given values
(evaluated from left to right) as its arguments. The number and types of these values
select which constructor is used.
}
@item{@elemtag['(inta "cast")]@(scheme (Type) Expression)
Evaluates Expression and then confirms that the value matches the specified type.
During compilation, the resulting expression has the specified type.
If during evaluation, this is not true, an error is raised;
otherwise the result of this expression is the result of Expression.
}
@item{@elemtag['(inta "instof")]@(scheme Expression instanceof Type)
Evaluates Expression and then confirms that the value matches the specified type.
Returns @(scheme true) when the type matches and @(scheme false) otherwise.
}
@item{ @elemtag['(inta "check")]@(scheme check Expression expect Expression)
Compares the resulting values of the two expressions through a deep comparison, including the fields of objects.
The resulting value will be a boolean. Neither expression can have type float or double.
When test reporting is enabled, results of checks appear in the testing window.
}
@item{@(scheme check Expression expect Expression within Expression)
Compares the resulting values of the first two expressions through a deep comparison.
The third value must be numeric. If the resulting values of the compared expressions are numeric,
their values must be within the third value of each other.
For example, in @(scheme check a expect b within c), the absolute value of a-b must be less than or
equal to c. If the compared expressions evaluate to objects, any numeric fields will be compared
with this formula. The resulting value will be a boolean. When test reporting is enabled, results of
checks appear in the testing window.
}
@item{ @elemtag['(inta "misc")]@(scheme (Expression))}
@item{@(scheme Id)
May refer to either a local variable, method parameter, or field of the current class.
}
@item{@(scheme Number)}
@item{@(scheme Character)
Values of type @(scheme char) are ASCII characters enclosed by single quotes such as 'a' is the character a.
They can be used as numbers as well as characters.
}
@item{@(scheme String)
Strings are created through placing text inside of double quotes. For example "I am a string" is a String.
A String value is an instance of the class String, which descends from Object, and can also be created with a constructor.
}
@item{@(scheme null)
A value representing an object with no fields or methods. It should be used as a placeholder for
uninitialized fields.
}
@item{@(scheme true)}
@item{@(scheme false)}
]
| false |
4571d8d623679d77822bb9e0e14da22d7eb2c56f | b08b7e3160ae9947b6046123acad8f59152375c3 | /Programming Language Detection/Experiment-2/Dataset/Train/Racket/thieles-interpolation-formula-2.rkt | 9df3913b4a5652a6ca56c862241fc0a465331bf1 | []
| no_license | dlaststark/machine-learning-projects | efb0a28c664419275e87eb612c89054164fe1eb0 | eaa0c96d4d1c15934d63035b837636a6d11736e3 | refs/heads/master | 2022-12-06T08:36:09.867677 | 2022-11-20T13:17:25 | 2022-11-20T13:17:25 | 246,379,103 | 9 | 5 | null | null | null | null | UTF-8 | Racket | false | false | 56 | rkt | thieles-interpolation-formula-2.rkt | 3.141592653589793
3.1415926535897936
3.1415926535897953
| false |
05fff16f44488a19611125e7d6adde982379b775 | 17126876cd4ff4847ff7c1fbe42471544323b16d | /beautiful-racket-demo/basic-demo-2/misc.rkt | 963910e7538a99a80557565021a4e92f2af2e94a | [
"MIT"
]
| permissive | zenspider/beautiful-racket | a9994ebbea0842bc09941dc6d161fd527a7f4923 | 1fe93f59a2466c8f4842f17d10c1841609cb0705 | refs/heads/master | 2020-06-18T11:47:08.444886 | 2019-07-04T23:21:02 | 2019-07-04T23:21:02 | 196,293,969 | 1 | 0 | NOASSERTION | 2019-07-11T00:47:46 | 2019-07-11T00:47:46 | null | UTF-8 | Racket | false | false | 379 | rkt | misc.rkt | #lang br
(require "struct.rkt")
(provide b-rem b-print b-let b-input)
(define (b-rem val) (void))
(define (b-print . vals)
(displayln (string-append* (map ~a vals))))
(define-macro (b-let ID VAL) #'(set! ID VAL))
(define-macro (b-input ID)
#'(b-let ID (let* ([str (read-line)]
[num (string->number (string-trim str))])
(or num str)))) | false |
a7a0cf5344f80911b671de7aad86e8e299d38a59 | 5fa722a5991bfeacffb1d13458efe15082c1ee78 | /src/c1_45.rkt | 125288897d2b096c39fae3d86f14e3c71f54a5ae | []
| no_license | seckcoder/sicp | f1d9ccb032a4a12c7c51049d773c808c28851c28 | ad804cfb828356256221180d15b59bcb2760900a | refs/heads/master | 2023-07-10T06:29:59.310553 | 2013-10-14T08:06:01 | 2013-10-14T08:06:01 | 11,309,733 | 3 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 682 | rkt | c1_45.rkt | #lang racket
(require "base.rkt")
(require "newton.rkt")
(require "c1_43.rkt")
(define (average-damp f)
(lambda (x) (average (f x) x)))
(define (damped-nth-root x n)
(fixed-point-of-transform (lambda (y) (/ x
(fast-exp y (- n 1))))
(repeated average-damp (ceiling (log2 n)))
1.0))
#|(roots (fast-exp 5 1) 1 average-damp)|#
;(roots (fast-exp 5 5) 5 (repeated average-damp 2))
;(roots (fast-exp 5 9) 9 (repeated average-damp 3))
;(roots (fast-exp 5 18) 18 (repeated average-damp 4))
#|(roots (fast-exp 5 33) 33 (repeated average-damp 5))|#
(damped-nth-root (fast-exp 3 18) 18)
| false |
6eed3105c9126443a518a772dd54107315e6a5c2 | b0c07ea2a04ceaa1e988d4a0a61323cda5c43e31 | /langs/test-programs/info.rkt | 1c5b3f78c2ae9dbe4dce2fd8708c5d0eb8fe0ed2 | [
"AFL-3.0"
]
| permissive | cmsc430/www | effa48f2e69fb1fd78910227778a1eb0078e0161 | 82864f846a7f8f6645821e237de42fac94dff157 | refs/heads/main | 2023-09-03T17:40:58.733672 | 2023-08-28T15:26:33 | 2023-08-28T15:26:33 | 183,064,322 | 39 | 30 | null | 2023-08-28T15:49:59 | 2019-04-23T17:30:12 | Racket | UTF-8 | Racket | false | false | 91 | rkt | info.rkt | #lang info
;; Only test get-progs.rkt
(define test-omit-paths '(#rx"(?<!get-progs.rkt)$"))
| false |
3e0a5a395cd634d500eaf1adb79a621703c4fc96 | 2c819623a83d8c53b7282622429e344389ce4030 | /test/riscv/test-macros.rkt | c45de6d0f5c43963dc22f81dd5771b1c8f81d302 | []
| no_license | uw-unsat/jitsynth | 6bc97dd1ede9da42c0b9313a4766095345493adc | 69529e18d4a8d4dace884bfde91aa26b549523fa | refs/heads/master | 2022-05-29T05:38:57.129444 | 2020-05-01T19:35:32 | 2020-05-01T19:35:32 | 260,513,113 | 14 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 17,266 | rkt | test-macros.rkt | #lang rosette
(require "../../common/data-utils.rkt"
"../../common/data-structures.rkt"
"../../common/instructions.rkt"
"../../riscv/machine-instance.rkt"
"../../riscv/interpreter.rkt"
"../../ams/machine.rkt")
(require rackunit)
(require (only-in "../../common/debug.rkt" [debugln common:debugln]))
; TODO make this better? Take stuff out?
(provide (except-out (all-defined-out) DEBUG debugln))
(define DEBUG #f)
(define (debugln x)
(if DEBUG (common:debugln x) x))
;-----------------------------------------------------------------------
; Helper macros
;-----------------------------------------------------------------------
; We use a macro hack to simpify code generation for various numbers
; of bubble cycles.
(define (TEST_INSERT_NOPS i)
(if (= i 0)
null
(cons riscv-nop (TEST_INSERT_NOPS (sub1 i)))))
(define x0 (bv 0 5))
(define x1 (bv 1 5))
(define x2 (bv 2 5))
(define x3 (bv 3 5))
(define x4 (bv 4 5))
(define x5 (bv 5 5))
(define x6 (bv 6 5))
(define temp1 (bv 7 5))
(define temp2 (bv 8 5))
(define tdat1 (bv16 #x00ff))
(define tdat2 (bv16 #xff00))
(define tdat3 (bv16 #x0ff0))
(define tdat4 (bv16 #xf00f))
(define tdat (concat tdat1 tdat2 tdat3 tdat4))
; TODO should I just actually use sign extend?
(define (SEXT_IMM x)
; ((x) | (-(((x) >> 11) & 1) << 11))
(set! x (if (integer? x) (bv x 12) x))
(bvor x (bvshl (bvneg (bvand (bvashr x (bv 11 12)) (bv 1 12))) (bv 11 12))))
(define (set-reg st reg val)
(set! val (if (integer? val) (bv64 val) val))
(make-state
(write-register (state-regs st) reg val)
(state-mem st)
(state-pc st)))
(define (set-regs-func regs vals)
(if (empty? regs) identity
(lambda (st)
(set-reg
((set-regs-func (rest regs) (rest vals)) st)
(first regs)
(first vals)))))
(define (li reg val)
(set! val (if (integer? val) (bv32 val) val))
(define adj (bvadd val (bvand (bv32 #x00001000) (bvshl val (bv32 #x00000001)))))
(define upper (extract 31 12 adj))
(define lower (extract 11 0 adj))
(list
(make 'lui reg #:imm upper)
(make 'addi32 reg x0 #:imm lower)))
#|
(define (la reg val)
; TODO
)
|#
(define (symbol-replace sym curr repl)
(string->symbol (string-replace (symbol->string sym) curr repl)))
; TODO consider imm as integer or bitvector
; reg1 = dst or src1, reg2 = src1 or src2, reg3 = src2, depending on instruction
(define (make instr-name reg1 [reg2 #f] [reg3 #f] #:imm [imm #f])
(set! instr-name
(symbol-replace
(symbol-replace
(symbol-replace
(symbol-replace
instr-name "w" "32")
"sll" "shl")
"sra" "ashr")
"srl" "lshr"))
(define type (riscv-constructor instr-name))
(cond
[(equal? type riscv-rtype)
(assert reg2)
(assert reg3)
(riscv-rtype
(param-values 'func7 instr-name)
reg3
reg2
(param-values 'func3 instr-name)
reg1
(param-values 'op instr-name))]
[(equal? type riscv-utype)
(assert imm)
(riscv-utype
(if (integer? imm) (bv imm 20) imm)
reg1
(param-values 'op instr-name))]
[(equal? type riscv-itype)
(assert reg2)
(assert imm)
(define my-imm
(bvor
(case instr-name [(ashri ashri32) (bv #b10000000000 12)] [else (bvn0l 12)])
(if (integer? imm) (bv imm 12) imm)))
(riscv-itype
my-imm
reg2
reg1
(param-values 'func3 instr-name)
(param-values 'op instr-name))]
[(equal? type riscv-stype)
(assert reg2)
(assert imm)
(riscv-stype
(if (integer? imm) (bv imm 12) imm)
reg2
reg1
(param-values 'func3 instr-name)
(param-values 'op instr-name))]
[(equal? type riscv-btype)
; TODO remove
; (displayln (~a "Jump imm: " imm))
(assert reg2)
(assert imm)
(riscv-btype
(if (integer? imm) (bv imm 12) imm)
reg2
reg1
(param-values 'func3 instr-name)
(param-values 'op instr-name))]
[(equal? type riscv-jtype)
(assert imm)
(riscv-utype
(if (integer? imm) (bv imm 20) imm)
reg1
(param-values 'op instr-name))]))
(define (TEST_CASE testnum instr reg result prog #:state-update-func [sf identity])
(debugln (~a "Instruction: " instr))
(debugln (~a "Test case number: " testnum))
(test-case (~a "Test number " testnum " for instruction " instr)
(set! result (if (integer? result) (bv64 result) result))
(define starting-state
(sf (make-state (make-zerod-registers 32) (make-zerod-memory 128) (bv64 0))))
(define actual-result
(read-register
; TODO make the bound less stupid?
(state-regs
(interpret-with-state
prog
(state-regs starting-state)
(state-mem starting-state)
(state-pc starting-state)
(bv64 (* 10 (length prog)))))
reg))
; TODO need something special for bveq?
(check-equal? actual-result result)))
;-----------------------------------------------------------------------
; RV64UI MACROS
;-----------------------------------------------------------------------
;-----------------------------------------------------------------------
; Tests for instructions with immediate operand
;-----------------------------------------------------------------------
(define (SRL_VAL v a)
(set! v (if (integer? v) (bv64 v) v))
(set! a (if (integer? a) (bv64 a) a))
(bvlshr v a))
(define (TEST_SRL n v a)
(TEST_IMM_OP n 'srli (SRL_VAL v a) v a))
(define (TEST_SRLI n v a)
(TEST_RR_OP n 'srl (SRL_VAL v a) v a))
(define (TEST_IMM_OP testnum inst result val1 imm)
(TEST_CASE
testnum inst x3 result
#:state-update-func (set-regs-func (list x1) (list val1))
(flatten-list
(make inst x3 x1 #:imm (SEXT_IMM imm)))))
(define (TEST_IMM_SRC1_EQ_DEST testnum inst result val1 imm)
(TEST_CASE
testnum inst x1 result
#:state-update-func (set-regs-func (list x1) (list val1))
(flatten-list
(make inst x1 x1 #:imm (SEXT_IMM imm)))))
(define (TEST_IMM_DEST_BYPASS testnum nop_cycles inst result val1 imm)
(define midcomp
(flatten-list
(make inst x3 x1 #:imm (SEXT_IMM imm))
(TEST_INSERT_NOPS nop_cycles)
(make 'addi x6 x3 #:imm 0)
(make 'addi x4 x4 #:imm 1)
(li x5 2)))
(TEST_CASE
testnum inst x6 result
#:state-update-func (set-regs-func (list x1) (list val1))
(flatten-list
(li x4 0)
midcomp
(make 'bne x4 x5 #:imm (- (* 2 (length midcomp)))))))
(define (TEST_IMM_SRC1_BYPASS testnum nop_cycles inst result val1 imm)
(define midcomp
(flatten-list
(TEST_INSERT_NOPS nop_cycles)
(make inst x3 x1 #:imm (SEXT_IMM imm))
(make 'addi x4 x4 #:imm 1)
(li x5 2)))
(TEST_CASE
testnum inst x3 result
#:state-update-func (set-regs-func (list x1) (list val1))
(flatten-list
(li x4 0)
midcomp
(make 'bne x4 x5 #:imm (- (* 2 (length midcomp)))))))
(define (TEST_IMM_ZEROSRC1 testnum inst result imm)
(TEST_CASE
testnum inst x1 result
(list (make inst x1 x0 #:imm (SEXT_IMM imm)))))
(define (TEST_IMM_ZERODEST testnum inst val1 imm)
(TEST_CASE
testnum inst x0 0
#:state-update-func (set-regs-func (list x1) (list val1))
(flatten-list
(make inst x0 x1 #:imm (SEXT_IMM imm)))))
;-----------------------------------------------------------------------
; Tests for an instruction with register operands
;-----------------------------------------------------------------------
(define (TEST_R_OP testnum inst result val1)
(TEST_CASE
testnum inst x3 result
#:state-update-func (set-regs-func (list x1) (list val1))
(flatten-list
(make inst x3 x1))))
(define (TEST_R_SRC1_EQ_DEST testnum inst result val1)
(TEST_CASE
testnum inst x1 result
#:state-update-func (set-regs-func (list x1) (list val1))
(flatten-list
(make inst x1 x1))))
(define (TEST_R_DEST_BYPASS testnum nop_cycles inst result val1)
(define midcomp
(flatten-list
(make inst x3 x1)
(TEST_INSERT_NOPS nop_cycles)
(make 'addi x6 x3 #:imm 0)
(make 'addi x4 x4 #:imm 1)
(li x5 2)))
(TEST_CASE
testnum inst x6 result
#:state-update-func (set-regs-func (list x1) (list val1))
(flatten-list
(li x4 0)
midcomp
(make 'bne x4 x5 #:imm (- (* 2 (length midcomp)))))))
;-----------------------------------------------------------------------
; Tests for an instruction with register-register operands
;-----------------------------------------------------------------------
(define (TEST_RR_OP testnum inst result val1 val2)
(TEST_CASE
testnum inst x3 result
#:state-update-func (set-regs-func (list x1 x2) (list val1 val2))
(flatten-list
(make inst x3 x1 x2))))
(define (TEST_RR_SRC1_EQ_DEST testnum inst result val1 val2)
(TEST_CASE
testnum inst x1 result
#:state-update-func (set-regs-func (list x1 x2) (list val1 val2))
(flatten-list
(make inst x1 x1 x2))))
(define (TEST_RR_SRC2_EQ_DEST testnum inst result val1 val2)
(TEST_CASE
testnum inst x2 result
#:state-update-func (set-regs-func (list x1 x2) (list val1 val2))
(flatten-list
(make inst x2 x1 x2))))
(define (TEST_RR_SRC12_EQ_DEST testnum inst result val1)
(TEST_CASE
testnum inst x1 result
#:state-update-func (set-regs-func (list x1) (list val1))
(flatten-list
(make inst x1 x1 x1))))
(define (TEST_RR_DEST_BYPASS testnum nop_cycles inst result val1 val2)
(define midcomp
(flatten-list
(make inst x3 x1 x2)
(TEST_INSERT_NOPS nop_cycles)
(make 'addi x6 x3 #:imm 0)
(make 'addi x4 x4 #:imm 1)
(li x5 2)))
(TEST_CASE
testnum inst x6 result
#:state-update-func (set-regs-func (list x1 x2) (list val1 val2))
(flatten-list
(li x4 0)
midcomp
(make 'bne x4 x5 #:imm (- (* 2 (length midcomp)))))))
(define (TEST_RR_SRC12_BYPASS testnum src1_nops src2_nops inst result val1 val2)
(define midcomp
(flatten-list
(TEST_INSERT_NOPS src1_nops)
(TEST_INSERT_NOPS src2_nops)
(make inst x3 x1 x2)
(make 'addi x4 x4 #:imm 1)
(li x5 2)))
(TEST_CASE
testnum inst x3 result
#:state-update-func (set-regs-func (list x1 x2) (list val1 val2))
(flatten-list
(li x4 0)
midcomp
(make 'bne x4 x5 #:imm (- (* 2 (length midcomp)))))))
(define (TEST_RR_SRC21_BYPASS testnum src1_nops src2_nops inst result val1 val2)
(define midcomp
(flatten-list
(TEST_INSERT_NOPS src1_nops)
(TEST_INSERT_NOPS src2_nops)
(make inst x3 x1 x2)
(make 'addi x4 x4 #:imm 1)
(li x5 2)))
(TEST_CASE
testnum inst x3 result
#:state-update-func (set-regs-func (list x1 x2) (list val1 val2))
(flatten-list
(li x4 0)
midcomp
(make 'bne x4 x5 #:imm (- (* 2 (length midcomp)))))))
(define (TEST_RR_ZEROSRC1 testnum inst result val)
(TEST_CASE
testnum inst x2 result
#:state-update-func (set-regs-func (list x1) (list val))
(flatten-list
(make inst x2 x0 x1))))
(define (TEST_RR_ZEROSRC2 testnum inst result val)
(TEST_CASE
testnum inst x2 result
#:state-update-func (set-regs-func (list x1) (list val))
(flatten-list
(make inst x2 x1 x0))))
(define (TEST_RR_ZEROSRC12 testnum inst result)
(TEST_CASE
testnum inst x1 result
(flatten-list
(make inst x1 x0 x0))))
(define (TEST_RR_ZERODEST testnum inst val1 val2)
(TEST_CASE
testnum inst x0 0
#:state-update-func (set-regs-func (list x1 x2) (list val1 val2))
(flatten-list
(make inst x0 x1 x2))))
;-----------------------------------------------------------------------
; Test memory instructions
;-----------------------------------------------------------------------
#|
; TODO
(define (TEST_LD_OP testnum inst result offset base)
(TEST_CASE
testnum inst x3 result
(flatten-list
(la x1 base)
(make inst x3 x1 #:imm offset))))
(define (TEST_ST_OP testnum load_inst store_inst result offset base)
(TEST_CASE
testnum inst x3 result
(flatten-list
(la x1 base)
(li x2 result)
(make store_inst x2 x1 #:imm offset)
(make load_inst x3 x1 #:imm offset))))
(define (TEST_LD_DEST_BYPASS testnum nop_cycles inst result offset base)
; TODO test label?
(TEST_LABEL(testnum TESTSUITE): \
li TESTNUM testnum; \
li x4 0; \
1: la x1 base; \
inst x3 offset(x1); \
TEST_INSERT_NOPS_ ## nop_cycles \
addi x6 x3 0; \
li x29 result; \
bne x6 x29 PASSFAIL_LABEL(fail TESTSUITE); \
addi x4 x4 1; \
li x5 2; \
bne x4 x5 1b; \
#define TEST_LD_SRC1_BYPASS( testnum nop_cycles inst result offset base ) \
TEST_LABEL(testnum TESTSUITE): \
li TESTNUM testnum; \
li x4 0; \
1: la x1 base; \
TEST_INSERT_NOPS_ ## nop_cycles \
inst x3 offset(x1); \
li x29 result; \
bne x3 x29 PASSFAIL_LABEL(fail TESTSUITE); \
addi x4 x4 1; \
li x5 2; \
bne x4 x5 1b \
#define TEST_ST_SRC12_BYPASS( testnum src1_nops src2_nops load_inst store_inst result offset base ) \
TEST_LABEL(testnum TESTSUITE): \
li TESTNUM testnum; \
li x4 0; \
1: la x1 result; \
TEST_INSERT_NOPS_ ## src1_nops \
la x2 base; \
TEST_INSERT_NOPS_ ## src2_nops \
store_inst x1 offset(x2); \
load_inst x3 offset(x2); \
li x29 result; \
bne x3 x29 PASSFAIL_LABEL(fail TESTSUITE); \
addi x4 x4 1; \
li x5 2; \
bne x4 x5 1b \
#define TEST_ST_SRC21_BYPASS( testnum src1_nops src2_nops load_inst store_inst result offset base ) \
TEST_LABEL(testnum TESTSUITE): \
li TESTNUM testnum; \
li x4 0; \
1: la x2 base; \
TEST_INSERT_NOPS_ ## src1_nops \
la x1 result; \
TEST_INSERT_NOPS_ ## src2_nops \
store_inst x1 offset(x2); \
load_inst x3 offset(x2); \
li x29 result; \
bne x3 x29 PASSFAIL_LABEL(fail TESTSUITE); \
addi x4 x4 1; \
li x5 2; \
bne x4 x5 1b \
;-----------------------------------------------------------------------
; Test branch instructions
;-----------------------------------------------------------------------
#define TEST_BR1_OP_TAKEN( testnum inst val1 ) \
TEST_LABEL(testnum TESTSUITE): \
li TESTNUM testnum; \
li x1 val1; \
inst x1 2f; \
bne x0 TESTNUM PASSFAIL_LABEL(fail TESTSUITE); \
1: bne x0 TESTNUM 3f; \
2: inst x1 1b; \
bne x0 TESTNUM PASSFAIL_LABEL(fail TESTSUITE); \
3:
#define TEST_BR1_OP_NOTTAKEN( testnum inst val1 ) \
TEST_LABEL(testnum TESTSUITE): \
li TESTNUM testnum; \
li x1 val1; \
inst x1 1f; \
bne x0 TESTNUM 2f; \
1: bne x0 TESTNUM PASSFAIL_LABEL(fail TESTSUITE); \
2: inst x1 1b; \
3:
#define TEST_BR1_SRC1_BYPASS( testnum nop_cycles inst val1 ) \
TEST_LABEL(testnum TESTSUITE): \
li TESTNUM testnum; \
li x4 0; \
1: li x1 val1; \
TEST_INSERT_NOPS_ ## nop_cycles \
inst x1 PASSFAIL_LABEL(fail TESTSUITE); \
addi x4 x4 1; \
li x5 2; \
bne x4 x5 1b \
#define TEST_BR2_OP_TAKEN( testnum inst val1 val2 ) \
TEST_LABEL(testnum TESTSUITE): \
li TESTNUM testnum; \
li x1 val1; \
li x2 val2; \
inst x1 x2 2f; \
bne x0 TESTNUM PASSFAIL_LABEL(fail TESTSUITE); \
1: bne x0 TESTNUM 3f; \
2: inst x1 x2 1b; \
bne x0 TESTNUM PASSFAIL_LABEL(fail TESTSUITE); \
3:
#define TEST_BR2_OP_NOTTAKEN( testnum inst val1 val2 ) \
TEST_LABEL(testnum TESTSUITE): \
li TESTNUM testnum; \
li x1 val1; \
li x2 val2; \
inst x1 x2 1f; \
bne x0 TESTNUM 2f; \
1: bne x0 TESTNUM PASSFAIL_LABEL(fail TESTSUITE); \
2: inst x1 x2 1b; \
3:
#define TEST_BR2_SRC12_BYPASS( testnum src1_nops src2_nops inst val1 val2 ) \
TEST_LABEL(testnum TESTSUITE): \
li TESTNUM testnum; \
li x4 0; \
1: li x1 val1; \
TEST_INSERT_NOPS_ ## src1_nops \
li x2 val2; \
TEST_INSERT_NOPS_ ## src2_nops \
inst x1 x2 PASSFAIL_LABEL(fail TESTSUITE); \
addi x4 x4 1; \
li x5 2; \
bne x4 x5 1b \
#define TEST_BR2_SRC21_BYPASS( testnum src1_nops src2_nops inst val1 val2 ) \
TEST_LABEL(testnum TESTSUITE): \
li TESTNUM testnum; \
li x4 0; \
1: li x2 val2; \
TEST_INSERT_NOPS_ ## src1_nops \
li x1 val1; \
TEST_INSERT_NOPS_ ## src2_nops \
inst x1 x2 PASSFAIL_LABEL(fail TESTSUITE); \
addi x4 x4 1; \
li x5 2; \
bne x4 x5 1b \
;-----------------------------------------------------------------------
; Test jump instructions
;-----------------------------------------------------------------------
#define TEST_JR_SRC1_BYPASS( testnum nop_cycles inst ) \
TEST_LABEL(testnum TESTSUITE): \
li TESTNUM testnum; \
li x4 0; \
1: la x6 2f; \
TEST_INSERT_NOPS_ ## nop_cycles \
inst x6; \
bne x0 TESTNUM PASSFAIL_LABEL(fail TESTSUITE); \
2: addi x4 x4 1; \
li x5 2; \
bne x4 x5 1b \
#define TEST_JALR_SRC1_BYPASS( testnum nop_cycles inst ) \
TEST_LABEL(testnum TESTSUITE): \
li TESTNUM testnum; \
li x4 0; \
1: la x6 2f; \
TEST_INSERT_NOPS_ ## nop_cycles \
inst x19 x6 0; \
bne x0 TESTNUM PASSFAIL_LABEL(fail TESTSUITE); \
2: addi x4 x4 1; \
li x5 2; \
bne x4 x5 1b \
|#
| false |
dbc3ef6fd73ded61b7d5c095eb515d0b85aff6a2 | db558340d9ca1f1dfc69836e8854d4ca55f1641c | /solns/racket/13.rkt | d9296b50408cf6c83c6669f35ff9c9848049cefe | [
"CC0-1.0"
]
| permissive | retiman/project-euler | 23d0185a9736b35484e5764b835417fcdbc5b07c | 2d718f431cfd8ee2e4fcdfab2a38677b00e726d8 | refs/heads/main | 2022-06-05T11:51:33.158520 | 2022-05-20T05:49:07 | 2022-05-20T05:49:07 | 143,558 | 12 | 1 | CC0-1.0 | 2022-05-20T05:49:08 | 2009-03-05T09:22:50 | Racket | UTF-8 | Racket | false | false | 272 | rkt | 13.rkt | #lang racket
(require rackunit)
(define result
((compose list->string
(curryr take 10)
string->list
number->string
(curry apply +))
(file->list "/data/13.txt")))
(displayln result)
(check-equal? result 5537376230)
| false |
3ebeae1313e8df199dec8ccf51b328d2c55e98cd | a70301d352dcc9987daf2bf12919aecd66defbd8 | /racket-way/st.rkt | 6cb74b1cf3d4c7d228cc787df3894523726baf2a | []
| no_license | mflatt/talks | 45fbd97b1ca72addecf8f4b92053b85001ed540b | 7abfdf9a9397d3d3d5d1b4c107ab6a62d0ac1265 | refs/heads/master | 2021-01-19T05:18:38.094408 | 2020-06-04T16:29:25 | 2020-06-04T16:29:25 | 87,425,078 | 2 | 2 | null | null | null | null | UTF-8 | Racket | false | false | 264 | rkt | st.rkt | #lang slideshow
(provide st)
(define (st s #:t [t t])
(define a (t s))
(define b (colorize a "black"))
(refocus (lt-superimpose (inset b 1 1 0 0)
(inset b -1 -1 0 0)
(colorize a "gold"))
a))
| false |
0ee3c537635b9566003bf7367acd53a226badb15 | 61267e4faf240ce94152d3203613e482f1fade40 | /minikanren.rkt | e0c036a376e9f345d0d27d76302a4b6db2e203fa | []
| no_license | swannodette/minikanren | 744bbb02a54058182c081e2abe0bf5fb17f6c16b | 3524857381f24031f23f446cf34f7b5bc9c49541 | refs/heads/master | 2021-01-02T09:32:38.804725 | 2011-11-19T21:46:04 | 2011-11-19T21:46:04 | 1,501,114 | 0 | 1 | null | null | null | null | UTF-8 | Racket | false | false | 17,125 | rkt | minikanren.rkt | #lang racket
(provide var
run
==
==-no-check
fresh
conde
succeed
fail
lambdaf@
lambdag@
bind*
inc
case-inf)
(define-syntax comment
(syntax-rules ()
((_ ...) #f)))
(define-syntax var
(syntax-rules ()
((_ x) (vector x))))
(define-syntax var?
(syntax-rules ()
((_ x) (vector? x))))
(define empty-s '())
(define ext-s-no-check
(lambda (x v s)
(cons (cons x v) s)))
(define lhs car)
(define rhs cdr)
(define walk
(lambda (v s)
(cond
((var? v)
(let ((a (assq v s)))
(cond
(a (walk (rhs a) s))
(else v))))
(else v))))
(define occurs-check
(lambda (x v s)
(let ((v (walk v s)))
(cond
((var? v) (eq? v x))
((pair? v)
(or (occurs-check x (car v) s)
(occurs-check x (cdr v) s)))
(else #f)))))
(define ext-s
(lambda (x v s)
(cond
((occurs-check x v s) #f)
(else (ext-s-no-check x v s)))))
(define unify
(lambda (u v s)
(let ((u (walk u s))
(v (walk v s)))
(cond
((eq? u v) s)
((var? u) (cond
((var? v) (ext-s-no-check u v s))
(else (ext-s u v s))))
((var? v) (ext-s v u s))
((and (pair? u) (pair? v))
(let ((s (unify (car u) (car v) s)))
(and s (unify (cdr u) (cdr v) s))))
((equal? u v) s)
(else #f)))))
(define unify-no-check
(lambda (u v s)
(let ((u (walk u s))
(v (walk v s)))
(cond
((eq? u v) s)
((var? u) (ext-s-no-check u v s))
((var? v) (ext-s-no-check v u s))
((and (pair? u) (pair? v))
(let ((s (unify-no-check (car u) (car v) s)))
(and s (unify-no-check (cdr u) (cdr v) s))))
((equal? u v) s)
(else #f)))))
(define reify
(lambda (v s)
(let ((v (walk* v s)))
(walk* v (reify-s v empty-s)))))
(define walk*
(lambda (v s)
(let ((v (walk v s)))
(cond
((var? v) v)
((pair? v) (cons (walk* (car v) s)
(walk* (cdr v) s)))
(else v)))))
(define reify-name
(lambda (n)
(string->symbol (string-append "_." (number->string n)))))
(define reify-s
(lambda (v s)
(let ((v (walk v s)))
(cond
((var? v) (ext-s v (reify-name (length s)) s))
((pair? v) (reify-s (cdr v) (reify-s (car v) s)))
(else s)))))
(define-syntax lambdag@
(syntax-rules ()
((_ (s) e) (lambda (s) e))))
(define-syntax lambdaf@
(syntax-rules ()
((_ () e) (lambda () e))))
(define succeed
(lambdag@ (a) a))
(define fail
(lambdag@ (a) (mzero)))
(define-syntax mzero
(syntax-rules ()
((_) #f)))
(define-syntax unit
(syntax-rules ()
((_ a) a)))
(define-syntax choice
(syntax-rules ()
((_ a f) (cons a f))))
(define-syntax inc
(syntax-rules ()
((_ e) (lambdaf@ () e))))
(define-syntax case-inf
(syntax-rules ()
((_ e (() e0) ((fp) e1) ((ap) e2) ((a f) e3))
(let ((a-inf e))
(cond
((not a-inf) e0)
((procedure? a-inf) (let ((fp a-inf))
e1))
((and (pair? a-inf) (procedure? (cdr a-inf)))
(let ((a (car a-inf)) (f (cdr a-inf))) e3))
(else (let ((ap a-inf)) e2)))))))
(define-syntax ==
(syntax-rules ()
((_ u v)
(lambdag@ (a)
(cond
((unify u v a) => (lambda (a) (unit a)))
(else (mzero)))))))
(define-syntax ==-no-check
(syntax-rules ()
((_ u v)
(lambdag@ (a)
(cond
((unify-no-check u v a) => (lambda (a) (unit a)))
(else (mzero)))))))
(define-syntax conde
(syntax-rules ()
((_ (g0 g ...) (g1 gp ...) ...)
(lambdag@ (a)
(inc
(mplus* (bind* (g0 a) g ...)
(bind* (g1 a) gp ...)
...))))))
(define-syntax mplus*
(syntax-rules ()
((_ e) e)
((_ e0 e ...) (mplus e0 (lambdaf@ () (mplus* e ...))))))
(define mplus
(lambda (a-inf f)
(case-inf a-inf
(() (f))
((fp) (inc (mplus (f) fp)))
((a) (choice a f))
((a fp) (choice a (lambdaf@ () (mplus (f) fp)))))))
(define-syntax fresh
(syntax-rules ()
((_ (x ...) g0 g ...)
(lambdag@ (a)
(inc
(let ((x (var 'x)) ...)
(bind* (g0 a) g ...)))))))
(define-syntax bind*
(syntax-rules ()
((_ e) e)
((_ e g0 g ...) (bind* (bind e g0) g ...))))
(define bind
(lambda (a-inf g)
(case-inf a-inf
(() (mzero))
((f) (inc (bind (f) g)))
((a) (g a))
((a f) (mplus (g a) (lambdaf@ () (bind (f) g)))))))
(define-syntax run
(syntax-rules ()
((_ n (x) g0 g ...)
(take n
(lambdaf@ ()
((fresh (x) g0 g ...
(lambdag@ (a)
(cons (reify x a) '())))
empty-s))))))
(define take
(lambda (n f)
(if (and n (zero? n))
'()
(case-inf (f)
(() '())
((f) (take n f))
((a) a)
((a f) (cons (car a) (take (and n (- n 1)) f)))))))
(define rember*o
(lambda (x ls out)
(conde
((== '() ls) (== ls out))
((fresh (a d b e)
(== `(,a . ,d) ls)
(conde
((== `(,b . ,e) a)
(fresh (res0 res1)
(rember*o x a res0)
(rember*o x d res1)
(== `(,res0 . ,res1) out)))
((== x a)
(rember*o x d out))
((fresh (res)
(rember*o x d res)
(== `(,a . ,res) out)))))))))
(define nullo
(lambda (x)
(== '() x)))
(define membo
(lambda (elt ls)
(fresh (d a)
(conde
((nullo ls) fail)
((== (cons elt d) ls))
((== (cons a d) ls) (membo elt d))))))
(define on-righto
(lambda (e1 e2 ls)
(fresh (d a r)
(conde
((nullo ls) fail)
((== (cons a '()) ls) fail)
((== (cons e1 d) ls) (== (cons e2 r) d))
((== (cons a d) ls) (on-righto e1 e2 d))))))
(define next-too
(lambda (e1 e2 ls)
(conde
((on-righto e1 e2 ls))
((on-righto e2 e1 ls)))))
(define test-zebra
(lambda (n)
(cond
((zero? n) '())
(else (begin
(zebrao)
(test-zebra (sub1 n)))))))
(define zebrao
(lambda ()
(run #f (h)
(fresh (a1 a2 a3 a4 a5
b1 b2 b3 b4 b5
c1 c2 c3 c4 c5
d1 d2 d3 d4 d5
e1 e2 e3 e4 e5)
(fresh (t1 t2 t3)
(membo `(englishman ,t1 ,t2 ,t3 red) h))
(fresh (t1 t2 t3 t4 t5 t6 t7 t8)
(on-righto `(,t1 ,t2 ,t3 ,t4 ivory)
`(,t5 ,t6 ,t7 ,t8 green) h))
(fresh (t1 t2 t3 t4 t5 t6 t7 t8)
(next-too `(norwegian ,t1 ,t2 ,t3 ,t4)
`(,t5 ,t6 ,t7 ,t8 blue) h))
(fresh (t1 t2 t3)
(membo `(,t1 kools ,t2 ,t3 yellow) h))
(fresh (t1 t2 t3)
(membo `(spaniard ,t1 ,t2 dog ,t3) h))
(fresh (t1 t2 t3)
(membo `(,t1 ,t2 coffee ,t3 green) h))
(fresh (t1 t2 t3)
(membo `(ukrainian ,t1 tea ,t2 ,t3) h))
(fresh (t1 t2 t3)
(membo `(,t1 luckystrikes oj ,t2 ,t3) h))
(fresh (t1 t2 t3)
(membo `(japanese parliaments ,t1 ,t2 ,t3) h))
(fresh (t1 t2 t3)
(membo `(,t1 oldgolds ,t2 snails ,t3) h))
(fresh (t1 t2 t3 t4)
(membo `(,t1 ,t2 water ,t3 ,t4) h))
(fresh (t1 t2 t3 t4)
(membo `(,t1 ,t2 ,t3 zebra ,t4) h))
(== h `((,a1 ,a2 ,a3 ,a4 ,a5)
(,b1 ,b2 ,b3 ,b4 ,b5)
(,c1 ,c2 ,c3 ,c4 ,c5)
(,d1 ,d2 ,d3 ,d4 ,d5)
(,e1 ,e2 ,e3 ,e4 ,e5)))
(== a1 'norwegian)
(== c3 'milk)
(fresh (t1 t2 t3 t4 t5 t6 t7 t8)
(next-too `(,t1 ,t2 ,t3 horse ,t4)
`(,t5 kools ,t6 ,t7 ,t8) h))
(fresh (t1 t2 t3 t4 t5 t6 t7 t8)
(next-too `(,t1 ,t2 ,t3 fox ,t4)
`(,t5 chesterfields ,t6 ,t7 ,t8) h))
))))
(comment
(time (zebrao))
;; ~70ms
(time
(run 60 (q)
(fresh (x l)
(rember*o x l '((b) c d))
(== `(,x ,l) q))))
(time
(do ((i 0 (+ i 1))) ((> i 1000))
(run #f (q)
(== #f #f)
(== #f #f)
(== #f #f)
(== #f #f)
(== #f #f)
(== #f #f)
(== #f #f)
(== #f #f)
(== #f #f)
(== #f #f)
(== #t #f))))
)
(comment
;; 915ms, the same!
(time
(do ((i 0 (+ i 1))) ((> i 4000))
(run 6 (q)
(fresh (l s)
(appendo l s '(a b c d e))
(== `(,l ,s) q)))))
)
;; =============================================================================
;; arithmetic
(define appendo
(lambda (l s out)
(conde
((nullo l) (== s out))
((fresh (a d res)
(caro l a)
(cdro l d)
(appendo d s res)
(conso a res out))))))
(define caro
(lambda (p a)
(fresh (d)
(== (cons a d) p))))
(define cdro
(lambda (p d)
(fresh (a)
(== (cons a d) p))))
(define conso
(lambda (a d p)
(== (cons a d) p)))
(define pairo
(lambda (p)
(fresh (a d)
(conso a d p))))
(define build-num
(lambda (n)
(cond
((odd? n)
(cons 1
(build-num (quotient (- n 1) 2))))
((and (not (zero? n)) (even? n))
(cons 0
(build-num (quotient n 2))))
((zero? n) '()))))
(define bit-xoro
(lambda (x y r)
(conde
((== 0 x) (== 0 y) (== 0 r))
((== 0 x) (== 1 y) (== 1 r))
((== 1 x) (== 0 y) (== 1 r))
((== 1 x) (== 1 y) (== 0 r)))))
(define bit-ando
(lambda (x y r)
(conde
((== 0 x) (== 0 y) (== 0 r))
((== 1 x) (== 0 y) (== 0 r))
((== 0 x) (== 1 y) (== 0 r))
((== 1 x) (== 1 y) (== 1 r)))))
(define addero
(lambda (d n m r)
(conde
((== 0 d) (== '() m) (== n r))
((== 0 d) (== '() n) (== m r)
(poso m))
((== 1 d) (== '() m)
(addero 0 n '(1) r))
((== 1 d) (== '() n) (poso m)
(addero 0 '(1) m r))
((== '(1) n) (== '(1) m)
(fresh (a c)
(== `(,a ,c) r)
(full-addero d 1 1 a c)))
((== '(1) n) (gen-addero d n m r))
((== '(1) m) (>1o n) (>1o r)
(addero d '(1) n r))
((>1o n) (gen-addero d n m r)))))
(define half-addero
(lambda (x y r c)
(fresh ()
(bit-xoro x y r)
(bit-ando x y c))))
(define full-addero
(lambda (b x y r c)
(fresh (w xy wz)
(half-addero x y w xy)
(half-addero w b r wz)
(bit-xoro xy wz c))))
(define gen-addero
(lambda (d n m r)
(fresh (a b c e x y z)
(== `(,a . ,x) n)
(== `(,b . ,y) m) (poso y)
(== `(,c . ,z) r) (poso z)
(full-addero d a b c e)
(addero e x y z))))
(define poso
(lambda (n)
(fresh (a d)
(== `(,a . ,d) n))))
(define >1o
(lambda (n)
(fresh (a ad dd)
(== `(,a ,ad . ,dd) n))))
(define pluso
(lambda (n m k)
(addero 0 n m k)))
(define minuso
(lambda (n m k)
(pluso m k n)))
(define *o
(lambda (n m p)
(conde
((== '() n) (== '() p))
((poso n) (== '() m) (== '() p))
((== '(1) n) (poso m) (== m p))
((>1o n) (== '(1) m) (== n p))
((fresh (x z)
(== `(0 . ,x) n) (poso x)
(== `(0 . ,z) p) (poso z)
(>1o m)
(*o x m z)))
((fresh (x y)
(== `(1 . ,x) n) (poso x)
(== `(0 . ,y) m) (poso y)
(*o m n p)))
((fresh (x y)
(== `(1 . ,x) n) (poso x)
(== `(1 . ,y) m) (poso y)
(odd-*o x n m p))))))
(define odd-*o
(lambda (x n m p)
(fresh (q)
(bound-*o q p n m)
(*o x m q)
(pluso `(0 . ,q) m p))))
(define bound-*o
(lambda (q p n m)
(conde
((nullo q) (pairo p))
((fresh (x y z)
(cdro q x)
(cdro p y)
(conde
((nullo n)
(cdro m z)
(bound-*o x y z '()))
((cdro n z)
(bound-*o x y z m))))))))
(define =lo
(lambda (n m)
(conde
((== '() n) (== '() m))
((== '(1) n) (== '(1) m))
((fresh (a x b y)
(== `(,a . ,x) n) (poso x)
(== `(,b . ,y) m) (poso y)
(=lo x y))))))
(define <lo
(lambda (n m)
(conde
((== '() n) (poso m))
((== '(1) n) (>1o m))
((fresh (a x b y)
(== `(,a . ,x) n) (poso x)
(== `(,b . ,y) m) (poso y)
(<lo x y))))))
(define <=lo
(lambda (n m)
(conde
((=lo n m))
((<lo n m)))))
(define <o
(lambda (n m)
(conde
((<lo n m))
((=lo n m)
(fresh (x)
(poso x)
(pluso n x m))))))
(define <=o
(lambda (n m)
(conde
((== n m))
((<o n m)))))
(define /o
(lambda (n m q r)
(conde
((== r n) (== '() q) (<o n m))
((== '(1) q) (=lo n m) (pluso r m n)
(<o r m))
((<lo m n)
(<o r m)
(poso q)
(fresh (nh nl qh ql qlm qlmr rr rh)
(splito n r nl nh)
(splito q r ql qh)
(conde
((== '() nh)
(== '() qh)
(minuso nl r qlm)
(*o ql m qlm))
((poso nh)
(*o ql m qlm)
(pluso qlm r qlmr)
(minuso qlmr nl rr)
(splito rr r '() rh)
(/o nh m qh rh))))))))
(define splito
(lambda (n r l h)
(conde
((== '() n) (== '() h) (== '() l))
((fresh (b n^)
(== `(0 ,b . ,n^) n)
(== '() r)
(== `(,b . ,n^) h)
(== '() l)))
((fresh (n^)
(== `(1 . ,n^) n)
(== '() r)
(== n^ h)
(== '(1) l)))
((fresh (b n^ a r^)
(== `(0 ,b . ,n^) n)
(== `(,a . ,r^) r)
(== '() l)
(splito `(,b . ,n^) r^ '() h)))
((fresh (n^ a r^)
(== `(1 . ,n^) n)
(== `(,a . ,r^) r)
(== '(1) l)
(splito n^ r^ '() h)))
((fresh (b n^ a r^ l^)
(== `(,b . ,n^) n)
(== `(,a . ,r^) r)
(== `(,b . ,l^) l)
(poso l^)
(splito n^ r^ l^ h))))))
(define logo
(lambda (n b q r)
(conde
((== '(1) n) (poso b) (== '() q) (== '() r))
((== '() q) (<o n b) (pluso r '(1) n))
((== '(1) q) (>1o b) (=lo n b) (pluso r b n))
((== '(1) b) (poso q) (pluso r '(1) n))
((== '() b) (poso q) (== r n))
((== '(0 1) b)
(fresh (a ad dd)
(poso dd)
(== `(,a ,ad . ,dd) n)
(exp2 n '() q)
(fresh (s)
(splito n dd r s))))
((fresh (a ad add ddd)
(conde
((== '(1 1) b))
((== `(,a ,ad ,add . ,ddd) b))))
(<lo b n)
(fresh (bw1 bw nw nw1 ql1 ql s)
(exp2 b '() bw1)
(pluso bw1 '(1) bw)
(<lo q n)
(fresh (q1 bwq1)
(pluso q '(1) q1)
(*o bw q1 bwq1)
(<o nw1 bwq1))
(exp2 n '() nw1)
(pluso nw1 '(1) nw)
(/o nw bw ql1 s)
(pluso ql '(1) ql1)
(<=lo ql q)
(fresh (bql qh s qdh qd)
(repeated-mul b ql bql)
(/o nw bw1 qh s)
(pluso ql qdh qh)
(pluso ql qd q)
(<=o qd qdh)
(fresh (bqd bq1 bq)
(repeated-mul b qd bqd)
(*o bql bqd bq)
(*o b bq bq1)
(pluso bq r n)
(<o n bq1))))))))
(define exp2
(lambda (n b q)
(conde
((== '(1) n) (== '() q))
((>1o n) (== '(1) q)
(fresh (s)
(splito n b s '(1))))
((fresh (q1 b2)
(== `(0 . ,q1) q)
(poso q1)
(<lo b n)
(appendo b `(1 . ,b) b2)
(exp2 n b2 q1)))
((fresh (q1 nh b2 s)
(== `(1 . ,q1) q)
(poso q1)
(poso nh)
(splito n b s nh)
(appendo b `(1 . ,b) b2)
(exp2 nh b2 q1))))))
(define repeated-mul
(lambda (n q nq)
(conde
((poso n) (== '() q) (== '(1) nq))
((== '(1) q) (== n nq))
((>1o q)
(fresh (q1 nq1)
(pluso q1 '(1) q)
(repeated-mul n q1 nq1)
(*o nq1 n nq))))))
(define expo
(lambda (b q n)
(logo n b q '())))
(comment
(run #f (s)
(fresh (x y)
(pluso x y '(1 0 1))
(== `(,x ,y) s)))
(time
(run 34 (t)
(fresh (x y r)
(*o x y r)
(== `(,x ,y ,r) t))))
;; 61ms for run 3
(time
(run 3 (s)
(fresh (b q r)
(logo '(0 0 1 0 0 0 1) b q r)
(>1o q)
(== `(,b ,q ,r) s))))
;; 475ms for run 4
(time
(run 4 (s)
(fresh (b q r)
(logo '(0 0 1 0 0 0 1) b q r)
(>1o q)
(== `(,b ,q ,r) s))))
;; 545 for run 5
;; 1237 for run 6
;; 5530 for run 7
;; 17241 for run 8
;; 17360 for run 9
;; ? for run 10
(time
(run 10 (s)
(fresh (b q r)
(logo '(0 0 1 0 0 0 1) b q r)
(>1o q)
(== `(,b ,q ,r) s))))
)
| true |
521bfd7fdee2def17941551d5a34e582829e3b19 | 53aba840e99984bafd6e77d7a636651fb2832cfe | /configurator/scribbling/syntax.rkt | c4f7b865613b7b7414263ab90b21001eb4379623 | []
| no_license | pbpf/DrEcampus | 243e018cd11a4a2341bbca99604729d5b8c9f656 | f3e2fd51b84ef982fd47f5a5cadfc28b15763ee6 | refs/heads/master | 2020-09-03T16:46:03.847836 | 2019-11-04T13:54:24 | 2019-11-04T13:54:24 | 219,512,146 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 135 | rkt | syntax.rkt | #lang scribble/manual
@(require (for-label racket configurator/syntax))
@title[#:tag "syntax"]{syntax}
@defmodule[configurator/syntax]
| false |
65468508b4210524e092f47ad6f8d0d29475a877 | 6805d79845c3bdb1c38f1d0829ba4eec3425029a | /scribblings/define2.scrbl | 8a6962a700e95831e3144a9a34e68392178022ba | [
"MIT",
"Apache-2.0"
]
| permissive | Metaxal/define2 | cb3868b6a6837714f322a8a11cfe39627034a46d | c9760f29b27e45c6fa9edee37d6275214745e8f8 | refs/heads/master | 2023-03-20T12:22:53.832015 | 2021-03-12T17:05:41 | 2021-03-12T17:05:41 | 326,416,429 | 6 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 8,193 | scrbl | define2.scrbl | #lang scribble/manual
@(require racket/sandbox
scribble/example
(for-label define2
define2/define-wrapper))
@(module def-racket racket/base
(require scribble/manual
(for-label racket/base))
(define rkt-define @racket[define])
(define rkt-lambda @racket[lambda])
(define rkt-λ @racket[λ])
(provide (all-defined-out)))
@(require 'def-racket)
@(define my-eval
(parameterize ([sandbox-output 'string]
[sandbox-error-output 'string]
[sandbox-memory-limit 50])
(make-evaluator 'racket/base '(require define2 define2/define-wrapper racket/list))))
@title{define2}
@author{Laurent Orseau}
@section{Define and lambda}
@defmodule[define2]
@margin-note{There may be incompatibility with code that uses the keywords @racket[#:!]
and @racket[#:?].}
The @racketmodname[define2] collection redefines @|rkt-lambda| and @|rkt-define| in a
(almost entirely) backward compatible way to provide the following functionalities:
@itemlist[
@item{a shortcut definition for keyword arguments to avoid the ubiquitous
@racket[#:some-arg some-arg] repetition,}
@item{a pass-through mechanism for optional keyword arguments to propagate
default values without having to know them.}]
@examples[
#:eval my-eval #:label @elem{@bold{Example:} Mandatory @racket[#:!] argument}
(define (make-fruits fruit #:! number)
(make-list number fruit))
@code:line[(make-fruits 'apple #:number 4) @code:comment{Notice the keyword name}]
]
@examples[
#:eval my-eval #:label @elem{@bold{Example:} Optional @racket[#:?] argument}
(define (make-fruits2 fruit #:? [number 3])
(make-list number fruit))
(make-fruits2 'pear)
(make-fruits2 'pear #:number 4)
]
@examples[
#:eval my-eval #:label @elem{@bold{Example:} Pass-through @racket[#:?] argument}
@code:comment{Let's write a function that uses `make-fruits2` without changing}
@code:comment{the default value for `number`—whatever value this is.}
(define (make-two-fruits fruit1 fruit2 #:? number)
(list (make-fruits2 fruit1 #:number number)
(make-fruits2 fruit2 #:number number)))
(make-two-fruits 'apple 'banana)
(make-two-fruits 'apple 'banana #:number 2)
]
The usual racket syntax @racket[#:keyword [id val]] can also be used with pass-through arguments:
@examples[
#:eval my-eval #:label #f
(define (make-fruits3 fruit #:number [a-number 3])
(make-list a-number fruit))
(define (make-fruits4 fruit #:? number)
(make-fruits3 fruit #:number number))
(make-fruits4 'clementine)
]
@deftogether[(@defthing[no-value symbol?]{}
@defproc[(no-value? [x any/c]) boolean?]{})]{
@racket[no-value] is an
@techlink[#:key "uninterned"
#:doc '(lib "scribblings/reference/reference.scrbl")
]{uninterned symbol}
representing the default value of pass-through arguments.
@racket[no-value] does not normally need to be used, but is provided
for clarity and possibly for user enhancements.
}
@deftogether[
(@defform[(lambda args body ...+)]{}
@defform[(λ args body ...+)
#:grammar
([args
(pos-id ... [opt-id opt-expr] ... kw-arg ...)
(pos-id ... [opt-id opt-expr] ... kw-arg ... . rest-id)
rest-id]
[kw-arg
(code:line #:! id)
(code:line #:? id)
(code:line #:? [id expr])
(code:line keyword id)
(code:line keyword [id expr])])]{})]{
Like @|rkt-lambda| and @|rkt-λ| from @racketmodname[racket/base], but
with support for @racket[#:!] mandatory keyword arguments and @racket[#:?] optional keyword arguments.
An argument of the form @racket[#:! name] is equivalent to @racket[#:name name].
An argument of the form @racket[#:? [name val]] is equivalent to @racket[#:name [name val]]
but binds @racket[name] to @racket[val] only if @racket[name] is @racket[no-value].
An argument of the form @racket[#:? name] is equivalent to @racket[#:name [name no-value]].
This means in particular that @racket[(lambda (#:a the-a #:! a) ...)] is a syntax error
(duplicate argument keyword),
as well as @racket[(lambda (#:a the-a #:! the-a) ...)] (duplicate argument identifier).
}
@defform*[
((define id expr)
(define (head args) body ...+))]{
Like @|rkt-define| from @racketmodname[racket/base],
but uses @racket[lambda] from @racketmodname[define2] instead.
Also supports the curried form.
}
@section{Wrapper functions}
@defmodule[define2/define-wrapper]
Writing wrapper functions is already simplified with the new @racket[define]
thanks to pass-through optional arguments, but there can still be some verbosity left
due to having to repeat the argument names.
@racket[define-wrapper] helps with this by passing the arguments to the wrapped
function automatically.
@defform[(define-wrapper (fun [wrapped-fun arg ... maybe-rest]
keyword-arg ...)
maybe-call-wrapped
body ...)
#:grammar
([maybe-call-wrapped (code:line) (code:line #:call-wrapped call-wrapped-id)])]{
@racket[arg ... maybe-rest] and @racket[keyword-arg ...] are arguments as for @racket[lambda],
but @racket[keyword-arg ...] are restricted to keyword arguments.
The resulting function @racket[fun] takes as input all the arguments
@racket[arg ... keyword-arg ... maybe-rest].
Only the arguments @racket[arg ... maybe-rest] are forwarded to the call to @racket[wrapped-fun].
The function @racket[wrapped-fun] must be defined elsewhere.
If @racket[call-wrapped-id] is not provided then @racket[wrapped-fun] is called in tail-position;
otherwise it should be called as @racket[(call-wrapped-id)] somewhere in @racket[body ...],
and this calls @racket[wrapped-fun] with the arguments @racket[arg ... maybe-rest].
More concretely (supposing that @racket[bar] is already defined elsewhere),
@racketblock[
(define-wrapper (foo (bar a #:? [b 'b])))]
is equivalent to
@racketblock[
(define (foo a #:? [b 'b])
(bar a #:b b))]
and
@racketblock[
(define-wrapper (foo (bar a #:? [b 'b])
#:c c)
(set! a (+ a c)))]
is equivalent to
@racketblock[
(define (foo a #:? [b 'b] #:c c)
(set! a (+ a c))
(bar a #:b b))]
and
@racketblock[
(define-wrapper (foo (bar a #:? [b 'b])
#:c c)
#:call-wrapped bar-wrapped
(set! a (+ a c))
(define res (bar-wrapped))
(displayln res)
res)]
is equivalent to
@racketblock[
(define (foo a #:? [b 'b] #:c c)
(set! a (+ a c))
(define res (bar a #:b b))
(displayln res)
res)]
}
@bold{Note:} Be careful to not use pass-through arguments
if the corresponding argument in @racket[wrapped-fun]
is not an optional keyword argument.
@examples[
#:eval my-eval #:label "For example, this fails:"
(define-wrapper (my-sort (sort l <? #:? key)))
(eval:error (my-sort '(1 4 2) <))]
@examples[
#:eval my-eval #:label "But this is fine:"
(define-wrapper (my-sort2 (sort l <? #:? [key values])))
(my-sort2 '(1 4 2) <)]
@section{Compile-time error checking}
In standard Racket, when a function is defined with @|rkt-define|,
and is later called with the wrong number of arguments or with the wrong keywords, an error
is signalled only at run time, when the function is called.
Instead, using the @racketid[define] form provided by @racketmodname[define2]
signals an error at @emph{compile-time}.
Thus, such errors are caught much earlier than with standard Racket,
for example with @exec{raco make}.
Furthermore, since DrRacket runs background expansion, such errors can be caught as early as
the are written.
@examples[
#:eval my-eval #:label "The following errors are raised at compile time:"
(define (foo bar [baz 'b] #:fizz fizz #:buzz [buzz #t])
#true)
(eval:error (foo))
(eval:error (foo 'a 'b 'c #:fizz 'f))
(eval:error (foo 'a))
(eval:error (foo 'a #:fizz 'f #:beurre 'b))]
For the last error, DrRacket even highlights the wrong keyword.
@section{Acknowledgements}
Thanks to
Ross Angle,
Sorawee Porncharoenwase,
Jack Firth,
Jens-Axel Soegaard,
Sam Tobin-Hochstadt,
Greg Hendershott,
Bogdan Popa,
Matthew Flatt,
Robby Findler,
and Leif Anderson
for their help.
| false |
ffba1ab7c2be1fbace370b44d1147e9bc7f78692 | 964bb56e1e21091cf07a49b51394d02fcdb018f7 | /ch03/3.3/3_25.rkt | cf6e1df83274f4341cd9832be2251a649744c768 | []
| no_license | halee99/SICP | fa7758f96c6363b3b262e3b695f11f1c1072c628 | de282c9f595b3813d3f6b162e560b0a996150bd2 | refs/heads/master | 2020-04-06T14:52:39.639013 | 2019-10-10T09:14:56 | 2019-10-10T09:14:56 | 157,557,554 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,895 | rkt | 3_25.rkt | #lang planet neil/sicp
(define (assoc key records)
(cond ((null? records) false)
((equal? key (caar records)) (car records))
(else (assoc key (cdr records)))))
(define (lookup keys table)
(let ((current-key (car keys))
(remain-keys (cdr keys)))
(let ((record (assoc current-key (cdr table))))
(cond ((and record (null? remain-keys))
(cdr record))
((and record (not (null? remain-keys)))
(lookup remain-keys record))
(else
false)))))
(define (insert! keys value table)
(let ((current-key (car keys))
(remain-keys (cdr keys)))
(let ((record (assoc current-key (cdr table))))
; 第一个 key 查到，没有其他 key
(cond ((and record (null? remain-keys))
(set-cdr! record value))
; 第一个 key 查不到，没有其他 key
((and (not record) (null? remain-keys))
(set-cdr! table
(cons (cons current-key value) (cdr table))))
; 第一个 key 查到，还有其他 key
((and record (not (null? remain-keys)))
(insert! remain-keys value record))
; 第一个 key 查不到，还有其他 key
((and (not record) (not (null? remain-keys)))
(set-cdr! table
(cons (cons current-key '()) (cdr table)))
(insert! remain-keys value (cadr table)))))
'ok!))
(define (make-table)
(list '*table*))
; test
(define t (make-table))
(insert! '(key1 key2 key3) 3 t)
(lookup '(key1 key2 key3) t)
(insert! '(key1 key2 key4) 2 t)
(lookup '(key1 key2 key4) t)
; BUG
; (insert! '(key1 key2) 1 t)
; 因为对于之前 '(key1 key2 key3) 等的插入，导致 '(key1 key2 ..) 是个三维表格
; 将三维表格 '(key1 key2 ..) 强行转换成二维表格 '(key1 key2) 会出错
| false |
531e4a5871b360662304f0d985577cf03dc3d72a | 453869ca6ccd4c055aa7ba5b09c1b2deccd5fe0c | /tests/basic/define-values-simple.rkt | 8a16151371635cc942414c5e6b81e885da6c7cca | [
"MIT"
]
| permissive | racketscript/racketscript | 52d1b67470aaecfd2606e96910c7dea0d98377c1 | bff853c802b0073d08043f850108a57981d9f826 | refs/heads/master | 2023-09-04T09:14:10.131529 | 2023-09-02T16:33:53 | 2023-09-02T16:33:53 | 52,491,211 | 328 | 16 | MIT | 2023-09-02T16:33:55 | 2016-02-25T02:38:38 | Racket | UTF-8 | Racket | false | false | 140 | rkt | define-values-simple.rkt | #lang racket/base
(define-values (a b)
(let-values (((c d) (values 12 24)))
(values (+ c d) (* c d))))
(displayln a)
(displayln b)
| false |
4adfff8e78985be2ba67cc3ae8e5a6f98f645dcb | 842628637fdf1893c87e7d3a38884c2dab48c7db | /gabarito_prova.rkt | 75c33554180ec074a6f1772b98ab8475920aeadc | []
| no_license | gustavooquinteiro/functional-programming-study | f76af66e747ddf3aec166367b56dfe8a76338596 | bccdfa7690ae1a45f6e1d6f3fc6bb7077d7d143f | refs/heads/master | 2020-08-22T01:05:22.189245 | 2019-11-01T14:42:24 | 2019-11-01T14:42:24 | 216,287,330 | 2 | 1 | null | null | null | null | UTF-8 | Racket | false | false | 7,380 | rkt | gabarito_prova.rkt | #lang racket
;; Prova 1 Solução
; Nesta prova vamos escrever um conjunto de versões para a macro pipe.
; Esta macro deve produzir uma forma sintática que encadeia
; linearmente a saída de uma expressão na próxima expressão listada.
; Para isto vamos, inicialmente, usar a seguinte gramática:
; (pipe val-expr clause ...)
; clause = (fn-expr arg-expr ...)
; Por exemplo:
; (pipe 10 (+ 2) (* 5)) , deve resultar na sintaxe (* (+ 10 2) 5) ,
; produzindo 60 quando executada.
; Ou seja, jogamos o valor 10 na expressão (+ 10 2) e o seu
; resultado na expressão seguinte
; (* resultado 5) , resultando em (* (+ 10 2) 5)
; Da mesma maneira:
; (pipe 'a (cons '(b)) (append '(1 2 3))) , deve resultar na sintaxe
; (append (cons 'a '(b)) '(1 2 3))
; produzindo '(a b 1 2 3) quando executada.
; Ou seja, jogamos o valor 'a na expressão (cons 'a '(b)) e o seu
; resultado na expressão seguinte
; (append resultado '(1 2 3)) ,
; resultando em (append (cons 'a '(b)) '(1 2 3))
;; QUESTÃO 1
;;
;; Escreva pipe-v1, uma versão simplificada de pipe
;; que tem a seguinte gramática:
;;
;; (pipe-v1 val-expr)
; A macro deve passar nos seguintes testes
;
; > (pipe-v1)
; . pipe-v1: bad syntax in: (pipe-v1)
; > (pipe-v1 3)
; 3
; > (pipe-v1 (* 4 30))
; 120
;; Solução
(define-syntax (pipe-v1 stx)
(syntax-case stx ()
[(_ val-expr) #'val-expr]
)
)
;; QUESTÃO 2
;;
;; Escreva pipe-v2, uma versão simplificada de pipe que tem a seguinte gramática:
;;
;; (pipe-v2 val-expr) |
;; (pipe-v2 val-expr (fn-expr arg-expr ...))
; A macro deve passar nos seguintes testes
;
; > (pipe-v2)
; . pipe-v2: bad syntax in: (pipe-v2)
; > (pipe-v2 4)
; 4
; > (pipe-v2 (* 4 30))
; 120
; > (pipe-v2 5 (* 4 30))
; 600
; >
;; Solução
(define-syntax (pipe-v2 stx)
(syntax-case stx ()
[(_ val-expr) #'val-expr]
[(_ val-expr (fn-expr arg-expr ...))
#'(fn-expr val-expr arg-expr ...)]
)
)
;; QUESTÃO 3
;; Escreva pipe-v3, uma versão de pipe que tem a seguinte gramática:
;;
;; (pipe-v3 val-expr clause ...)
;; clause = (fn-expr arg-expr ...)
; A macro deve passar nos seguintes testes
;
; > (pipe-v3)
; . pipe-v3: bad syntax in: (pipe-v3)
; > (pipe-v3 4)
; 4
; > (pipe-v3 (* 4 30))
; 120
; > (pipe-v3 5 (* 4 30))
; 600
; > (pipe-v3 5 (* 4 30) (+ 10) (/ 2))
; 305
; > (pipe-v3 #\a (list #\z) (list->string))
; "az"
; > (pipe-v3 'abc (symbol->string) (string-ref 0) (char->integer) (- 2))
; 95
;; Solução
(define-syntax (pipe-v3 stx)
(syntax-case stx ()
[(_ val-expr) #'val-expr]
[(_ val-expr (fn-expr arg-expr ...) clause ...)
#'(pipe-v3 (fn-expr val-expr arg-expr ...) clause ...)]
)
)
;; QUESTÃO 4
;; Escreva pipe-v4, uma versão de pipe que tem a seguinte gramática:
;;
;; (pipe-v4 val-expr clause ...)
;; clause = (fn-expr arg-expr ...) |
;; id-fn-expr
;;
;; Esta gramática permite a inclusão de funções sem parênteses,
;; id-fn-expr, no encadeamento. Esta notação deve ser equivalente
;; a escrever (id-fn-expr) e devem resultar na sintaxe
;; (id-fn-expr resultado), sobre a sintaxe anterior.
; A macro deve passar nos seguintes testes
;
; > (pipe-v4)
; . pipe-v3: bad syntax in: (pipe-v4)
; > (pipe-v4 4)
; 4
; > (pipe-v4 (* 4 30))
; 120
; > (pipe-v4 5 (* 4 30))
; 600
; > (pipe-v4 5 (* 4 30) (+ 10) (/ 2))
; 305
; > (pipe-v4 #\a (list #\z) (list->string))
; "az"
; > (pipe-v4 'abc (symbol->string) (string-ref 0) (char->integer) (- 2))
; 95
; > (pipe-v4 #\a (list #\z) list->string)
; "az"
; > (pipe-v4 'abc symbol->string (string-ref 0) char->integer (- 2))
; 95
;; Solução
(define-syntax (pipe-v4 stx)
(syntax-case stx ()
[(_ val-expr) #'val-expr]
[(_ val-expr (fn-expr arg-expr ...) clause ...)
#'(pipe-v4 (fn-expr val-expr arg-expr ...) clause ...)]
[(_ val-expr id-fn-expr clause ...)
#'(pipe-v4 (id-fn-expr val-expr) clause ...)]
)
)
;; QUESTÃO 5
;; As gramáticas anteriores sempre inseriam o resultado da expressão
;; anterior como o primeiro parâmetro da expressão sendo processada.
;; Vamos criar uma macro que permite a inclusão de um marcador "_"
;; para indicar aonde o resultado da expressão anterior deve se
;; encaixar na expressão sendo processada.
;; Escreva pipe-v5, uma versão de pipe que tem a seguinte gramática:
;; (pipe-v5 val-expr clause ...)
;; clause =(fn-expr pre-expr ... _ post-expr ...) |
;; (fn-expr arg-expr ...) |
;; id
;;
;; DICA
;;
;; O syntax-case não deixa você usar a expressão
;; (_ val-expr (fn-expr pre-expr ... '_ post-expr ...))
;; como template
;;
;; use um MATCH com
;; (list _ val-expr (list fn-expr pre-expr ... '_ post-expr ... ))
; A macro deve passar nos seguintes testes
;
; > (pipe-v5)
; . pipe-v5: bad syntax in: (pipe-v5)
; > (pipe-v5 4)
; 4
; > (pipe-v5 (* 4 30))
; 120
; > (pipe-v5 5 (* 4 30))
; 600
; > (pipe-v5 5 (* 4 30) (+ 10) (/ 2))
; 305
; > (pipe-v5 #\a (list #\z) (list->string))
; "az"
; > (pipe-v5 'abc (symbol->string) (string-ref 0) (char->integer) (- 2))
; 95
; > (pipe-v5 #\a (list #\z) list->string)
; "az"
; > (pipe-v5 'abc symbol->string (string-ref 0) char->integer (- 2))
; 95
; > (pipe-v5 1 (list-ref '(10 20) _))
; 20
; > (pipe-v5 '(1 2 3) (map add1 _) (apply + _) (/ 1 7))
; 1 2/7
(require (for-syntax racket/match))
(define-syntax (pipe-v5 stx)
(match (syntax->datum stx)
;; processa caso base
[(list _ val-expr)
(datum->syntax stx val-expr)]
;; processa clausula com expressão com marcador
[(list _ val-expr (list fn-expr pre-expr ... '_ post-expr ...) clause ...)
(datum->syntax stx
(cons 'pipe-v5
(cons
(cons fn-expr
(append pre-expr
(cons val-expr
post-expr)))
clause)))]
;; processa clausula com expressão sem marcador
[(list _ val-expr (list fn-expr arg-expr ...) clause ...)
(datum->syntax stx
(cons 'pipe-v5
(cons
(cons fn-expr
(cons val-expr
arg-expr))
clause)))]
;; processa clausula com id
[(list _ val-expr id clause ...)
(datum->syntax stx
(cons 'pipe-v5
(cons (list id val-expr)
clause)))]
))
;; Outra solução
;; com quasiquotes
(define-syntax (pipe-v5-2 stx)
(match (syntax->datum stx)
;; processa caso base
[(list _ val-expr)
(datum->syntax stx val-expr)]
;; processa clausula com expressão com marcador
[(list _ val-expr (list fn-expr pre-expr ... '_ post-expr ...) clause ...)
(datum->syntax stx
`(pipe-v5-2
,(append (cons fn-expr pre-expr) (cons val-expr post-expr)) . ,clause))]
;; processa clausula com expressão sem marcador
[(list _ val-expr (list fn-expr arg-expr ...) clause ...)
(datum->syntax stx
`(pipe-v5-2 ,(cons fn-expr (cons val-expr arg-expr)) . ,clause))]
;; processa clausula com id
[(list _ val-expr id clause ...)
(datum->syntax stx
`(pipe-v5-2 ,(list id val-expr) . ,clause))]
))
| true |
7bf3790fc4180ba3944d4e6cdeac90c6c8ffab52 | fa2c4230c4db9b7da91887a742ed932229ae0d6b | /eval.rkt | 4694a13c289d1fe3e16ca4ddf036761c2b48c70e | []
| no_license | qingyunha/sicp | 36eec74e571e954615c01fce337d8a1ccd364e6f | 34c077b729d48e3a4c3c11eb11cadf873963136c | refs/heads/master | 2020-03-30T08:16:46.895338 | 2015-05-19T03:02:56 | 2015-05-19T03:02:56 | 35,856,314 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 9,716 | rkt | eval.rkt | ;; The first three lines of this file were inserted by DrRacket. They record metadata
;; about the language level of this file in a form that our tools can easily process.
#reader(lib "htdp-intermediate-lambda-reader.ss" "lang")((modname eval) (read-case-sensitive #t) (teachpacks ((lib "image.rkt" "teachpack" "2htdp") (lib "batch-io.rkt" "teachpack" "2htdp") (lib "universe.rkt" "teachpack" "2htdp") (lib "dir.rkt" "teachpack" "htdp"))) (htdp-settings #(#t constructor repeating-decimal #f #t none #f ((lib "image.rkt" "teachpack" "2htdp") (lib "batch-io.rkt" "teachpack" "2htdp") (lib "universe.rkt" "teachpack" "2htdp") (lib "dir.rkt" "teachpack" "htdp")))))
; A BSL-expr is one of:
; – Number
; – (make-add BSL-var-expr BSL-var-expr)
; – (make-mul BSL-var-expr BSL-var-expr)
; A BSL-var-expr is one of:
; – Number
; – Symbol
; – (make-add BSL-var-expr BSL-var-expr)
; – (make-mul BSL-var-expr BSL-var-expr)
; A BSL-fun-expr is one of:
; – Number
; – Symbol
; – (make-add BSL-var-expr BSL-var-expr)
; – (make-mul BSL-var-expr BSL-var-expr)
; - (cons Symbol [list-of-BSL-fun-expr])
(define-struct add [left right])
(define-struct mul [left right])
;BSL-value is a number
; An AL (association list) is [List-of Association].
; An Association is (cons Symbol (cons Number empty)).
;An DL (definition list) is [list-of Definition]
;An Definition is def
(define-struct def [name para body])
;BSL-da-all is [list-of Association or DL]
;A BSL-fun-def is a
;(make-def Symbol Symbol BSL-fun-expr)
;(define (f x) (+ 3 x))
;(define (g y) (f (* 2 y)))
;(define (h v) (+ (f v) (g v)))
(define ff (make-def 'ff 'x (make-add 3 'x)))
(define g (make-def 'g 'y (cons 'ff (cons (make-mul 2 'y) empty))))
(define h (make-def 'h 'v (make-add (cons 'ff (cons 'v empty)) (cons 'g (cons 'v empty)))))
;BSL-fun-def* is a DL
(define da-fgh (list ff g h))
(define AL '((x 5) (y 3)))
(define all-da (append AL da-fgh))
(define e1 (make-add (make-mul 3 3)
(make-mul 4 4)))
(define e2 (make-add 'x 3))
(define e3 (make-add (make-mul 'x 'x)
(make-mul 'y 'y)))
(define b (make-add 'x 1))
(define f (cons 'f (cons 8 empty)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EVAL
(define (eval-expression bsl-exp)
(cond [(add? bsl-exp)
(+ (eval-expression (add-left bsl-exp))
(eval-expression (add-right bsl-exp)))]
[(mul? bsl-exp)
(* (eval-expression (mul-left bsl-exp))
(eval-expression (mul-right bsl-exp)))]
[else bsl-exp]))
(define (eval-variable e)
(if (numeric? e)
(eval-expression e)
(error "impossible to evaluate an expression that contains a variable.")))
;BSL-var-exp AL -> BSL-value
;(check-expect (eval-variable* e3 AL) 34)
(define (eval-variable* e da)
(local(
(define ee
(foldl (lambda (assoc base)(subst base (car assoc) (cadr assoc))) e da)))
(eval-variable ee)))
; BSL-var-expr AL -> Number
;(check-expect (eval-var-lookup e3 AL) 34)
(define (eval-var-lookup e da)
(cond [(add? e)
(+ (eval-var-lookup (add-left e) da)
(eval-var-lookup (add-right e) da))]
[(mul? e)
(* (eval-var-lookup (mul-left e) da)
(eval-var-lookup (mul-right e) da))]
[(number? e) e]
[else (lookup-con da e)]))
;AL symbol -> BSL-value
;(check-expect (lookup-con AL 'x) 5)
;(check-expect (lookup-con AL 'y) 3)
(define (lookup-con da x)
(cond [(empty? da) (error "not find")]
[else (if (symbol=? x (caar da))
(cadar da)
(lookup-con (cdr da) x))]))
(define (eval-definition1 e f x b)
(cond [(add? e)
(+ (eval-definition1 (add-left e) f x b)
(eval-definition1 (add-right e) f x b))]
[(mul? e)
(* (eval-definition1 (mul-left e) f x b)
(eval-definition1 (mul-right e) f x b))]
[(number? e) e]
[(symbol? e) (lookup-con empty e)]
[else (eval-definition1 (subst b x (eval-definition1 (cadr e) f x b)) f x b)]))
; BSL-fun-def* Symbol -> BSL-fun-def
; retrieves the definition of f in da
; or signal "undefined function" if da does not contain one
;(check-expect (lookup-def da-fgh 'g) g)
(define (lookup-def da f)
(cond [(empty? da) (error "not find fuction")]
[else (if (symbol=? f (def-name (car da)))
(car da)
(lookup-def (cdr da) f))]))
;BSL-fun-exp BSL-fun-def* -> BSL-value
;(check-expect (eval-function* (cons 'ff (cons 0 empty)) da-fgh) 3)
;(check-expect (eval-function* (cons 'g (cons 0 empty)) da-fgh) 3)
(define (eval-function* e da)
(cond [(add? e)
(+ (eval-function* (add-left e) da)
(eval-function* (add-right e) da))]
[(mul? e)
(* (eval-function* (mul-left e) da)
(eval-function* (mul-right e) da))]
[(number? e) e]
[(symbol? e) (lookup-con empty e)]
[else
(local (
(define f (lookup-def da (car e)))
(define arg (eval-function* (cadr e) da)))
(eval-function* (subst (def-body f) (def-para f) arg) da))]))
;BSL-da-all -> number
(define (lookup-con-def da x)
(cond [(empty? da) (error "constant not find")]
[else (if (and (not (def? (car da))) (symbol=? x (caar da)))
(cadar da)
(lookup-con-def (cdr da) x))]))
(define (lookup-fun-def da x)
(cond [(empty? da) (error "function not find")]
[else (if (and (def? (car da)) (symbol=? x (def-name (car da))))
(car da)
(lookup-fun-def (cdr da) x))]))
;(check-expect (eval-all 'x all-da) 5)
;(check-expect (eval-all '(ff 0) all-da) 3)
;(check-expect (eval-all '(ff x) all-da) 8)
(define (eval-all e da)
(cond [(add? e)
(+ (eval-all (add-left e) da)
(eval-all (add-right e) da))]
[(mul? e)
(* (eval-all (mul-left e) da)
(eval-all (mul-right e) da))]
[(number? e) e]
[(symbol? e) (lookup-con-def da e)]
[else
(local (
(define f (lookup-fun-def da (car e)))
(define arg (eval-all (cadr e) da)))
(eval-all (subst (def-body f) (def-para f) arg) da))]))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;BSL-var-exp symbol number -> BSL-var-exp
;(check-expect (subst e2 'x 2) (make-add 2 3))
(define (subst e x v)
(cond [(add? e) (make-add (subst (add-left e) x v) (subst (add-right e) x v))]
[(mul? e) (make-mul (subst (mul-left e) x v) (subst (mul-right e) x v))]
[(number? e) e]
[(symbol? e) (if (symbol=? e x) v e)]
[else (cons (car e) (cons (subst (cadr e) x v) empty))]))
;BSL-var-exp -> boolen
;(check-expect (numeric? e1) true)
;(check-expect (numeric? e2) false)
(define (numeric? e)
(cond [(add? e)
(and (numeric? (add-left e)) (numeric? (add-right e)))]
[(mul? e)
(and (numeric? (mul-left e)) (numeric? (mul-right e)))]
[(number? e) true]
[else false]))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;PARSE
(define WRONG "wrong kind of S-expression")
(define (atom? s) (or (symbol? s) (number? s) (string? s)))
; S-expr -> BSL-expr
; creates representation of a BSL expression for s (if possible)
(define (parse s)
(local (; S-expr -> BSL-expr
(define (parse s)
(cond
[(atom? s) (parse-atom s)]
[else (parse-sl s)]))
; SL -> BSL-expr
(define (parse-sl s)
(local ((define L (length s)))
(cond
[(and (= L 3) (symbol? (first s)))
(cond
[(symbol=? (first s) '+)
(make-add (parse (second s)) (parse (third s)))]
[(symbol=? (first s) '*)
(make-mul (parse (second s)) (parse (third s)))]
[else (error WRONG)])]
[(and (= L 2) (symbol? (first s))) (cons (first s) (cons (parse (cadr s)) empty))]
[else
(error WRONG)])))
; Atom -> BSL-expr
(define (parse-atom s)
(cond
[(number? s) s]
[(symbol? s) s]
[else (error "not allowed")])))
(parse s)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define WRONGs "wrong kind of S-expression")
;{S-expr} -> (tech "BSL-fun-def")
; creates representation of a BSL definition for s (if possible)
(define (def-parse s)
(local (; S-expr -> BSL-fun-def
(define (def-parse s)
(cond
[(atom? s) (error WRONG)]
[else
(if (and (= (length s) 3) (eq? (first s) 'define))
(head-parse (second s) (parse (third s)))
(error WRONG))]))
; S-expr BSL-expr -> BSL-fun-def
(define (head-parse s body)
(cond
[(atom? s) (list s body)]
[else
(if (not (= (length s) 2))
(error WRONG)
(local ((define name (first s))
(define para (second s)))
(if (and (symbol? name) (symbol? para))
(make-def name para body)
(error WRONG))))])))
(def-parse s)))
(define (da-parse sl)
(foldl (lambda (s base) (cons (def-parse s) base)) empty sl))
(define (eval-all-sexpr s sl)
(local (
(define e (parse s))
(define da (da-parse sl)))
(eval-all e da)))
| false |
337f9ccc3d28349a578711acf70ccc69459e8b0c | 5f8d781ca6e4c9d3d1c3c38d2c04e18d090589cc | /0/www/exercises/5.scrbl | 33032734d583b4826f6615964b50ab5fb73d3604 | [
"AFL-3.0",
"AFL-2.1",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | plum-umd/fundamentals | a8458621131b864f0e3389b030c5197ea6bb3f41 | eb01ac528d42855be53649991a17d19c025a97ad | refs/heads/master | 2021-06-20T05:30:57.640422 | 2019-07-26T15:27:50 | 2019-07-26T15:27:50 | 112,412,388 | 12 | 1 | AFL-3.0 | 2018-02-12T15:44:48 | 2017-11-29T01:52:12 | Racket | UTF-8 | Racket | false | false | 4,308 | scrbl | 5.scrbl | #lang scribble/manual
@(require scribble/core
scribble/examples
racket/sandbox
(for-label lang/htdp-beginner)
(for-label (except-in 2htdp/image image?))
;"helper.rkt"
"../utils.rkt"
"../defns.rkt")
@title[#:style 'unnumbered #:tag "ex5"]{Exercise 5}
@bold{Due}: Wednesday, July 17, 11:59:59 PM EST.
@(define ex (make-exerciser "Problem"))
Implement these exercises with the
@link["https://docs.racket-lang.org/htdp-langs/beginner.html"]{Beginning
Student Language}.
@section[#:tag "ex5:submit"]{Directions for submitting}
Please read and follow these intructions carefully. You should submit
a @bold{single} file named @tt{ex5.rkt} on @link[elms-url]{ELMS}. You
may submit many times, but each submission should be one file called
@tt{ex5.rkt}. You may lose points for not following these
instructions.
Make sure the top of the file contains the following, with your name filled in:
@codeblock[#:keep-lang-line? #false]|{
#lang racket
;; Exercise 5
;; Name: ...your name here...
}|
@section[#:tag "ex5:overview"]{Oveview}
The goal of this exercise is to practice using the ``design recipe'' for
systematic problem solving with lists.
In this exercise, you will develop functions for operating on
arbitrarily large collections of data. There are many problems, but
practicing the design process will help make them go quickly.
@section[#:tag "ex:lon"]{Lists of numbers}
@codeblock[#:keep-lang-line? #false]|{
#lang racket
;; A LoN (list of numbers) is one of:
;; - '()
;; - (cons Number LoN)
}|
@ex[@racket[lon-count : LoN -> Natural]]{
Count the number of elements in a given list of numbers.
}
@ex[@racket[lon-product : LoN -> Number]]{
Compute the product of the given list of numbers (multiply all numbers
together).
}
@ex[@racket[lon-add1-all : LoN -> LoN]]{
Add one to every element of a given list and collect the results as a
list.
}
@ex[@racket[lon-abs-all : LoN -> LoN]]{
Compute the absolute value of every element of a given list and
collect the results as a list.
}
@ex[@racket[lon-filter-even : LoN -> LoN]]{
Produce a list that contains only the even elements of a given list.
}
@ex[@racket[lon-all-odd? : LoN -> Boolean]]{
Determine if every element of a given list is odd.
}
@section[#:tag "ex5:los"]{List of strings}
@codeblock[#:keep-lang-line? #false]|{
#lang racket
;; A LoS (list of strings) is one of:
;; - '()
;; - (cons String LoS)
}|
@ex[@racket[los-count : LoS -> Natural]]{
Count the number of elements in a given list of strings.
}
@ex[@racket[los-string-append : LoS -> String]]{
Append together all the strings in a given list of strings.
}
@ex[@racket[los-upcase-all : LoS -> LoS]]{
Capitalize every string in a given list and collect the results as a
list. (Hint: @racket[string-upcase].)
}
@ex[@racket[los-length-all : LoS -> LoN]]{
Compute the length of every string in a given list and
collect the results as a list (of numbers).
}
@ex[@racket[los-filter-contains-e : LoS -> LoS]]{
Produce a list that contains only the elements of a given list that
contain the letter @racket["e"]. (Hint: @racket[string-contains?].)
}
@ex[@racket[los-any-whitespace? : LoS -> Boolean]]{
Determine if any element of a given list is whitespace. (Hint:
@racket[string-whitespace?].)
}
@section[#:tag "ex:lop"]{Lists of positions}
@codeblock[#:keep-lang-line? #false]|{
#lang racket
;; A LoP (list of positions) is one of:
;; - '()
;; - (cons Posn LoP)
;; A Posn is a (make-posn Number Number)
}|
@ex[@racket[lop-count : LoP -> Natural]]{
Count the number of elements in a given list of positions.
}
@ex[@racket[lop-dist-sum : LoP -> Number]]{
Compute the sum of each position's distance to the origin in a given list.
}
@ex[@racket[lop-dist-all : LoP -> LoN]]{
Compute a list of distances to the origin for a given list of positions.
}
@ex[@racket[lop-change-x : LoP Number -> LoP]]{
Change each position's x-coordinate by given amount.
}
@ex[@racket[lop-remove-y-bound : LoP Number -> LoP]]{
Produce a list that contains only the elements whose y-coordinate is
between 0 (inclusive) and the given number (inclusive).
}
@ex[@racket[lop-any-equal? : LoP Posn -> Boolean]]{
Determine if any element of a given list is the same as given position.
}
| false |
c083b617b59da9a7c18537ec41ae5f20ce3221c5 | 82c76c05fc8ca096f2744a7423d411561b25d9bd | /typed-racket-test/fail/pr13365-variation-3.rkt | b1be43870ecd58e908d4f240bf8eb333889cd199 | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/typed-racket | 2cde60da289399d74e945b8f86fbda662520e1ef | f3e42b3aba6ef84b01fc25d0a9ef48cd9d16a554 | refs/heads/master | 2023-09-01T23:26:03.765739 | 2023-08-09T01:22:36 | 2023-08-09T01:22:36 | 27,412,259 | 571 | 131 | NOASSERTION | 2023-08-09T01:22:41 | 2014-12-02T03:00:29 | Racket | UTF-8 | Racket | false | false | 136 | rkt | pr13365-variation-3.rkt | #;
(exn-pred #rx"mismatch in.*a ...")
#lang typed/racket
(: f (All (a ...) (a ... a -> (Values a ... a))))
(define (f . x) (values 1))
| false |
c13c7dfd448565bf544d090547ab089ee4bab4f2 | 7e500549765a0bdc49d4fcf40158fb9bb5b07e3e | /system.rkt | dff1d86a465549d81da581e1e7a128d203a27a82 | []
| no_license | capfredf/digimon | 94f3b3946ce115e8ae4472fc757b5f548c519f04 | 1215bb3b1ab86fd115a6f2e393afa4d8530ed576 | refs/heads/master | 2023-04-05T01:27:59.773661 | 2021-04-14T05:32:44 | 2021-04-14T05:32:44 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 8,495 | rkt | system.rkt | #lang typed/racket/base
(provide (all-defined-out) current-digimon current-digivice current-free-zone)
(provide #%info digimon-waketime digimon-uptime digimon-partner digimon-system digimon-path digivice-path)
(require racket/fixnum)
(require racket/format)
(require racket/match)
(require racket/port)
(require racket/place)
(require "digitama/system.rkt")
(require "digitama/sugar.rkt")
(require "digitama/evt.rkt")
(require "continuation.rkt")
(require "symbol.rkt")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(void (print-boolean-long-form #true)
;;; Ignore DrRacket's convention. But don't change "compiled" since
;;; the compiler checks bytecodes in the core collection
;;; which have already been compiled into <path:compiled>.
(use-compiled-file-paths (list (build-path "compiled"))))
(define string-null? : (-> Any Boolean : #:+ String)
(lambda [str]
(and (string? str)
(string=? str ""))))
(define maybe? : (All (a) (-> (Option a) (-> a Boolean) Boolean))
(lambda [val ?]
(or (not val)
(and val (? val)))))
(define read:+? : (All (a) (-> Any (-> Any Boolean : #:+ a) [#:from-string Boolean] a))
(lambda [src type? #:from-string [? #true]]
(define v : Any
(cond [(and ? (string? src)) (read (open-input-string src))]
[(and ? (bytes? src)) (read (open-input-bytes src))]
[(or (path? src) (path-string? src)) (call-with-input-file src read)]
[(input-port? src) (read src)]
[else src]))
(cond [(type? v) v]
[(not (eof-object? v)) (raise-result-error 'read:+? (~a (object-name type?)) v)]
[else (raise (make-exn:fail:read:eof (format "read:+?: ~a: unexpected <eof>" (object-name type?))
(current-continuation-marks)
null))])))
(define hash-ref:+? : (All (a b) (->* (HashTableTop Any (-> Any Boolean : #:+ a)) ((-> b)) (U a b)))
(lambda [src key type? [defval #false]]
(define v : Any (if defval (hash-ref src key defval) (hash-ref src key)))
(cond [(type? v) v]
[(not defval) (raise-result-error 'hash-ref:+? (~a (object-name type?)) v)]
[else (defval)])))
(define current-microseconds : (-> Fixnum)
(lambda []
(fl->fx (real->double-flonum (* (current-inexact-milliseconds) 1000)))))
(define timer-evt : (->* (Fixnum) (Fixnum) Timer-EvtSelf)
(lambda [interval [basetime (current-milliseconds)]]
(define alarm-time : Fixnum (fx+ basetime interval))
((inst wrap-evt Any (Vector Timer-EvtSelf Fixnum Fixnum))
(alarm-evt alarm-time)
(λ [alarm] (vector (timer-evt interval alarm-time) interval alarm-time)))))
(define timer-thread : (-> Fixnum (-> Thread Fixnum Any) [#:basetime Fixnum] Thread)
(lambda [interval on-timer #:basetime [basetime (current-milliseconds)]]
(define thdsrc : Thread (current-thread))
(thread (λ [] (let wait-dotask-loop ([evt (timer-evt interval basetime)])
(match (sync/enable-break evt)
[(vector (? evt? next-alarm) (? fixnum? interval) (? fixnum? alarm-time))
(on-timer thdsrc (fxquotient (fx- alarm-time basetime) interval))
(wait-dotask-loop next-alarm)]))))))
(define exn->message : (-> exn [#:level Log-Level] [#:detail Any] (Vector Log-Level String Any Symbol (Listof Continuation-Stack)))
(lambda [e #:level [level 'error] #:detail [detail #false]]
(vector level (exn-message e) detail (datum-name e)
(continuation-mark->stacks (exn-continuation-marks e)))))
(define the-synced-place-channel : (Parameterof (Option Place-Channel)) (make-parameter #false))
(define place-channel-evt : (-> Place-Channel [#:hint (Parameterof (Option Place-Channel))] (Evtof Any))
(lambda [source-evt #:hint [hint the-synced-place-channel]]
(hint #false)
(wrap-evt source-evt ; do not work with guard evt since the maker may not be invoked
(λ [datum] (hint source-evt)
(cond [(not (place-message? datum)) datum]
[else (let ([stream : Any (place-message-stream datum)])
(match/handlers (if (bytes? stream) (with-input-from-bytes stream read) (box stream))
[(? exn:fail:read? e) (exn->message e #:level 'fatal #:detail stream)]))])))))
(define place-channel-send : (-> Place-Channel Any Void)
(lambda [dest datum]
(match datum
[(? place-message-allowed?) (place-channel-put dest datum)]
[(? exn?) (place-channel-put dest (exn->message datum))]
[(box (and (not (? bytes? v)) (? place-message-allowed? v))) (place-channel-put dest (place-message v))]
[_ (place-channel-put dest (place-message (with-output-to-bytes (λ [] (write datum)))))])))
(define place-channel-recv : (-> Place-Channel [#:timeout Nonnegative-Real] [#:hint (Parameterof (Option Place-Channel))] Any)
(lambda [channel #:timeout [s +inf.0] #:hint [hint the-synced-place-channel]]
; Note: the `hint` can also be used to determine whether it is timeout or receiving #false
(sync/timeout/enable-break s (place-channel-evt channel #:hint hint))))
(define place-channel-send/recv : (-> Place-Channel Any [#:timeout Nonnegative-Real] [#:hint (Parameterof (Option Place-Channel))] Any)
(lambda [channel datum #:timeout [s +inf.0] #:hint [hint the-synced-place-channel]]
(place-channel-send channel datum)
(place-channel-recv channel #:timeout s #:hint hint)))
(define place-status : (-> Place (U 'running Integer))
(lambda [p]
(if (sync/timeout 0 (place-dead-evt p)) (place-wait p) 'running)))
(define place-wait-evt : (-> Place Place-EvtExit)
(lambda [p]
(wrap-evt (place-dead-evt p)
(λ _ (cons p (place-wait p))))))
(define thread-mailbox-evt : (-> (Evtof Any))
(lambda []
(wrap-evt (thread-receive-evt)
(λ _ (thread-receive)))))
(define place-statistics : (-> (Values Integer Integer Integer Integer Integer Integer))
(let ([stat : (Vectorof Integer) (vector 0 0 0 0 0 0 0 0 0 0 0 0)])
(lambda []
(vector-set-performance-stats! stat)
(values (vector-ref stat 0) (vector-ref stat 1) (vector-ref stat 2)
(vector-ref stat 3) (vector-ref stat 6)
(+ (vector-ref stat 10) (current-memory-use))))))
(define thread-statistics : (->* () (Thread) (Values Boolean Boolean Boolean Natural))
(let ([stat : (Vectorof (U Boolean Integer)) (vector #false #false #false 0)])
(lambda [[thd (current-thread)]]
(vector-set-performance-stats! stat thd)
(values (and (vector-ref stat 0) #true)
(and (vector-ref stat 1) #true)
(and (vector-ref stat 2) #true)
(let ([bs : (U Boolean Integer) (vector-ref stat 3)])
(if (exact-nonnegative-integer? bs) bs 0))))))
(define call-as-normal-termination : (-> (-> Any) [#:atinit (-> Any)] [#:atexit (-> Any)] Void)
(lambda [#:atinit [atinit/0 void] main/0 #:atexit [atexit/0 void]]
(define exit-racket : (-> Any AnyValues) (exit-handler))
(define codes : (HashTable Symbol Byte) #hasheq((FATAL . 95) (ECONFIG . 96) (ENOSERVICE . 99) (EPERM . 100)))
(define (terminate [status : Any]) : Any
(parameterize ([exit-handler exit-racket])
(cond [(exact-nonnegative-integer? status) (exit (min status 255))]
[(hash-ref codes status (λ [] #false)) => exit]
[else (exit 0)])))
(parameterize ([exit-handler terminate])
(exit (with-handlers ([exn? (λ [[e : exn]] (and (eprintf "~a~n" (exn-message e)) 'FATAL))]
[void (λ [e] (and (eprintf "(uncaught-exception-handler) => ~a~n" e) 'FATAL))])
(dynamic-wind (λ [] (with-handlers ([exn? (λ [[e : exn]] (atexit/0) (raise e))]) (atinit/0)))
(λ [] (main/0))
(λ [] (atexit/0))))))))
(define immutable-guard : (-> Symbol (Any -> Nothing))
(lambda [pname]
(λ [pval] (error pname "Immutable Parameter: ~a" pval))))
(define car.eval : (->* (Any) (Namespace) Any)
(lambda [sexp [ns (current-namespace)]]
(call-with-values (λ [] (eval sexp ns))
(λ result (car result)))))
(define void.eval : (->* (Any) (Namespace) Void)
(lambda [sexp [ns (current-namespace)]]
(call-with-values (λ [] (eval sexp ns)) void)))
| false |
3eb36f00bddca4dc35bc14508ec3086ad6468660 | 779adb8f4e9a335d4187dd610dc01cdc4893a74e | /sweet-exp-utils/info.rkt | 12c2a950b73a203cd25a9ef2e04c0f0aa9ce8972 | [
"MIT"
]
| permissive | AlexKnauth/sweet-exp-utils | a3ef92d66953b03ce97bd395720f50833d83dff0 | 7d223f0c4ba5266b799db309afb6ba163cd4ea25 | refs/heads/master | 2022-01-24T19:18:53.618207 | 2022-01-07T14:44:40 | 2022-01-07T14:44:40 | 31,812,529 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 71 | rkt | info.rkt | #lang info
(define scribblings '(["docs/sweet-exp-utils.scrbl" ()]))
| false |
9789209395737c68764ef1cfaf2dcc8b5132e46d | fc69a32687681f5664f33d360f4062915e1ac136 | /test/dssl2/str-huh.rkt | f90d934bdac71b57aef5fb6043f1c84f572bbb8d | []
| no_license | tov/dssl2 | 3855905061d270a3b5e0105c45c85b0fb5fe325a | e2d03ea0fff61c5e515ecd4bff88608e0439e32a | refs/heads/main | 2023-07-19T22:22:53.869561 | 2023-07-03T15:18:32 | 2023-07-03T15:18:32 | 93,645,003 | 12 | 6 | null | 2021-05-26T16:04:38 | 2017-06-07T14:31:59 | Racket | UTF-8 | Racket | false | false | 75 | rkt | str-huh.rkt | #lang dssl2
assert str?('ehlo')
assert str?("ehlo")
assert not str?(str?)
| false |
7cbcf9dd35d81ca9e71bcd296c754afb616c5c27 | ef61a036fd7e4220dc71860053e6625cf1496b1f | /HTDP2e/03-abstraction/ch-14/ex-241.rkt | 6c62ab6aa0596c6261401f4382bec418ccc3b649 | []
| no_license | lgwarda/racket-stuff | adb934d90858fa05f72d41c29cc66012e275931c | 936811af04e679d7fefddc0ef04c5336578d1c29 | refs/heads/master | 2023-01-28T15:58:04.479919 | 2020-12-09T10:36:02 | 2020-12-09T10:36:02 | 249,515,050 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 803 | rkt | ex-241.rkt | ;; The first three lines of this file were inserted by DrRacket. They record metadata
;; about the language level of this file in a form that our tools can easily process.
#reader(lib "htdp-intermediate-reader.ss" "lang")((modname ex-241) (read-case-sensitive #t) (teachpacks ()) (htdp-settings #(#t constructor repeating-decimal #f #t none #f () #f)))
; An NEList-of-temperatures is one of:
; – (cons CTemperature '())
; – (cons CTemperature NEList-of-temperatures)
; interpretation non-empty lists of Celsius temperatures
; An NEList-of-booleans is one of:
; – (cons Boolean '())
; – (cons Boolean NEList-of-boolean)
; interpretation non-empty lists of Boolean values
; A NEList-of is one of:
; - (cons ITEM '())
; - (cons ITEM NEList-of)
; interpretation non-empty lists of some items | false |
71614abd3e8349c9822260779871d89efe7fd3fe | 5f792140b853f40e3c7be559c2a412d7b8296c96 | /2019/day05/programs/input-part1.rkt | aa2fa4c586e98f25f69a39ecf152e1a820865b67 | [
"Unlicense"
]
| permissive | winny-/aoc | 9d53666faf341f1cc2016a3d21e93d7f4064a72b | f986cacf14d81d220030bca94e99ec8179861e1b | refs/heads/master | 2022-12-05T00:19:47.570034 | 2022-12-04T09:55:11 | 2022-12-04T09:55:11 | 225,185,486 | 7 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 2,575 | rkt | input-part1.rkt | #lang reader "reader-p1.rkt"
3,225,1,225,6,6,1100,1,238,225,104,0,1101,82,10,225,101,94,44,224,101,-165,224,224,4,224,1002,223,8,223,101,3,224,224,1,224,223,223,1102,35,77,225,1102,28,71,225,1102,16,36,225,102,51,196,224,101,-3468,224,224,4,224,102,8,223,223,1001,224,7,224,1,223,224,223,1001,48,21,224,101,-57,224,224,4,224,1002,223,8,223,101,6,224,224,1,223,224,223,2,188,40,224,1001,224,-5390,224,4,224,1002,223,8,223,101,2,224,224,1,224,223,223,1101,9,32,224,101,-41,224,224,4,224,1002,223,8,223,1001,224,2,224,1,223,224,223,1102,66,70,225,1002,191,28,224,101,-868,224,224,4,224,102,8,223,223,101,5,224,224,1,224,223,223,1,14,140,224,101,-80,224,224,4,224,1002,223,8,223,101,2,224,224,1,224,223,223,1102,79,70,225,1101,31,65,225,1101,11,68,225,1102,20,32,224,101,-640,224,224,4,224,1002,223,8,223,1001,224,5,224,1,224,223,223,4,223,99,0,0,0,677,0,0,0,0,0,0,0,0,0,0,0,1105,0,99999,1105,227,247,1105,1,99999,1005,227,99999,1005,0,256,1105,1,99999,1106,227,99999,1106,0,265,1105,1,99999,1006,0,99999,1006,227,274,1105,1,99999,1105,1,280,1105,1,99999,1,225,225,225,1101,294,0,0,105,1,0,1105,1,99999,1106,0,300,1105,1,99999,1,225,225,225,1101,314,0,0,106,0,0,1105,1,99999,8,226,226,224,1002,223,2,223,1006,224,329,101,1,223,223,1008,677,677,224,102,2,223,223,1006,224,344,101,1,223,223,1107,226,677,224,102,2,223,223,1005,224,359,101,1,223,223,1008,226,226,224,1002,223,2,223,1006,224,374,1001,223,1,223,1108,677,226,224,1002,223,2,223,1006,224,389,1001,223,1,223,7,677,226,224,1002,223,2,223,1006,224,404,101,1,223,223,7,226,226,224,1002,223,2,223,1005,224,419,101,1,223,223,8,226,677,224,1002,223,2,223,1006,224,434,1001,223,1,223,7,226,677,224,1002,223,2,223,1006,224,449,1001,223,1,223,107,226,677,224,1002,223,2,223,1005,224,464,1001,223,1,223,1007,677,677,224,102,2,223,223,1005,224,479,101,1,223,223,1007,226,226,224,102,2,223,223,1005,224,494,1001,223,1,223,1108,226,677,224,102,2,223,223,1005,224,509,101,1,223,223,1008,677,226,224,102,2,223,223,1005,224,524,1001,223,1,223,1007,677,226,224,102,2,223,223,1005,224,539,101,1,223,223,1108,226,226,224,1002,223,2,223,1005,224,554,101,1,223,223,108,226,226,224,102,2,223,223,1005,224,569,101,1,223,223,108,677,677,224,102,2,223,223,1005,224,584,101,1,223,223,1107,226,226,224,1002,223,2,223,1006,224,599,101,1,223,223,8,677,226,224,1002,223,2,223,1006,224,614,1001,223,1,223,108,677,226,224,102,2,223,223,1006,224,629,1001,223,1,223,1107,677,226,224,1002,223,2,223,1006,224,644,1001,223,1,223,107,677,677,224,102,2,223,223,1005,224,659,101,1,223,223,107,226,226,224,102,2,223,223,1006,224,674,1001,223,1,223,4,223,99,226
| false |
630966ae54891c26e22c12f4986e6691b175519e | e995fce18dbdd69a757f55a2c023d07fcce3cb6b | /tests/cpcf/redex.rkt | 99e4dc95c3e9773062e8957b4884b79556c2a9fc | []
| no_license | dvanhorn/pcf | 883deb8c60547f04027e9381d54849ee2e0acd7f | f04e2ff7f34b89a3dc6c2a70a6a3283f954d3a67 | refs/heads/master | 2021-01-18T21:52:28.126007 | 2016-03-30T09:26:31 | 2016-03-30T09:26:31 | 6,306,139 | 8 | 1 | null | 2015-07-20T20:34:58 | 2012-10-20T06:45:08 | Racket | UTF-8 | Racket | false | false | 178 | rkt | redex.rkt | #lang racket
(require tests/pcf/make-tests
tests/cpcf/make-tests
cpcf/redex)
(make-pcf-tests -->cv typable/contract?)
(make-cpcf-tests -->cv typable/contract?)
| false |
fc8268994ca5ac5c66893153b53168b6bd4bf413 | 87e7d3837e7c7fc5147d611a1d2a6e1ec2c0a78a | /rosette/lib/optimize/renderer/path-split/adviser.rkt | 3290757fa5be6bc1f3ac6d40f565710f86bf73d6 | [
"BSD-2-Clause"
]
| permissive | zeta1999/symfix-vmcai20 | 1e646d8bba35ded6ddba0901c8ec02bd15b1eccd | d95339e14e282d1946d826f09089f8b3b72d1fa0 | refs/heads/master | 2022-03-30T07:43:32.210830 | 2019-12-21T13:45:55 | 2019-12-21T13:45:55 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 7,805 | rkt | adviser.rkt | #lang racket
(provide advise-path-split)
(require syntax/parse
syntax/stx
syntax/id-set
racket/generator
racket/function
(only-in rosette/base/form/control
[branch-and-merge rosette:branch-and-merge])
rosette/lib/util/utility/main
rosette/lib/util/utility/syntax/free-vars
"../../struct.rkt"
"structs.rkt"
"../../../syntax-utils/utils.rkt"
"../../optimize-reporter.rkt"
"../utils.rkt"
"./transformer.rkt"
"../optimize-analyze.rkt"
"../structs.rkt")
(define (report msg . payload) (void))
(define (find-forall-expr stx target-expr frame)
(define occurrences (count (curry free-identifier=? target-expr)
(free-vars frame #:module-bound? #t)))
(cond
[(positive? occurrences)
;; target-expr is bound
;; `(for/all ([x x]) body)`: equivalent to `body` when `x` is not `set!`
(define safe? (syntax-parse frame
#:literal-sets (kernel-literals)
[(define-values _ _)
(report 'path-split:advise:forall:frame-define frame)
#f]
[_ #:when (no-set!? target-expr frame)
#t]
[_ (report 'path-split:advise:forall:frame-has-set! frame)
#f]))
(and safe? (list frame occurrences))]
[else (report 'path-split:advise:forall:out-of-scope target-expr frame)
#f]))
;; find the value to quantify on the expanded code and all frames
(define (find-target+frames stx module-source line ch pos-sym phase)
(define (transform-find-uexpr return)
(make-syntax-transformer
(let ()
(define (trans-expr stx frames)
(define (trans-exprs stxs) (for ([e (in-syntax stxs)]) (trans-expr e (cons e frames))))
(syntax-parse stx
#:literal-sets (kernel-literals)
[(#%plain-app _ . args)
#:when (and (equal? (syntax-source stx) module-source)
(syntax-line stx) (syntax-column stx)
(= line (syntax-line stx)) (= ch (syntax-column stx)))
(return (list (list-ref (stx->list #'args) pos-sym) frames))]
[(define-values _ rhs) (trans-exprs #'(rhs))]
[_:id stx]
[(#%plain-lambda . form:lambda-body-form)
(trans-exprs #'(form.body ...))]
[(case-lambda form:lambda-body-form ...)
(trans-exprs #'({~@ form.body ...} ...))]
[(set! _ rhs) (trans-exprs #'(rhs))]
[(_:leaf-form ~! . _) stx]
[(_:let-values-form . form:let-values-body-form)
(trans-exprs #'(form.rhs ... form.body ...))]
[(_:compound-form ~! . body) (trans-exprs #'body)]
[_ (error 'transform "unrecognized expression form: ~.s"
(syntax->datum stx))])
#'#f)
(λ (stx) (trans-expr stx (list stx))))))
(let/ec return
((transform-find-uexpr return) stx phase)
#f))
(define (process-row the-row src)
(match the-row
[(profiler-row+ [function f]
[callsite (and callsite
(pregexp #px"(.*?):(\\d+):(\\d+)"
(list _
path
(app string->number line)
(app string->number ch))))]
[sigs `((,sym-loc-list . ,_) ...)]
parent
columns)
(define sym-locs (remove-duplicates (append* sym-loc-list)))
(report 'path-split:advise:row f callsite columns sym-locs)
(define current
(match (assoc path src)
[(list _ expanded-stx phase)
(in-spread
(in-generator
(define module-source (syntax-source expanded-stx))
(for* ([sym-loc sym-locs])
(match-define (cons pos-sym type-sym) sym-loc)
(match type-sym
[(or "union" "struct")
(match (find-target+frames expanded-stx
module-source
line ch
pos-sym phase)
[#f (report 'path-split:advise:value-not-found module-source line ch)]
[(list target forall-frames)
(report 'path-split:advise:target target)
(define filtered-frames
(reverse
(for/list ([forall-frame (in-list forall-frames)])
(when (not (identifier? target))
(report 'path-split:advise:forall:bad-target
target module-source line ch))
#:break (not (identifier? target))
(define item (find-forall-expr expanded-stx
target
forall-frame))
#:break (not item)
item)))
(cond
[(empty? filtered-frames)
(debug: forall-frames)]
[else
(define first-frame-item (first filtered-frames))
(define optimal-frame-item (last (takef filtered-frames (λ (item) (= (second item) (second first-frame-item))))))
(define last-frame-item (last filtered-frames))
(define candidates (remove-duplicates (list first-frame-item
optimal-frame-item
last-frame-item)
eq?))
(yield
(for/list ([frame-item (in-list candidates)])
(match-define (list forall _) frame-item)
(advice-path-split+ forall target [type type-sym])))])])]
[_ (void)]))))]
[_ (report 'path-split:advise:path-not-found path (map first src))
'()]))
(in-spread
(list current
(in-generator
(for ([row (in-list parent)])
(yield-from (process-row row src))))))]
[(profiler-row+ [function f]
callsite
[sigs `((,sym-loc-list . ,_) ...)]
parent
columns)
(define sym-locs (remove-duplicates (append* sym-loc-list)))
(report 'path-split:advise:bad-callsite f callsite columns sym-locs)
(in-generator
(for ([row (in-list parent)])
(yield-from (process-row row src))))]
[_
(report 'path-split:advise:no-parent the-row)
'()]))
(define (advise-path-split rows src)
(define-values (member? record!) (make-file-set ".symfix"))
(in-zigzag
(in-generator
(for ([row (in-list rows)])
(yield
(in-generator
(for ([adv (process-row row src)])
(match-define (advice-path-split+ forall target type) adv)
(define adv-repr (list (syntax->datum forall)
(syntax->datum target)
type))
(cond
[(member? adv-repr) (report 'path-split:advise:elide adv-repr)]
[else (record! adv-repr)
(yield (advice+
[transformer (transform-path-split forall target type)]
[explanation adv]))]))))))))
| false |
8c8e98a878e549e83300d4f31250b6ca6bbf54b0 | 6aff2404a2898b2587c286d7e1dcce8b2c2499f3 | /rosette/private/install.rkt | a1bc08400403748c25f3de7af98dd45c7d51862e | [
"BSD-2-Clause"
]
| permissive | juliandolby/rosette | ebb7d6d395548896a4c9e634759aba41ff2cfcad | 2fd19c740e2cbcddad5813ec74d2008696c1c041 | refs/heads/master | 2020-12-25T21:13:06.244958 | 2016-12-17T16:14:43 | 2016-12-17T16:14:43 | 45,522,216 | 0 | 1 | NOASSERTION | 2018-12-07T23:07:21 | 2015-11-04T07:23:40 | Racket | UTF-8 | Racket | false | false | 1,847 | rkt | install.rkt | #lang racket/base
;; Check whether z3 is installed during package setup.
;; If missing, builds & links a z3 binary.
(provide pre-installer)
(require racket/match
racket/file
racket/port
net/url
file/unzip)
(define (pre-installer collections-top-path racl-path)
(with-handlers ([exn:fail? (lambda (e) (printf "Could not install z3.\n~a" e))])
(define bin-path (build-path racl-path ".." "bin"))
(define z3-path (build-path bin-path "z3"))
(unless (file-exists? z3-path)
(define-values (z3-url z3-extracted-subdir) (get-z3-url))
(define z3-port (get-pure-port (string->url z3-url) #:redirections 10))
(make-directory* bin-path) ;; Ensure that `bin-path` exists
(parameterize ([current-directory bin-path])
(call-with-unzip z3-port
(λ (dir)
(copy-directory/files (build-path dir "z3") z3-path)))
;; Unzipping loses file permissions, so we reset the z3 binary here
(file-or-directory-permissions
z3-path
(if (equal? (system-type) 'windows) #o777 #o755))))))
;; Currently unused, but will be useful if Rosette is using a stable z3 release
(define (get-z3-url)
(match (list (system-type) (system-type 'word))
['(unix 64)
(values
"https://github.com/emina/rosette/releases/download/v2.0/z3-d89c39cb-x64-ubuntu-14.04.zip"
"z3-d89c39cb-x64-ubuntu-14.04")]
[`(macosx ,_)
(values
"https://github.com/emina/rosette/releases/download/v2.0/z3-d89c39cb-x64-osx-10.11.zip"
"z3-d89c39cb-x64-osx-10.11")]
['(windows 64)
(values
"https://github.com/emina/rosette/releases/download/v2.0/z3-d89c39cb-x64-win.zip"
"z3-d89c39cb-x64-win")]
[any
(raise-user-error 'get-z3-url "Unknown system type '~a'" any)]))
| false |
782f7fd7f397f89175fc548db6441e4e7d55157c | 25357ec72c399c3f20363b764d8f0df939a7d23f | /private/gc-transformer.rkt | de81c968eee189d9da40f6fb4f344f03f0026906 | []
| no_license | mflatt/plai-lazy | d1743dd259a60a589574383ffd05da986c669622 | 814aa836ba1b981b9916fbfa9ba7b2683b0350c4 | refs/heads/master | 2020-04-17T23:47:12.825626 | 2015-08-03T16:25:26 | 2015-08-03T16:25:26 | 40,133,156 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 871 | rkt | gc-transformer.rkt | #lang scheme
(provide/contract (find-referenced-locals ((listof identifier?) syntax? . -> . (listof identifier?))))
(define (find-referenced-locals env-ids stx)
(local ([define id-hash (make-custom-hash free-identifier=?
(λ (v) (equal-hash-code (syntax->datum v)))
(λ (v) (equal-secondary-hash-code (syntax->datum v))))]
[define (find stx)
(syntax-case stx ()
[(head . tail)
(begin
(find #'head)
(find #'tail))]
[id (identifier? stx)
(begin
(unless (dict-ref id-hash stx false)
(dict-set! id-hash stx true)))]
[_ (void)])])
(find stx)
(filter (λ (env-id) (dict-ref id-hash env-id false)) env-ids))) | false |
755506d5c84eea5e934da2fc03f9b61bb37e228c | bfdea13ca909b25a0a07c044ec456c00124b6053 | /mischief/id-table.rkt | 6f87b533b8c2b72a6e6b4a6b23a76d4eb2acf594 | []
| no_license | carl-eastlund/mischief | 7598630e44e83dd477b7539b601d9e732a96ea81 | ce58c3170240f12297e2f98475f53c9514225825 | refs/heads/master | 2018-12-19T07:25:43.768476 | 2018-09-15T16:00:33 | 2018-09-15T16:00:33 | 9,098,458 | 7 | 2 | null | 2015-07-30T20:52:08 | 2013-03-29T13:02:31 | Racket | UTF-8 | Racket | false | false | 2,493 | rkt | id-table.rkt | #lang racket/base
(provide
check-duplicate-label
label-id-representative
label-identifier=?
label-identifier-hash-code
free-identifier-hash-code
bound-identifier-hash-code
make-immutable-label-id-table
make-weak-label-id-table
make-label-id-table)
(require
racket/list
racket/dict
racket/match
mischief/define
mischief/transform)
(define (bound-identifier-hash-code id
[hash-code eq-hash-code]
#:phase [phase (syntax-local-phase-level)])
(hash-code (syntax-e id)))
(define (label-identifier-hash-code id
[hash-code eq-hash-code]
#:phase [phase (syntax-local-phase-level)])
(hash-code (syntax-e id)))
(define (free-identifier-hash-code id
[hash-code eq-hash-code]
#:phase [phase (syntax-local-phase-level)])
(hash-code (identifier-binding-symbol id phase)))
(define-if-unbound (identifier-binding-symbol id
[phase (syntax-local-phase-level)])
(match (identifier-binding id phase)
[(list _ sym _ _ _ _ _) sym]
[_ (syntax-e id)]))
(define (check-duplicate-label ids)
(define table (make-label-id-table))
(for/or {[id (in-list ids)]}
(cond
[(dict-has-key? table id) id]
[else
(dict-set! table id #true)
#false])))
(define (label-id-representative original-id)
(define unbound-id
(to-syntax #:context original-id
unique-symbol))
(define delta
(make-syntax-delta-introducer unbound-id #false))
(delta
(to-syntax
(syntax-e original-id))))
(define unique-symbol
(string->uninterned-symbol
"unique-unbound-name"))
(define (label-identifier=? one two)
(and (eq? (syntax-e one) (syntax-e two))
(bound-identifier=?
(label-id-representative one)
(label-id-representative two))))
(define (make-immutable-label-id-table [init '()])
(define table0
(make-immutable-custom-hash
label-identifier=?
label-identifier-hash-code))
(for/fold {[table table0]} {[(key value) (in-dict init)]}
(dict-set table key value)))
(define (make-weak-label-id-table [init '()])
(define table
(make-weak-custom-hash
label-identifier=?
label-identifier-hash-code))
(for {[(key value) (in-dict init)]}
(dict-set! table key value))
table)
(define (make-label-id-table [init '()])
(define table
(make-custom-hash
label-identifier=?
label-identifier-hash-code))
(for {[(key value) (in-dict init)]}
(dict-set! table key value))
table)
| false |
a5d68004f5dc2ae3e274445ba958d1be21f69e44 | 25a6efe766d07c52c1994585af7d7f347553bf54 | /gui-lib/framework/private/srcloc-snip.rkt | ee6cbd1766d8e78fb038a6f8438ee2313f94e24a | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/gui | 520ff8f4ae5704210822204aa7cd4b74dd4f3eef | d01d166149787e2d94176d3046764b35c7c0a876 | refs/heads/master | 2023-08-25T15:24:17.693905 | 2023-08-10T16:45:35 | 2023-08-10T16:45:35 | 27,413,435 | 72 | 96 | NOASSERTION | 2023-09-14T17:09:52 | 2014-12-02T03:35:22 | Racket | UTF-8 | Racket | false | false | 4,607 | rkt | srcloc-snip.rkt | #lang racket/base
(require racket/unit
racket/class
racket/gui/base
racket/snip
"sig.rkt"
(prefix-in base: racket/base))
(provide srcloc-snip@)
(define-unit srcloc-snip@
(import [prefix frame: framework:frame^]
[prefix group: framework:group^]
[prefix text: framework:text^]
[prefix editor: framework:editor^])
(export (rename framework:srcloc-snip^ [-snip% snip%]))
(define (select-srcloc srcloc)
(let frame-loop ([frames (send (group:get-the-frame-group) get-frames)])
(unless (null? frames)
(let ([frame (car frames)])
(cond
[(and (is-a? frame frame:editor<%>)
(send frame find-editor
(lambda (editor)
(send editor port-name-matches? (srcloc-source srcloc)))))
=> (lambda (editor)
(show-editor frame editor)
(send (send frame get-interactions-text)
highlight-error
editor (srcloc-position srcloc) (+ (srcloc-position srcloc) (srcloc-span srcloc))))]
[else
(frame-loop (cdr frames))])))))
(define (show-editor frame editor)
(let* ([current-tab (send editor get-tab)]
[frame (send current-tab get-frame)])
(let loop ([tabs (send frame get-tabs)] [i 0])
(unless (null? tabs)
(if (eq? (car tabs) current-tab)
(send frame change-to-nth-tab i)
(loop (cdr tabs) (+ i 1)))))
(send frame show #t)))
; honest attempt
(define (source->datum source)
(if (path? source)
(path->bytes source)
source))
(define (datum->source source)
(if (bytes? source)
(bytes->path source)
source))
(define srcloc-snip-class%
(class snip-class%
(inherit set-version set-classname)
(super-new)
(set-version 1)
(set-classname (format "~s" '((lib "srcloc-snip.rkt" "framework")
(lib "wxme-srcloc-snip.rkt" "framework"))))
; serialize as (srcloc <source> <line> <column> <position> <span>) <text>
(define/override (read f)
(with-handlers ([exn? (lambda (exn) #f)])
(let* ((bytes (send f get-unterminated-bytes))
(port (open-input-bytes bytes 'srcloc))
(datum (base:read port))
(srcloc (apply
(lambda (_ source line column position span)
(srcloc (datum->source source) line column position span))
datum))
(snip
(new -snip% [srcloc srcloc]))
(editor (send snip get-editor)))
(send editor read-from-file f #t)
(send snip activate-link)
snip)))))
(define snipclass (new srcloc-snip-class%))
(send (get-the-snip-class-list) add snipclass)
;; class for snips embedded in markup
(define markup-text%
(text:wide-snip-mixin
(text:basic-mixin
(editor:standard-style-list-mixin
(editor:basic-mixin
text%)))))
(define -snip%
(class editor-snip%
(init-field srcloc)
(inherit set-snipclass
use-style-background
get-editor)
(super-new [editor (new markup-text%)]
[with-border? #f])
(set-snipclass snipclass)
; you must call this after having put something in the editor
(define/public (activate-link)
(let ((editor (get-editor)))
(send editor set-clickback
0 (send editor get-end-position)
(lambda (t s e)
(select-srcloc srcloc))
#f #f)
(send editor lock #t)))
(use-style-background #t)
(define/override (copy)
(let ((snip (new -snip% [srcloc srcloc])))
(send (get-editor) copy-self-to (send snip get-editor))
(send snip activate-link)
snip))
(define/override (write f)
(let ((port (open-output-string))
(sexpr `(srcloc ,(source->datum (srcloc-source srcloc))
,(srcloc-line srcloc)
,(srcloc-column srcloc)
,(srcloc-position srcloc)
,(srcloc-span srcloc))))
(base:write sexpr port)
(let ((bytes (get-output-bytes port)))
(send f put (bytes-length bytes) bytes))
(send (get-editor) write-to-file f))))))
| false |
cd485631f44317e603fc4993de78d0ee6c4ed38c | 76df16d6c3760cb415f1294caee997cc4736e09b | /interface/line-count.rkt | c6cd238cdcbd3c496e817e4ddae080caaed6f2c3 | [
"MIT"
]
| permissive | uw-unsat/leanette-popl22-artifact | 70409d9cbd8921d794d27b7992bf1d9a4087e9fe | 80fea2519e61b45a283fbf7903acdf6d5528dbe7 | refs/heads/master | 2023-04-15T21:00:49.670873 | 2021-11-16T04:37:11 | 2021-11-16T04:37:11 | 414,331,908 | 6 | 1 | null | null | null | null | UTF-8 | Racket | false | false | 6,585 | rkt | line-count.rkt | #lang racket
(require racket/cmdline
csv-reading
file/glob
syntax/moddep
setup/dirs
pkg/path
racket/path)
(define (invoke-cloc args)
(define s (with-output-to-string
(λ () (apply system* (find-executable-path "cloc") "--csv" args))))
(first (filter-map
(λ (line)
(match line
[`(,_ "Racket" ,_ ,_ ,total) (string->number total)]
[_ #f]))
(csv->list s))))
(define (path-prefix? a b)
(string-prefix? (path->string (resolve-path a))
(path->string (resolve-path b))))
(define (trace entry-path)
(define the-mod
(cond
[(module-declared? `(submod ,entry-path line-count) #t)
`(submod ,entry-path line-count)]
[else entry-path]))
(define current-paths (mutable-set))
(define (check path)
(match path
[`(submod ,path ,_) (check path)]
[_
(cond
[(not (path? path)) (void)]
[(path-prefix? path (find-collects-dir)) (void)]
[else
(match (path->pkg path)
[#f (set-add! current-paths path)]
[_ (void)])])]))
(show-import-tree
the-mod
#:dag? #t
#:show (λ (indent path require-mode phase) (check path)))
(set->list current-paths))
(define touched-path (make-hash))
(define (count-line name entry-path)
(define paths (if entry-path
(for/list ([path (trace entry-path)])
(~a (find-relative-path (current-directory) path)))
(for/list ([path (glob (string-append name "/**/*.rkt"))])
(~a (find-relative-path (current-directory) path)))))
(hash-set! touched-path name paths)
(invoke-cloc paths))
(define z3 "Z3")
(define cvc4 "CVC4")
(define boolector "Boolector")
(define BENCHMARKS
`(["bagpipe" "bagpipe/setups/textbook/run.rkt" ,z3]
["bonsai" "bonsai/nanoscala.rkt" ,boolector]
["cosette" "cosette/cidr-benchmarks/oracle-12c-bug.rkt" ,z3]
["ferrite" "ferrite/rename.rkt" ,z3]
["fluidics" "fluidics/ex2.rkt" ,z3]
["greenthumb" "greenthumb/GA/output/0/driver-0.rkt" ,boolector]
["memsynth" "memsynth/case-studies/synthesis/ppc/ppc0.rkt" ,z3]
["neutrons" "neutrons/filterWedgeProp.rkt" ,z3]
["nonograms" "nonograms/puzzle/src/run-batch-learn-rules.rkt" ,z3]
["quivela" "quivela/test-inc-arg.rkt" ,z3]
["rtr" "rtr/benchmarks/all.rkt" ,cvc4]
["wallingford" "wallingford/tests/all-tests.rkt" ,z3]
["jitterbug" #f ,boolector]
["ifcl" "ifcl/test.rkt" ,boolector]
["synthcl" "synthcl/examples/sobelFilter/test.rkt" ,boolector]
["websynth" "websynth/test/all-tests.rkt" ,z3]))
(module+ main
(define current-diff? #f)
(define where #f)
(define mode #f)
(command-line
#:args (what)
(set! mode what)
(match what
["rosette-4"
(set! current-diff? #t)
(set! where "../rosette-benchmarks-4")]
["rosette-3"
(set! where "../rosette-benchmarks-3")]
[_ (error "expect either rosette-3 or rosette-4")]))
(define current-diff-file (simple-form-path "workspace/diff.csv"))
(define current-loc-file (simple-form-path (format "workspace/~a-total.csv" mode)))
(current-directory where)
(with-output-to-file current-loc-file
#:exists 'replace
void)
(for ([benchmark BENCHMARKS])
(define v (count-line (first benchmark) (second benchmark)))
(define (output)
(printf "~a,~a\n" (first benchmark) v))
(with-output-to-file current-loc-file
#:exists 'append
output)
(output))
(when current-diff?
(with-output-to-file current-diff-file
#:exists 'replace
void)
(for ([benchmark BENCHMARKS])
(define outs
(with-output-to-string
(λ () (system*
(find-executable-path "git")
"diff"
"--no-index"
"--ignore-blank-lines"
"-w"
"-b"
"--diff-filter=A"
(first benchmark)
(string-append "../rosette-benchmarks-3/" (first benchmark))))))
(define-values (+diffs -diffs)
(cond
[(non-empty-string? outs)
(define outl (string-split outs "\n"))
(define +diff (- (count (λ (s) (regexp-match #px"^\\+.*$" s)) outl)
(count (λ (s) (regexp-match #px"^\\+ *(;.*)?$" s)) outl)
(count (λ (s) (regexp-match #px"^\\+\\+\\+.*$" s)) outl)))
(define -diff (- (count (λ (s) (regexp-match #px"^-.*$" s)) outl)
(count (λ (s) (regexp-match #px"^- *(;.*)?$" s)) outl)
(count (λ (s) (regexp-match #px"^---.*$" s)) outl)))
(values +diff -diff)]
[else (values 0 0)]))
(define offset 0)
(define out
(string-split
(with-output-to-string
(λ ()
(for ([f (hash-ref touched-path (first benchmark))])
(cond
[(file-exists? (string-append "../rosette-benchmarks-3/" f))
(unless (equal? (file->string f) (file->string (string-append "../rosette-benchmarks-3/" f)))
(system*
(find-executable-path "git")
"diff"
"--no-index"
"--ignore-blank-lines"
"-w"
"-b"
f
(string-append "../rosette-benchmarks-3/" f)))]
[else (set! offset (+ offset (length (filter (λ (s) (non-empty-string? (string-trim s)))
(file->lines f)))))]))))
"\n"))
(define +diff (- (count (λ (s) (regexp-match #px"^\\+.*$" s)) out)
(count (λ (s) (regexp-match #px"^\\+ *(;.*)?$" s)) out)
(count (λ (s) (regexp-match #px"^\\+\\+\\+.*$" s)) out)))
(define -diff (- (count (λ (s) (regexp-match #px"^-.*$" s)) out)
(count (λ (s) (regexp-match #px"^- *(;.*)?$" s)) out)
(count (λ (s) (regexp-match #px"^---.*$" s)) out)))
(define (output)
(printf "~a,~a,~a,~a\n"
(first benchmark)
(+ -diff -diffs offset)
(+ +diff +diffs)
(third benchmark)))
(with-output-to-file current-diff-file
#:exists 'append
output)
(output))))
| false |
2e16c58202cffd93e05b3a685f10cce9b67e1c76 | 71060ffeffa3469ec44ba661b04118b487fc0602 | /ex_1_37.rkt | 2247c7330552c99834fdd005ae25f9d3d92f206d | []
| no_license | ackinc/sicp | 18741d3ffc46041ecd08021d57a50702be2e0f92 | 4ee2250f8b7454fb88bc27edb41a1349d7a3016c | refs/heads/master | 2021-09-13T08:55:37.171840 | 2018-04-27T10:02:08 | 2018-04-27T10:02:08 | 114,095,803 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 558 | rkt | ex_1_37.rkt | #lang racket
(require "./ch_1_cont_frac.rkt")
(define (cont-frac n d k) (cf n d k +))
(define (cont-frac-iter n d k) (cf-iter n d k +))
;TESTING
;approximating 1/phi using cont-frac
(define phi 1.6180327868852458)
(define i-phi (/ 1 phi))
(define (test-fn depth) (cont-frac (lambda (x) 1.0) (lambda (x) 1.0) depth))
(< (abs (- i-phi (test-fn 5))) 0.0001)
(< (abs (- i-phi (test-fn 6))) 0.0001)
(< (abs (- i-phi (test-fn 7))) 0.0001)
(< (abs (- i-phi (test-fn 8))) 0.0001)
(< (abs (- i-phi (test-fn 9))) 0.0001)
(< (abs (- i-phi (test-fn 10))) 0.0001) ; #t | false |
740b6ec6a15f5c706b8826272a8d6951d333f069 | b08b7e3160ae9947b6046123acad8f59152375c3 | /Programming Language Detection/Experiment-2/Dataset/Train/Racket/five-weekends.rkt | 31dcecae17af214576543ef9ab631866bad0987b | []
| no_license | dlaststark/machine-learning-projects | efb0a28c664419275e87eb612c89054164fe1eb0 | eaa0c96d4d1c15934d63035b837636a6d11736e3 | refs/heads/master | 2022-12-06T08:36:09.867677 | 2022-11-20T13:17:25 | 2022-11-20T13:17:25 | 246,379,103 | 9 | 5 | null | null | null | null | UTF-8 | Racket | false | false | 806 | rkt | five-weekends.rkt | #lang racket
(require srfi/19)
(define long-months '(1 3 5 7 8 10 12))
(define days #(sun mon tue wed thu fri sat))
(define (week-day date)
(vector-ref days (date-week-day date)))
(define (five-weekends-a-month start end)
(for*/list ([year (in-range start (+ end 1))]
[month long-months]
[date (in-value (make-date 0 0 0 0 31 month year 0))]
#:when (eq? (week-day date) 'sun))
date))
(define weekends (five-weekends-a-month 1900 2100))
(define count (length weekends))
(displayln (~a "There are " count " weeks with five weekends."))
(displayln "The first five are: ")
(for ([w (take weekends 5)])
(displayln (date->string w "~b ~Y")))
(displayln "The last five are: ")
(for ([w (drop weekends (- count 5))])
(displayln (date->string w "~b ~Y")))
| false |
f91657d98c10c4ef2a80f43151c780756339548e | 662e55de9b4213323395102bd50fb22b30eaf957 | /dissertation/scrbl/shallow/with-cache/fig:appendix:overhead:0.rktd | 1a24db77a3ccd70d10550575099d2efb5074b7d1 | []
| no_license | bennn/dissertation | 3000f2e6e34cc208ee0a5cb47715c93a645eba11 | 779bfe6f8fee19092849b7e2cfc476df33e9357b | refs/heads/master | 2023-03-01T11:28:29.151909 | 2021-02-11T19:52:37 | 2021-02-11T19:52:37 | 267,969,820 | 7 | 1 | null | null | null | null | UTF-8 | Racket | false | false | 125,979 | rktd | fig:appendix:overhead:0.rktd | ;; This file was generated by the `with-cache` library on 2020-12-18
((((sieve "7.8.0.5" . "transient") (forth "7.8.0.5" . "transient") (fsm "7.8.0.5" . "transient") (fsmoo "7.8.0.5" . "transient") (mbta "7.8.0.5" . "transient") (morsecode "7.8.0.5" . "transient") (zombie "7.8.0.5" . "transient"))) (3) 1 (((lib "pict/private/pict.rkt") . pict-deserialize-info)) 71 ((q 255 255 255 1.0) (q 12 #f default normal normal #f default #f aligned) (q (0 0 0 1.0) 1 solid round round #f) (q (255 255 255 1.0) solid #f #f #f) (q 12 "bold" roman normal normal #f default #f aligned) (q (0 0 0 1.0) 1/2 solid round round #f) (q 255 255 255 1.0) "1" (q 0 0 0 1.0) "2" "15.62x" "0" "50" "100%" (q (0 0 0 1.0) 1 transparent round round #f) (q (169 96 0 1.0) 0.1 solid round round #f) (q 0 0 0 1.0) (q 12 "Liberation Serif" default normal bold #f default #t unaligned) (q 12 #f default normal normal #f default #t unaligned) (q 255 255 255 1.0) "1" (q 0 0 0 1.0) "2" "5823.21x" "0" "50" "100%" (q (255 239 186 1.0) solid #f #f #f) (q (227 232 255 1.0) solid #f #f #f) (q (0 2 123 1.0) 0.1 solid round round #f) (q (0 2 123 1.0) solid #f #f #f) (q (169 96 0 1.0) solid #f #f #f) (q 255 255 255 1.0) "1" (q 0 0 0 1.0) "2" "2.38x" "0" "50" "100%" (q 255 255 255 1.0) "1" (q 0 0 0 1.0) "2" "420.45x" "0" "50" "100%" (q 255 255 255 1.0) "1" (q 0 0 0 1.0) "1.91x" "0" "50" "100%" (q 255 255 255 1.0) "1" (q 0 0 0 1.0) "2" "2.77x" "0" "50" "100%" (q 255 255 255 1.0) "1" (q 0 0 0 1.0) "2" "46.23x" "0" "50" "100%") () (0 (q (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-font (12 #f default normal normal #f default #f aligned)) (set-smoothing unsmoothed) (set-text-mode transparent) (set-alpha 1.0) (set-clipping-region #f) (set-background (255 255 255 1.0)) (set-text-background (255 255 255 1.0)) (set-text-foreground (0 0 0 1.0)) (set-font (12 "Liberation Serif" default normal bold #f default #t unaligned)) (draw-text "sieve-7.8.0.5, sieve-transient" 0.0 0.0 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (set-origin 0.0 12.0) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 12.0) (410.0 . 12.0) (410.0 . 96.0) (0.0 . 96.0)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-origin 0.0 12.0) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 12.0) (410.0 . 12.0) (410.0 . 96.0) (0.0 . 96.0)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-alpha 1) (clear) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 35.0 67.0 391.0 67.0) (draw-line 35.0 6.0 391.0 6.0) (draw-line 35.0 6.0 35.0 67.0) (draw-line 391.0 6.0 391.0 67.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 35.0 65.0 35.0 69.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 58.61559508789415 66.0 58.61559508789415 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 78.58229623579072 66.0 78.58229623579072 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 95.87823948679696 66.0 95.87823948679696 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 111.13434264429466 66.0 111.13434264429466 68.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 124.78139195530329 65.0 124.78139195530329 69.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 214.56278391060658 66.0 214.56278391060658 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 267.08153146700704 66.0 267.08153146700704 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 304.3441758659098 66.0 304.3441758659098 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 333.2473283344162 66.0 333.2473283344162 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 356.86292342231036 66.0 356.86292342231036 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 376.8296245702069 66.0 376.8296245702069 68.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 391.0 65.0 391.0 69.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 67.0 37.0 67.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 36.5 37.0 36.5) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 6.0 37.0 6.0) (set-text-foreground (255 255 255 1.0)) (draw-text "1" 30.5 70.0 #t 0 0) (draw-text "1" 30.5 71.0 #t 0 0) (draw-text "1" 30.5 72.0 #t 0 0) (draw-text "1" 31.5 70.0 #t 0 0) (draw-text "1" 31.5 72.0 #t 0 0) (draw-text "1" 32.5 70.0 #t 0 0) (draw-text "1" 32.5 71.0 #t 0 0) (draw-text "1" 32.5 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "1" 31.5 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "2" 120.28139195530329 70.0 #t 0 0) (draw-text "2" 120.28139195530329 71.0 #t 0 0) (draw-text "2" 120.28139195530329 72.0 #t 0 0) (draw-text "2" 121.28139195530329 70.0 #t 0 0) (draw-text "2" 121.28139195530329 72.0 #t 0 0) (draw-text "2" 122.28139195530329 70.0 #t 0 0) (draw-text "2" 122.28139195530329 71.0 #t 0 0) (draw-text "2" 122.28139195530329 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "2" 121.28139195530329 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "15.62x" 372.0 70.0 #t 0 0) (draw-text "15.62x" 372.0 71.0 #t 0 0) (draw-text "15.62x" 372.0 72.0 #t 0 0) (draw-text "15.62x" 373.0 70.0 #t 0 0) (draw-text "15.62x" 373.0 72.0 #t 0 0) (draw-text "15.62x" 374.0 70.0 #t 0 0) (draw-text "15.62x" 374.0 71.0 #t 0 0) (draw-text "15.62x" 374.0 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "15.62x" 373.0 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "0" 23.0 60.0 #t 0 0) (draw-text "0" 23.0 61.0 #t 0 0) (draw-text "0" 23.0 62.0 #t 0 0) (draw-text "0" 24.0 60.0 #t 0 0) (draw-text "0" 24.0 62.0 #t 0 0) (draw-text "0" 25.0 60.0 #t 0 0) (draw-text "0" 25.0 61.0 #t 0 0) (draw-text "0" 25.0 62.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "0" 24.0 61.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "50" 17.0 29.5 #t 0 0) (draw-text "50" 17.0 30.5 #t 0 0) (draw-text "50" 17.0 31.5 #t 0 0) (draw-text "50" 18.0 29.5 #t 0 0) (draw-text "50" 18.0 31.5 #t 0 0) (draw-text "50" 19.0 29.5 #t 0 0) (draw-text "50" 19.0 30.5 #t 0 0) (draw-text "50" 19.0 31.5 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "50" 18.0 30.5 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "100%" -1.0 -1.0 #t 0 0) (draw-text "100%" -1.0 0.0 #t 0 0) (draw-text "100%" -1.0 1.0 #t 0 0) (draw-text "100%" 0.0 -1.0 #t 0 0) (draw-text "100%" 0.0 1.0 #t 0 0) (draw-text "100%" 1.0 -1.0 #t 0 0) (draw-text "100%" 1.0 0.0 #t 0 0) (draw-text "100%" 1.0 1.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "100%" 0.0 0.0 #t 0 0) (set-clipping-region (#t (((((34.5 . 17.5) (392.0 . 17.5) (392.0 . 80.0) (34.5 . 80.0)))) . any))) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 0.6) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-brush! ((255 239 186 1.0) solid #f #f #f)) (set-smoothing unsmoothed) (draw-polygon ((35.0 . 67.0) (53.73684210526316 . 67.0) (72.47368421052632 . 67.0) (91.21052631578945 . 67.0) (109.94736842105263 . 67.0) (128.6842105263158 . 67.0) (147.4210526315789 . 67.0) (166.15789473684208 . 67.0) (184.89473684210526 . 67.0) (203.63157894736844 . 67.0) (222.36842105263162 . 67.0) (241.10526315789474 . 67.0) (259.8421052631579 . 67.0) (278.57894736842104 . 67.0) (297.31578947368416 . 67.0) (316.0526315789474 . 67.0) (334.7894736842105 . 67.0) (353.5263157894737 . 67.0) (372.2631578947369 . 67.0) (391.0 . 67.0) (391.0 . 6.0) (372.2631578947369 . 6.0) (353.5263157894737 . 6.0) (334.7894736842105 . 6.0) (316.0526315789474 . 6.0) (297.31578947368416 . 6.0) (278.57894736842104 . 6.0) (259.8421052631579 . 6.0) (241.10526315789474 . 6.0) (230.73239104109695 . 14.714285714285715) (222.36842105263162 . 21.25) (203.63157894736844 . 21.25) (184.89473684210526 . 21.25) (174.52186472530744 . 38.67857142857143) (166.15789473684208 . 51.75) (147.4210526315789 . 51.75) (128.6842105263158 . 51.75) (109.94736842105263 . 51.75) (91.21052631578945 . 51.75) (72.47368421052632 . 51.75) (53.73684210526316 . 51.75) (35.0 . 51.75)) 0 0 winding) (set-smoothing smoothed) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-pen! ((169 96 0 1.0) 0.1 solid round round #f)) (draw-lines ((391.0 . 6.0) (372.2631578947369 . 6.0) (353.5263157894737 . 6.0) (334.7894736842105 . 6.0) (316.0526315789474 . 6.0) (297.31578947368416 . 6.0) (278.57894736842104 . 6.0) (259.8421052631579 . 6.0) (241.10526315789474 . 6.0) (230.73239104109695 . 14.714285714285715) (222.36842105263162 . 21.25) (203.63157894736844 . 21.25) (184.89473684210526 . 21.25) (174.52186472530744 . 38.67857142857143) (166.15789473684208 . 51.75) (147.4210526315789 . 51.75) (128.6842105263158 . 51.75) (109.94736842105263 . 51.75) (91.21052631578945 . 51.75) (72.47368421052632 . 51.75) (53.73684210526316 . 51.75) (35.0 . 51.75)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 0.6) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-brush! ((227 232 255 1.0) solid #f #f #f)) (set-smoothing unsmoothed) (draw-polygon ((35.0 . 67.0) (53.73684210526316 . 67.0) (72.47368421052632 . 67.0) (91.21052631578945 . 67.0) (109.94736842105263 . 67.0) (128.6842105263158 . 67.0) (147.4210526315789 . 67.0) (166.15789473684208 . 67.0) (184.89473684210526 . 67.0) (203.63157894736844 . 67.0) (222.36842105263162 . 67.0) (241.10526315789474 . 67.0) (259.8421052631579 . 67.0) (278.57894736842104 . 67.0) (297.31578947368416 . 67.0) (316.0526315789474 . 67.0) (334.7894736842105 . 67.0) (353.5263157894737 . 67.0) (372.2631578947369 . 67.0) (391.0 . 67.0) (391.0 . 6.0) (380.6271278832022 . 14.714285714285715) (372.2631578947369 . 21.25) (353.5263157894737 . 21.25) (334.7894736842105 . 21.25) (316.0526315789474 . 21.25) (297.31578947368416 . 21.25) (278.57894736842104 . 21.25) (259.8421052631579 . 21.25) (241.10526315789474 . 21.25) (230.73239104109695 . 29.964285714285715) (222.36842105263162 . 36.5) (203.63157894736844 . 36.5) (184.89473684210526 . 36.5) (166.15789473684208 . 36.5) (147.4210526315789 . 36.5) (128.6842105263158 . 36.5) (109.94736842105263 . 36.5) (91.21052631578945 . 36.5) (72.47368421052632 . 36.5) (53.73684210526316 . 36.5) (35.0 . 36.5)) 0 0 winding) (set-smoothing smoothed) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-pen! ((0 2 123 1.0) 0.1 solid round round #f)) (draw-lines ((391.0 . 6.0) (380.6271278832022 . 14.714285714285715) (372.2631578947369 . 21.25) (353.5263157894737 . 21.25) (334.7894736842105 . 21.25) (316.0526315789474 . 21.25) (297.31578947368416 . 21.25) (278.57894736842104 . 21.25) (259.8421052631579 . 21.25) (241.10526315789474 . 21.25) (230.73239104109695 . 29.964285714285715) (222.36842105263162 . 36.5) (203.63157894736844 . 36.5) (184.89473684210526 . 36.5) (166.15789473684208 . 36.5) (147.4210526315789 . 36.5) (128.6842105263158 . 36.5) (109.94736842105263 . 36.5) (91.21052631578945 . 36.5) (72.47368421052632 . 36.5) (53.73684210526316 . 36.5) (35.0 . 36.5)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1) (do-set-pen! ((169 96 0 1.0) 0.1 solid round round #f)) (draw-lines ((391.0 . 6.0) (372.2631578947369 . 6.0) (353.5263157894737 . 6.0) (334.7894736842105 . 6.0) (316.0526315789474 . 6.0) (297.31578947368416 . 6.0) (278.57894736842104 . 6.0) (259.8421052631579 . 6.0) (241.10526315789474 . 6.0) (230.73239104109695 . 14.714285714285715) (222.36842105263162 . 21.25) (203.63157894736844 . 21.25) (184.89473684210526 . 21.25) (174.52186472530744 . 38.67857142857143) (166.15789473684208 . 51.75) (147.4210526315789 . 51.75) (128.6842105263158 . 51.75) (109.94736842105263 . 51.75) (91.21052631578945 . 51.75) (72.47368421052632 . 51.75) (53.73684210526316 . 51.75) (35.0 . 51.75)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1/2) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 67.0) (35.0 . 6.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 58.61559508789415 67.0 58.61559508789415 63.0) (draw-line 58.61559508789415 59.0 58.61559508789415 54.0) (draw-line 58.61559508789415 50.0 58.61559508789415 45.0) (draw-line 58.61559508789415 41.0 58.61559508789415 36.0) (draw-line 58.61559508789415 32.0 58.61559508789415 27.0) (draw-line 58.61559508789415 23.0 58.61559508789415 18.0) (draw-line 58.61559508789415 14.0 58.61559508789415 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 78.58229623579072 67.0 78.58229623579072 63.0) (draw-line 78.58229623579072 59.0 78.58229623579072 54.0) (draw-line 78.58229623579072 50.0 78.58229623579072 45.0) (draw-line 78.58229623579072 41.0 78.58229623579072 36.0) (draw-line 78.58229623579072 32.0 78.58229623579072 27.0) (draw-line 78.58229623579072 23.0 78.58229623579072 18.0) (draw-line 78.58229623579072 14.0 78.58229623579072 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 95.87823948679696 67.0 95.87823948679696 63.0) (draw-line 95.87823948679696 59.0 95.87823948679696 54.0) (draw-line 95.87823948679696 50.0 95.87823948679696 45.0) (draw-line 95.87823948679696 41.0 95.87823948679696 36.0) (draw-line 95.87823948679696 32.0 95.87823948679696 27.0) (draw-line 95.87823948679696 23.0 95.87823948679696 18.0) (draw-line 95.87823948679696 14.0 95.87823948679696 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 111.13434264429466 67.0 111.13434264429466 63.0) (draw-line 111.13434264429466 59.0 111.13434264429466 54.0) (draw-line 111.13434264429466 50.0 111.13434264429466 45.0) (draw-line 111.13434264429466 41.0 111.13434264429466 36.0) (draw-line 111.13434264429466 32.0 111.13434264429466 27.0) (draw-line 111.13434264429466 23.0 111.13434264429466 18.0) (draw-line 111.13434264429466 14.0 111.13434264429466 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((124.78139195530329 . 67.0) (124.78139195530329 . 6.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 214.56278391060658 67.0 214.56278391060658 63.0) (draw-line 214.56278391060658 59.0 214.56278391060658 54.0) (draw-line 214.56278391060658 50.0 214.56278391060658 45.0) (draw-line 214.56278391060658 41.0 214.56278391060658 36.0) (draw-line 214.56278391060658 32.0 214.56278391060658 27.0) (draw-line 214.56278391060658 23.0 214.56278391060658 18.0) (draw-line 214.56278391060658 14.0 214.56278391060658 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 267.08153146700704 67.0 267.08153146700704 63.0) (draw-line 267.08153146700704 59.0 267.08153146700704 54.0) (draw-line 267.08153146700704 50.0 267.08153146700704 45.0) (draw-line 267.08153146700704 41.0 267.08153146700704 36.0) (draw-line 267.08153146700704 32.0 267.08153146700704 27.0) (draw-line 267.08153146700704 23.0 267.08153146700704 18.0) (draw-line 267.08153146700704 14.0 267.08153146700704 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 304.3441758659098 67.0 304.3441758659098 63.0) (draw-line 304.3441758659098 59.0 304.3441758659098 54.0) (draw-line 304.3441758659098 50.0 304.3441758659098 45.0) (draw-line 304.3441758659098 41.0 304.3441758659098 36.0) (draw-line 304.3441758659098 32.0 304.3441758659098 27.0) (draw-line 304.3441758659098 23.0 304.3441758659098 18.0) (draw-line 304.3441758659098 14.0 304.3441758659098 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 333.2473283344162 67.0 333.2473283344162 63.0) (draw-line 333.2473283344162 59.0 333.2473283344162 54.0) (draw-line 333.2473283344162 50.0 333.2473283344162 45.0) (draw-line 333.2473283344162 41.0 333.2473283344162 36.0) (draw-line 333.2473283344162 32.0 333.2473283344162 27.0) (draw-line 333.2473283344162 23.0 333.2473283344162 18.0) (draw-line 333.2473283344162 14.0 333.2473283344162 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 356.86292342231036 67.0 356.86292342231036 63.0) (draw-line 356.86292342231036 59.0 356.86292342231036 54.0) (draw-line 356.86292342231036 50.0 356.86292342231036 45.0) (draw-line 356.86292342231036 41.0 356.86292342231036 36.0) (draw-line 356.86292342231036 32.0 356.86292342231036 27.0) (draw-line 356.86292342231036 23.0 356.86292342231036 18.0) (draw-line 356.86292342231036 14.0 356.86292342231036 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 376.8296245702069 67.0 376.8296245702069 63.0) (draw-line 376.8296245702069 59.0 376.8296245702069 54.0) (draw-line 376.8296245702069 50.0 376.8296245702069 45.0) (draw-line 376.8296245702069 41.0 376.8296245702069 36.0) (draw-line 376.8296245702069 32.0 376.8296245702069 27.0) (draw-line 376.8296245702069 23.0 376.8296245702069 18.0) (draw-line 376.8296245702069 14.0 376.8296245702069 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((391.0 . 67.0) (391.0 . 6.0)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1/2) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 67.0) (391.0 . 67.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 36.5) (391.0 . 36.5)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 6.0) (391.0 . 6.0)) 0.0 0.0) (set-origin 0.0 12.0) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 12.0) (410.0 . 12.0) (410.0 . 96.0) (0.0 . 96.0)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-origin 0.0 0.0) (set-smoothing unsmoothed) (set-text-mode transparent) (set-clipping-region #f) (set-font (12 #f default normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1.0) (set-font (12 "Liberation Serif" default normal bold #f default #t unaligned)) (draw-text "4 configurations" 316.66015625 0.0 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (do-set-brush! ((0 2 123 1.0) solid #f #f #f)) (draw-rectangle 200.35546875 98.06640625 10 10) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (set-font (12 #f default normal normal #f default #t unaligned)) (draw-text "sieve-7.8.0.5" 212.35546875 96.0 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (do-set-brush! ((169 96 0 1.0) solid #f #f #f)) (draw-rectangle 310.208984375 98.06640625 10 10) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (set-font (12 #f default normal normal #f default #t unaligned)) (draw-text "sieve-transient" 322.208984375 96.0 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (set-font (12 "Liberation Serif" default normal bold #f default #t unaligned)) (draw-text "forth-7.8.0.5, forth-transient" 0.0 120.1328125 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (set-origin 0.0 132.1328125) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 132.1328125) (410.0 . 132.1328125) (410.0 . 216.1328125) (0.0 . 216.1328125)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-origin 0.0 132.1328125) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 132.1328125) (410.0 . 132.1328125) (410.0 . 216.1328125) (0.0 . 216.1328125)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-alpha 1) (clear) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 35.0 67.0 384.0 67.0) (draw-line 35.0 6.0 384.0 6.0) (draw-line 35.0 6.0 35.0 67.0) (draw-line 384.0 6.0 384.0 67.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 35.0 65.0 35.0 69.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 42.33945899905798 66.0 42.33945899905798 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 48.54488316372588 66.0 48.54488316372588 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 53.92026607778453 66.0 53.92026607778453 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 58.66168983581858 66.0 58.66168983581858 68.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 62.90303791548715 65.0 62.90303791548715 69.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 90.8060758309743 66.0 90.8060758309743 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 107.12830666773488 66.0 107.12830666773488 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 118.70911374646141 66.0 118.70911374646141 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 127.69188558416404 66.0 127.69188558416404 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 135.03134458322202 66.0 135.03134458322202 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 141.23676874788993 66.0 141.23676874788993 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 146.6121516619486 66.0 146.6121516619486 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 151.3535754199826 66.0 151.3535754199826 68.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 384.0 65.0 384.0 69.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 67.0 37.0 67.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 36.5 37.0 36.5) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 6.0 37.0 6.0) (set-text-foreground (255 255 255 1.0)) (draw-text "1" 30.5 70.0 #t 0 0) (draw-text "1" 30.5 71.0 #t 0 0) (draw-text "1" 30.5 72.0 #t 0 0) (draw-text "1" 31.5 70.0 #t 0 0) (draw-text "1" 31.5 72.0 #t 0 0) (draw-text "1" 32.5 70.0 #t 0 0) (draw-text "1" 32.5 71.0 #t 0 0) (draw-text "1" 32.5 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "1" 31.5 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "2" 58.40303791548715 70.0 #t 0 0) (draw-text "2" 58.40303791548715 71.0 #t 0 0) (draw-text "2" 58.40303791548715 72.0 #t 0 0) (draw-text "2" 59.40303791548715 70.0 #t 0 0) (draw-text "2" 59.40303791548715 72.0 #t 0 0) (draw-text "2" 60.40303791548715 70.0 #t 0 0) (draw-text "2" 60.40303791548715 71.0 #t 0 0) (draw-text "2" 60.40303791548715 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "2" 59.40303791548715 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "5823.21x" 358.5 70.0 #t 0 0) (draw-text "5823.21x" 358.5 71.0 #t 0 0) (draw-text "5823.21x" 358.5 72.0 #t 0 0) (draw-text "5823.21x" 359.5 70.0 #t 0 0) (draw-text "5823.21x" 359.5 72.0 #t 0 0) (draw-text "5823.21x" 360.5 70.0 #t 0 0) (draw-text "5823.21x" 360.5 71.0 #t 0 0) (draw-text "5823.21x" 360.5 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "5823.21x" 359.5 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "0" 23.0 60.0 #t 0 0) (draw-text "0" 23.0 61.0 #t 0 0) (draw-text "0" 23.0 62.0 #t 0 0) (draw-text "0" 24.0 60.0 #t 0 0) (draw-text "0" 24.0 62.0 #t 0 0) (draw-text "0" 25.0 60.0 #t 0 0) (draw-text "0" 25.0 61.0 #t 0 0) (draw-text "0" 25.0 62.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "0" 24.0 61.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "50" 17.0 29.5 #t 0 0) (draw-text "50" 17.0 30.5 #t 0 0) (draw-text "50" 17.0 31.5 #t 0 0) (draw-text "50" 18.0 29.5 #t 0 0) (draw-text "50" 18.0 31.5 #t 0 0) (draw-text "50" 19.0 29.5 #t 0 0) (draw-text "50" 19.0 30.5 #t 0 0) (draw-text "50" 19.0 31.5 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "50" 18.0 30.5 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "100%" -1.0 -1.0 #t 0 0) (draw-text "100%" -1.0 0.0 #t 0 0) (draw-text "100%" -1.0 1.0 #t 0 0) (draw-text "100%" 0.0 -1.0 #t 0 0) (draw-text "100%" 0.0 1.0 #t 0 0) (draw-text "100%" 1.0 -1.0 #t 0 0) (draw-text "100%" 1.0 0.0 #t 0 0) (draw-text "100%" 1.0 1.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "100%" 0.0 0.0 #t 0 0) (set-clipping-region (#t (((((34.5 . 137.6328125) (385.0 . 137.6328125) (385.0 . 200.1328125) (34.5 . 200.1328125)))) . any))) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 0.6) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-brush! ((255 239 186 1.0) solid #f #f #f)) (set-smoothing unsmoothed) (draw-polygon ((35.0 . 67.0) (53.368421052631575 . 67.0) (71.73684210526315 . 67.0) (90.10526315789474 . 67.0) (108.47368421052632 . 67.0) (126.84210526315789 . 67.0) (145.21052631578948 . 67.0) (163.57894736842107 . 67.0) (181.94736842105263 . 67.0) (200.31578947368422 . 67.0) (218.68421052631578 . 67.0) (237.05263157894737 . 67.0) (255.42105263157893 . 67.0) (273.7894736842105 . 67.0) (292.15789473684214 . 67.0) (310.5263157894737 . 67.0) (328.89473684210526 . 67.0) (347.2631578947368 . 67.0) (365.63157894736844 . 67.0) (384.0 . 67.0) (384.0 . 6.0) (365.63157894736844 . 6.0) (347.2631578947368 . 6.0) (328.89473684210526 . 6.0) (310.5263157894737 . 6.0) (292.15789473684214 . 6.0) (273.7894736842105 . 6.0) (255.42105263157893 . 6.0) (237.05263157894737 . 6.0) (218.68421052631578 . 6.0) (200.31578947368422 . 6.0) (181.94736842105263 . 6.0) (163.57894736842107 . 6.0) (145.21052631578948 . 6.0) (126.84210526315789 . 6.0) (108.47368421052632 . 6.0) (103.34450651728292 . 15.959183673469383) (99.01734392212393 . 23.42857142857143) (94.16839412662742 . 30.89795918367347) (90.10526315789474 . 36.5) (71.73684210526315 . 36.5) (62.280501816860756 . 40.85714285714286) (53.368421052631575 . 44.125) (43.91208076422918 . 52.839285714285715) (35.0 . 59.375)) 0 0 winding) (set-smoothing smoothed) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-pen! ((169 96 0 1.0) 0.1 solid round round #f)) (draw-lines ((384.0 . 6.0) (365.63157894736844 . 6.0) (347.2631578947368 . 6.0) (328.89473684210526 . 6.0) (310.5263157894737 . 6.0) (292.15789473684214 . 6.0) (273.7894736842105 . 6.0) (255.42105263157893 . 6.0) (237.05263157894737 . 6.0) (218.68421052631578 . 6.0) (200.31578947368422 . 6.0) (181.94736842105263 . 6.0) (163.57894736842107 . 6.0) (145.21052631578948 . 6.0) (126.84210526315789 . 6.0) (108.47368421052632 . 6.0) (103.34450651728292 . 15.959183673469383) (99.01734392212393 . 23.42857142857143) (94.16839412662742 . 30.89795918367347) (90.10526315789474 . 36.5) (71.73684210526315 . 36.5) (62.280501816860756 . 40.85714285714286) (53.368421052631575 . 44.125) (43.91208076422918 . 52.839285714285715) (35.0 . 59.375)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 0.6) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-brush! ((227 232 255 1.0) solid #f #f #f)) (set-smoothing unsmoothed) (draw-polygon ((35.0 . 67.0) (53.368421052631575 . 67.0) (71.73684210526315 . 67.0) (90.10526315789474 . 67.0) (108.47368421052632 . 67.0) (126.84210526315789 . 67.0) (145.21052631578948 . 67.0) (163.57894736842107 . 67.0) (181.94736842105263 . 67.0) (200.31578947368422 . 67.0) (218.68421052631578 . 67.0) (237.05263157894737 . 67.0) (255.42105263157893 . 67.0) (273.7894736842105 . 67.0) (292.15789473684214 . 67.0) (310.5263157894737 . 67.0) (328.89473684210526 . 67.0) (347.2631578947368 . 67.0) (365.63157894736844 . 67.0) (384.0 . 67.0) (384.0 . 6.0) (378.8708223067566 . 15.959183673469383) (374.5436597115975 . 23.42857142857143) (369.6947099161011 . 30.89795918367347) (365.63157894736844 . 36.5) (347.2631578947368 . 36.5) (328.89473684210526 . 36.5) (310.5263157894737 . 36.5) (292.15789473684214 . 36.5) (273.7894736842105 . 36.5) (255.42105263157893 . 36.5) (237.05263157894737 . 36.5) (218.68421052631578 . 36.5) (200.31578947368422 . 36.5) (181.94736842105263 . 36.5) (163.57894736842107 . 36.5) (145.21052631578948 . 36.5) (126.84210526315789 . 36.5) (108.47368421052632 . 36.5) (90.10526315789474 . 36.5) (80.64892286949234 . 38.67857142857143) (71.73684210526315 . 40.3125) (62.280501816860756 . 42.49107142857143) (53.368421052631575 . 44.125) (43.91208076422918 . 55.01785714285714) (35.0 . 63.1875)) 0 0 winding) (set-smoothing smoothed) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-pen! ((0 2 123 1.0) 0.1 solid round round #f)) (draw-lines ((384.0 . 6.0) (378.8708223067566 . 15.959183673469383) (374.5436597115975 . 23.42857142857143) (369.6947099161011 . 30.89795918367347) (365.63157894736844 . 36.5) (347.2631578947368 . 36.5) (328.89473684210526 . 36.5) (310.5263157894737 . 36.5) (292.15789473684214 . 36.5) (273.7894736842105 . 36.5) (255.42105263157893 . 36.5) (237.05263157894737 . 36.5) (218.68421052631578 . 36.5) (200.31578947368422 . 36.5) (181.94736842105263 . 36.5) (163.57894736842107 . 36.5) (145.21052631578948 . 36.5) (126.84210526315789 . 36.5) (108.47368421052632 . 36.5) (90.10526315789474 . 36.5) (80.64892286949234 . 38.67857142857143) (71.73684210526315 . 40.3125) (62.280501816860756 . 42.49107142857143) (53.368421052631575 . 44.125) (43.91208076422918 . 55.01785714285714) (35.0 . 63.1875)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1) (do-set-pen! ((169 96 0 1.0) 0.1 solid round round #f)) (draw-lines ((384.0 . 6.0) (365.63157894736844 . 6.0) (347.2631578947368 . 6.0) (328.89473684210526 . 6.0) (310.5263157894737 . 6.0) (292.15789473684214 . 6.0) (273.7894736842105 . 6.0) (255.42105263157893 . 6.0) (237.05263157894737 . 6.0) (218.68421052631578 . 6.0) (200.31578947368422 . 6.0) (181.94736842105263 . 6.0) (163.57894736842107 . 6.0) (145.21052631578948 . 6.0) (126.84210526315789 . 6.0) (108.47368421052632 . 6.0) (103.34450651728292 . 15.959183673469383) (99.01734392212393 . 23.42857142857143) (94.16839412662742 . 30.89795918367347) (90.10526315789474 . 36.5) (71.73684210526315 . 36.5) (62.280501816860756 . 40.85714285714286) (53.368421052631575 . 44.125) (43.91208076422918 . 52.839285714285715) (35.0 . 59.375)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1/2) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 67.0) (35.0 . 6.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 42.33945899905798 67.0 42.33945899905798 63.0) (draw-line 42.33945899905798 59.0 42.33945899905798 54.0) (draw-line 42.33945899905798 50.0 42.33945899905798 45.0) (draw-line 42.33945899905798 41.0 42.33945899905798 36.0) (draw-line 42.33945899905798 32.0 42.33945899905798 27.0) (draw-line 42.33945899905798 23.0 42.33945899905798 18.0) (draw-line 42.33945899905798 14.0 42.33945899905798 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 48.54488316372588 67.0 48.54488316372588 63.0) (draw-line 48.54488316372588 59.0 48.54488316372588 54.0) (draw-line 48.54488316372588 50.0 48.54488316372588 45.0) (draw-line 48.54488316372588 41.0 48.54488316372588 36.0) (draw-line 48.54488316372588 32.0 48.54488316372588 27.0) (draw-line 48.54488316372588 23.0 48.54488316372588 18.0) (draw-line 48.54488316372588 14.0 48.54488316372588 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 53.92026607778453 67.0 53.92026607778453 63.0) (draw-line 53.92026607778453 59.0 53.92026607778453 54.0) (draw-line 53.92026607778453 50.0 53.92026607778453 45.0) (draw-line 53.92026607778453 41.0 53.92026607778453 36.0) (draw-line 53.92026607778453 32.0 53.92026607778453 27.0) (draw-line 53.92026607778453 23.0 53.92026607778453 18.0) (draw-line 53.92026607778453 14.0 53.92026607778453 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 58.66168983581858 67.0 58.66168983581858 63.0) (draw-line 58.66168983581858 59.0 58.66168983581858 54.0) (draw-line 58.66168983581858 50.0 58.66168983581858 45.0) (draw-line 58.66168983581858 41.0 58.66168983581858 36.0) (draw-line 58.66168983581858 32.0 58.66168983581858 27.0) (draw-line 58.66168983581858 23.0 58.66168983581858 18.0) (draw-line 58.66168983581858 14.0 58.66168983581858 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((62.90303791548715 . 67.0) (62.90303791548715 . 6.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 90.8060758309743 67.0 90.8060758309743 63.0) (draw-line 90.8060758309743 59.0 90.8060758309743 54.0) (draw-line 90.8060758309743 50.0 90.8060758309743 45.0) (draw-line 90.8060758309743 41.0 90.8060758309743 36.0) (draw-line 90.8060758309743 32.0 90.8060758309743 27.0) (draw-line 90.8060758309743 23.0 90.8060758309743 18.0) (draw-line 90.8060758309743 14.0 90.8060758309743 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 107.12830666773488 67.0 107.12830666773488 63.0) (draw-line 107.12830666773488 59.0 107.12830666773488 54.0) (draw-line 107.12830666773488 50.0 107.12830666773488 45.0) (draw-line 107.12830666773488 41.0 107.12830666773488 36.0) (draw-line 107.12830666773488 32.0 107.12830666773488 27.0) (draw-line 107.12830666773488 23.0 107.12830666773488 18.0) (draw-line 107.12830666773488 14.0 107.12830666773488 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 118.70911374646141 67.0 118.70911374646141 63.0) (draw-line 118.70911374646141 59.0 118.70911374646141 54.0) (draw-line 118.70911374646141 50.0 118.70911374646141 45.0) (draw-line 118.70911374646141 41.0 118.70911374646141 36.0) (draw-line 118.70911374646141 32.0 118.70911374646141 27.0) (draw-line 118.70911374646141 23.0 118.70911374646141 18.0) (draw-line 118.70911374646141 14.0 118.70911374646141 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 127.69188558416404 67.0 127.69188558416404 63.0) (draw-line 127.69188558416404 59.0 127.69188558416404 54.0) (draw-line 127.69188558416404 50.0 127.69188558416404 45.0) (draw-line 127.69188558416404 41.0 127.69188558416404 36.0) (draw-line 127.69188558416404 32.0 127.69188558416404 27.0) (draw-line 127.69188558416404 23.0 127.69188558416404 18.0) (draw-line 127.69188558416404 14.0 127.69188558416404 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 135.03134458322202 67.0 135.03134458322202 63.0) (draw-line 135.03134458322202 59.0 135.03134458322202 54.0) (draw-line 135.03134458322202 50.0 135.03134458322202 45.0) (draw-line 135.03134458322202 41.0 135.03134458322202 36.0) (draw-line 135.03134458322202 32.0 135.03134458322202 27.0) (draw-line 135.03134458322202 23.0 135.03134458322202 18.0) (draw-line 135.03134458322202 14.0 135.03134458322202 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 141.23676874788993 67.0 141.23676874788993 63.0) (draw-line 141.23676874788993 59.0 141.23676874788993 54.0) (draw-line 141.23676874788993 50.0 141.23676874788993 45.0) (draw-line 141.23676874788993 41.0 141.23676874788993 36.0) (draw-line 141.23676874788993 32.0 141.23676874788993 27.0) (draw-line 141.23676874788993 23.0 141.23676874788993 18.0) (draw-line 141.23676874788993 14.0 141.23676874788993 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 146.6121516619486 67.0 146.6121516619486 63.0) (draw-line 146.6121516619486 59.0 146.6121516619486 54.0) (draw-line 146.6121516619486 50.0 146.6121516619486 45.0) (draw-line 146.6121516619486 41.0 146.6121516619486 36.0) (draw-line 146.6121516619486 32.0 146.6121516619486 27.0) (draw-line 146.6121516619486 23.0 146.6121516619486 18.0) (draw-line 146.6121516619486 14.0 146.6121516619486 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 151.3535754199826 67.0 151.3535754199826 63.0) (draw-line 151.3535754199826 59.0 151.3535754199826 54.0) (draw-line 151.3535754199826 50.0 151.3535754199826 45.0) (draw-line 151.3535754199826 41.0 151.3535754199826 36.0) (draw-line 151.3535754199826 32.0 151.3535754199826 27.0) (draw-line 151.3535754199826 23.0 151.3535754199826 18.0) (draw-line 151.3535754199826 14.0 151.3535754199826 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((384.0 . 67.0) (384.0 . 6.0)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1/2) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 67.0) (384.0 . 67.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 36.5) (384.0 . 36.5)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 6.0) (384.0 . 6.0)) 0.0 0.0) (set-origin 0.0 132.1328125) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 132.1328125) (410.0 . 132.1328125) (410.0 . 216.1328125) (0.0 . 216.1328125)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-origin 0.0 0.0) (set-smoothing unsmoothed) (set-text-mode transparent) (set-clipping-region #f) (set-font (12 #f default normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1.0) (set-font (12 "Liberation Serif" default normal bold #f default #t unaligned)) (draw-text "16 configurations" 309.986328125 120.1328125 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (do-set-brush! ((0 2 123 1.0) solid #f #f #f)) (draw-rectangle 201.43359375 218.19921875 10 10) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (set-font (12 #f default normal normal #f default #t unaligned)) (draw-text "forth-7.8.0.5" 213.43359375 216.1328125 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (do-set-brush! ((169 96 0 1.0) solid #f #f #f)) (draw-rectangle 310.748046875 218.19921875 10 10) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (set-font (12 #f default normal normal #f default #t unaligned)) (draw-text "forth-transient" 322.748046875 216.1328125 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (set-font (12 "Liberation Serif" default normal bold #f default #t unaligned)) (draw-text "fsm-7.8.0.5, fsm-transient" 0.0 240.265625 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (set-origin 0.0 252.265625) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 252.265625) (410.0 . 252.265625) (410.0 . 336.265625) (0.0 . 336.265625)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-origin 0.0 252.265625) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 252.265625) (410.0 . 252.265625) (410.0 . 336.265625) (0.0 . 336.265625)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-alpha 1) (clear) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 35.0 67.0 394.0 67.0) (draw-line 35.0 6.0 394.0 6.0) (draw-line 35.0 6.0 35.0 67.0) (draw-line 394.0 6.0 394.0 67.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 35.0 65.0 35.0 69.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 110.60327812344387 66.0 110.60327812344387 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 174.52493897822103 66.0 174.52493897822103 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 229.89640021586064 66.0 229.89640021586064 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 278.7374904277907 66.0 278.7374904277907 68.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 322.42733439676357 65.0 322.42733439676357 69.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 394.0 65.0 394.0 69.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 67.0 37.0 67.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 36.5 37.0 36.5) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 6.0 37.0 6.0) (set-text-foreground (255 255 255 1.0)) (draw-text "1" 30.5 70.0 #t 0 0) (draw-text "1" 30.5 71.0 #t 0 0) (draw-text "1" 30.5 72.0 #t 0 0) (draw-text "1" 31.5 70.0 #t 0 0) (draw-text "1" 31.5 72.0 #t 0 0) (draw-text "1" 32.5 70.0 #t 0 0) (draw-text "1" 32.5 71.0 #t 0 0) (draw-text "1" 32.5 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "1" 31.5 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "2" 317.92733439676357 70.0 #t 0 0) (draw-text "2" 317.92733439676357 71.0 #t 0 0) (draw-text "2" 317.92733439676357 72.0 #t 0 0) (draw-text "2" 318.92733439676357 70.0 #t 0 0) (draw-text "2" 318.92733439676357 72.0 #t 0 0) (draw-text "2" 319.92733439676357 70.0 #t 0 0) (draw-text "2" 319.92733439676357 71.0 #t 0 0) (draw-text "2" 319.92733439676357 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "2" 318.92733439676357 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "2.38x" 378.5 70.0 #t 0 0) (draw-text "2.38x" 378.5 71.0 #t 0 0) (draw-text "2.38x" 378.5 72.0 #t 0 0) (draw-text "2.38x" 379.5 70.0 #t 0 0) (draw-text "2.38x" 379.5 72.0 #t 0 0) (draw-text "2.38x" 380.5 70.0 #t 0 0) (draw-text "2.38x" 380.5 71.0 #t 0 0) (draw-text "2.38x" 380.5 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "2.38x" 379.5 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "0" 23.0 60.0 #t 0 0) (draw-text "0" 23.0 61.0 #t 0 0) (draw-text "0" 23.0 62.0 #t 0 0) (draw-text "0" 24.0 60.0 #t 0 0) (draw-text "0" 24.0 62.0 #t 0 0) (draw-text "0" 25.0 60.0 #t 0 0) (draw-text "0" 25.0 61.0 #t 0 0) (draw-text "0" 25.0 62.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "0" 24.0 61.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "50" 17.0 29.5 #t 0 0) (draw-text "50" 17.0 30.5 #t 0 0) (draw-text "50" 17.0 31.5 #t 0 0) (draw-text "50" 18.0 29.5 #t 0 0) (draw-text "50" 18.0 31.5 #t 0 0) (draw-text "50" 19.0 29.5 #t 0 0) (draw-text "50" 19.0 30.5 #t 0 0) (draw-text "50" 19.0 31.5 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "50" 18.0 30.5 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "100%" -1.0 -1.0 #t 0 0) (draw-text "100%" -1.0 0.0 #t 0 0) (draw-text "100%" -1.0 1.0 #t 0 0) (draw-text "100%" 0.0 -1.0 #t 0 0) (draw-text "100%" 0.0 1.0 #t 0 0) (draw-text "100%" 1.0 -1.0 #t 0 0) (draw-text "100%" 1.0 0.0 #t 0 0) (draw-text "100%" 1.0 1.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "100%" 0.0 0.0 #t 0 0) (set-clipping-region (#t (((((34.5 . 257.765625) (395.0 . 257.765625) (395.0 . 320.265625) (34.5 . 320.265625)))) . any))) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 0.6) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-brush! ((255 239 186 1.0) solid #f #f #f)) (set-smoothing unsmoothed) (draw-polygon ((35.0 . 67.0) (53.89473684210529 . 67.0) (72.78947368421052 . 67.0) (91.68421052631581 . 67.0) (110.57894736842104 . 67.0) (129.4736842105264 . 67.0) (148.36842105263162 . 67.0) (167.2631578947369 . 67.0) (186.15789473684217 . 67.0) (205.05263157894737 . 67.0) (223.94736842105266 . 67.0) (242.84210526315795 . 67.0) (261.7368421052632 . 67.0) (280.6315789473685 . 67.0) (299.5263157894738 . 67.0) (318.42105263157896 . 67.0) (337.3157894736842 . 67.0) (356.2105263157894 . 67.0) (375.10526315789474 . 67.0) (394.0 . 67.0) (394.0 . 6.0) (375.10526315789474 . 17.4375) (356.2105263157894 . 21.25) (337.3157894736842 . 21.25) (318.42105263157896 . 21.25) (299.5263157894738 . 21.25) (280.6315789473685 . 25.0625) (261.7368421052632 . 32.6875) (242.84210526315795 . 36.5) (223.94736842105266 . 40.3125) (205.05263157894737 . 40.3125) (186.15789473684217 . 51.75) (167.2631578947369 . 51.75) (148.36842105263162 . 51.75) (129.4736842105264 . 51.75) (110.57894736842104 . 51.75) (91.68421052631581 . 51.75) (72.78947368421052 . 51.75) (53.89473684210529 . 55.5625) (35.0 . 55.5625)) 0 0 winding) (set-smoothing smoothed) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-pen! ((169 96 0 1.0) 0.1 solid round round #f)) (draw-lines ((394.0 . 6.0) (375.10526315789474 . 17.4375) (356.2105263157894 . 21.25) (337.3157894736842 . 21.25) (318.42105263157896 . 21.25) (299.5263157894738 . 21.25) (280.6315789473685 . 25.0625) (261.7368421052632 . 32.6875) (242.84210526315795 . 36.5) (223.94736842105266 . 40.3125) (205.05263157894737 . 40.3125) (186.15789473684217 . 51.75) (167.2631578947369 . 51.75) (148.36842105263162 . 51.75) (129.4736842105264 . 51.75) (110.57894736842104 . 51.75) (91.68421052631581 . 51.75) (72.78947368421052 . 51.75) (53.89473684210529 . 55.5625) (35.0 . 55.5625)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 0.6) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-brush! ((227 232 255 1.0) solid #f #f #f)) (set-smoothing unsmoothed) (draw-polygon ((35.0 . 67.0) (53.89473684210529 . 67.0) (72.78947368421052 . 67.0) (91.68421052631581 . 67.0) (110.57894736842104 . 67.0) (129.4736842105264 . 67.0) (148.36842105263162 . 67.0) (167.2631578947369 . 67.0) (186.15789473684217 . 67.0) (205.05263157894737 . 67.0) (223.94736842105266 . 67.0) (242.84210526315795 . 67.0) (261.7368421052632 . 67.0) (280.6315789473685 . 67.0) (299.5263157894738 . 67.0) (318.42105263157896 . 67.0) (337.3157894736842 . 67.0) (356.2105263157894 . 67.0) (375.10526315789474 . 67.0) (394.0 . 67.0) (394.0 . 6.0) (375.10526315789474 . 6.0) (356.2105263157894 . 9.8125) (337.3157894736842 . 17.4375) (318.42105263157896 . 21.25) (299.5263157894738 . 25.0625) (280.6315789473685 . 25.0625) (261.7368421052632 . 32.6875) (242.84210526315795 . 32.6875) (223.94736842105266 . 36.5) (205.05263157894737 . 36.5) (186.15789473684217 . 36.5) (167.2631578947369 . 36.5) (148.36842105263162 . 36.5) (129.4736842105264 . 36.5) (110.57894736842104 . 36.5) (91.68421052631581 . 36.5) (72.78947368421052 . 36.5) (53.89473684210529 . 36.5) (35.0 . 40.3125)) 0 0 winding) (set-smoothing smoothed) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-pen! ((0 2 123 1.0) 0.1 solid round round #f)) (draw-lines ((394.0 . 6.0) (375.10526315789474 . 6.0) (356.2105263157894 . 9.8125) (337.3157894736842 . 17.4375) (318.42105263157896 . 21.25) (299.5263157894738 . 25.0625) (280.6315789473685 . 25.0625) (261.7368421052632 . 32.6875) (242.84210526315795 . 32.6875) (223.94736842105266 . 36.5) (205.05263157894737 . 36.5) (186.15789473684217 . 36.5) (167.2631578947369 . 36.5) (148.36842105263162 . 36.5) (129.4736842105264 . 36.5) (110.57894736842104 . 36.5) (91.68421052631581 . 36.5) (72.78947368421052 . 36.5) (53.89473684210529 . 36.5) (35.0 . 40.3125)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1) (do-set-pen! ((169 96 0 1.0) 0.1 solid round round #f)) (draw-lines ((394.0 . 6.0) (375.10526315789474 . 17.4375) (356.2105263157894 . 21.25) (337.3157894736842 . 21.25) (318.42105263157896 . 21.25) (299.5263157894738 . 21.25) (280.6315789473685 . 25.0625) (261.7368421052632 . 32.6875) (242.84210526315795 . 36.5) (223.94736842105266 . 40.3125) (205.05263157894737 . 40.3125) (186.15789473684217 . 51.75) (167.2631578947369 . 51.75) (148.36842105263162 . 51.75) (129.4736842105264 . 51.75) (110.57894736842104 . 51.75) (91.68421052631581 . 51.75) (72.78947368421052 . 51.75) (53.89473684210529 . 55.5625) (35.0 . 55.5625)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1/2) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 67.0) (35.0 . 6.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 110.60327812344387 67.0 110.60327812344387 63.0) (draw-line 110.60327812344387 59.0 110.60327812344387 54.0) (draw-line 110.60327812344387 50.0 110.60327812344387 45.0) (draw-line 110.60327812344387 41.0 110.60327812344387 36.0) (draw-line 110.60327812344387 32.0 110.60327812344387 27.0) (draw-line 110.60327812344387 23.0 110.60327812344387 18.0) (draw-line 110.60327812344387 14.0 110.60327812344387 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 174.52493897822103 67.0 174.52493897822103 63.0) (draw-line 174.52493897822103 59.0 174.52493897822103 54.0) (draw-line 174.52493897822103 50.0 174.52493897822103 45.0) (draw-line 174.52493897822103 41.0 174.52493897822103 36.0) (draw-line 174.52493897822103 32.0 174.52493897822103 27.0) (draw-line 174.52493897822103 23.0 174.52493897822103 18.0) (draw-line 174.52493897822103 14.0 174.52493897822103 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 229.89640021586064 67.0 229.89640021586064 63.0) (draw-line 229.89640021586064 59.0 229.89640021586064 54.0) (draw-line 229.89640021586064 50.0 229.89640021586064 45.0) (draw-line 229.89640021586064 41.0 229.89640021586064 36.0) (draw-line 229.89640021586064 32.0 229.89640021586064 27.0) (draw-line 229.89640021586064 23.0 229.89640021586064 18.0) (draw-line 229.89640021586064 14.0 229.89640021586064 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 278.7374904277907 67.0 278.7374904277907 63.0) (draw-line 278.7374904277907 59.0 278.7374904277907 54.0) (draw-line 278.7374904277907 50.0 278.7374904277907 45.0) (draw-line 278.7374904277907 41.0 278.7374904277907 36.0) (draw-line 278.7374904277907 32.0 278.7374904277907 27.0) (draw-line 278.7374904277907 23.0 278.7374904277907 18.0) (draw-line 278.7374904277907 14.0 278.7374904277907 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((322.42733439676357 . 67.0) (322.42733439676357 . 6.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((394.0 . 67.0) (394.0 . 6.0)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1/2) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 67.0) (394.0 . 67.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 36.5) (394.0 . 36.5)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 6.0) (394.0 . 6.0)) 0.0 0.0) (set-origin 0.0 252.265625) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 252.265625) (410.0 . 252.265625) (410.0 . 336.265625) (0.0 . 336.265625)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-origin 0.0 0.0) (set-smoothing unsmoothed) (set-text-mode transparent) (set-clipping-region #f) (set-font (12 #f default normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1.0) (set-font (12 "Liberation Serif" default normal bold #f default #t unaligned)) (draw-text "16 configurations" 309.986328125 240.265625 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (do-set-brush! ((0 2 123 1.0) solid #f #f #f)) (draw-rectangle 215.2265625 338.33203125 10 10) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (set-font (12 #f default normal normal #f default #t unaligned)) (draw-text "fsm-7.8.0.5" 227.2265625 336.265625 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (do-set-brush! ((169 96 0 1.0) solid #f #f #f)) (draw-rectangle 317.64453125 338.33203125 10 10) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (set-font (12 #f default normal normal #f default #t unaligned)) (draw-text "fsm-transient" 329.64453125 336.265625 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (set-font (12 "Liberation Serif" default normal bold #f default #t unaligned)) (draw-text "fsmoo-7.8.0.5, fsmoo-transient" 0.0 360.3984375 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (set-origin 0.0 372.3984375) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 372.3984375) (410.0 . 372.3984375) (410.0 . 456.3984375) (0.0 . 456.3984375)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-origin 0.0 372.3984375) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 372.3984375) (410.0 . 372.3984375) (410.0 . 456.3984375) (0.0 . 456.3984375)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-alpha 1) (clear) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 35.0 67.0 388.0 67.0) (draw-line 35.0 6.0 388.0 6.0) (draw-line 35.0 6.0 35.0 67.0) (draw-line 388.0 6.0 388.0 67.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 35.0 65.0 35.0 69.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 45.65319736609507 66.0 45.65319736609507 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 54.66034739922799 66.0 54.66034739922799 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 62.46269565257365 66.0 62.46269565257365 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 69.34485455517287 66.0 69.34485455517287 68.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 75.50115547555637 65.0 75.50115547555637 69.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 116.00231095111273 66.0 116.00231095111273 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 139.69396814019052 66.0 139.69396814019052 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 156.5034664266691 66.0 156.5034664266691 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 169.54192624965185 66.0 169.54192624965185 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 180.19512361574692 66.0 180.19512361574692 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 189.2022736488798 66.0 189.2022736488798 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 197.00462190222547 66.0 197.00462190222547 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 203.8867808048247 66.0 203.8867808048247 68.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 388.0 65.0 388.0 69.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 67.0 37.0 67.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 36.5 37.0 36.5) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 6.0 37.0 6.0) (set-text-foreground (255 255 255 1.0)) (draw-text "1" 30.5 70.0 #t 0 0) (draw-text "1" 30.5 71.0 #t 0 0) (draw-text "1" 30.5 72.0 #t 0 0) (draw-text "1" 31.5 70.0 #t 0 0) (draw-text "1" 31.5 72.0 #t 0 0) (draw-text "1" 32.5 70.0 #t 0 0) (draw-text "1" 32.5 71.0 #t 0 0) (draw-text "1" 32.5 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "1" 31.5 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "2" 71.00115547555637 70.0 #t 0 0) (draw-text "2" 71.00115547555637 71.0 #t 0 0) (draw-text "2" 71.00115547555637 72.0 #t 0 0) (draw-text "2" 72.00115547555637 70.0 #t 0 0) (draw-text "2" 72.00115547555637 72.0 #t 0 0) (draw-text "2" 73.00115547555637 70.0 #t 0 0) (draw-text "2" 73.00115547555637 71.0 #t 0 0) (draw-text "2" 73.00115547555637 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "2" 72.00115547555637 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "420.45x" 365.5 70.0 #t 0 0) (draw-text "420.45x" 365.5 71.0 #t 0 0) (draw-text "420.45x" 365.5 72.0 #t 0 0) (draw-text "420.45x" 366.5 70.0 #t 0 0) (draw-text "420.45x" 366.5 72.0 #t 0 0) (draw-text "420.45x" 367.5 70.0 #t 0 0) (draw-text "420.45x" 367.5 71.0 #t 0 0) (draw-text "420.45x" 367.5 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "420.45x" 366.5 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "0" 23.0 60.0 #t 0 0) (draw-text "0" 23.0 61.0 #t 0 0) (draw-text "0" 23.0 62.0 #t 0 0) (draw-text "0" 24.0 60.0 #t 0 0) (draw-text "0" 24.0 62.0 #t 0 0) (draw-text "0" 25.0 60.0 #t 0 0) (draw-text "0" 25.0 61.0 #t 0 0) (draw-text "0" 25.0 62.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "0" 24.0 61.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "50" 17.0 29.5 #t 0 0) (draw-text "50" 17.0 30.5 #t 0 0) (draw-text "50" 17.0 31.5 #t 0 0) (draw-text "50" 18.0 29.5 #t 0 0) (draw-text "50" 18.0 31.5 #t 0 0) (draw-text "50" 19.0 29.5 #t 0 0) (draw-text "50" 19.0 30.5 #t 0 0) (draw-text "50" 19.0 31.5 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "50" 18.0 30.5 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "100%" -1.0 -1.0 #t 0 0) (draw-text "100%" -1.0 0.0 #t 0 0) (draw-text "100%" -1.0 1.0 #t 0 0) (draw-text "100%" 0.0 -1.0 #t 0 0) (draw-text "100%" 0.0 1.0 #t 0 0) (draw-text "100%" 1.0 -1.0 #t 0 0) (draw-text "100%" 1.0 0.0 #t 0 0) (draw-text "100%" 1.0 1.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "100%" 0.0 0.0 #t 0 0) (set-clipping-region (#t (((((34.5 . 377.8984375) (389.0 . 377.8984375) (389.0 . 440.3984375) (34.5 . 440.3984375)))) . any))) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 0.6) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-brush! ((255 239 186 1.0) solid #f #f #f)) (set-smoothing unsmoothed) (draw-polygon ((35.0 . 67.0) (53.578947368421055 . 67.0) (72.15789473684211 . 67.0) (90.73684210526315 . 67.0) (109.3157894736842 . 67.0) (127.89473684210526 . 67.0) (146.4736842105263 . 67.0) (165.05263157894737 . 67.0) (183.6315789473684 . 67.0) (202.21052631578945 . 67.0) (220.78947368421052 . 67.0) (239.3684210526316 . 67.0) (257.9473684210526 . 67.0) (276.52631578947364 . 67.0) (295.10526315789474 . 67.0) (313.6842105263158 . 67.0) (332.2631578947368 . 67.0) (350.8421052631579 . 67.0) (369.4210526315789 . 67.0) (388.0 . 67.0) (388.0 . 67.0) (388.0 . 6.0) (388.0 . 6.0) (369.4210526315789 . 6.0) (350.8421052631579 . 6.0) (332.2631578947368 . 6.0) (313.6842105263158 . 6.0) (295.10526315789474 . 6.0) (276.52631578947364 . 6.0) (257.9473684210526 . 6.0) (239.3684210526316 . 6.0) (220.78947368421052 . 6.0) (202.21052631578945 . 6.0) (183.6315789473684 . 6.0) (165.05263157894737 . 6.0) (146.4736842105263 . 6.0) (127.89473684210526 . 6.0) (122.4522580748741 . 15.959183673469383) (118.00955999753886 . 23.42857142857143) (109.3157894736842 . 36.5) (90.73684210526315 . 36.5) (72.15789473684211 . 36.5) (62.272717892275715 . 45.214285714285715) (53.578947368421055 . 51.75) (43.69377052385465 . 58.285714285714285) (35.0 . 63.1875)) 0 0 winding) (set-smoothing smoothed) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-pen! ((169 96 0 1.0) 0.1 solid round round #f)) (draw-lines ((388.0 . 6.0) (388.0 . 6.0) (369.4210526315789 . 6.0) (350.8421052631579 . 6.0) (332.2631578947368 . 6.0) (313.6842105263158 . 6.0) (295.10526315789474 . 6.0) (276.52631578947364 . 6.0) (257.9473684210526 . 6.0) (239.3684210526316 . 6.0) (220.78947368421052 . 6.0) (202.21052631578945 . 6.0) (183.6315789473684 . 6.0) (165.05263157894737 . 6.0) (146.4736842105263 . 6.0) (127.89473684210526 . 6.0) (122.4522580748741 . 15.959183673469383) (118.00955999753886 . 23.42857142857143) (109.3157894736842 . 36.5) (90.73684210526315 . 36.5) (72.15789473684211 . 36.5) (62.272717892275715 . 45.214285714285715) (53.578947368421055 . 51.75) (43.69377052385465 . 58.285714285714285) (35.0 . 63.1875)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 0.6) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-brush! ((227 232 255 1.0) solid #f #f #f)) (set-smoothing unsmoothed) (draw-polygon ((35.0 . 67.0) (53.578947368421055 . 67.0) (72.15789473684211 . 67.0) (90.73684210526315 . 67.0) (109.3157894736842 . 67.0) (127.89473684210526 . 67.0) (146.4736842105263 . 67.0) (165.05263157894737 . 67.0) (183.6315789473684 . 67.0) (202.21052631578945 . 67.0) (220.78947368421052 . 67.0) (239.3684210526316 . 67.0) (257.9473684210526 . 67.0) (276.52631578947364 . 67.0) (295.10526315789474 . 67.0) (313.6842105263158 . 67.0) (332.2631578947368 . 67.0) (350.8421052631579 . 67.0) (369.4210526315789 . 67.0) (388.0 . 67.0) (388.0 . 67.0) (388.0 . 6.0) (388.0 . 9.8125) (378.1148231554336 . 16.348214285714285) (369.4210526315789 . 21.25) (359.53587578701257 . 29.964285714285715) (350.8421052631579 . 36.5) (332.2631578947368 . 36.5) (313.6842105263158 . 36.5) (295.10526315789474 . 36.5) (276.52631578947364 . 36.5) (257.9473684210526 . 36.5) (239.3684210526316 . 36.5) (220.78947368421052 . 36.5) (202.21052631578945 . 36.5) (183.6315789473684 . 36.5) (165.05263157894737 . 36.5) (146.4736842105263 . 36.5) (127.89473684210526 . 36.5) (109.3157894736842 . 36.5) (90.73684210526315 . 36.5) (72.15789473684211 . 36.5) (53.578947368421055 . 36.5) (43.69377052385465 . 43.035714285714285) (35.0 . 47.9375)) 0 0 winding) (set-smoothing smoothed) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-pen! ((0 2 123 1.0) 0.1 solid round round #f)) (draw-lines ((388.0 . 6.0) (388.0 . 9.8125) (378.1148231554336 . 16.348214285714285) (369.4210526315789 . 21.25) (359.53587578701257 . 29.964285714285715) (350.8421052631579 . 36.5) (332.2631578947368 . 36.5) (313.6842105263158 . 36.5) (295.10526315789474 . 36.5) (276.52631578947364 . 36.5) (257.9473684210526 . 36.5) (239.3684210526316 . 36.5) (220.78947368421052 . 36.5) (202.21052631578945 . 36.5) (183.6315789473684 . 36.5) (165.05263157894737 . 36.5) (146.4736842105263 . 36.5) (127.89473684210526 . 36.5) (109.3157894736842 . 36.5) (90.73684210526315 . 36.5) (72.15789473684211 . 36.5) (53.578947368421055 . 36.5) (43.69377052385465 . 43.035714285714285) (35.0 . 47.9375)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1) (do-set-pen! ((169 96 0 1.0) 0.1 solid round round #f)) (draw-lines ((388.0 . 6.0) (388.0 . 6.0) (369.4210526315789 . 6.0) (350.8421052631579 . 6.0) (332.2631578947368 . 6.0) (313.6842105263158 . 6.0) (295.10526315789474 . 6.0) (276.52631578947364 . 6.0) (257.9473684210526 . 6.0) (239.3684210526316 . 6.0) (220.78947368421052 . 6.0) (202.21052631578945 . 6.0) (183.6315789473684 . 6.0) (165.05263157894737 . 6.0) (146.4736842105263 . 6.0) (127.89473684210526 . 6.0) (122.4522580748741 . 15.959183673469383) (118.00955999753886 . 23.42857142857143) (109.3157894736842 . 36.5) (90.73684210526315 . 36.5) (72.15789473684211 . 36.5) (62.272717892275715 . 45.214285714285715) (53.578947368421055 . 51.75) (43.69377052385465 . 58.285714285714285) (35.0 . 63.1875)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1/2) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 67.0) (35.0 . 6.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 45.65319736609507 67.0 45.65319736609507 63.0) (draw-line 45.65319736609507 59.0 45.65319736609507 54.0) (draw-line 45.65319736609507 50.0 45.65319736609507 45.0) (draw-line 45.65319736609507 41.0 45.65319736609507 36.0) (draw-line 45.65319736609507 32.0 45.65319736609507 27.0) (draw-line 45.65319736609507 23.0 45.65319736609507 18.0) (draw-line 45.65319736609507 14.0 45.65319736609507 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 54.66034739922799 67.0 54.66034739922799 63.0) (draw-line 54.66034739922799 59.0 54.66034739922799 54.0) (draw-line 54.66034739922799 50.0 54.66034739922799 45.0) (draw-line 54.66034739922799 41.0 54.66034739922799 36.0) (draw-line 54.66034739922799 32.0 54.66034739922799 27.0) (draw-line 54.66034739922799 23.0 54.66034739922799 18.0) (draw-line 54.66034739922799 14.0 54.66034739922799 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 62.46269565257365 67.0 62.46269565257365 63.0) (draw-line 62.46269565257365 59.0 62.46269565257365 54.0) (draw-line 62.46269565257365 50.0 62.46269565257365 45.0) (draw-line 62.46269565257365 41.0 62.46269565257365 36.0) (draw-line 62.46269565257365 32.0 62.46269565257365 27.0) (draw-line 62.46269565257365 23.0 62.46269565257365 18.0) (draw-line 62.46269565257365 14.0 62.46269565257365 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 69.34485455517287 67.0 69.34485455517287 63.0) (draw-line 69.34485455517287 59.0 69.34485455517287 54.0) (draw-line 69.34485455517287 50.0 69.34485455517287 45.0) (draw-line 69.34485455517287 41.0 69.34485455517287 36.0) (draw-line 69.34485455517287 32.0 69.34485455517287 27.0) (draw-line 69.34485455517287 23.0 69.34485455517287 18.0) (draw-line 69.34485455517287 14.0 69.34485455517287 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((75.50115547555637 . 67.0) (75.50115547555637 . 6.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 116.00231095111273 67.0 116.00231095111273 63.0) (draw-line 116.00231095111273 59.0 116.00231095111273 54.0) (draw-line 116.00231095111273 50.0 116.00231095111273 45.0) (draw-line 116.00231095111273 41.0 116.00231095111273 36.0) (draw-line 116.00231095111273 32.0 116.00231095111273 27.0) (draw-line 116.00231095111273 23.0 116.00231095111273 18.0) (draw-line 116.00231095111273 14.0 116.00231095111273 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 139.69396814019052 67.0 139.69396814019052 63.0) (draw-line 139.69396814019052 59.0 139.69396814019052 54.0) (draw-line 139.69396814019052 50.0 139.69396814019052 45.0) (draw-line 139.69396814019052 41.0 139.69396814019052 36.0) (draw-line 139.69396814019052 32.0 139.69396814019052 27.0) (draw-line 139.69396814019052 23.0 139.69396814019052 18.0) (draw-line 139.69396814019052 14.0 139.69396814019052 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 156.5034664266691 67.0 156.5034664266691 63.0) (draw-line 156.5034664266691 59.0 156.5034664266691 54.0) (draw-line 156.5034664266691 50.0 156.5034664266691 45.0) (draw-line 156.5034664266691 41.0 156.5034664266691 36.0) (draw-line 156.5034664266691 32.0 156.5034664266691 27.0) (draw-line 156.5034664266691 23.0 156.5034664266691 18.0) (draw-line 156.5034664266691 14.0 156.5034664266691 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 169.54192624965185 67.0 169.54192624965185 63.0) (draw-line 169.54192624965185 59.0 169.54192624965185 54.0) (draw-line 169.54192624965185 50.0 169.54192624965185 45.0) (draw-line 169.54192624965185 41.0 169.54192624965185 36.0) (draw-line 169.54192624965185 32.0 169.54192624965185 27.0) (draw-line 169.54192624965185 23.0 169.54192624965185 18.0) (draw-line 169.54192624965185 14.0 169.54192624965185 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 180.19512361574692 67.0 180.19512361574692 63.0) (draw-line 180.19512361574692 59.0 180.19512361574692 54.0) (draw-line 180.19512361574692 50.0 180.19512361574692 45.0) (draw-line 180.19512361574692 41.0 180.19512361574692 36.0) (draw-line 180.19512361574692 32.0 180.19512361574692 27.0) (draw-line 180.19512361574692 23.0 180.19512361574692 18.0) (draw-line 180.19512361574692 14.0 180.19512361574692 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 189.2022736488798 67.0 189.2022736488798 63.0) (draw-line 189.2022736488798 59.0 189.2022736488798 54.0) (draw-line 189.2022736488798 50.0 189.2022736488798 45.0) (draw-line 189.2022736488798 41.0 189.2022736488798 36.0) (draw-line 189.2022736488798 32.0 189.2022736488798 27.0) (draw-line 189.2022736488798 23.0 189.2022736488798 18.0) (draw-line 189.2022736488798 14.0 189.2022736488798 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 197.00462190222547 67.0 197.00462190222547 63.0) (draw-line 197.00462190222547 59.0 197.00462190222547 54.0) (draw-line 197.00462190222547 50.0 197.00462190222547 45.0) (draw-line 197.00462190222547 41.0 197.00462190222547 36.0) (draw-line 197.00462190222547 32.0 197.00462190222547 27.0) (draw-line 197.00462190222547 23.0 197.00462190222547 18.0) (draw-line 197.00462190222547 14.0 197.00462190222547 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 203.8867808048247 67.0 203.8867808048247 63.0) (draw-line 203.8867808048247 59.0 203.8867808048247 54.0) (draw-line 203.8867808048247 50.0 203.8867808048247 45.0) (draw-line 203.8867808048247 41.0 203.8867808048247 36.0) (draw-line 203.8867808048247 32.0 203.8867808048247 27.0) (draw-line 203.8867808048247 23.0 203.8867808048247 18.0) (draw-line 203.8867808048247 14.0 203.8867808048247 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((388.0 . 67.0) (388.0 . 6.0)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1/2) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 67.0) (388.0 . 67.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 36.5) (388.0 . 36.5)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 6.0) (388.0 . 6.0)) 0.0 0.0) (set-origin 0.0 372.3984375) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 372.3984375) (410.0 . 372.3984375) (410.0 . 456.3984375) (0.0 . 456.3984375)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-origin 0.0 0.0) (set-smoothing unsmoothed) (set-text-mode transparent) (set-clipping-region #f) (set-font (12 #f default normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1.0) (set-font (12 "Liberation Serif" default normal bold #f default #t unaligned)) (draw-text "16 configurations" 309.986328125 360.3984375 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (do-set-brush! ((0 2 123 1.0) solid #f #f #f)) (draw-rectangle 185.7421875 458.46484375 10 10) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (set-font (12 #f default normal normal #f default #t unaligned)) (draw-text "fsmoo-7.8.0.5" 197.7421875 456.3984375 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (do-set-brush! ((169 96 0 1.0) solid #f #f #f)) (draw-rectangle 302.90234375 458.46484375 10 10) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (set-font (12 #f default normal normal #f default #t unaligned)) (draw-text "fsmoo-transient" 314.90234375 456.3984375 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (set-font (12 "Liberation Serif" default normal bold #f default #t unaligned)) (draw-text "mbta-7.8.0.5, mbta-transient" 0.0 480.53125 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (set-origin 0.0 492.53125) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 492.53125) (410.0 . 492.53125) (410.0 . 576.53125) (0.0 . 576.53125)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-origin 0.0 492.53125) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 492.53125) (410.0 . 492.53125) (410.0 . 576.53125) (0.0 . 576.53125)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-alpha 1) (clear) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 35.0 67.0 394.0 67.0) (draw-line 35.0 6.0 394.0 6.0) (draw-line 35.0 6.0 35.0 67.0) (draw-line 394.0 6.0 394.0 67.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 35.0 65.0 35.0 69.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 136.38265831849495 66.0 136.38265831849495 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 222.10047456198157 66.0 222.10047456198157 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 296.352624397144 66.0 296.352624397144 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 361.84766222835987 66.0 361.84766222835987 68.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 394.0 65.0 394.0 69.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 67.0 37.0 67.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 36.5 37.0 36.5) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 6.0 37.0 6.0) (set-text-foreground (255 255 255 1.0)) (draw-text "1" 30.5 70.0 #t 0 0) (draw-text "1" 30.5 71.0 #t 0 0) (draw-text "1" 30.5 72.0 #t 0 0) (draw-text "1" 31.5 70.0 #t 0 0) (draw-text "1" 31.5 72.0 #t 0 0) (draw-text "1" 32.5 70.0 #t 0 0) (draw-text "1" 32.5 71.0 #t 0 0) (draw-text "1" 32.5 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "1" 31.5 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "1.91x" 378.5 70.0 #t 0 0) (draw-text "1.91x" 378.5 71.0 #t 0 0) (draw-text "1.91x" 378.5 72.0 #t 0 0) (draw-text "1.91x" 379.5 70.0 #t 0 0) (draw-text "1.91x" 379.5 72.0 #t 0 0) (draw-text "1.91x" 380.5 70.0 #t 0 0) (draw-text "1.91x" 380.5 71.0 #t 0 0) (draw-text "1.91x" 380.5 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "1.91x" 379.5 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "0" 23.0 60.0 #t 0 0) (draw-text "0" 23.0 61.0 #t 0 0) (draw-text "0" 23.0 62.0 #t 0 0) (draw-text "0" 24.0 60.0 #t 0 0) (draw-text "0" 24.0 62.0 #t 0 0) (draw-text "0" 25.0 60.0 #t 0 0) (draw-text "0" 25.0 61.0 #t 0 0) (draw-text "0" 25.0 62.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "0" 24.0 61.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "50" 17.0 29.5 #t 0 0) (draw-text "50" 17.0 30.5 #t 0 0) (draw-text "50" 17.0 31.5 #t 0 0) (draw-text "50" 18.0 29.5 #t 0 0) (draw-text "50" 18.0 31.5 #t 0 0) (draw-text "50" 19.0 29.5 #t 0 0) (draw-text "50" 19.0 30.5 #t 0 0) (draw-text "50" 19.0 31.5 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "50" 18.0 30.5 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "100%" -1.0 -1.0 #t 0 0) (draw-text "100%" -1.0 0.0 #t 0 0) (draw-text "100%" -1.0 1.0 #t 0 0) (draw-text "100%" 0.0 -1.0 #t 0 0) (draw-text "100%" 0.0 1.0 #t 0 0) (draw-text "100%" 1.0 -1.0 #t 0 0) (draw-text "100%" 1.0 0.0 #t 0 0) (draw-text "100%" 1.0 1.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "100%" 0.0 0.0 #t 0 0) (set-clipping-region (#t (((((34.5 . 498.03125) (395.0 . 498.03125) (395.0 . 560.53125) (34.5 . 560.53125)))) . any))) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 0.6) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-brush! ((255 239 186 1.0) solid #f #f #f)) (set-smoothing unsmoothed) (draw-polygon ((35.0 . 67.0) (53.89473684210527 . 67.0) (72.78947368421053 . 67.0) (91.68421052631572 . 67.0) (110.57894736842098 . 67.0) (129.47368421052636 . 67.0) (148.36842105263162 . 67.0) (167.26315789473688 . 67.0) (186.15789473684214 . 67.0) (205.0526315789475 . 67.0) (223.9473684210526 . 67.0) (242.842105263158 . 67.0) (261.73684210526324 . 67.0) (280.6315789473684 . 67.0) (299.52631578947376 . 67.0) (318.4210526315789 . 67.0) (337.3157894736843 . 67.0) (356.2105263157894 . 67.0) (375.1052631578948 . 67.0) (394.0 . 67.0) (394.0 . 6.0) (375.1052631578948 . 6.0) (356.2105263157894 . 6.0) (337.3157894736843 . 9.8125) (318.4210526315789 . 32.6875) (299.52631578947376 . 36.5) (280.6315789473684 . 36.5) (261.73684210526324 . 36.5) (242.842105263158 . 36.5) (223.9473684210526 . 36.5) (205.0526315789475 . 36.5) (186.15789473684214 . 36.5) (167.26315789473688 . 36.5) (148.36842105263162 . 36.5) (129.47368421052636 . 36.5) (110.57894736842098 . 36.5) (91.68421052631572 . 36.5) (72.78947368421053 . 36.5) (53.89473684210527 . 44.125) (35.0 . 59.375)) 0 0 winding) (set-smoothing smoothed) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-pen! ((169 96 0 1.0) 0.1 solid round round #f)) (draw-lines ((394.0 . 6.0) (375.1052631578948 . 6.0) (356.2105263157894 . 6.0) (337.3157894736843 . 9.8125) (318.4210526315789 . 32.6875) (299.52631578947376 . 36.5) (280.6315789473684 . 36.5) (261.73684210526324 . 36.5) (242.842105263158 . 36.5) (223.9473684210526 . 36.5) (205.0526315789475 . 36.5) (186.15789473684214 . 36.5) (167.26315789473688 . 36.5) (148.36842105263162 . 36.5) (129.47368421052636 . 36.5) (110.57894736842098 . 36.5) (91.68421052631572 . 36.5) (72.78947368421053 . 36.5) (53.89473684210527 . 44.125) (35.0 . 59.375)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 0.6) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-brush! ((227 232 255 1.0) solid #f #f #f)) (set-smoothing unsmoothed) (draw-polygon ((35.0 . 67.0) (53.89473684210527 . 67.0) (72.78947368421053 . 67.0) (91.68421052631572 . 67.0) (110.57894736842098 . 67.0) (129.47368421052636 . 67.0) (148.36842105263162 . 67.0) (167.26315789473688 . 67.0) (186.15789473684214 . 67.0) (205.0526315789475 . 67.0) (223.9473684210526 . 67.0) (242.842105263158 . 67.0) (261.73684210526324 . 67.0) (280.6315789473684 . 67.0) (299.52631578947376 . 67.0) (318.4210526315789 . 67.0) (337.3157894736843 . 67.0) (356.2105263157894 . 67.0) (375.1052631578948 . 67.0) (394.0 . 67.0) (394.0 . 6.0) (375.1052631578948 . 21.25) (356.2105263157894 . 21.25) (337.3157894736843 . 21.25) (318.4210526315789 . 25.0625) (299.52631578947376 . 36.5) (280.6315789473684 . 36.5) (261.73684210526324 . 36.5) (242.842105263158 . 36.5) (223.9473684210526 . 36.5) (205.0526315789475 . 36.5) (186.15789473684214 . 36.5) (167.26315789473688 . 36.5) (148.36842105263162 . 44.125) (129.47368421052636 . 51.75) (110.57894736842098 . 51.75) (91.68421052631572 . 51.75) (72.78947368421053 . 51.75) (53.89473684210527 . 51.75) (35.0 . 63.1875)) 0 0 winding) (set-smoothing smoothed) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-pen! ((0 2 123 1.0) 0.1 solid round round #f)) (draw-lines ((394.0 . 6.0) (375.1052631578948 . 21.25) (356.2105263157894 . 21.25) (337.3157894736843 . 21.25) (318.4210526315789 . 25.0625) (299.52631578947376 . 36.5) (280.6315789473684 . 36.5) (261.73684210526324 . 36.5) (242.842105263158 . 36.5) (223.9473684210526 . 36.5) (205.0526315789475 . 36.5) (186.15789473684214 . 36.5) (167.26315789473688 . 36.5) (148.36842105263162 . 44.125) (129.47368421052636 . 51.75) (110.57894736842098 . 51.75) (91.68421052631572 . 51.75) (72.78947368421053 . 51.75) (53.89473684210527 . 51.75) (35.0 . 63.1875)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1) (do-set-pen! ((169 96 0 1.0) 0.1 solid round round #f)) (draw-lines ((394.0 . 6.0) (375.1052631578948 . 6.0) (356.2105263157894 . 6.0) (337.3157894736843 . 9.8125) (318.4210526315789 . 32.6875) (299.52631578947376 . 36.5) (280.6315789473684 . 36.5) (261.73684210526324 . 36.5) (242.842105263158 . 36.5) (223.9473684210526 . 36.5) (205.0526315789475 . 36.5) (186.15789473684214 . 36.5) (167.26315789473688 . 36.5) (148.36842105263162 . 36.5) (129.47368421052636 . 36.5) (110.57894736842098 . 36.5) (91.68421052631572 . 36.5) (72.78947368421053 . 36.5) (53.89473684210527 . 44.125) (35.0 . 59.375)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1/2) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 67.0) (35.0 . 6.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 136.38265831849495 67.0 136.38265831849495 63.0) (draw-line 136.38265831849495 59.0 136.38265831849495 54.0) (draw-line 136.38265831849495 50.0 136.38265831849495 45.0) (draw-line 136.38265831849495 41.0 136.38265831849495 36.0) (draw-line 136.38265831849495 32.0 136.38265831849495 27.0) (draw-line 136.38265831849495 23.0 136.38265831849495 18.0) (draw-line 136.38265831849495 14.0 136.38265831849495 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 222.10047456198157 67.0 222.10047456198157 63.0) (draw-line 222.10047456198157 59.0 222.10047456198157 54.0) (draw-line 222.10047456198157 50.0 222.10047456198157 45.0) (draw-line 222.10047456198157 41.0 222.10047456198157 36.0) (draw-line 222.10047456198157 32.0 222.10047456198157 27.0) (draw-line 222.10047456198157 23.0 222.10047456198157 18.0) (draw-line 222.10047456198157 14.0 222.10047456198157 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 296.352624397144 67.0 296.352624397144 63.0) (draw-line 296.352624397144 59.0 296.352624397144 54.0) (draw-line 296.352624397144 50.0 296.352624397144 45.0) (draw-line 296.352624397144 41.0 296.352624397144 36.0) (draw-line 296.352624397144 32.0 296.352624397144 27.0) (draw-line 296.352624397144 23.0 296.352624397144 18.0) (draw-line 296.352624397144 14.0 296.352624397144 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 361.84766222835987 67.0 361.84766222835987 63.0) (draw-line 361.84766222835987 59.0 361.84766222835987 54.0) (draw-line 361.84766222835987 50.0 361.84766222835987 45.0) (draw-line 361.84766222835987 41.0 361.84766222835987 36.0) (draw-line 361.84766222835987 32.0 361.84766222835987 27.0) (draw-line 361.84766222835987 23.0 361.84766222835987 18.0) (draw-line 361.84766222835987 14.0 361.84766222835987 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((394.0 . 67.0) (394.0 . 6.0)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1/2) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 67.0) (394.0 . 67.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 36.5) (394.0 . 36.5)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 6.0) (394.0 . 6.0)) 0.0 0.0) (set-origin 0.0 492.53125) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 492.53125) (410.0 . 492.53125) (410.0 . 576.53125) (0.0 . 576.53125)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-origin 0.0 0.0) (set-smoothing unsmoothed) (set-text-mode transparent) (set-clipping-region #f) (set-font (12 #f default normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1.0) (set-font (12 "Liberation Serif" default normal bold #f default #t unaligned)) (draw-text "16 configurations" 309.986328125 480.53125 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (do-set-brush! ((0 2 123 1.0) solid #f #f #f)) (draw-rectangle 198.94921875 578.59765625 10 10) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (set-font (12 #f default normal normal #f default #t unaligned)) (draw-text "mbta-7.8.0.5" 210.94921875 576.53125 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (do-set-brush! ((169 96 0 1.0) solid #f #f #f)) (draw-rectangle 309.505859375 578.59765625 10 10) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (set-font (12 #f default normal normal #f default #t unaligned)) (draw-text "mbta-transient" 321.505859375 576.53125 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (set-font (12 "Liberation Serif" default normal bold #f default #t unaligned)) (draw-text "morsecode-7.8.0.5, morsecode-transient" 0.0 600.6640625 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (set-origin 0.0 612.6640625) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 612.6640625) (410.0 . 612.6640625) (410.0 . 696.6640625) (0.0 . 696.6640625)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-origin 0.0 612.6640625) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 612.6640625) (410.0 . 612.6640625) (410.0 . 696.6640625) (0.0 . 696.6640625)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-alpha 1) (clear) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 35.0 67.0 394.0 67.0) (draw-line 35.0 6.0 394.0 6.0) (draw-line 35.0 6.0 35.0 67.0) (draw-line 394.0 6.0 394.0 67.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 35.0 65.0 35.0 69.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 99.30748429283196 66.0 99.30748429283196 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 153.678687545137 66.0 153.678687545137 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 200.77716610577102 66.0 200.77716610577102 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 242.3209684329684 66.0 242.3209684329684 68.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 279.4831659530754 65.0 279.4831659530754 69.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 394.0 65.0 394.0 69.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 67.0 37.0 67.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 36.5 37.0 36.5) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 6.0 37.0 6.0) (set-text-foreground (255 255 255 1.0)) (draw-text "1" 30.5 70.0 #t 0 0) (draw-text "1" 30.5 71.0 #t 0 0) (draw-text "1" 30.5 72.0 #t 0 0) (draw-text "1" 31.5 70.0 #t 0 0) (draw-text "1" 31.5 72.0 #t 0 0) (draw-text "1" 32.5 70.0 #t 0 0) (draw-text "1" 32.5 71.0 #t 0 0) (draw-text "1" 32.5 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "1" 31.5 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "2" 274.9831659530754 70.0 #t 0 0) (draw-text "2" 274.9831659530754 71.0 #t 0 0) (draw-text "2" 274.9831659530754 72.0 #t 0 0) (draw-text "2" 275.9831659530754 70.0 #t 0 0) (draw-text "2" 275.9831659530754 72.0 #t 0 0) (draw-text "2" 276.9831659530754 70.0 #t 0 0) (draw-text "2" 276.9831659530754 71.0 #t 0 0) (draw-text "2" 276.9831659530754 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "2" 275.9831659530754 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "2.77x" 378.5 70.0 #t 0 0) (draw-text "2.77x" 378.5 71.0 #t 0 0) (draw-text "2.77x" 378.5 72.0 #t 0 0) (draw-text "2.77x" 379.5 70.0 #t 0 0) (draw-text "2.77x" 379.5 72.0 #t 0 0) (draw-text "2.77x" 380.5 70.0 #t 0 0) (draw-text "2.77x" 380.5 71.0 #t 0 0) (draw-text "2.77x" 380.5 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "2.77x" 379.5 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "0" 23.0 60.0 #t 0 0) (draw-text "0" 23.0 61.0 #t 0 0) (draw-text "0" 23.0 62.0 #t 0 0) (draw-text "0" 24.0 60.0 #t 0 0) (draw-text "0" 24.0 62.0 #t 0 0) (draw-text "0" 25.0 60.0 #t 0 0) (draw-text "0" 25.0 61.0 #t 0 0) (draw-text "0" 25.0 62.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "0" 24.0 61.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "50" 17.0 29.5 #t 0 0) (draw-text "50" 17.0 30.5 #t 0 0) (draw-text "50" 17.0 31.5 #t 0 0) (draw-text "50" 18.0 29.5 #t 0 0) (draw-text "50" 18.0 31.5 #t 0 0) (draw-text "50" 19.0 29.5 #t 0 0) (draw-text "50" 19.0 30.5 #t 0 0) (draw-text "50" 19.0 31.5 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "50" 18.0 30.5 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "100%" -1.0 -1.0 #t 0 0) (draw-text "100%" -1.0 0.0 #t 0 0) (draw-text "100%" -1.0 1.0 #t 0 0) (draw-text "100%" 0.0 -1.0 #t 0 0) (draw-text "100%" 0.0 1.0 #t 0 0) (draw-text "100%" 1.0 -1.0 #t 0 0) (draw-text "100%" 1.0 0.0 #t 0 0) (draw-text "100%" 1.0 1.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "100%" 0.0 0.0 #t 0 0) (set-clipping-region (#t (((((34.5 . 618.1640625) (395.0 . 618.1640625) (395.0 . 680.6640625) (34.5 . 680.6640625)))) . any))) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 0.6) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-brush! ((255 239 186 1.0) solid #f #f #f)) (set-smoothing unsmoothed) (draw-polygon ((35.0 . 67.0) (53.89473684210524 . 67.0) (72.78947368421052 . 67.0) (91.68421052631581 . 67.0) (110.57894736842105 . 67.0) (129.47368421052633 . 67.0) (148.36842105263162 . 67.0) (167.26315789473685 . 67.0) (186.1578947368421 . 67.0) (205.05263157894737 . 67.0) (223.94736842105266 . 67.0) (242.8421052631579 . 67.0) (261.7368421052631 . 67.0) (280.63157894736844 . 67.0) (299.5263157894737 . 67.0) (318.42105263157896 . 67.0) (337.3157894736843 . 67.0) (356.2105263157894 . 67.0) (375.10526315789485 . 67.0) (394.0 . 67.0) (394.0 . 6.0) (375.10526315789485 . 13.625) (356.2105263157894 . 36.5) (337.3157894736843 . 36.5) (318.42105263157896 . 36.5) (299.5263157894737 . 36.5) (280.63157894736844 . 36.5) (261.7368421052631 . 36.5) (242.8421052631579 . 36.5) (223.94736842105266 . 36.5) (205.05263157894737 . 36.5) (186.1578947368421 . 36.5) (167.26315789473685 . 36.5) (148.36842105263162 . 36.5) (129.47368421052633 . 36.5) (110.57894736842105 . 36.5) (91.68421052631581 . 36.5) (72.78947368421052 . 36.5) (53.89473684210524 . 36.5) (35.0 . 59.375)) 0 0 winding) (set-smoothing smoothed) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-pen! ((169 96 0 1.0) 0.1 solid round round #f)) (draw-lines ((394.0 . 6.0) (375.10526315789485 . 13.625) (356.2105263157894 . 36.5) (337.3157894736843 . 36.5) (318.42105263157896 . 36.5) (299.5263157894737 . 36.5) (280.63157894736844 . 36.5) (261.7368421052631 . 36.5) (242.8421052631579 . 36.5) (223.94736842105266 . 36.5) (205.05263157894737 . 36.5) (186.1578947368421 . 36.5) (167.26315789473685 . 36.5) (148.36842105263162 . 36.5) (129.47368421052633 . 36.5) (110.57894736842105 . 36.5) (91.68421052631581 . 36.5) (72.78947368421052 . 36.5) (53.89473684210524 . 36.5) (35.0 . 59.375)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 0.6) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-brush! ((227 232 255 1.0) solid #f #f #f)) (set-smoothing unsmoothed) (draw-polygon ((35.0 . 67.0) (53.89473684210524 . 67.0) (72.78947368421052 . 67.0) (91.68421052631581 . 67.0) (110.57894736842105 . 67.0) (129.47368421052633 . 67.0) (148.36842105263162 . 67.0) (167.26315789473685 . 67.0) (186.1578947368421 . 67.0) (205.05263157894737 . 67.0) (223.94736842105266 . 67.0) (242.8421052631579 . 67.0) (261.7368421052631 . 67.0) (280.63157894736844 . 67.0) (299.5263157894737 . 67.0) (318.42105263157896 . 67.0) (337.3157894736843 . 67.0) (356.2105263157894 . 67.0) (375.10526315789485 . 67.0) (394.0 . 67.0) (394.0 . 6.0) (375.10526315789485 . 6.0) (356.2105263157894 . 6.0) (337.3157894736843 . 6.0) (318.42105263157896 . 6.0) (299.5263157894737 . 6.0) (280.63157894736844 . 6.0) (261.7368421052631 . 6.0) (242.8421052631579 . 6.0) (223.94736842105266 . 6.0) (205.05263157894737 . 6.0) (186.1578947368421 . 9.8125) (167.26315789473685 . 9.8125) (148.36842105263162 . 13.625) (129.47368421052633 . 17.4375) (110.57894736842105 . 28.875) (91.68421052631581 . 28.875) (72.78947368421052 . 36.5) (53.89473684210524 . 36.5) (35.0 . 40.3125)) 0 0 winding) (set-smoothing smoothed) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-pen! ((0 2 123 1.0) 0.1 solid round round #f)) (draw-lines ((394.0 . 6.0) (375.10526315789485 . 6.0) (356.2105263157894 . 6.0) (337.3157894736843 . 6.0) (318.42105263157896 . 6.0) (299.5263157894737 . 6.0) (280.63157894736844 . 6.0) (261.7368421052631 . 6.0) (242.8421052631579 . 6.0) (223.94736842105266 . 6.0) (205.05263157894737 . 6.0) (186.1578947368421 . 9.8125) (167.26315789473685 . 9.8125) (148.36842105263162 . 13.625) (129.47368421052633 . 17.4375) (110.57894736842105 . 28.875) (91.68421052631581 . 28.875) (72.78947368421052 . 36.5) (53.89473684210524 . 36.5) (35.0 . 40.3125)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1) (do-set-pen! ((169 96 0 1.0) 0.1 solid round round #f)) (draw-lines ((394.0 . 6.0) (375.10526315789485 . 13.625) (356.2105263157894 . 36.5) (337.3157894736843 . 36.5) (318.42105263157896 . 36.5) (299.5263157894737 . 36.5) (280.63157894736844 . 36.5) (261.7368421052631 . 36.5) (242.8421052631579 . 36.5) (223.94736842105266 . 36.5) (205.05263157894737 . 36.5) (186.1578947368421 . 36.5) (167.26315789473685 . 36.5) (148.36842105263162 . 36.5) (129.47368421052633 . 36.5) (110.57894736842105 . 36.5) (91.68421052631581 . 36.5) (72.78947368421052 . 36.5) (53.89473684210524 . 36.5) (35.0 . 59.375)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1/2) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 67.0) (35.0 . 6.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 99.30748429283196 67.0 99.30748429283196 63.0) (draw-line 99.30748429283196 59.0 99.30748429283196 54.0) (draw-line 99.30748429283196 50.0 99.30748429283196 45.0) (draw-line 99.30748429283196 41.0 99.30748429283196 36.0) (draw-line 99.30748429283196 32.0 99.30748429283196 27.0) (draw-line 99.30748429283196 23.0 99.30748429283196 18.0) (draw-line 99.30748429283196 14.0 99.30748429283196 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 153.678687545137 67.0 153.678687545137 63.0) (draw-line 153.678687545137 59.0 153.678687545137 54.0) (draw-line 153.678687545137 50.0 153.678687545137 45.0) (draw-line 153.678687545137 41.0 153.678687545137 36.0) (draw-line 153.678687545137 32.0 153.678687545137 27.0) (draw-line 153.678687545137 23.0 153.678687545137 18.0) (draw-line 153.678687545137 14.0 153.678687545137 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 200.77716610577102 67.0 200.77716610577102 63.0) (draw-line 200.77716610577102 59.0 200.77716610577102 54.0) (draw-line 200.77716610577102 50.0 200.77716610577102 45.0) (draw-line 200.77716610577102 41.0 200.77716610577102 36.0) (draw-line 200.77716610577102 32.0 200.77716610577102 27.0) (draw-line 200.77716610577102 23.0 200.77716610577102 18.0) (draw-line 200.77716610577102 14.0 200.77716610577102 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 242.3209684329684 67.0 242.3209684329684 63.0) (draw-line 242.3209684329684 59.0 242.3209684329684 54.0) (draw-line 242.3209684329684 50.0 242.3209684329684 45.0) (draw-line 242.3209684329684 41.0 242.3209684329684 36.0) (draw-line 242.3209684329684 32.0 242.3209684329684 27.0) (draw-line 242.3209684329684 23.0 242.3209684329684 18.0) (draw-line 242.3209684329684 14.0 242.3209684329684 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((279.4831659530754 . 67.0) (279.4831659530754 . 6.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((394.0 . 67.0) (394.0 . 6.0)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1/2) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 67.0) (394.0 . 67.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 36.5) (394.0 . 36.5)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 6.0) (394.0 . 6.0)) 0.0 0.0) (set-origin 0.0 612.6640625) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 612.6640625) (410.0 . 612.6640625) (410.0 . 696.6640625) (0.0 . 696.6640625)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-origin 0.0 0.0) (set-smoothing unsmoothed) (set-text-mode transparent) (set-clipping-region #f) (set-font (12 #f default normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1.0) (set-font (12 "Liberation Serif" default normal bold #f default #t unaligned)) (draw-text "16 configurations" 309.986328125 600.6640625 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (do-set-brush! ((0 2 123 1.0) solid #f #f #f)) (draw-rectangle 130.60546875 698.73046875 10 10) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (set-font (12 #f default normal normal #f default #t unaligned)) (draw-text "morsecode-7.8.0.5" 142.60546875 696.6640625 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (do-set-brush! ((169 96 0 1.0) solid #f #f #f)) (draw-rectangle 275.333984375 698.73046875 10 10) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (set-font (12 #f default normal normal #f default #t unaligned)) (draw-text "morsecode-transient" 287.333984375 696.6640625 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (set-font (12 "Liberation Serif" default normal bold #f default #t unaligned)) (draw-text "zombie-7.8.0.5, zombie-transient" 0.0 720.796875 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (set-origin 0.0 732.796875) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 732.796875) (410.0 . 732.796875) (410.0 . 816.796875) (0.0 . 816.796875)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-origin 0.0 732.796875) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 732.796875) (410.0 . 732.796875) (410.0 . 816.796875) (0.0 . 816.796875)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-alpha 1) (clear) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 35.0 67.0 391.0 67.0) (draw-line 35.0 6.0 391.0 6.0) (draw-line 35.0 6.0 35.0 67.0) (draw-line 391.0 6.0 391.0 67.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 35.0 65.0 35.0 69.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 51.931234548409805 66.0 51.931234548409805 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 66.24638938718569 66.0 66.24638938718569 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 78.64674054619115 66.0 78.64674054619115 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 89.58462544356313 66.0 89.58462544356313 68.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 99.36889689293466 65.0 99.36889689293466 69.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 163.73779378586931 66.0 163.73779378586931 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 201.39118468102265 66.0 201.39118468102265 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 228.10669067880394 66.0 228.10669067880394 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 248.82884702554747 66.0 248.82884702554747 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 265.76008157395734 66.0 265.76008157395734 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 280.07523641273315 66.0 280.07523641273315 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 292.47558757173863 66.0 292.47558757173863 68.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 303.41347246911056 66.0 303.41347246911056 68.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 391.0 65.0 391.0 69.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 67.0 37.0 67.0) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 36.5 37.0 36.5) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (draw-line 33.0 6.0 37.0 6.0) (set-text-foreground (255 255 255 1.0)) (draw-text "1" 30.5 70.0 #t 0 0) (draw-text "1" 30.5 71.0 #t 0 0) (draw-text "1" 30.5 72.0 #t 0 0) (draw-text "1" 31.5 70.0 #t 0 0) (draw-text "1" 31.5 72.0 #t 0 0) (draw-text "1" 32.5 70.0 #t 0 0) (draw-text "1" 32.5 71.0 #t 0 0) (draw-text "1" 32.5 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "1" 31.5 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "2" 94.86889689293466 70.0 #t 0 0) (draw-text "2" 94.86889689293466 71.0 #t 0 0) (draw-text "2" 94.86889689293466 72.0 #t 0 0) (draw-text "2" 95.86889689293466 70.0 #t 0 0) (draw-text "2" 95.86889689293466 72.0 #t 0 0) (draw-text "2" 96.86889689293466 70.0 #t 0 0) (draw-text "2" 96.86889689293466 71.0 #t 0 0) (draw-text "2" 96.86889689293466 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "2" 95.86889689293466 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "46.23x" 372.0 70.0 #t 0 0) (draw-text "46.23x" 372.0 71.0 #t 0 0) (draw-text "46.23x" 372.0 72.0 #t 0 0) (draw-text "46.23x" 373.0 70.0 #t 0 0) (draw-text "46.23x" 373.0 72.0 #t 0 0) (draw-text "46.23x" 374.0 70.0 #t 0 0) (draw-text "46.23x" 374.0 71.0 #t 0 0) (draw-text "46.23x" 374.0 72.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "46.23x" 373.0 71.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "0" 23.0 60.0 #t 0 0) (draw-text "0" 23.0 61.0 #t 0 0) (draw-text "0" 23.0 62.0 #t 0 0) (draw-text "0" 24.0 60.0 #t 0 0) (draw-text "0" 24.0 62.0 #t 0 0) (draw-text "0" 25.0 60.0 #t 0 0) (draw-text "0" 25.0 61.0 #t 0 0) (draw-text "0" 25.0 62.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "0" 24.0 61.0 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "50" 17.0 29.5 #t 0 0) (draw-text "50" 17.0 30.5 #t 0 0) (draw-text "50" 17.0 31.5 #t 0 0) (draw-text "50" 18.0 29.5 #t 0 0) (draw-text "50" 18.0 31.5 #t 0 0) (draw-text "50" 19.0 29.5 #t 0 0) (draw-text "50" 19.0 30.5 #t 0 0) (draw-text "50" 19.0 31.5 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "50" 18.0 30.5 #t 0 0) (set-text-foreground (255 255 255 1.0)) (draw-text "100%" -1.0 -1.0 #t 0 0) (draw-text "100%" -1.0 0.0 #t 0 0) (draw-text "100%" -1.0 1.0 #t 0 0) (draw-text "100%" 0.0 -1.0 #t 0 0) (draw-text "100%" 0.0 1.0 #t 0 0) (draw-text "100%" 1.0 -1.0 #t 0 0) (draw-text "100%" 1.0 0.0 #t 0 0) (draw-text "100%" 1.0 1.0 #t 0 0) (set-text-foreground (0 0 0 1.0)) (draw-text "100%" 0.0 0.0 #t 0 0) (set-clipping-region (#t (((((34.5 . 738.296875) (392.0 . 738.296875) (392.0 . 800.796875) (34.5 . 800.796875)))) . any))) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 0.6) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-brush! ((255 239 186 1.0) solid #f #f #f)) (set-smoothing unsmoothed) (draw-polygon ((35.0 . 67.0) (53.73684210526316 . 67.0) (72.47368421052633 . 67.0) (91.21052631578948 . 67.0) (109.94736842105264 . 67.0) (128.6842105263158 . 67.0) (147.42105263157896 . 67.0) (166.1578947368421 . 67.0) (184.8947368421053 . 67.0) (203.6315789473684 . 67.0) (222.36842105263162 . 67.0) (241.1052631578947 . 67.0) (259.8421052631579 . 67.0) (278.5789473684211 . 67.0) (297.3157894736842 . 67.0) (316.0526315789474 . 67.0) (334.7894736842106 . 67.0) (353.52631578947364 . 67.0) (372.2631578947368 . 67.0) (391.0 . 67.0) (391.0 . 6.0) (372.2631578947368 . 6.0) (362.02299660901855 . 12.535714285714285) (353.52631578947364 . 17.4375) (343.2861545037554 . 28.330357142857146) (334.7894736842106 . 36.5) (316.0526315789474 . 36.5) (297.3157894736842 . 36.5) (278.5789473684211 . 36.5) (259.8421052631579 . 36.5) (241.1052631578947 . 36.5) (222.36842105263162 . 36.5) (203.6315789473684 . 36.5) (184.8947368421053 . 36.5) (166.1578947368421 . 36.5) (147.42105263157896 . 36.5) (137.1808913458607 . 40.85714285714286) (128.6842105263158 . 44.125) (118.44404924059752 . 48.48214285714286) (109.94736842105264 . 51.75) (91.21052631578948 . 51.75) (72.47368421052633 . 51.75) (53.73684210526316 . 51.75) (43.49668081954488 . 56.10714285714286) (35.0 . 59.375)) 0 0 winding) (set-smoothing smoothed) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-pen! ((169 96 0 1.0) 0.1 solid round round #f)) (draw-lines ((391.0 . 6.0) (372.2631578947368 . 6.0) (362.02299660901855 . 12.535714285714285) (353.52631578947364 . 17.4375) (343.2861545037554 . 28.330357142857146) (334.7894736842106 . 36.5) (316.0526315789474 . 36.5) (297.3157894736842 . 36.5) (278.5789473684211 . 36.5) (259.8421052631579 . 36.5) (241.1052631578947 . 36.5) (222.36842105263162 . 36.5) (203.6315789473684 . 36.5) (184.8947368421053 . 36.5) (166.1578947368421 . 36.5) (147.42105263157896 . 36.5) (137.1808913458607 . 40.85714285714286) (128.6842105263158 . 44.125) (118.44404924059752 . 48.48214285714286) (109.94736842105264 . 51.75) (91.21052631578948 . 51.75) (72.47368421052633 . 51.75) (53.73684210526316 . 51.75) (43.49668081954488 . 56.10714285714286) (35.0 . 59.375)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 0.6) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-brush! ((227 232 255 1.0) solid #f #f #f)) (set-smoothing unsmoothed) (draw-polygon ((35.0 . 67.0) (53.73684210526316 . 67.0) (72.47368421052633 . 67.0) (91.21052631578948 . 67.0) (109.94736842105264 . 67.0) (128.6842105263158 . 67.0) (147.42105263157896 . 67.0) (166.1578947368421 . 67.0) (184.8947368421053 . 67.0) (203.6315789473684 . 67.0) (222.36842105263162 . 67.0) (241.1052631578947 . 67.0) (259.8421052631579 . 67.0) (278.5789473684211 . 67.0) (297.3157894736842 . 67.0) (316.0526315789474 . 67.0) (334.7894736842106 . 67.0) (353.52631578947364 . 67.0) (372.2631578947368 . 67.0) (391.0 . 67.0) (391.0 . 6.0) (380.7598387142817 . 14.714285714285715) (372.2631578947368 . 21.25) (362.02299660901855 . 29.964285714285715) (353.52631578947364 . 36.5) (334.7894736842106 . 36.5) (316.0526315789474 . 36.5) (297.3157894736842 . 36.5) (278.5789473684211 . 36.5) (259.8421052631579 . 36.5) (241.1052631578947 . 36.5) (222.36842105263162 . 36.5) (203.6315789473684 . 36.5) (184.8947368421053 . 36.5) (166.1578947368421 . 36.5) (147.42105263157896 . 36.5) (128.6842105263158 . 36.5) (118.44404924059752 . 40.85714285714286) (109.94736842105264 . 44.125) (99.70720713533436 . 48.48214285714286) (91.21052631578948 . 51.75) (72.47368421052633 . 51.75) (53.73684210526316 . 51.75) (43.49668081954488 . 56.10714285714286) (35.0 . 59.375)) 0 0 winding) (set-smoothing smoothed) (do-set-pen! ((0 0 0 1.0) 1 transparent round round #f)) (do-set-pen! ((0 2 123 1.0) 0.1 solid round round #f)) (draw-lines ((391.0 . 6.0) (380.7598387142817 . 14.714285714285715) (372.2631578947368 . 21.25) (362.02299660901855 . 29.964285714285715) (353.52631578947364 . 36.5) (334.7894736842106 . 36.5) (316.0526315789474 . 36.5) (297.3157894736842 . 36.5) (278.5789473684211 . 36.5) (259.8421052631579 . 36.5) (241.1052631578947 . 36.5) (222.36842105263162 . 36.5) (203.6315789473684 . 36.5) (184.8947368421053 . 36.5) (166.1578947368421 . 36.5) (147.42105263157896 . 36.5) (128.6842105263158 . 36.5) (118.44404924059752 . 40.85714285714286) (109.94736842105264 . 44.125) (99.70720713533436 . 48.48214285714286) (91.21052631578948 . 51.75) (72.47368421052633 . 51.75) (53.73684210526316 . 51.75) (43.49668081954488 . 56.10714285714286) (35.0 . 59.375)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1) (do-set-pen! ((169 96 0 1.0) 0.1 solid round round #f)) (draw-lines ((391.0 . 6.0) (372.2631578947368 . 6.0) (362.02299660901855 . 12.535714285714285) (353.52631578947364 . 17.4375) (343.2861545037554 . 28.330357142857146) (334.7894736842106 . 36.5) (316.0526315789474 . 36.5) (297.3157894736842 . 36.5) (278.5789473684211 . 36.5) (259.8421052631579 . 36.5) (241.1052631578947 . 36.5) (222.36842105263162 . 36.5) (203.6315789473684 . 36.5) (184.8947368421053 . 36.5) (166.1578947368421 . 36.5) (147.42105263157896 . 36.5) (137.1808913458607 . 40.85714285714286) (128.6842105263158 . 44.125) (118.44404924059752 . 48.48214285714286) (109.94736842105264 . 51.75) (91.21052631578948 . 51.75) (72.47368421052633 . 51.75) (53.73684210526316 . 51.75) (43.49668081954488 . 56.10714285714286) (35.0 . 59.375)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1/2) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 67.0) (35.0 . 6.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 51.931234548409805 67.0 51.931234548409805 63.0) (draw-line 51.931234548409805 59.0 51.931234548409805 54.0) (draw-line 51.931234548409805 50.0 51.931234548409805 45.0) (draw-line 51.931234548409805 41.0 51.931234548409805 36.0) (draw-line 51.931234548409805 32.0 51.931234548409805 27.0) (draw-line 51.931234548409805 23.0 51.931234548409805 18.0) (draw-line 51.931234548409805 14.0 51.931234548409805 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 66.24638938718569 67.0 66.24638938718569 63.0) (draw-line 66.24638938718569 59.0 66.24638938718569 54.0) (draw-line 66.24638938718569 50.0 66.24638938718569 45.0) (draw-line 66.24638938718569 41.0 66.24638938718569 36.0) (draw-line 66.24638938718569 32.0 66.24638938718569 27.0) (draw-line 66.24638938718569 23.0 66.24638938718569 18.0) (draw-line 66.24638938718569 14.0 66.24638938718569 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 78.64674054619115 67.0 78.64674054619115 63.0) (draw-line 78.64674054619115 59.0 78.64674054619115 54.0) (draw-line 78.64674054619115 50.0 78.64674054619115 45.0) (draw-line 78.64674054619115 41.0 78.64674054619115 36.0) (draw-line 78.64674054619115 32.0 78.64674054619115 27.0) (draw-line 78.64674054619115 23.0 78.64674054619115 18.0) (draw-line 78.64674054619115 14.0 78.64674054619115 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 89.58462544356313 67.0 89.58462544356313 63.0) (draw-line 89.58462544356313 59.0 89.58462544356313 54.0) (draw-line 89.58462544356313 50.0 89.58462544356313 45.0) (draw-line 89.58462544356313 41.0 89.58462544356313 36.0) (draw-line 89.58462544356313 32.0 89.58462544356313 27.0) (draw-line 89.58462544356313 23.0 89.58462544356313 18.0) (draw-line 89.58462544356313 14.0 89.58462544356313 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((99.36889689293466 . 67.0) (99.36889689293466 . 6.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 163.73779378586931 67.0 163.73779378586931 63.0) (draw-line 163.73779378586931 59.0 163.73779378586931 54.0) (draw-line 163.73779378586931 50.0 163.73779378586931 45.0) (draw-line 163.73779378586931 41.0 163.73779378586931 36.0) (draw-line 163.73779378586931 32.0 163.73779378586931 27.0) (draw-line 163.73779378586931 23.0 163.73779378586931 18.0) (draw-line 163.73779378586931 14.0 163.73779378586931 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 201.39118468102265 67.0 201.39118468102265 63.0) (draw-line 201.39118468102265 59.0 201.39118468102265 54.0) (draw-line 201.39118468102265 50.0 201.39118468102265 45.0) (draw-line 201.39118468102265 41.0 201.39118468102265 36.0) (draw-line 201.39118468102265 32.0 201.39118468102265 27.0) (draw-line 201.39118468102265 23.0 201.39118468102265 18.0) (draw-line 201.39118468102265 14.0 201.39118468102265 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 228.10669067880394 67.0 228.10669067880394 63.0) (draw-line 228.10669067880394 59.0 228.10669067880394 54.0) (draw-line 228.10669067880394 50.0 228.10669067880394 45.0) (draw-line 228.10669067880394 41.0 228.10669067880394 36.0) (draw-line 228.10669067880394 32.0 228.10669067880394 27.0) (draw-line 228.10669067880394 23.0 228.10669067880394 18.0) (draw-line 228.10669067880394 14.0 228.10669067880394 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 248.82884702554747 67.0 248.82884702554747 63.0) (draw-line 248.82884702554747 59.0 248.82884702554747 54.0) (draw-line 248.82884702554747 50.0 248.82884702554747 45.0) (draw-line 248.82884702554747 41.0 248.82884702554747 36.0) (draw-line 248.82884702554747 32.0 248.82884702554747 27.0) (draw-line 248.82884702554747 23.0 248.82884702554747 18.0) (draw-line 248.82884702554747 14.0 248.82884702554747 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 265.76008157395734 67.0 265.76008157395734 63.0) (draw-line 265.76008157395734 59.0 265.76008157395734 54.0) (draw-line 265.76008157395734 50.0 265.76008157395734 45.0) (draw-line 265.76008157395734 41.0 265.76008157395734 36.0) (draw-line 265.76008157395734 32.0 265.76008157395734 27.0) (draw-line 265.76008157395734 23.0 265.76008157395734 18.0) (draw-line 265.76008157395734 14.0 265.76008157395734 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 280.07523641273315 67.0 280.07523641273315 63.0) (draw-line 280.07523641273315 59.0 280.07523641273315 54.0) (draw-line 280.07523641273315 50.0 280.07523641273315 45.0) (draw-line 280.07523641273315 41.0 280.07523641273315 36.0) (draw-line 280.07523641273315 32.0 280.07523641273315 27.0) (draw-line 280.07523641273315 23.0 280.07523641273315 18.0) (draw-line 280.07523641273315 14.0 280.07523641273315 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 292.47558757173863 67.0 292.47558757173863 63.0) (draw-line 292.47558757173863 59.0 292.47558757173863 54.0) (draw-line 292.47558757173863 50.0 292.47558757173863 45.0) (draw-line 292.47558757173863 41.0 292.47558757173863 36.0) (draw-line 292.47558757173863 32.0 292.47558757173863 27.0) (draw-line 292.47558757173863 23.0 292.47558757173863 18.0) (draw-line 292.47558757173863 14.0 292.47558757173863 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-line 303.41347246911056 67.0 303.41347246911056 63.0) (draw-line 303.41347246911056 59.0 303.41347246911056 54.0) (draw-line 303.41347246911056 50.0 303.41347246911056 45.0) (draw-line 303.41347246911056 41.0 303.41347246911056 36.0) (draw-line 303.41347246911056 32.0 303.41347246911056 27.0) (draw-line 303.41347246911056 23.0 303.41347246911056 18.0) (draw-line 303.41347246911056 14.0 303.41347246911056 9.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((391.0 . 67.0) (391.0 . 6.0)) 0.0 0.0) (set-alpha 1) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (set-alpha 1/2) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 67.0) (391.0 . 67.0)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 36.5) (391.0 . 36.5)) 0.0 0.0) (do-set-pen! ((0 0 0 1.0) 1/2 solid round round #f)) (draw-lines ((35.0 . 6.0) (391.0 . 6.0)) 0.0 0.0) (set-origin 0.0 732.796875) (set-smoothing smoothed) (set-text-mode transparent) (set-clipping-region (#t (((((0.0 . 732.796875) (410.0 . 732.796875) (410.0 . 816.796875) (0.0 . 816.796875)))) . any))) (set-font (12 "bold" roman normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1) (set-origin 0.0 0.0) (set-smoothing unsmoothed) (set-text-mode transparent) (set-clipping-region #f) (set-font (12 #f default normal normal #f default #f aligned)) (set-text-foreground (0 0 0 1.0)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (set-background (255 255 255 1.0)) (set-alpha 1.0) (set-font (12 "Liberation Serif" default normal bold #f default #t unaligned)) (draw-text "16 configurations" 309.986328125 720.796875 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (do-set-brush! ((0 2 123 1.0) solid #f #f #f)) (draw-rectangle 172.37109375 818.86328125 10 10) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (set-font (12 #f default normal normal #f default #t unaligned)) (draw-text "zombie-7.8.0.5" 184.37109375 816.796875 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned)) (do-set-brush! ((169 96 0 1.0) solid #f #f #f)) (draw-rectangle 296.216796875 818.86328125 10 10) (do-set-brush! ((255 255 255 1.0) solid #f #f #f)) (do-set-pen! ((0 0 0 1.0) 1 solid round round #f)) (set-font (12 #f default normal normal #f default #t unaligned)) (draw-text "zombie-transient" 308.216796875 816.796875 #t 0 0) (set-font (12 #f default normal normal #f default #f aligned))) 410.0 830.9296875 9.240234375 2.06640625))
| false |
8614d1187776570506169878fc010dd8fa47c888 | 52c2225c9f44c0da28ca1fd44606a8d197c8eac8 | /EOPL/ch1/1.18.rkt | 016a0452c3d495e366d94e55152554a5f8baa874 | []
| no_license | alanzplus/EOPL | c74c1e9dd27c0580107fd860b88016320a6f231c | d7b06392d26d93df851d0ca66d9edc681a06693c | refs/heads/master | 2021-06-20T00:59:21.685904 | 2019-08-15T06:18:10 | 2019-08-15T07:06:53 | 147,045,798 | 8 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 359 | rkt | 1.18.rkt | #lang eopl
(define swapper
(lambda (s1 s2 slist)
(if (null? slist)
'()
(if (symbol? slist)
(cond
((eqv? s1 slist) s2)
((eqv? s2 slist) s1)
(else slist))
(cons
(swapper s1 s2 (car slist))
(swapper s1 s2 (cdr slist)))))))
(provide swapper)
| false |
92d8cf65fe3975484886c0ef0f20b3574e87bece | 561eac844dbad77a7fa88720d8f5b9ab6e6ba4b2 | /corpse-reviver-benchmark/benchmarks/snake/untyped/motion.rkt | 13e99aee4fd3f69a3007f1f6b4919450bc0269e2 | [
"0BSD"
]
| permissive | camoy/corpse-reviver | 7c0a5c5d7abbeccd8f2260a4adea4ca6b3363567 | 67fda012093bfd5fe8f9bb699b7558699743217d | refs/heads/master | 2023-08-18T14:47:26.601987 | 2023-08-03T15:17:01 | 2023-08-03T15:17:01 | 261,932,938 | 19 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,224 | rkt | motion.rkt | #lang racket
(require "data.rkt"
"const.rkt"
"motion-help.rkt")
(provide reset!)
(define (reset!)
(random-seed 1324))
;; world->world : World -> World
(define (world->world w)
(cond [(eating? w) (snake-eat w)]
[else
(world (snake-slither (world-snake w))
(world-food w))]))
;; eating? : World -> Boolean
;; Is the snake eating the food in the world.
(define (eating? w)
(posn=? (world-food w)
(car (snake-segs (world-snake w)))))
;; snake-change-direction : Snake Direction -> Snake
;; Change the direction of the snake.
(define (snake-change-direction snk dir)
(snake dir
(snake-segs snk)))
;; world-change-dir : World Direction -> World
;; Change direction of the world.
(define (world-change-dir w dir)
(world (snake-change-direction (world-snake w) dir)
(world-food w)))
;; snake-eat : World -> World
;; Eat the food and generate a new one.
(define (snake-eat w)
(define i (add1 (random (sub1 BOARD-WIDTH))))
(define j (add1 (random (sub1 BOARD-HEIGHT))))
(world (snake-grow (world-snake w))
(posn i j)
#;(posn (- BOARD-WIDTH 1) (- BOARD-HEIGHT 1))))
(provide
world-change-dir
world->world)
| false |
61ca33b7a5c75278d5573fb60076d516bbcf463e | 7779e409be6f3238e811df9be8b7c89dd2986e06 | /src/arrayforth-def.rkt | 8ccde6dbd0fd0845522082bdc76786ed325b9342 | [
"BSD-3-Clause"
]
| permissive | mangpo/chlorophyll | ffba3d0f8659f8cad7246e70a43cfcb88847f25c | ab6d4268c5d12aa66eff817c678aaf7ebf935ba7 | refs/heads/master | 2020-04-16T01:43:55.873675 | 2016-07-08T13:11:21 | 2016-07-08T13:11:21 | 10,754,851 | 55 | 7 | null | 2016-07-08T13:11:21 | 2013-06-18T05:47:19 | Racket | UTF-8 | Racket | false | false | 24,495 | rkt | arrayforth-def.rkt | #lang racket
(require "header.rkt"
"arrayforth.rkt"
"arrayforth-print.rkt"
"arrayforth-miner.rkt")
(provide define-repeating-code define-repeating-codes aforth-linklist)
(define debug #f)
(define (list->linklist lst)
(define (copy x)
(if (block? x)
(block (block-body x) (block-in x) (block-out x)
(block-cnstr x) (block-incnstr x) (block-org x))
x))
(define (inner lst)
(if (empty? lst)
(linklist #f #f #f)
(let* ([rest (inner (cdr lst))]
[me (linklist #f (copy (car lst)) rest)])
(when rest
(set-linklist-prev! rest me))
me)))
(define non-empty (filter (lambda (x) (not (empty-block? x))) lst))
(define start (inner non-empty))
(define head (linklist #f #f start))
(set-linklist-prev! start head)
head)
(define (linklist->list lst)
(define (inner lst)
(if (linklist-entry lst)
(cons (linklist-entry lst) (inner (linklist-next lst)))
(if (linklist-next lst)
(raise "Invalid linklist: inproper tail.")
(list))))
(if (linklist-entry lst)
(raise "Invalid linklist: no head.")
(inner (linklist-next lst))))
(define (aforth-linklist ast)
(cond
[(list? ast)
(list->linklist (for/list ([x ast]) (aforth-linklist x)))]
;; [(linklist? ast)
;; (define (inner lst)
;; (if (linklist-entry lst)
;; (cons (aforth-linklist (linklist-entry lst))
;; (inner (linklist-next lst)))
;; (if (linklist-next lst)
;; (raise "Invalid linklist: inproper tail.")
;; (list))))
;; (if (linklist-entry ast)
;; (raise "Invalid linklist: no head.")
;; (inner (linklist-next ast)))
;; ]
[(forloop? ast)
(define init (forloop-init ast))
(forloop (if (list? init)
(list->linklist init)
(list->linklist (list init)))
(aforth-linklist (forloop-body ast))
(forloop-iter ast)
(forloop-from ast)
(forloop-to ast))]
[(ift? ast)
(ift (aforth-linklist (ift-t ast)))]
[(iftf? ast)
(iftf (aforth-linklist (iftf-t ast))
(aforth-linklist (iftf-f ast)))]
[(-ift? ast)
(-ift (aforth-linklist (-ift-t ast)))]
[(-iftf? ast)
(-iftf (aforth-linklist (-iftf-t ast))
(aforth-linklist (-iftf-f ast)))]
[(funcdecl? ast)
(funcdecl (funcdecl-name ast)
(aforth-linklist (funcdecl-body ast))
(funcdecl-simple ast))
]
[(aforth? ast)
(aforth (aforth-linklist (aforth-code ast))
(aforth-memsize ast) (aforth-bit ast) (aforth-indexmap ast)
(aforth-a ast) (aforth-position ast) (aforth-set-p ast))]
[else ast]))
;; return the first funcdecl in the given linklist
(define (first-funcdecl-linklist lst)
(if (funcdecl? (linklist-entry lst))
lst
(first-funcdecl-linklist (linklist-next lst))))
(define count 0)
;; Return new name for definition.
(define (new-def)
(set! count (add1 count))
(format "~arep" count))
(define (insert-definition from to program new-name)
(define (constrain-mem l)
(when (block? (linklist-entry l))
(set-restrict-mem! (block-cnstr (linklist-entry l)) #t))
(when (linklist-next l)
(constrain-mem (linklist-next l))))
;; set head for from
(define head (linklist #f #f from))
(set-linklist-prev! from head)
;; set tail for to
(set-linklist-next! to (linklist to #f #f))
(constrain-mem from)
;; (pretty-display `(insert-definition ,new-name))
;; (aforth-struct-print from)
;; insert new funcdecl into program
(define def-entry (first-funcdecl-linklist (aforth-code program)))
(define pre-entry (linklist-prev def-entry))
(define new-entry (linklist pre-entry (funcdecl new-name head #f) def-entry))
(set-linklist-next! pre-entry new-entry)
(set-linklist-prev! def-entry new-entry))
;; Mutate program by definig a new definition for the repeated structure.
;; lst is a list of linklists that point to the starting of the structure
;; at multiple places in the program.
(define (extract-structure lst program)
(when debug
(pretty-display `(extract-structure ,lst))
(aforth-struct-print lst)
)
;; args: list of linklists
;; return: true if their entries are the same
(define (same? x)
(let ([ele (linklist-entry (car x))])
(and (not (equal? ele #f))
(andmap (lambda (a) (aforth-eq? (linklist-entry a) ele))
(cdr x)))))
;; return a pair of
;; 1) list of common insts
;; 2) list of different list of insts
(define (common-prefix inst-lists)
(if (empty? (car inst-lists))
(cons (list)
inst-lists)
(let ([inst (caar inst-lists)])
(if (andmap (lambda (x) (and (not (empty? x)) (equal? (car x) inst)))
(cdr inst-lists))
;; if not empty and the first element is the same
(let ([res (common-prefix (map cdr inst-lists))])
(cons (cons inst (car res))
(cdr res)))
(cons (list)
inst-lists)))))
;; update block inside the linklists to the given code
(define (update linklists inst-lists location)
(for ([x-linklist linklists]
[x-code inst-lists])
;; TODO update in, out, org
(let* ([bbb (linklist-entry x-linklist)]
[cnstr (block-cnstr bbb)]
[org (if (string? (block-org bbb))
(string-split (block-org bbb))
(block-org bbb))]
[inout (estimate-inout x-code)]
[a (estimate-a x-code)]
[b (estimate-b x-code)]
[r (estimate-r x-code)]
)
(set-block-body! bbb x-code)
(set-block-in! bbb (car inout))
(set-block-out! bbb (cdr inout))
(set-block-cnstr! bbb (restrict (restrict-mem cnstr)
(or (restrict-a cnstr) a) b r))
(if (equal? location `front)
(set-block-org! bbb (string-join (take org (length x-code))))
(set-block-org! bbb (string-join (drop org (- (length org) (length x-code))))))
)))
;; (for ([x lst] [i (in-naturals)])
;; (pretty-display `(input ,i))
;; (aforth-struct-print (linklist-entry x))
;; (pretty-display `(prev ,i))
;; (aforth-struct-print (linklist-entry (linklist-prev x)))
;; (newline))
;; the first common entries
(define froms lst)
;; the last common entries
(define tos lst)
(define ref (linklist-entry (car lst)))
(define refs (map linklist-entry lst))
;; get previous entries in list of linklists x
;; (define (get-from x)
;; (if (and (not (aforth-eq? (linklist-entry (car x)) ref))
;; ;; compare to ref to ensure we don't extract overlapping chunk
;; (same? x))
;; (begin
;; (set! froms x)
;; (get-from (map linklist-prev x)))
;; x))
(define (get-from x)
(unless (same? x) (raise "arrayforth-def: extract-structure does not return structures that start with different blocks"))
(map linklist-prev x))
;; get next entries in list of linklists x
;; (define (get-to x)
;; (if (and (not (aforth-eq? (linklist-entry (car x)) ref))
;; ;; compare to ref to ensure we don't extract overlapping chunk
;; (same? x))
;; (begin
;; (set! tos x)
;; (get-to (map linklist-next x)))
;; x))
(define (get-to x)
(define overlap #f)
(for* ([i x] [ref refs] #:break overlap)
(set! overlap (or overlap (equal? i ref))))
(if (or overlap (not (same? x)))
x
(begin
(set! tos x)
(get-to (map linklist-next x)))))
;; the previous entries from the first common entries
;; (define from-diffs (get-from (map linklist-prev lst)))
(define from-diffs (get-from lst))
;; the next entries from the last common entries
(define to-diffs (get-to (map linklist-next lst)))
(define is-gap (not (aforth-eq?
(linklist-entry (first froms))
(linklist-entry (linklist-next (second tos))))))
;; (for ([from-diff from-diffs]
;; [to-diff to-diffs]
;; [i (in-naturals)])
;; (pretty-display `(from-diff ,i))
;; (aforth-struct-print (linklist-entry from-diff))
;; (pretty-display `(to-diff ,i))
;; (aforth-struct-print (linklist-entry to-diff))
;; (newline))
(define prefix #f)
(define prefix-org #f)
(define prefix-cnstr #f)
(define prefix-incnstr #f)
;; check that it is a linklist that contains block
(when (and is-gap
(andmap (lambda (x) (and (linklist? x) (block? (linklist-entry x))))
from-diffs))
;; if not off the list
(let* ([entry (linklist-entry (car from-diffs))]
[org (block-org entry)]
[first-insts (if (string? org) (string-split org) org)]
[revs (map (lambda (x)
(let* ([insts (block-body (linklist-entry x))]
[insts-list (if (list? insts) insts (string-split insts))])
(reverse insts-list)))
from-diffs)]
[pair (common-prefix revs)])
(update from-diffs (map reverse (cdr pair)) `front)
(set! prefix (reverse (car pair)))
(set! prefix-org (drop first-insts (- (length first-insts) (length prefix))))
(set! prefix-cnstr (block-cnstr entry))
(set! prefix-incnstr (block-incnstr entry))
))
(define suffix #f)
(define suffix-org #f)
(define suffix-cnstr #f)
(define suffix-incnstr #f)
;; check that it is a linklist that contains block
(when (and is-gap
(andmap (lambda (x) (and (linklist? x) (block? (linklist-entry x))))
to-diffs))
;; if not off the list
(let* ([entry (linklist-entry (car to-diffs))]
[org (block-org entry)]
[first-insts (if (string? org) (string-split org) org)]
[forwards (map (lambda (x)
(let* ([insts (block-body (linklist-entry x))]
[insts-list (if (list? insts) insts (string-split insts))])
insts-list))
to-diffs)]
[pair (common-prefix forwards)])
(update to-diffs (cdr pair) `back)
;; TODO suffix-org
(set! suffix (car pair))
(set! suffix-org (take first-insts (length suffix)))
(set! suffix-cnstr (block-cnstr entry))
(set! suffix-incnstr (block-incnstr entry))
))
(define new-name (new-def))
(define from (car froms))
(define to (car tos))
;; replace common sequences with funccalls
(for ([from froms]
[to tos])
(let* ([from-prev (linklist-prev from)]
[to-next (linklist-next to)]
[new-linklist (linklist from-prev (funccall new-name) to-next)])
(set-linklist-next! from-prev new-linklist)
(set-linklist-prev! to-next new-linklist)))
(when prefix
(let ([inout (estimate-inout prefix)]
[a (estimate-a prefix)]
[b (estimate-b prefix)]
[r (estimate-r prefix)]
)
(set! from (linklist #f
(new-block prefix (car inout) (cdr inout)
(restrict (restrict-mem prefix-cnstr)
(or (restrict-a prefix-cnstr) a)
b r)
prefix-incnstr
prefix-org)
from))))
(when suffix
(let* ([inout (estimate-inout suffix)]
[a (estimate-a suffix)]
[b (estimate-b suffix)]
[r (estimate-r suffix)]
[suffix-linklist (linklist to
(new-block suffix (car inout) (cdr inout)
(restrict (restrict-mem suffix-cnstr)
(or (restrict-a suffix-cnstr) a)
b r)
suffix-incnstr
suffix-org)
#f)])
(set-linklist-next! to suffix-linklist)
(set! to suffix-linklist)))
(insert-definition from to program new-name)
)
(define (extract-all-structure linklist-program)
(define same-structures (send (new structure-extractor%) visit linklist-program))
(when same-structures
(extract-structure same-structures linklist-program)
;; call itself until there is no more repeated structure found.
(extract-all-structure linklist-program)))
(define (extract-all-sequence linklist-program min-len occur)
(define (get-linklist ll index)
(define entry (linklist-entry ll))
(when debug
(if (block? entry)
(pretty-display `(get-linklist ,(block-body entry) ,index))
(pretty-display `(get-linklist ,(funccall-name entry) ,index))))
(define insts
(if (block? entry)
(if (string? (block-body entry))
(string-trim (block-body entry))
(string-join (block-body entry)))
(funccall-name entry)))
(define org
(if (block? entry)
(if (string? (block-org entry))
(string-trim (block-org entry))
(string-join (block-org entry)))
(funccall-name entry)))
(if (> (string-length insts) index)
(values ll index insts org)
(if (equal? insts "")
(get-linklist (linklist-next ll) index)
(get-linklist (linklist-next ll) (- index (string-length insts) 1))))) ;; minus 1 for space
;; Split linklist ll into 2 linklists by inserting a new linklist
;; after the splitted one.
(define (split-linklist ll index code org)
(when debug
(pretty-display `(split-linklist ,(substring code 0 index) ,(substring code index)))
(pretty-display "ll:")
(aforth-struct-print (linklist-entry ll)))
;; (pretty-display `(org ,org))
(let* ([n (length (string-split (substring code 0 index)))]
[code-list (string-split code)]
[org-list (string-split org)]
[insts (string-join (take code-list n))]
[fst-org (string-join (take org-list n))]
[inout (estimate-inout insts)]
[a (estimate-a insts)]
[b (estimate-b insts)]
[r (estimate-r insts)]
[entry (linklist-entry ll)]
[mem (restrict-mem (block-cnstr entry))]
[org-a (restrict-a (block-cnstr entry))]
[org-r (restrict-r (block-cnstr entry))]
[snd-insts (string-join (drop code-list n))]
[snd-org (string-join (drop org-list n))]
[snd-inout (estimate-inout snd-insts)]
[snd-a (estimate-a snd-insts)]
[snd-b (estimate-b snd-insts)]
[snd-r (estimate-r snd-insts)]
[snd-in (block-incnstr entry)]
[new-linklist (linklist ll
(if snd-org
(new-block snd-insts (car snd-inout) (cdr snd-inout)
;; need to handle a special because of @+/!+ opt
(restrict mem (or org-a snd-a) snd-b snd-r)
snd-in
snd-org)
(funccall snd-insts))
(linklist-next ll))])
(set-block-body! entry insts)
(set-block-org! entry fst-org)
(set-block-in! entry (car inout))
(set-block-out! entry (cdr inout))
;; need to handle a special because of @+/!+ opt
(set-block-cnstr! entry (restrict mem (or org-a a) b r))
(set-linklist-prev! (linklist-next ll) new-linklist)
(set-linklist-next! ll new-linklist)))
(define (replace-with head func exp)
(define ll (linklist-next head))
(define pair (first-location exp ll))
(define from (car pair))
(define to (cdr pair))
(define len (- to from))
(define-values (ll-from index-from code-from org-from) (get-linklist ll from))
(when (> index-from 0)
(when debug (pretty-display "(> index-from 0)"))
(split-linklist ll-from index-from code-from org-from)
(set! ll-from (linklist-next ll-from))
)
(define-values (ll-to index-to code-to org-to) (get-linklist ll-from (sub1 len)))
(when debug
(pretty-display "----------------------")
(pretty-display "ll-from:")
(aforth-struct-print (linklist-entry ll-from))
(pretty-display `(len ,len))
(pretty-display "ll-to:")
(aforth-struct-print (linklist-entry ll-to))
(pretty-display `(,index-to ,code-to ,org-to)))
(set! index-to (add1 index-to))
(when (< index-to (string-length code-to))
(when debug (pretty-display "(< index-to)"))
(split-linklist ll-to index-to code-to org-to)
(when debug (pretty-display "(< index-to) done"))
)
(define from-prev (linklist-prev ll-from))
(define to-next (linklist-next ll-to))
(when debug
(pretty-display "from-prev:")
(aforth-struct-print (linklist-entry from-prev))
(pretty-display "ll-from:")
(aforth-struct-print (linklist-entry ll-from))
(pretty-display "ll-to:")
(aforth-struct-print (linklist-entry ll-to))
(pretty-display "to-next:")
(aforth-struct-print (linklist-entry to-next)))
(define new-linklist (linklist from-prev func to-next))
(set-linklist-next! from-prev new-linklist)
(set-linklist-prev! to-next new-linklist)
(cons ll-from ll-to)
)
(define (define-and-replace locations exp)
(define new-name (new-def))
(when debug (pretty-display locations))
(define res-list
(for/list ([location locations])
(replace-with location (funccall new-name) exp)))
(define res (car res-list))
(define (combine-restriction lst)
;; combine restriction in the first one.
(define first-item (car lst))
(when (block? (linklist-entry first-item))
(define first-block (linklist-entry first-item))
(define a #f)
(define b #f)
(define mem #f)
(define r #f)
(for ([item (map linklist-entry lst)])
(set! a (or a (restrict-a (block-cnstr item))))
(set! b (or b (restrict-b (block-cnstr item))))
(set! r (or r (restrict-r (block-cnstr item))))
(set! mem (or mem (restrict-mem (block-cnstr item)))))
(set-restrict-a! (block-cnstr first-block) a)
(set-restrict-b! (block-cnstr first-block) b)
(set-restrict-r! (block-cnstr first-block) r)
(set-restrict-mem! (block-cnstr first-block) mem))
(unless (equal? first-item (cdr res))
(combine-restriction (map linklist-next lst))))
(combine-restriction (map car res-list))
(when (block? (linklist-entry (car res)))
;; If initial state constraints of the repeating seqeunces are different,
;; need to set it to false.
(let* ([def-block (linklist-entry (car res))]
[incnstr (block-incnstr def-block)]
[same
(for/and ([x (cdr res-list)])
(equal? (block-incnstr (linklist-entry (car x))) incnstr))])
(unless same
(set-block-incnstr! def-block #f))))
(insert-definition (car res) (cdr res) linklist-program new-name))
(define-values (seqs max-len) (send (new sequence-miner%) visit linklist-program))
(define subseqs (sort-subsequence seqs min-len max-len
(add1 (quotient (* 4 occur) (sub1 occur)))))
(when debug (pretty-display subseqs))
(for ([subseq subseqs])
(let* ([str (string-join subseq)]
[push-pos (regexp-match-positions #rx"push" str)]
[pop-pos (regexp-match-positions #rx"pop" str)])
;; Define repeating sequence if "push" and "pop" won't mess up
;; the return stack.
(when (and (= (length (regexp-match* #rx"push" str))
(length (regexp-match* #rx"pop" str)))
(or (not push-pos) (< (caar push-pos) (caar pop-pos))))
(let* ([reformatted (string-replace (string-replace str "+" "\\+") "*" "\\*")]
[exp (regexp reformatted)]
[matcher (new sequence-matcher% [exp exp])]
[locations (send matcher visit linklist-program)])
(when debug
(pretty-display (format "SEQ: ~a OCCUR: ~a" str (length locations))))
(when (>= (length locations) occur)
;; if repeat more then a certain number
(when debug (pretty-display (format "STRING: ~a" reformatted)))
(define-and-replace locations exp)
;;(aforth-syntax-print linklist-program 2 2)
))
)
))
;(aforth-struct-print linklist-program)
)
(define (reorder-definition program dependency-collector)
(define (get-funcdecl lst)
(define entry (linklist-entry lst))
(if (funcdecl? entry)
(cons (cons entry (send dependency-collector visit entry))
(get-funcdecl (linklist-next lst)))
(list)))
;; Return a topo sorted list of funcdecls
(define (topo-sort lst)
(when debug (pretty-display `(topo-sort ,lst)))
(if (empty? lst)
lst
(let* ([fst (findf (lambda (pair) (set-empty? (cdr pair))) lst)]
[func (car fst)]
[name (funcdecl-name func)]
[rst (remove fst lst
(lambda (x y) (equal? (funcdecl-name (car x)) (funcdecl-name (car y)))))]
[updated (map (lambda (pair) (cons (car pair)
(set-remove (cdr pair) name)))
rst)])
(cons func (topo-sort updated)))))
(define start (first-funcdecl-linklist (aforth-code program)))
(define funcdecls (topo-sort (get-funcdecl start)))
(define new-start (list->linklist funcdecls))
(set-linklist-next! (linklist-prev start) (linklist-next new-start))
(set-linklist-prev! (linklist-next new-start) (linklist-prev start))
)
(define (define-repeating-code program dependency-collector)
(if (and program (aforth-code program))
(let ([linklist-program (aforth-linklist program)])
(when debug (pretty-display ">>> EXTRACT-STRUCTURES"))
(extract-all-structure linklist-program)
(when debug (pretty-display ">>> EXTRACT-SEQUENCES"))
(extract-all-sequence linklist-program 6 2)
;; TODO: if the code doesn't fit in, do this
;(when debug (pretty-display ">>> EXTRACT-SEQUENCES"))
;(extract-all-sequence linklist-program 3 4)
(reorder-definition linklist-program dependency-collector)
;(send (new block-merger%) visit linklist-program)
linklist-program
)
program)
)
(define (define-repeating-codes programs w h)
(define dependencies '())
(define (topo-sort lst)
(when debug (pretty-display `(this-topo-sort ,lst)))
(if (empty? lst)
lst
(let* ([fst (findf (lambda (pair) (set-empty? (cdr pair))) lst)]
[func (cdar fst)]
[name (caar fst)]
[rst (remove fst lst
(lambda (x y) (equal? (caar x) (caar y))))]
[updated (map (lambda (pair) (cons (car pair)
(set-remove (cdr pair) name)))
rst)])
(cons func (topo-sort updated)))))
(define res (make-vector (* w h)))
(define program #f)
(define repeating #f)
(define collector (new dependencey-collector% [w w]))
(define core #f)
(for ([i (in-range (* w h))])
(pretty-display
(format "--------------- define-repeating ~a ------------------" i))
(set! core (core-id i w))
(set! program (vector-ref programs i))
(set-field! dependent-nodes collector (set))
(set! repeating (define-repeating-code program collector))
(vector-set! res i repeating)
(set! dependencies
(cons (cons (cons core repeating)
(get-field dependent-nodes collector)
;; (for/set ([d (get-field dependent-nodes collector)])
;; (core-id d w))
)
dependencies))
)
(for ((node (topo-sort dependencies))
(i (* w h)))
(when node
(set-aforth-position! node i)))
res)
| false |
3ce95dd11077e2dcda9724dbc44c5dd5983f4b0b | 5a19631a10bab15dafa5353bfb2faa454e5be6b9 | /ESI_2021/ps.scrbl | 7585cbada6c4ccc839fcd7fe58f872228a4890f8 | []
| no_license | amkhlv/talks | 3d14256dbf58c9c5534fdca585bad0055cf31371 | 04ab693beffb4c132fd83577b28c6472fd27bd34 | refs/heads/master | 2021-09-08T07:40:54.579550 | 2021-09-04T17:50:50 | 2021-09-04T17:50:50 | 14,686,398 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 27,384 | scrbl | ps.scrbl | #lang scribble/base
@(require racket scribble/core scribble/base scribble/html-properties)
@(require "defs.rkt" bystroTeX/common bystroTeX/slides (for-syntax bystroTeX/slides_for-syntax))
@; ---------------------------------------------------------------------------------------------------
@; User definitions:
@(bystro-set-css-dir (build-path (find-system-path 'home-dir) "a" "git" "amkhlv" "profiles" "talk"))
@(define bystro-conf
(bystro (bystro-connect-to-server (build-path (find-system-path 'home-dir) ".config" "amkhlv" "latex2svg.xml"))
"ps/formulas.sqlite" ; name for the database
"ps" ; directory where to store image files of formulas
25 ; formula size
(list 255 255 255) ; formula background color
(list 0 0 0) ; formula foreground color
2 ; automatic alignment adjustment
0 ; manual alignment adjustment
))
@(define singlepage-mode #f)
@(bystro-def-formula "formula-enormula-humongula!")
@title[#:style '(no-toc no-sidebar)]{Pure spinor string}
@bystro-source[]
@bystro-ribbon[]
@table-of-contents[]
@bystro-ribbon[]
@page[@elem{Pure spinor sigma-model in @f{AdS_5\times S^5}: Main Action} #:tag "AdSPureSpinorMainAction" #:showtitle #t]
Let @f{G = PSU(2,2|4)} be the superconformal group,
@f{{\bf g} = \mbox{Lie} G}, it has some @f{{\bf Z}_4} grading:
@e{
{\bf g} = {\bf g}_{\bar{0}} + {\bf g}_{\bar{1}} + {\bf g}_{\bar{2}} + {\bf g}_{\bar{3}}
}
The zero grading part @f{{\bf g}_{\bar{0}}} is the Lie algebra of:
@e{
SO(1,4)\times SO(5)
}
The @f{AdS_5\times S^5} is a coset space:
@e{
{PSU(2,2|4)\over SO(1,4)\times SO(5)}
}
@image{ps/target-space.svg}
Consider the cone in the spin bundle
over @f{AdS_5\times S^5}, parametrized by @f{\lambda_3} and @f{\lambda_1} satisfying the pure
spinor constraints:
@e[#:label "IntroPSCone"
]{
\lambda_3^{\alpha}\Gamma_{\alpha\beta}^m\lambda_3^{\beta} =
\lambda_1^{\hat{\alpha}}\Gamma_{\hat{\alpha}\hat{\beta}}^m\lambda_1^{\hat{\beta}} = 0
}
We will call this space @f{M}. It is parametrized by coordinates @f{g\in PSU(2,2|4)}
modulo the equivalence relation @f{g\simeq hg} (the @f{AdS_5\times S^5}) and @f{\lambda_3,\lambda_1}.
The coordinates
of the base (@italic{i.e.} @f{g,\lambda_3,\lambda_1}) are ``fields''. The coordinates of the fiber
are ``antifields''.
The BV Main Action is a functional on this space of maps. It consists of two terms:
@e{
S_{\rm BV} = S_0 + \widehat{Q}
}
where @f{S_0} depends on fields only, while @f{\widehat{Q}} is a function of the fields
and antifields, linear in the antifields.
@subpage[1 @elem{The structure of @f{\widehat{Q}}} #:tag "sec:StructureOfQHat"]
We think of @f{\widehat{Q}} as a generating function of a nilpotent vector field @f{Q} on the space of maps:
@e{
i\;:\;\Sigma \rightarrow M
}
In fact, this vector
field comes from a vector field on @f{M} which we also call @f{Q}. It is:
@(align
r.l.n
`(@,f{Q \;\in\;} @,f{\mbox{Vect}(M)} "")
`(@,f{Qg \;=\;} @,f{(\lambda_3 + \lambda_1)g} @,label{Qong})
)
@subpage[1 @elem{The structure of @f{S_0}} #:tag "sec:StructureOfS0"]
The @f{S_0} depends on fields only, it is often denoted ``@f{S_{cl}}''. In our ``minimalistic''
sigma-model it is equal to the pullback to @f{\Sigma} of some two-form @f{\cal B} on @f{M}:
@e{
S_0 = \int_{\Sigma} i^*{\cal B}
}
This two-form is given by the formula:
@(align
r.l.n
`(@,f{\cal B\;\in\;} @,f{\Omega^2(M)} "")
`(@,f{\cal B\;=\;}
@,f{
\mbox{STr}
\left((dgg^{-1})_{\bar 3} \wedge ({\bf 1} - 2{\bf P}_{13}) (dgg^{-1})_{\bar 1}\right)
}
@,label{CalB})
)
where @f{{\bf P}_{13}} is a projector on the tangent space to the pure spinor cone
at the point @f{\lambda_1} along the subspace generated by expressions of the form
@f{[v_2,\lambda_3]} when @f{v_2\in {\bf g}_2}.
The main property of @f{\cal B} is that @f{d{\cal B}} is @f{Q}-base:
@e{
\iota_Q d{\cal B} = 0
}
Perhaps we can say that @f{d{\cal B}} represents a cohomology class of @f{M/{\bf R}^{0|1}}
where @f{{\bf R}^{0|1}} is generated by @f{Q}.
On the other hand we can consider the restriction to the fiber:
@e{
V = {\cal B}|_{T{\bf R}^{0|1}}
}
This is called ``unintegrated vertex operator''.
@subpage[1 "Global symmetries" #:tag "sec:GlobalSymmetries"]
Global symmetries act on @f{g} by constant right shifts:
@e{
R_a g = g t_a
}
@page["Additional fields and regularization" #:tag "Regularization" #:showtitle #t]
@bystro-local-toc[]
@subpage[1 @elem{Problems with @f{S_{\rm BV}}} #:tag "sec:ProblemsWithSBV"]
We observe the following problems:
@(itemlist
#:style 'ordered
@item{The ghost field @f{\lambda} lives on a cone --- singular target space!}
@item{Action is not a polynomial function of @f{\lambda}}
@item{The ghost field @f{\lambda} enters without derivatives (no kinetic term?)}
@item{The action for @f{g} is weird (only contains a 2-form, no usual kinetic term)}
)
We will not repair @bold{item 1}.
But we will repair @bold{items 2,3,4} by introducing extra fields and choosing an appropriate
Lagrangian submanifold.
@subpage[1 @elem{Structure of denominators in @f{\cal B}} #:tag "sec:StructureOfDenominators"]
This @f{\cal B} has denominator, but only of a very special kind.
The denominator only enters through:
@(align
r.l.n
`("" @,f{{\bf P}_{13} J_{\bar 1}} "")
`(@,elem{where } @,f{J = -dg g^{-1}} "")
)
and a similar expression with @f{1\leftrightarrow 3}. These expressions have one crucial
property: the BRST variation of them does not have denominators. Namely:
@e{
Q {\bf P}_{13} J_{\bar 1} = - D_{0}\lambda_1
}
This hints at how the denominators can be actually removed.
Let us first discuss some general construction. Suppose I have a BV action @f{S_{\rm BV}} whose expansion
in powers of antifields terminates at the linear terms. Suppose that we are given a set
of local operators
@f{\{{\cal O}_1,\ldots,{\cal O}_N\}}, which are built only from fields (@italic{i.e.} do not contain antifields).
Suppose that we can construct out of them
a volume element @f{\mu({\cal O}_1,\ldots,{\cal O}_N)} on @f{\Sigma}. (For example, if @f{{\cal O}_1} and @f{{\cal O}_2}
are one-forms, we may take @f{\mu({\cal O}_1,{\cal O}_2) = {\cal O}_1\wedge {\cal O}_2}.)
Then, consider the following half-density:
@e[#:label "NewHalfDensity"]{
\rho_{\rm new} \;=\;
\exp\left(S_{\rm BV} + \int_{\Sigma}\mu({\cal O}_1,\ldots,{\cal O}_N)\right)
\prod_{i=1}^N\delta (Q{\cal O}_i)
}
(while @f{\rho_{\rm old}} was just @f{e^{S_{\rm BV}}}).
Then @f{\rho_{\rm new}} satisfies the
Main Equation.
@subpage[1 @elem{Adding @f{w} and @f{w^{\star}}} #:tag "sec:AddingW"]
@subpage[2 "General construction" #:tag "sec:GeneralConstruction"]
We will now interpret Eq. (@ref{NewHalfDensity}) as a field theory by introducing the
Lagrange multipliers. Namely, we represent:
@e{
\delta (Q{\cal O}_i) = \int [dw^i] \exp\left(\int_{\Sigma} w^i\;Q{\cal O}_i\right)
}
This is a different theory. Moreover, different sets @f{\{{\cal O}_1,\ldots,{\cal O}_N\}}
and choices of @f{\mu({\cal O}_1,\ldots,{\cal O}_N)} give different theories. We can think of it as introducing
an extra field-antifield pair @f{w^i, w^{\star}_i} for each @f{{\cal O}_i} with
@f{
S_{\rm BV}^{\{w\}} = \int_{\Sigma} \mu(w^{\star}_1,\ldots,w^{\star}_N)
}
and then taking the Lagrangian submanifold where @f{w^{\star}_i = 0} and deforming it
with the gauge fermion:
@e{
\Psi = \int_{\Sigma} w^i {\cal O}_i
}
@subpage[2 "Applying to the pure spinor sigma-model" #:tag "sec:PureSpinorW"]
Now, we choose:
@(align
r.l.n
`(@,elem[#:style 'no-break]{1st approx: }
@,f{\left\{{\cal O}_i\right\} = \left\{ {\bf P}_{31} J_3 \mbox{ \tt and } {\bf P}_{13} J_1 \right\}}
"")
)
And the construction of @f{\mu} is the following. As we explained, all
denominators come either @italic{via} @f{{\bf P}_{31}J_3} or @italic{via} @f{{\bf P}_{13}J_1}.
We just replace:
@(align
r.l.n
`(@,f{{\bf P}_{31}J_3\;\longrightarrow\;} @,f{\omega_3^{\star}} @,label{ReplacePJ3})
`(@,f{{\bf P}_{13}J_1\;\longrightarrow\;} @,f{\omega_1^{\star}} @,label{ReplacePJ1})
)
Literally doing this is wrong, because the kinetic terms becomes:
@e{
\mbox{STr}(\omega_1\wedge d\lambda_3) + \mbox{STr}(\omega_3\wedge d\lambda_1)
}
But I want @bold{chiral} kinetic terms: left-moving @f{\lambda_3} and right-moving @f{\lambda_1}.
I could have said, let us restrict @f{\omega^{\star}_3} to only have @f{\overline{dz}}-component,
and @f{\omega^{\star}_1} to only have @f{dz}-component. But I dont want to break diffeomorphism
invariance at the level of the BV Main Action. In string theory the Main Action should be
invariant under diffeomorphisms. Therefore, I will leave @f{\omega} and @f{\omega^{\star}} generic
1-forms on @f{\Sigma}.
Just to completely fix the notations, the odd sympectic form is:
@e{
\omega_{\rm BV} = \int_{\Sigma} \mbox{STr}\left( \delta\omega^{\star}_3\wedge \delta\omega_1 + \delta\omega^{\star}_1\wedge \delta\omega_3\right)
}
@subpage[1 "The full Main Action" #:tag "sec:FullMainAction"]
We define the BV Main Action as follows:
@(align
r.l.n
`(""
@,f{S^{+}_{\rm BV} = \int_{\Sigma} i^*{\cal B} + \widehat{Q} + \int_{\Sigma} \mbox{STr}(\omega_3^{\star} \wedge\omega_1^{\star})}
@,label{HatSBV})
)
and gauge fermion:
@(align
r.l.n
`(@,elem{(tentative)}
@,f{\Psi \;=\; \int_{\Sigma}
\mbox{STr}\left(
\omega_3 \wedge {\bf P}_{13} J_1
+
\omega_1 \wedge {\bf P}_{31} J_3
\right)}
"")
)
Naively this seems to be the sum of two non-interacting theories
(one for @f{g,\lambda} and another for @f{w}), but there is an important subtlety.
I want @f{w} and @f{w^{\star}} to live in a nontrivial vector bundle over AdS, namely in @f{{\bf g}_{\rm odd}}.
@subpage[1 "Gluing charts" #:tag "sec:Gluing"]
@subpage[2 "Vector bundle" #:tag "sec:VectorBundle"]
Let @f{M} be a manifold, parameterized by @f{\phi}, and @f{S_{\rm BV}} on @f{\Pi TM^*}
of the form:
@e{
S_{\rm BV}(\phi,\phi^{\star}) = S_{cl}(\phi) + Q^{\mu}(\phi)\phi^{\star}_{\mu}
}
Let @f{H} be a Lie group. Suppose that we are given some vector bundle
over @f{M} with a fiber @f{W} --- a symplectic linear space with the action of @f{H}.
Consider the action which in a local trivialization looks like:
@e{
S_{\rm tot} \;=\;
S_{(\phi)} + S_{(w)} = S_{\rm cl}(\phi) + Q^{\mu}(\phi)\phi^{\star}_{\mu} \;+\;
{1\over 2}w^{\star}_a (\Omega^{-1})^{ab} w^{\star}_b
}
where @f{\Omega} is the symplectic form of @f{W}.
@subpage[2 "Transition functions" #:tag "sec:TransitionFunctions"]
We want the transition functions to be canonical transformations preserving @f{S_{\rm tot}}.
We can choose the transition functions to be @f{\{S_{\rm tot},\_\}}-exact:
@(align
r.l.n
`(""
@,f{\chi_{\alpha} \;=\;\left\{S_{\rm tot} , F_{\alpha}\right\}}
@,label{DefHXi})
`(""
@,f{\mbox{\tt\small where } F_{\alpha} \;=\;-{1\over 2}w^b\rho_*(\alpha(\phi))_b^a\;\Omega_{ac}\;w^c}
@,label{DefFXi})
`(""
@,f{\chi_{\alpha} \;=\; \rho_*(\alpha(\phi))^a_bw^b \;w^{\star}_a
\;-\; {1\over 2} w^b\rho_*(Q\alpha(\phi))^a_b\Omega_{ac}w^c}
"")
)
Notice that:
@e[#:label "FsInInvolution"]{
\{F_{\alpha},F_{\beta}\} = 0
}
@e[#:label "EquivarianceOfF"]{
\left\{\chi_{\alpha_1}\;,\;F_{\alpha_2}\right\}\;=\;- F_{[\alpha_1,\alpha_2]}
}
This canonical transformation does not touch @f{\phi^{\mu}}, it only acts on @f{\phi^{\star}, w, w^{\star}}. We identify
@f{(\phi, \phi^{\star}_{i}, w_{i}, w^{\star}_{i})} on chart @f{U_{(i)}} with @f{(\phi,\phi^{\star}_{j}, w_{j}, w^{\star}_{j})} on chart @f{U_{(j)}} when
@f{(\phi^{\star}_{j}, w_{j}, w^{\star}_{j})} is the flux of @f{(\phi_i^{\star}, w_{i}, w^{\star}_{i})} by the time @f{1} along the vector field
@f{\{\chi_{\alpha_{ji}},\_\}} where @f{\alpha_{ji}} is the log of @f{u_{ji}}, @italic{ i.e.} @f{u_{ji} = e^{\alpha_{ji}}}. Explicitly:
@(align
r.l.n
`(""
@,f{w_{j}^a \;=\;\rho\left(u_{ji}\right)^a_bw^b_{i}}
@,label{RotationOfW})
`(""
@,f{w^{\star}_{ja} \;=\;\rho\left(u_{ji}^{-1}\right)_a^b\; w^{\star}_{ib}
\; - \; \Omega_{ab}\;Q\rho\left(u_{ji}\right)^b_c \; w^c_{i}}
@,label{RotationAndShiftOfWStar})
`(""
@,f{\phi^{\star}_{j\mu} \;=\;\phi^{\star}_{i\mu} -
w^{\star}_{ja}\rho_*\left(u_{ji}\stackrel{\leftarrow}{\partial \over\partial\phi^{\mu}}u_{ji}^{-1}\right)_b^aw_{j}^b
- {1\over 2}w^a_{j}\Omega_{ab}
{\partial\over\partial\phi^{\mu}}\rho_*\left(Qu_{ji} u_{ji}^{-1}\right)^b_cw_{j}^c}
@,label{ShiftOfPhiStar})
)
Given these transition functions, how can we construct a Lagrangian submanifold?
The ``standard'' construction @f{\phi^{\star} = w^{\star} = 0} does not work because @f{w^{\star}=0} is not
invariant under transition functions.
On every chart, let us pass to a new set of Darboux coordinates, by doing the canonical
transformation with the following gauge fermion:
@e{
\Psi_{i} = {1\over 2}w^a_{i}\;\Omega_{ab} \; Q^{\mu}(\phi)\rho_*(A_{i\mu}(\phi))^b_c\; w^c_{i}
}
The new @f{S_{\rm BV}} will contain the term @f{\tilde{w}^{\star}Q^{\mu}\rho_*(A_{i\mu})\tilde{w}}, which means that the action of the BRST
operator on @f{\tilde{w}} involves the connection. On the other hand, the transition functions simplify:
@(align
r.l.n
`(@,f{\tilde{w}_{j}^a \;=\;}
@,f{\rho\left(u_{ji}(\phi)\right)^a_b\tilde{w}^b_{i}}
@,label{SimplifiedRotationOfW})
`(@,f{\tilde{w}^{\star}_{ja} \;=\;}
@,f{\rho\left(u_{ji}(\phi)^{-1}\right)_a^b\; \tilde{w}^{\star}_{ib}}
@,label{SimplifiedRotationOfWStar})
`(@,f{\tilde{\phi}^{\star}_{j\mu} \;=\;}
@,f{\tilde{\phi}^{\star}_{i\mu} - \tilde{w}^{\star}_{ic}
\rho\left(u_{ji}(\phi)^{-1}\right)^c_a
\left(
\rho\left(u_{ji}(\phi)
\right)^a_b
\stackrel{\leftarrow}{\partial\over\partial\phi^{\mu}}
\right) \tilde{w}_{i}^b \;}
@,label{SimplifiedPhiStar})
)
These are the usual transition functions of the odd cotangent bundle @f{\Pi T^* {\cal W}}, where @f{\cal W}
is the vector bundle with the fiber @f{W}, associated to the principal vector bundle @f{E\stackrel{H}\rightarrow B}.
In particular, the ``standard'' Lagrangian submanifold @f{\tilde{w}^{\star}=\tilde{\phi}^{\star}=0} is compatible with gluing.
The corresponding BRST operator is defined by the part of the BV action linear in the antifields:
@e{
Q_{\rm BRST} \;=\;Q^{\mu}{\partial\over\partial\phi^{\mu}} + Q^{\nu}\rho_*(A_{\nu})^a_b\tilde{w}^b{\partial\over\partial \tilde{w}^a}
}
@subpage[1 @elem{Lagrangian submanifold mixes @f{w} with @f{\lambda} and breaks @f{{\rm Diff}(\Sigma)}} #:tag "L0"]
Let us choose vector fields @f{\nabla}, @f{\overline{\nabla}} ---
some sections of @f{{\bf C}\otimes T^1\Sigma}
(@italic{i.e.} complex vector fields on the worldsheet).
We assume that @f{\nabla} and @f{\overline{\nabla}} form a basis.
In other words exist complex 1-forms @f{\alpha} and @f{\overline{\alpha}} such that:
@(align
r.l.n
`(@,f{\nabla\otimes \alpha + \overline{\nabla}\otimes \overline{\alpha} = {\bf 1}\;:\;}
@,f{T\Sigma \longrightarrow T\Sigma}
@,label{NablaAndAlpha})
`(@,elem[#:style 'no-break]{that is: }
@,f{\iota(\nabla)\overline{\alpha} = \iota(\overline{\nabla})\alpha = 0
\mbox{ \tt\small and }
\iota(\nabla)\alpha = \iota(\overline{\nabla})\overline{\alpha} = 1}
"")
)
(Example: @f{\nabla = \partial_z} and @f{\alpha = dz}.)
We define the Lagrangian submanifold as the odd conormal bundle of the
following constraint surface:
@(align
r.l.n
`(@,f{({\bf 1} - {\bf P}_{13}) \omega_1 \;=\;}
@,f{0}
@,label{Conormal1})
`(@,f{({\bf 1} - {\bf P}_{31}) \omega_3 \;=\;}
@,f{0}
@,label{Conormal3})
`(@,f{\iota(\overline{\nabla})\omega_1 \;=\;} @,f{0}
@,label{Conormal1Sym})
`(@,f{\iota({\nabla})\omega_3 \;=\;} @,f{0}
@,label{Conormal3Sym})
)
@comment{
The last two break the diffeomorphism invariance.
The purpose of this constraint is to kill half of the components of
@f{\omega} in the direction tangent to the cone.
}
In other words:
@(align
r.l.n
`(@,f{\omega_1\;=\;}
@,f{{\bf P}_{13} w_{1+} \alpha}
"")
`(@,f{\omega_3\;=\;}
@,f{{\bf P}_{31} w_{3-} \overline{\alpha}}
"")
)
The fiber of the conormal bundle can be parameterized by fermionic 1-form fields
@f{v^{\star}_3}, @f{v^{\star}_1}, and fermionic scalar fields @f{w^{\star}_3} and @f{w^{\star}_1}:
@(align
r.l.n
`(@,f{\omega_3^{\star}\;=\;}
@,f{({\bf 1} - {\bf P}_{31})v^{\star}_3 + {\bf P}_{31}w^{\star}_{3+}\alpha}
"")
`(@,f{\lambda_3\;=\;}
@,f{\ldots}
"")
`(@,f{\omega_1^{\star}\;=\;}
@,f{({\bf 1} - {\bf P}_{13})v^{\star}_1 + {\bf P}_{13}w^{\star}_{1-}\overline{\alpha}}
"")
`(@,f{\lambda_1\;=\;}
@,f{\ldots}
"")
)
We need to remove the denominator due to @f{{\bf P}_{31}}. This is done by the following gauge fermion:
@(align
r.l.n
`(""
@,f{\Psi \;=\; \int_{\Sigma}
\mbox{STr}\left(
\omega_3 \wedge {\bf P}_{13} (dg g^{-1})_1
+
\omega_1 \wedge {\bf P}_{31} (dg g^{-1})_3
\right)}
"")
)
This generates the kinetic term for @f{\lambda}s:
@e{
\int_{\Sigma}
\mbox{STr}\left(
w_{3-}\overline{\alpha}\wedge d\lambda_1
+
w_{1+}\alpha\wedge d\lambda_3
\right)
\;=\;
\int_{\Sigma} \alpha\wedge\overline{\alpha}\;
\mbox{STr}\left(
w_{3-}\nabla \lambda_1 + w_{1+}\overline{\nabla} \lambda_3
\right)
}
(pops up when we hit @f{dg g^{-1}} with @f{Q}).
At the same time @f{\int_{\Sigma} \mbox{STr}\left(\omega_3^{\star} \wedge \omega_1^{\star}\right)}
gives:
@(align
r.l.n
`(""
@,f{\int_{\Sigma} \mbox{STr}
\left(
\left(\omega_3^{\star} + {\bf P}_{31}(dgg^{-1})_3\right)
\wedge
\left(\omega_1^{\star} + {\bf P}_{13}(dgg^{-1})_1\right)
\right) \mapsto}
"")
`(@,f{\mapsto}
@,f{\int_{\Sigma} \mbox{STr}
\left(
\left(
({\bf 1} - {\bf P}_{31})v_3^{\star}
+
{\bf P}_{31} (w_{3+}^{\star}\alpha + (dgg^{-1})_3)
\right)
\wedge
\left(
({\bf 1} - {\bf P}_{13})v_1^{\star}
+
{\bf P}_{13} (w_{1+}^{\star}\alpha + (dgg^{-1})_1)
\right)
\right)}
"")
)
Integration over @f{v^{\star}} decouples. Integration over @f{w_{3+}^{\star}}
projects @f{{\bf P}_{31}(dg g^{-1})_3} to @f{{\bf P}_{31}(\overline{\nabla}g g^{-1})_3\overline{\alpha}}. Integration over @f{w_{1-}^{\star}} projects
@f{{\bf P}_{13}(dg g^{-1})_1} to @f{{\bf P}_{13}(\nabla g g^{-1})_1\alpha}.
We are left with:
@e[#:label "XY"]{
\int_{\Sigma} \alpha\wedge \overline{\alpha}\;
\mbox{STr}\left((\nabla gg_{-1})_1\wedge {\bf P}_{31}(\overline{\nabla} gg_{-1})_3\right)
}
This term should cancel the denominators --- see Eq. (@ref{CalB}).
But it is not antisymmetric under @f{+ \leftrightarrow -}.
It turns out that we can further deform the Lagrangian submanifold, so that effectively
@e{
{\cal B} \mapsto {\cal B} + {\cal G}
}
where @f{\cal G} is worldsheet parity even.
(See 〚@seclink["sec:BGhostAsSymmetricTensor"]{@secref{sec:BGhostAsSymmetricTensor}}〛.)
It is important for us that the term in @f{\cal G}
containing @f{{\bf P}_{31}} combine with the term in @f{\cal B} containing @f{{\bf P}_{31}} into the expression
given by Eq. (@ref{XY}). This expression is rather special. Indeed, it has the form:
@e{
\int_{\Sigma} dz^{\alpha}\wedge dz^{\beta}
\;
Y_{\alpha}^{\alpha'}(z,\bar{z}) \overline{Y}_{\beta}^{\beta'}(z,\bar{z})
\;
A_{\mu\nu}(x)
\;
\partial_{\alpha'}x^{\mu} \partial_{\beta'}x^{\nu}
}
where
@e{
\mbox{det} Y = \mbox{det} \overline{Y} = 0
}
and
@e{
\mbox{det}(Y\otimes \overline{Y}) = {\bf 1}\;:\;\Lambda^2{\bf C}^2 \longrightarrow \Lambda^2{\bf C}^2
}
(Indeed, @f{Y = \nabla\otimes\alpha} and @f{\overline{Y} = \overline{\nabla}\otimes\overline{\alpha}}.)
This implies that @f{Y_{[\alpha}^{(\alpha'}\overline{Y}_{\beta]}^{\beta')}} is of the form:
@e{
Y_{[\alpha}^{(\alpha'}\overline{Y}_{\beta]}^{\beta')}
= \epsilon_{\alpha\beta} \sqrt{h} h^{\alpha'\beta'}
}
In other words, the parity-even part of Eq. (@ref{XY}) is of the form:
@e{
\int d^2z \sqrt{h} h^{\alpha\beta} {\cal G}_{\mu\nu}\partial_{\alpha} x^{\mu} \partial_{\beta} x^{\nu}
}
@(hyperlink
"https://andreimikhailov.com/slides/talk_ESI_2021/bosonic/IntroductionString.html#%28part._sec%7E3a.Nonlinearity%29"
"As in the case of bosonic string")
this is @bold{not} of the most general form
@f{\int d^2z a^{\alpha\beta} {\cal G}_{\mu\nu}\partial_{\alpha} x^{\mu} \partial_{\beta} x^{\nu}},
as @f{a^{\alpha\beta}} is restricted to be of the form @f{\sqrt{h}h^{\alpha\beta}} --- a nonlinear
constraint. The mechanism, however, is quite different from what it was in bosonic string.
@subpage[1 @elem{The @f{b}-ghost is a target space symmetric tensor} #:tag "sec:BGhostAsSymmetricTensor"]
First of all, sigma-models whose action is an integral of a two-form over the worldsheet
(of the type @f{\int {\cal B}_{IJ}(x) \partial_+ x^I \partial _- x^J} with antisymmetric @f{{\cal B}_{IJ}(x)})
are degenerate and cannot be immediately quantized.
We need a term symmetric under @f{+ \leftrightarrow -}.
Such a term is generated by the shift of the standard Lagrangian submanifold by a gauge fermion
of the form:
@e{
\int_{\Sigma} d^2z\; {\bf b}_{IJ}(x) a^{\alpha\beta} \partial_{\alpha} x^I \partial_{\beta} x^J
}
where @f{a^{\alpha\beta}} is a symmetric tensor-density on @f{\Sigma} and
@f{{\bf b}_{IJ}} is a @bold{symmetric} tensor on the target space.
It is unfortunate that we must call it @f{\bf b}
because letter B usually suggests the Kalb-Ramond B-field, an @bold{antisymmetric} tensor.
But we do insist on calling it @f{\bf b} because it is actually the BV prototype
of the pure spinor @f{b}-ghost. (For an antisymmetric tensor, we use @f{\cal B}.)
@div[redbox]{The BV ``origin'' of the @f{b}-ghost is a fermionic symmetric tensor field @f{\bf b} on
the target space}
(See: @(hyperlink "https://andreimikhailov.com/math/projector/sec_ActionWithoutW.html#%28elem._.Gauging.Away.G%29" @elem{Target space @f{\bf b}}))
We introduce
@e{
Qi^* {\bf b} = i^*\left( {\cal L}_Q {\bf b} \right)
}
Then the deformation of the action is:
@e[#:label "LQb"]{
Q\,\int_{\Sigma} \left\langle a \,,\, i^*{\bf b} \right\rangle \;=\;
\int_{\Sigma} \left\langle
a
\,,\,
\mbox{STr} \left(
{1\over 2} i^*J_2\otimes i^*J_2
+
i^*J_1\otimes i^*({\bf 1} - {\bf P}_{31})J_3
\right)
\right\rangle
}
@subpage[1 "Finally" #:tag "sec:Finally"]
@(align
r.l.n
`(""
@,f{S \;=\; \int d^2z\; L}
"")
`(""
@,f{L \;=\;\mbox{STr}
\left(
{1\over 2} J_{2+}J_{2-} + {3\over 4} J_{1+}J_{3-} + {1\over 4} J_{3+}J_{1-} +
w_{1+}D_{0-}\lambda_3 + w_{3-}D_{0+}\lambda_1 - N_{0+}N_{0-}
\right)
}
"")
)
where @f{N_{0+} = \{w_{1+},\lambda_3\}} and @f{N_{0-} = \{w_{3-},\lambda_1\}}.
@page["Diffeomorphisms" #:tag "Diffeomorphisms" #:showtitle #t]
@subpage[1 "Example when diffeomorphisms are exact" #:tag "sec:ExampleDiffExact"]
Let @f{M} be some manifold. Consider the space of maps:
@e{
\mbox{Map}(\Sigma,\Pi TM)
}
An element of @f{\mbox{Map}(\Sigma,\Pi TM)} is a map
@e{
\Sigma\times {\bf R}^{0|1} \rightarrow M
}
We parameterize @f{{\bf R}^{0|1}} by @f{\zeta}, so elements of @f{\mbox{Map}(\Sigma,\Pi TM)}
are functions @f{\phi(z,\zeta)} with values in @f{M}.
There is a cohomological vector field @f{Q} induced by @f{d} on @f{\Pi TM}.
The flux by odd time @f{\theta} of @f{Q} is:
@e{
(e^{\theta Q}\phi) (z,\zeta) = \phi(z,\zeta + \theta)
}
There is a canonical map:
@e{
v \;:\; \mbox{Vect}(\Sigma) \rightarrow \mbox{Vect}\left(\mbox{Map}(\Sigma,\Pi TM)\right)
}
For any @f{\xi\in\mbox{Vect}(\Sigma)}, by definition:
@e{
(e^{t v\langle \xi\rangle}\phi)(z,\zeta) = \phi(e^{tv}z, \zeta)
}
We observe that @f{v} is covariantly @f{Q}-exact, in the following sense. Exists a map
@e{
i\;:\;\mbox{Vect}(\Sigma) \longrightarrow \mbox{Vect}\left(\mbox{Map}(\Sigma,\Pi TM)\right)
}
such that:
@(align
r.l.n
`(""
@,f{v(\xi) = [Q, i(\xi)]}
@,label{EnergyIsExact}
)
`(""
@,f{[v(\xi),i(\eta)] = i([\xi,\eta])}
@,label{CovariantlyExact}
)
)
This map is defined as follows:
@e{
(e^{\theta i\langle \xi\rangle}\phi)(z,\zeta)
= \phi(e^{\theta\zeta\, v\langle\xi\rangle}z,\zeta)
}
@subpage[1 "Differential ideals in PDFs" #:tag "sec:DifferentialIdeals"]
Suppose that we are given a submanifold (possibly singular):
@e{
C\subset \Pi TM
}
such that the vector field @f{d} is tangent to it.
Then @f{d} induces on @f{C} a nilpotent vector field @f{Q}.
This is same as specifying a differential ideal
in the supercommutative algebra of PDFs.
We can then consider the space of maps @f{\mbox{Map}(\Sigma, C)}.
It still has @f{Q} and @f{v}.
But does it have @f{i} such that Eq. (@ref{EnergyIsExact})
is satisfied?
@subpage[1 @elem{Example: pure spinors in AdS} #:tag "sec:ExamplePureSpinorsInAdS"]
Consider, again, the pure spinor cone over @f{AdS_5\times S^5}:
@image{ps/target-space.svg}
Let us associate to it a differential ideal in PDFs on @f{PSU(2,2|4)} in the following way.
In a local chart @f{\Pi T (AdS_5\times S^5)} is parameterized by:
@e{
g
\;,\;\;
J_1 = - (dgg^{-1})_1
\;,\;\;
J_2 = - (dgg^{-1})_2
\;,\;\;
J_3 = - (dgg^{-1})_3
}
with @f{d} acting as follows:
@(align
r.l.n
`("" @,f{dg \;=\; -(A_0 + J_1 + J_2 + J_3)g} "")
`("" @,f{dJ_1 \;=\; [J_2,J_3] + [A_0,J_1]} "")
`("" @,f{dJ_2 \;=\; \{J_1,J_1\} + \{J_3,J_3\} + [A_0,J_2]} "")
)
where @f{A_0} is some @f{so(1,4)\oplus so(5)} connection.
The differential ideal is given by:
@(align
r.l.n
`("" @,f{J_2 = 0} @,label{ZeroJ2})
`("" @,f{\{J_1,J_1\} = \{J_3,J_3\} = 0} @,label{PureSpinorJ1J3})
)
Let us call this @f{CAdS} (``cone bundle of AdS''):
@(align
r.l.n
`(@,f{CAdS \subset \Pi T(AdS_5\times S^5)}
@,(elem #:style 'no-break @`{solving Eqs (@,ref{ZeroJ2}) and (@,ref{PureSpinorJ1J3})})
"")
)
On this constraint, we denote:
@e{
\lambda_3 = J_3\;,\;\;\lambda_1 = J_1
}
In this case the map @f{i} was partially constructed in
@(hyperlink "https://andreimikhailov.com/math/projector/sec_diffeomorphisms.html" "my paper").
@; ---------------------------------------------------------------------------------------------------
@(bystro-close-connection bystro-conf)
@disconnect[formula-database]
| false |
da142dd07eb74db87be7112b0d22d38d4c0e9980 | 099418d7d7ca2211dfbecd0b879d84c703d1b964 | /whalesong/tests/older-tests/all-tests.rkt | df6b1aeb4f6fe94bac0ad7bc017228b08a48187a | []
| no_license | vishesh/whalesong | f6edd848fc666993d68983618f9941dd298c1edd | 507dad908d1f15bf8fe25dd98c2b47445df9cac5 | refs/heads/master | 2021-01-12T21:36:54.312489 | 2015-08-19T19:28:25 | 2015-08-19T20:34:55 | 34,933,778 | 3 | 0 | null | 2015-05-02T03:04:54 | 2015-05-02T03:04:54 | null | UTF-8 | Racket | false | false | 99 | rkt | all-tests.rkt | #lang s-exp "../lang/base.rkt"
(require "mz-tests/all-tests.rkt"
"moby-programs/all-tests.rkt")
| false |
99c0fadfc29c9d123954cba8b480a7e9edee1e3d | bfff08ec416296ebf11ed9181789608f0836419c | /second-edition/Chapter3/switch-if.rkt | e94521ed5d933c8bc4c971fda52d09306ad21b70 | []
| no_license | kesava/eopl | 8c54bb024ee50478ce6f7835fa1f511236a64175 | 9c6cf32e9bdc6ff659ecb45feabaa38550e732a5 | refs/heads/master | 2022-01-24T15:21:30.826989 | 2021-12-27T02:23:36 | 2021-12-27T02:23:36 | 170,910,305 | 3 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 916 | rkt | switch-if.rkt | (define (match-case-default lst check-against isodd acc)
(if (null? lst)
acc
(let ((condition-type (car (car lst))))
(if (eq? condition-type 'case)
(let ((value-for-case (cadr (car lst))) (statement (if isodd
(cons (list '(if (eq? value-for-case check-against) value-fo-case)) acc)
(cons value-for-case acc))))
(match-case-default (cdr lst) check-against (not isodd) statement))
(let ((statement (cons value-for-case acc)))
(cons statement acc))))))
(define (switch->if exp)
(if (eq? (car exp) 'switch)
(let ((conditional-value (cadr exp)))
(match-case-default (cddr exp) conditional-value #t '()))
exp))
(switch->if '(switch (= 2 1) (case (+ 2 1) x) (case (- 2 1) y))) | false |
96826403b8711da00c8197af4dac57634caa5e4d | 25a6efe766d07c52c1994585af7d7f347553bf54 | /gui-lib/framework/private/standard-menus-items.rkt | 05e6fe09c30323ed4b4739a79080449331553b51 | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/gui | 520ff8f4ae5704210822204aa7cd4b74dd4f3eef | d01d166149787e2d94176d3046764b35c7c0a876 | refs/heads/master | 2023-08-25T15:24:17.693905 | 2023-08-10T16:45:35 | 2023-08-10T16:45:35 | 27,413,435 | 72 | 96 | NOASSERTION | 2023-09-14T17:09:52 | 2014-12-02T03:35:22 | Racket | UTF-8 | Racket | false | false | 18,504 | rkt | standard-menus-items.rkt | #lang at-exp racket/base
(provide
(struct-out generic)
(struct-out generic/docs)
(struct-out generic-override)
(struct-out generic-augment)
(struct-out generic-method)
(struct-out generic-private-field)
(struct-out menu-item)
menu-name->get-menu-name ;; : menu-item -> symbol
(struct-out before/after)
(struct-out before)
(struct-out after)
(struct-out between)
(struct-out an-item)
(struct-out a-checkable-item)
(struct-out a-submenu-item)
;; an-item -> symbol
;; calcualates the names of various identifiers associated with the item.
an-item->callback-name
an-item->create-menu-item-name
an-item->get-item-name
an-item->item-name
an-item->on-demand-name
an-item->string-name
an-item->help-string-name
before/after->name
between->name
items)
(define-struct generic (name initializer))
(define-struct (generic/docs generic) (documentation))
(define-struct (generic-override generic/docs) ())
(define-struct (generic-augment generic/docs) ())
(define-struct (generic-method generic/docs) ())
(define-struct (generic-private-field generic) ())
(define-struct menu-item (menu-name))
(define (menu-name->get-menu-name menu-item)
(string->symbol
(format "get-~a" (menu-item-menu-name menu-item))))
(define-struct (before/after menu-item) (name procedure))
(define-struct (before before/after) ())
(define-struct (after before/after) ())
(define (before/after->name before/after)
(string->symbol (format "~a:~a-~a"
(menu-item-menu-name before/after)
(if (before? before/after)
"before"
"after")
(before/after-name before/after))))
(define-struct (between menu-item) (before after procedure))
(define (between->name between)
(string->symbol (format "~a:between-~a-and-~a"
(menu-item-menu-name between)
(between-before between)
(between-after between))))
(define-struct (an-item menu-item)
(item-name
help-string
proc
shortcut
shortcut-prefix
menu-string
on-demand
create))
(define-struct (a-submenu-item an-item) ())
(define-struct (a-checkable-item an-item) ())
(define (an-item->callback-name item)
(string->symbol
(format "~a:~a-callback" (menu-item-menu-name item) (an-item-item-name item))))
(define (an-item->create-menu-item-name item)
(string->symbol
(format "~a:create-~a?" (menu-item-menu-name item) (an-item-item-name item))))
(define (an-item->get-item-name item)
(string->symbol
(format "~a:get-~a-item" (menu-item-menu-name item) (an-item-item-name item))))
(define (an-item->item-name item)
(string->symbol
(format "~a:~a-item" (menu-item-menu-name item) (an-item-item-name item))))
(define (an-item->on-demand-name item)
(string->symbol
(format "~a:~a-on-demand" (menu-item-menu-name item) (an-item-item-name item))))
(define (an-item->string-name item)
(string->symbol
(format "~a:~a-string" (menu-item-menu-name item) (an-item-item-name item))))
(define (an-item->help-string-name item)
(string->symbol
(format "~a:~a-help-string" (menu-item-menu-name item) (an-item-item-name item))))
(define (edit-menu:do const)
`(λ (menu evt)
(let ([edit (get-edit-target-object)])
(when (and edit
(is-a? edit editor<%>))
(send edit do-edit-operation ',const)))
#t))
(define (edit-menu:can-do-on-demand const)
`(λ (item)
(let* ([editor (get-edit-target-object)]
[enable?
(and editor
(is-a? editor editor<%>)
(send editor can-do-edit-operation? ',const))])
(send item enable enable?))))
(define edit-menu:edit-target-on-demand
`(λ (item)
(send item enable
(let ([target (get-edit-target-object)])
(and target (is-a? target editor<%>))))))
(define on-demand-do-nothing '(λ (menu-item) (void)))
(define items
(list (make-generic-augment
'on-close
'(λ ()
(remove-prefs-callback)
(inner (void) on-close))
(list
'@defmethod[(on-close) void?]{
Removes the preferences callbacks for the menu items
}))
(make-generic-method
'get-menu% '(λ () menu:can-restore-underscore-menu%)
(list
'@defmethod[(get-menu%)
(is-a?/c menu:can-restore-underscore-menu%)]{
The result of this method is used as the class
for creating the result of these methods:
@method[frame:standard-menus get-file-menu],
@method[frame:standard-menus get-edit-menu], and
@method[frame:standard-menus get-help-menu].}))
(make-generic-method
'get-menu-item% '(λ () menu:can-restore-menu-item%)
(list
'@defmethod[(get-menu-item%) (is-a?/c menu:can-restore-menu-item%)]{
The result of this method is used as the class for creating
the menu items in this frame.
Returns @racket[menu:can-restore-menu-item] by default.}))
(make-generic-method
'get-checkable-menu-item% '(λ () menu:can-restore-checkable-menu-item%)
(list
'@defmethod[(get-checkable-menu-item%) (is-a?/c menu:can-restore-checkable-menu-item%)]{
The result of this method is used as the class for creating
checkable menu items in this class.
returns @racket[menu:can-restore-checkable-menu-item] by default.}))
(make-generic-method
'get-file-menu
'(λ () file-menu)
(list
'@defmethod[(get-file-menu) (is-a?/c menu%)]{
Returns the file menu.
See also @method[frame:standard-menus<%> get-menu%].}))
(make-generic-private-field
'file-menu
'(make-object (get-menu%)
(string-constant file-menu-label)
(get-menu-bar)))
(make-generic-method
'get-edit-menu
'(λ () edit-menu)
(list
'@defmethod[(get-edit-menu) (is-a?/c menu%)]{
Returns the edit menu.
See also @method[frame:standard-menus<%> get-menu%].}))
(make-generic-private-field
'edit-menu
'(make-object (get-menu%) (string-constant edit-menu-label) (get-menu-bar)))
(make-generic-method
'get-help-menu
'(λ () help-menu)
(list
'@defmethod[(get-help-menu) (is-a?/c menu%)]{
Returns the help menu.
See also @method[frame:standard-menus<%> get-menu%].}))
(make-generic-private-field
'help-menu
'(make-object (get-menu%) (string-constant help-menu-label) (get-menu-bar)))
(make-an-item 'file-menu 'new
'(string-constant new-info)
'(λ (item control) (handler:edit-file #f) #t)
#\n
'(get-default-shortcut-prefix)
'(string-constant new-menu-item)
on-demand-do-nothing
#t)
(make-between 'file-menu 'new 'open 'nothing)
(make-an-item 'file-menu 'open '(string-constant open-info)
'(λ (item control) (handler:open-file) #t)
#\o
'(get-default-shortcut-prefix)
'(string-constant open-menu-item)
on-demand-do-nothing
#t)
(make-a-submenu-item 'file-menu 'open-recent
'(string-constant open-recent-info)
'(λ (x y) (void))
#f
'(get-default-shortcut-prefix)
'(string-constant open-recent-menu-item)
'(λ (menu)
(handler:install-recent-items menu))
#t)
(make-between 'file-menu 'open 'revert 'nothing)
(make-an-item 'file-menu 'revert
'(string-constant revert-info)
'(λ (item control) (void))
#\e
'(cons 'shift (get-default-shortcut-prefix))
'(string-constant revert-menu-item)
on-demand-do-nothing
#f)
(make-between 'file-menu 'revert 'save 'nothing)
(make-an-item 'file-menu 'save
'(string-constant save-info)
'(λ (item control) (void))
#\s
'(get-default-shortcut-prefix)
'(string-constant save-menu-item)
on-demand-do-nothing
#f)
(make-an-item 'file-menu 'save-as
'(string-constant save-as-info)
'(λ (item control) (void))
#\s
'(cons 'shift (get-default-shortcut-prefix))
'(string-constant save-as-menu-item)
on-demand-do-nothing
#f)
(make-between 'file-menu 'save-as 'print 'nothing)
(make-an-item 'file-menu 'print
'(string-constant print-info)
'(λ (item control) (void))
#\p
'(get-default-shortcut-prefix)
'(string-constant print-menu-item)
on-demand-do-nothing
#f)
(make-between 'file-menu 'print 'close 'separator)
(make-an-item 'file-menu 'close
'(string-constant close-info)
'(λ (item control) (when (can-close?) (on-close) (show #f)) #t)
#\w
'(get-default-shortcut-prefix)
'(if (eq? (system-type) 'unix)
(string-constant close-menu-item)
(string-constant close-window-menu-item))
on-demand-do-nothing
#t)
(make-between 'file-menu 'close 'quit 'nothing)
(make-an-item 'file-menu 'quit
'(string-constant quit-info)
'(λ (item control)
(when (exit:user-oks-exit)
(exit:exit)))
#\q
'(get-default-shortcut-prefix)
'(if (eq? (system-type) 'windows)
(string-constant quit-menu-item-windows)
(string-constant quit-menu-item-others))
on-demand-do-nothing
'(not (eq? (system-type) 'macosx)))
(make-after 'file-menu 'quit 'nothing)
(make-an-item 'edit-menu 'undo
'(string-constant undo-info)
(edit-menu:do 'undo)
#\z
'(get-default-shortcut-prefix)
'(string-constant undo-menu-item)
(edit-menu:can-do-on-demand 'undo)
#t)
(make-an-item 'edit-menu 'redo
'(string-constant redo-info)
(edit-menu:do 'redo)
'(if (eq? (system-type) 'windows)
#\y
#\z)
'(if (eq? (system-type) 'windows)
(get-default-shortcut-prefix)
(cons 'shift (get-default-shortcut-prefix)))
'(string-constant redo-menu-item)
(edit-menu:can-do-on-demand 'redo)
#t)
(make-between 'edit-menu 'redo 'cut 'separator)
(make-an-item 'edit-menu 'cut '(string-constant cut-info)
(edit-menu:do 'cut)
#\x
'(get-default-shortcut-prefix)
'(string-constant cut-menu-item)
(edit-menu:can-do-on-demand 'cut)
#t)
(make-between 'edit-menu 'cut 'copy 'nothing)
(make-an-item 'edit-menu 'copy
'(string-constant copy-info)
(edit-menu:do 'copy)
#\c
'(get-default-shortcut-prefix)
'(string-constant copy-menu-item)
(edit-menu:can-do-on-demand 'copy)
#t)
(make-between 'edit-menu 'copy 'paste 'nothing)
(make-an-item 'edit-menu 'paste
'(string-constant paste-info)
(edit-menu:do 'paste)
#\v
'(get-default-shortcut-prefix)
'(string-constant paste-menu-item)
(edit-menu:can-do-on-demand 'paste)
#t)
(make-between 'edit-menu 'paste 'clear 'nothing)
(make-an-item 'edit-menu 'clear
'(string-constant clear-info)
(edit-menu:do 'clear)
#f
'(get-default-shortcut-prefix)
'(if (eq? (system-type) 'windows)
(string-constant clear-menu-item-windows)
(string-constant clear-menu-item-windows))
(edit-menu:can-do-on-demand 'clear)
#t)
(make-between 'edit-menu 'clear 'select-all 'nothing)
(make-an-item 'edit-menu 'select-all
'(string-constant select-all-info)
(edit-menu:do 'select-all)
#\a
'(get-default-shortcut-prefix)
'(string-constant select-all-menu-item)
(edit-menu:can-do-on-demand 'select-all)
#t)
(make-between 'edit-menu 'select-all 'find 'separator)
(make-an-item 'edit-menu 'find
'(string-constant find-info)
'(λ (item control) (void))
#\f
'(get-default-shortcut-prefix)
'(string-constant find-menu-item)
edit-menu:edit-target-on-demand
#f)
(make-an-item 'edit-menu 'find-from-selection
'(string-constant find-info)
'(λ (item control) (void))
'(if (eq? (system-type) 'macosx)
#\f
#f)
'(if (eq? (system-type) 'macosx)
(cons 'option (get-default-shortcut-prefix))
(get-default-shortcut-prefix))
'(string-constant find-from-selection-menu-item)
edit-menu:edit-target-on-demand
#f)
(make-an-item 'edit-menu 'find-next
'(string-constant find-next-info)
'(λ (item control) (void))
#\g
'(get-default-shortcut-prefix)
'(string-constant find-next-menu-item)
edit-menu:edit-target-on-demand
#f)
(make-an-item 'edit-menu 'find-previous
'(string-constant find-previous-info)
'(λ (item control) (void))
#\g
'(cons 'shift (get-default-shortcut-prefix))
'(string-constant find-previous-menu-item)
edit-menu:edit-target-on-demand
#f)
(make-an-item 'edit-menu 'show/hide-replace
'(string-constant show/hide-replace-info)
'(λ (item control) (void))
#\r
'(cons 'shift (get-default-shortcut-prefix))
'(string-constant show-replace-menu-item)
on-demand-do-nothing
#f)
(make-an-item 'edit-menu 'replace
'(string-constant replace-info)
'(λ (item control) (void))
#\f
'(cons 'shift (get-default-shortcut-prefix))
'(string-constant replace-menu-item)
on-demand-do-nothing
#f)
(make-an-item 'edit-menu 'replace-all
'(string-constant replace-all-info)
'(λ (item control) (void))
#f
'(get-default-shortcut-prefix)
'(string-constant replace-all-menu-item)
on-demand-do-nothing
#f)
(make-a-checkable-item 'edit-menu 'find-case-sensitive
'(string-constant find-case-sensitive-info)
'(λ (item control) (void))
#f
'(get-default-shortcut-prefix)
'(string-constant find-case-sensitive-menu-item)
edit-menu:edit-target-on-demand
#f)
(make-between 'edit-menu 'find 'preferences 'nothing-with-standard-menus)
(make-an-item 'edit-menu 'preferences
'(string-constant preferences-info)
'(λ (item control) (preferences:show-dialog) #t)
'(case (system-type)
[(macosx) #\,]
[else #\;])
'(get-default-shortcut-prefix)
'(string-constant preferences-menu-item)
on-demand-do-nothing
'(not (current-eventspace-has-standard-menus?)))
(make-after 'edit-menu 'preferences 'nothing)
(make-before 'help-menu 'about 'nothing)
(make-an-item 'help-menu 'about
'(string-constant about-info)
'(λ (item control) (void))
#f
'(get-default-shortcut-prefix)
'(string-constant about-menu-item)
on-demand-do-nothing
#f)
(make-after 'help-menu 'about 'nothing)))
| false |
cf592ee8d9851bfa83bbe3d9a4878e94ab0b7c10 | e553691752e4d43e92c0818e2043234e7a61c01b | /rosette/query/query.rkt | 9583a659971a082232124e164361239fea945039 | [
"BSD-2-Clause"
]
| permissive | emina/rosette | 2b8c1bcf0bf744ba01ac41049a00b21d1d5d929f | 5dd348906d8bafacef6354c2e5e75a67be0bec66 | refs/heads/master | 2023-08-30T20:16:51.221490 | 2023-08-11T01:38:48 | 2023-08-11T01:38:48 | 22,478,354 | 656 | 89 | NOASSERTION | 2023-09-14T02:27:51 | 2014-07-31T17:29:18 | Racket | UTF-8 | Racket | false | false | 181 | rkt | query.rkt | #lang racket
(require racket/provide)
(require "eval.rkt" "finitize.rkt" "form.rkt")
(provide (all-from-out
"eval.rkt"
"finitize.rkt"
"form.rkt"))
| false |
babc950c0b13dfe9207670259ed6c35a2450eb0a | 78ca4b96e85da5b3b60f29789f4edc254ef8bb22 | /cs151/hw2/hw2.rkt | eaefa48483ca493efeb5bbbb2104115e6d60ab74 | []
| no_license | sschwartz222/Programming-Projects-and-Assignments | 47b46762c7fc0c2fcc998e89fa08f3349df20b57 | 85352fb125824a463a62459d17b3610aa7aedac3 | refs/heads/master | 2020-12-01T20:22:06.771564 | 2019-12-29T14:36:36 | 2019-12-29T14:36:36 | 230,757,252 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 10,457 | rkt | hw2.rkt | #lang typed/racket
;; CMSC15100 Winter 2018
;; Homework 2
;; Sam Schwartz
;; include CS151-specific definitions
(require "../include/cs151-core.rkt")
;; include testing framework
(require typed/test-engine/racket-tests)
;; The days of the week
(define-type Weekday (U 'Sun 'Mon 'Tue 'Wed 'Thu 'Fri 'Sat))
;; Representation of dates
(define-struct Date
([month : Integer] ;; value from 1..12 that represents January, ...
[day : Integer] ;; value from 1..31 that represents the day of the month
[year : Integer])) ;; value from 1900..2199 that represents the year
;; find the value in the trinomial triangle in row x, element y
(: trinomial : Integer Integer -> Integer)
(define (trinomial x y)
(cond
[(or (< x 0) (< y 0) (>= y ( + (* x 2) 1))) 0]
[(or (= x 0) (= x 1) (= y 0) (= y ( + (* x 2) 1))) 1]
[else ( + (trinomial ( - x 1) y)
(trinomial ( - x 1) ( - y 1))
(trinomial ( - x 1) (- y 2)))]))
(check-expect (trinomial 1 4) 0)
(check-expect (trinomial -1 1) 0)
(check-expect (trinomial 4 3) 16)
(check-expect (trinomial 3 4) 6)
(check-expect (trinomial 2 1) 2)
;; helper function for trinomial-row that determines # of elements in a row
;; and converts the elements to strings
(: row-aux : Integer Integer -> String)
(define (row-aux max i)
(cond
[(< i (* 2 max))
(string-append (number->string (trinomial max i)) " " (row-aux max (+ i 1)))]
[(= i (* 2 max))
(string-append "1")]
[else ""]))
(check-expect (row-aux 1 0) "1 1 1")
(check-expect (row-aux 3 0) "1 3 6 7 6 3 1")
;; prints the nth row of the trinomial triangle
(: trinomial-row : Integer -> String)
(define (trinomial-row n)
(if (< n 0) (number->string 0) (row-aux n 0)))
(check-expect (trinomial-row -1) "0")
(check-expect (trinomial-row 0) "1")
(check-expect (trinomial-row 3) "1 3 6 7 6 3 1")
;; problem 2
(: leap-year? : Integer -> Boolean)
;; determine whether a year is a leap year
(define (leap-year? z)
(cond
[(=(remainder z 400) 0) #t]
[(=(remainder z 100) 0) #f]
[(=(remainder z 4) 0) #t]
[else #f]))
(check-expect (leap-year? 2000) #t)
(check-expect (leap-year? 2004) #t)
(check-expect (leap-year? 2100) #f)
(check-expect (leap-year? 988) #t)
(check-expect (leap-year? 2018) #f)
;; checks whether a given date exists
(: valid-date? : Date -> Boolean)
(define (valid-date? date)
(or
(and (< (Date-year date) 2100) (> (Date-year date) 1899) (= (Date-month date) 2)
(leap-year? (Date-year date)) (> (Date-day date) 0) (< (Date-day date) 30))
(and (< (Date-year date) 2100) (> (Date-year date) 1899) (= (Date-month date) 2)
(> (Date-day date) 0) (< (Date-day date) 29))
(and (< (Date-year date) 2100) (> (Date-year date) 1899) (= (Date-month date) 1)
(> (Date-day date) 0) (< (Date-day date) 32))
(and (< (Date-year date) 2100) (> (Date-year date) 1899) (= (Date-month date) 3)
(> (Date-day date) 0) (< (Date-day date) 32))
(and (< (Date-year date) 2100) (> (Date-year date) 1899) (= (Date-month date) 5)
(> (Date-day date) 0) (< (Date-day date) 32))
(and (< (Date-year date) 2100) (> (Date-year date) 1899) (= (Date-month date) 7)
(> (Date-day date) 0) (< (Date-day date) 32))
(and (< (Date-year date) 2100) (> (Date-year date) 1899) (= (Date-month date) 8)
(> (Date-day date) 0) (< (Date-day date) 32))
(and (< (Date-year date) 2100) (> (Date-year date) 1899) (= (Date-month date) 10)
(> (Date-day date) 0) (< (Date-day date) 32))
(and (< (Date-year date) 2100) (> (Date-year date) 1899) (= (Date-month date) 12)
(> (Date-day date) 0) (< (Date-day date) 32))
(and (< (Date-year date) 2100) (> (Date-year date) 1899) (= (Date-month date) 4)
(> (Date-day date) 0) (< (Date-day date) 31))
(and (< (Date-year date) 2100) (> (Date-year date) 1899) (= (Date-month date) 6)
(> (Date-day date) 0) (< (Date-day date) 31))
(and (< (Date-year date) 2100) (> (Date-year date) 1899) (= (Date-month date) 9)
(> (Date-day date) 0) (< (Date-day date) 31))
(and (< (Date-year date) 2100) (> (Date-year date) 1899) (= (Date-month date) 11)
(> (Date-day date) 0) (< (Date-day date) 31))))
(check-expect (valid-date? (Date 2 29 2000)) #t)
(check-expect (valid-date? (Date 2 29 2001)) #f)
(check-expect (valid-date? (Date 1 29 2000)) #t)
(check-expect (valid-date? (Date 4 31 2000)) #f)
(check-expect (valid-date? (Date 4 30 2000)) #t)
;; turns a set of three integers into the date form
(: make-date : Integer Integer Integer -> Date)
(define (make-date x y z)
(if (valid-date? (Date x y z))
(Date x y z)
(error "make-date: invalid date")))
(check-expect (make-date 1 23 2018) (Date 1 23 2018))
(check-expect (make-date 2 29 2018) (error "make-date: invalid date"))
(check-expect (make-date 2 29 2016) (Date 2 29 2016))
(: number-day-of-week : Integer Integer Integer -> Integer)
;; find the number day of the week
(define (number-day-of-week x y z)
(cond
[(and (= x 1) (leap-year? z))
(remainder (+ (- z 1900) y (exact-floor ( / z 4))) 7)]
[(and (= x 2) (leap-year? z))
(remainder (+ (- z 1900) y 3 (exact-floor ( / z 4))) 7)]
[(= x 1)
(remainder (+ (- z 1900) y 1 (exact-floor ( / z 4))) 7)]
[(= x 2)
(remainder (+ (- z 1900) y 4 (exact-floor ( / z 4))) 7)]
[(= x 3)
(remainder (+ (- z 1900) y 4 (exact-floor ( / z 4))) 7)]
[(= x 4)
(remainder (+ (- z 1900) y (exact-floor ( / z 4))) 7)]
[(= x 5)
(remainder (+ (- z 1900) y 2 (exact-floor ( / z 4))) 7)]
[(= x 6)
(remainder (+ (- z 1900) y 5 (exact-floor ( / z 4))) 7)]
[(= x 7)
(remainder (+ (- z 1900) y (exact-floor ( / z 4))) 7)]
[(= x 8)
(remainder (+ (- z 1900) y 3 (exact-floor ( / z 4))) 7)]
[(= x 9)
(remainder (+ (- z 1900) y 6 (exact-floor ( / z 4))) 7)]
[(= x 10)
(remainder (+ (- z 1900) y 1 (exact-floor ( / z 4))) 7)]
[(= x 11)
(remainder (+ (- z 1900) y 4 (exact-floor ( / z 4))) 7)]
[(= x 12)
(remainder (+ (- z 1900) y 6 (exact-floor ( / z 4))) 7)]
[else remainder (+ (- z 1900) y 6 (exact-floor ( / z 4))) 7]))
;; enter a date to output the day of the week
(: weekday : Date -> Weekday)
(define (weekday date)
(if (valid-date? date)
(cond
[(= (number-day-of-week (Date-month date) (Date-day date) (Date-year date)) 0) 'Sun]
[(= (number-day-of-week (Date-month date) (Date-day date) (Date-year date)) 1) 'Mon]
[(= (number-day-of-week (Date-month date) (Date-day date) (Date-year date)) 2) 'Tue]
[(= (number-day-of-week (Date-month date) (Date-day date) (Date-year date)) 3) 'Wed]
[(= (number-day-of-week (Date-month date) (Date-day date) (Date-year date)) 4) 'Thu]
[(= (number-day-of-week (Date-month date) (Date-day date) (Date-year date)) 5) 'Fri]
[(= (number-day-of-week (Date-month date) (Date-day date) (Date-year date)) 6) 'Sat]
[else (error "no")])
(error "no")))
(check-expect (weekday (Date 1 12 2018)) 'Fri)
(check-expect (weekday (Date 1 13 2018)) 'Sat)
(check-expect (weekday (Date 1 14 2018)) 'Sun)
(check-expect (weekday (Date 1 15 2018)) 'Mon)
(check-expect (weekday (Date 1 16 2018)) 'Tue)
;; checks if date1 is before date2
(: date<? : Date Date -> Boolean)
(define (date<? date1 date2)
(or
( < (Date-year date1) (Date-year date2))
(and ( = (Date-year date1) (Date-year date2)) ( < (Date-month date1) (Date-month date2)))
(and ( = (Date-year date1) (Date-year date2)) ( = (Date-month date1) (Date-month date2))
( < (Date-day date1) (Date-day date2)))))
(check-expect (date<? (Date 1 23 2018) (Date 1 24 2018)) #t)
(check-expect (date<? (Date 1 23 2018) (Date 1 23 2018)) #f)
(check-expect (date<? (Date 1 23 2018) (Date 1 22 2018)) #f)
(check-expect (date<? (Date 1 23 2018) (Date 1 1 2019)) #t)
;; checks if date1 is after date2
(: date>? : Date Date -> Boolean)
(define (date>? date1 date2)
(cond
[(and ( = (Date-year date1) (Date-year date2)) ( = (Date-month date1) (Date-month date2))
( = (Date-day date1) (Date-day date2))) #f]
[(date<? date1 date2) #f]
[else #t]))
(check-expect (date>? (Date 1 23 2018) (Date 1 24 2018)) #f)
(check-expect (date>? (Date 1 23 2018) (Date 1 23 2018)) #f)
(check-expect (date>? (Date 1 23 2018) (Date 1 22 2018)) #t)
(check-expect (date>? (Date 1 23 2018) (Date 1 1 2019)) #f)
;; checks if date1 is the same as date2
(: date=? : Date Date -> Boolean)
(define (date=? date1 date2)
(and ( = (Date-year date1) (Date-year date2)) ( = (Date-month date1) (Date-month date2))
( = (Date-day date1) (Date-day date2))))
(check-expect (date=? (Date 1 23 2018) (Date 1 24 2018)) #f)
(check-expect (date=? (Date 1 23 2018) (Date 1 23 2018)) #t)
(check-expect (date=? (Date 1 23 2018) (Date 1 22 2018)) #f)
(check-expect (date=? (Date 1 23 2018) (Date 1 1 2019)) #f)
;; Problem 3
(define-struct Cubic
([a : Exact-Rational]
[b : Exact-Rational]
[c : Exact-Rational]
[d : Exact-Rational]))
;; input x will be evaluated in the cubic formula according to the cubic coefficients
(: eval-cubic : Cubic Real -> Real)
(define (eval-cubic f x)
(+ (* (Cubic-a f) (expt x 3)) (* (Cubic-b f) (expt x 2)) (* (Cubic-c f) x) (Cubic-d f)))
(check-expect (eval-cubic (Cubic 2 2 2 2) 3) 80)
(check-expect (eval-cubic (Cubic 6 5 4 3) 2) 79)
(check-expect (eval-cubic (Cubic -2 -2 -2 -2) -3) 40)
;; displays the cubic formula in a string with numerical values as coefficients
(: cubic->string : Cubic -> String)
(define (cubic->string f)
(string-append (number->string (Cubic-a f)) "*x^3 + " (number->string (Cubic-b f))
"*x^2 + " (number->string (Cubic-c f)) "*x + " (number->string (Cubic-d f))))
(check-expect (cubic->string (Cubic 2 2 2 2)) "2*x^3 + 2*x^2 + 2*x + 2")
(check-expect (cubic->string (Cubic 6 5 4 3)) "6*x^3 + 5*x^2 + 4*x + 3")
(check-expect (cubic->string (Cubic -2 -2 -2 -2)) "-2*x^3 + -2*x^2 + -2*x + -2")
;; finds the coefficients of the derivative of a cubic function
(define-struct Quadratic
([a : Exact-Rational]
[b : Exact-Rational]
[c : Exact-Rational]))
(: derivative : Cubic -> Quadratic)
(define (derivative cubic)
(Quadratic (* 3 (Cubic-a cubic)) (* 2 (Cubic-b cubic)) (Cubic-c cubic)))
(check-expect (derivative (Cubic 2 2 2 2)) (Quadratic 6 4 2))
(check-expect (derivative (Cubic -2 -2 -2 -2)) (Quadratic -6 -4 -2))
(check-expect (derivative (Cubic 6 5 4 3)) (Quadratic 18 10 4))
;; run tests
;;
(test)
| false |
032717ef6a84ac602d982ce67fe206c67e53a8b5 | 5bbc152058cea0c50b84216be04650fa8837a94b | /paper/popl-2016/data/fsm-10-17.rktd | 884f0eef08508e93b38c8f79410d3ef8aace1684 | []
| 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 | Racket | false | false | 425 | rktd | fsm-10-17.rktd | ;; #(-i 2 -o fsm2.rktd fsm)
;; 6.3.0.1
#((2312 2242) (2208 2214) (2193 2195) (2212 2229) (2196 2200) (2206 2214) (2189 2204) (2208 2236) (4423 4426) (4452 4459) (4403 4463) (4420 4388) (4427 4384) (4402 4403) (4428 4377) (4390 4481) (2218 2250) (2187 2184) (2286 2238) (2189 2200) (2247 2237) (2186 2192) (2260 2217) (2204 2196) (2238 2277) (2204 2197) (2240 2230) (2182 2194) (2238 2234) (2176 2190) (2237 2281) (2185 2184)) | false |
4e0ccc0591eeb356ea242731acd2f74a6aa36118 | 50508fbb3a659c1168cb61f06a38a27a1745de15 | /turnstile-example/turnstile/examples/optimize/stlc.rkt | 2c8c7c8ca2a7af193d67c734949fcc68ee9ea0c8 | [
"BSD-2-Clause"
]
| permissive | phlummox/macrotypes | e76a8a4bfe94a2862de965a4fefd03cae7f2559f | ea3bf603290fd9d769f4f95e87efe817430bed7b | refs/heads/master | 2022-12-30T17:59:15.489797 | 2020-08-11T16:03:02 | 2020-08-11T16:03:02 | 307,035,363 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,242 | rkt | stlc.rkt | #lang turnstile/base
(provide (type-out →) λ #%app ann #%module-begin #%top-interaction require)
(define-type-constructor → #:arity >= 1
#:arg-variances (λ (stx)
(syntax-parse stx
[(_ τ_in ... τ_out)
(append
(stx-map (λ _ contravariant) #'[τ_in ...])
(list covariant))])))
(define-typed-syntax λ #:datum-literals (:)
[(_ ([x:id : τ_in:type] ...) e) ≫
[[x ≫ x- : τ_in.norm] ... ⊢ e ≫ e- ⇒ τ_out]
-------
[⊢ (#%plain-lambda- (x- ...) e-) ⇒ #,(mk-→- #'(τ_in.norm ... τ_out))]]
[(_ (x:id ...) e) ⇐ (~→ τ_in ... τ_out) ≫
[[x ≫ x- : τ_in] ... ⊢ e ≫ e- ⇐ τ_out]
---------
[⊢ (#%plain-lambda- (x- ...) e-)]])
(define-typed-syntax (#%app e_fn e_arg ...) ≫
[⊢ e_fn ≫ e_fn- ⇒ (~→ τ_in ... τ_out)]
#:fail-unless (stx-length=? #'[τ_in ...] #'[e_arg ...])
(num-args-fail-msg #'e_fn #'[τ_in ...] #'[e_arg ...])
[⊢ e_arg ≫ e_arg- ⇐ τ_in] ...
--------
[⊢ (#%plain-app- e_fn- e_arg- ...) ⇒ τ_out])
(define-typed-syntax (ann e (~datum :) τ:type) ≫
[⊢ e ≫ e- ⇐ τ.norm]
--------
[⊢ e- ⇒ τ.norm])
| false |
c4aa9618794e3f46fce3a5e6f2ea64b75ef4ae2f | 1f9cbbfd10c5757d44cc016f59ad230a0babb9a6 | /CS5010-Programming-Design-Paradigm/pdp-singhay-dishasoni-master/set10/square.rkt | fc83e1f10119760136d366a8a94b31267f665110 | []
| no_license | singhay/ms-courses-code | 95dda6d5902218b4e95bf63a5275de5c405a6a14 | 5f986bd66582909b306c7aabcf1c2cda261c68ba | refs/heads/master | 2021-01-01T18:21:29.043344 | 2018-11-10T21:40:58 | 2018-11-10T21:40:58 | 98,319,843 | 1 | 1 | null | null | null | null | UTF-8 | Racket | false | false | 12,016 | rkt | square.rkt | #lang racket
(require rackunit)
(require "extras.rkt")
(require "interfaces.rkt")
(require 2htdp/image)
(provide make-square-toy)
;;CONSTANTS
;; Square Dimensions
(define SQUARE-SIDE 40)
(define SQUARE-MODE "outline")
(define SQUARE-COLOR "blue")
(define SQUARE-IMG (square SQUARE-SIDE SQUARE-MODE SQUARE-COLOR))
(define HALF-SQUARE-SIDE (/ SQUARE-SIDE 2))
(define MAX-X-SQUARE (- CANVAS-WIDTH HALF-SQUARE-SIDE))
(define MAX-Y-SQUARE (- CANVAS-HEIGHT HALF-SQUARE-SIDE))
;; Square start at the center of the target and travels rightward
;; instantaneously.
;; They are selectable and draggable.
;; A Square is a (new Square% [x Integer][y Integer][s Integer]
;; these 3 are optional [selected? Boolean][mx Integer][my Integer])
;; REPRESENTS: a blue square of size 40x40 in outline mode.
(define Square%
(class* object% (Toy<%>)
;; the init-fields are the values that may vary from one square to
;; the next.
; the x and y position of the center of the square
(init-field x y speed)
; is the square selected? Default is false.
(init-field [selected? false])
;; if the square is selected, the position of
;; the last button-down event inside the square, relative to the
;; square's center. Else any value.
(init-field [saved-mx 0] [saved-my 0])
(super-new)
;; after-tick : Square -> Void
;; GIVEN: a square
;; RETURNS: a square like this one, but as it should be after a tick
;; a selected square doesn't move.
;; STRATEGY: Cases on selected?
(define/public (after-tick)
(local
((define sp
(if
(or
(>=(+ x speed) MAX-X-SQUARE)
(<=(+ x speed) HALF-SQUARE-SIDE))
(- speed)
speed))
(define calculated-x
(cond
[(<=(+ x speed) HALF-SQUARE-SIDE) HALF-SQUARE-SIDE]
[(>=(+ x speed) MAX-X-SQUARE) MAX-X-SQUARE]
[else (+ x speed)])))
(if selected?
this
(begin
(set! speed sp)
(set! x calculated-x)
))))
;; after-key-event : KeyEvent -> Square
;; RETURNS: A world like this one, but as it should be after the
;; given key event.
;; DETAILS: a square ignores key events
(define/public (after-key-event kev)
this)
; after-button-down : Integer Integer -> Void
; GIVEN: the location of a button-down event
; STRATEGY: Cases on whether the event is in the square
(define/public (after-button-down mx my)
(if (in-square? mx my)
(begin
(set! selected? true)
(set! saved-mx (- mx x))
(set! saved-my (- my y)))
this))
; after-button-up : Integer Integer -> Void
; GIVEN: the location of a button-up event
; STRATEGY: Cases on whether the event is in the square.
; If the square is selected, then unselect it.
(define/public (after-button-up mx my)
(set! selected? false))
; after-drag : Integer Integer -> Void
; GIVEN: the location of a drag event
; STRATEGY: Cases on whether the square is selected.
; If it is selected, move it so that the vector from the center to
; the drag event is equal to (mx, my)
(define/public (after-drag mx my)
(if selected?
(begin
(set! x (calculate-x mx))
(set! y (calculate-y my)))
this))
; calculate-x : Integer -> Integer
; calculate-y : Integer ->Integer
; GIVEN: the x/y coordinate of the mouse event
; RETURNS: x/y coordinate of the target
; STRATEGY: Cases on whether the position of target
;; is within limits.
(define (calculate-x mx)
(local
((define x (- mx saved-mx)))
(cond
[(<= x HALF-SQUARE-SIDE) HALF-SQUARE-SIDE]
[(>= x MAX-X-SQUARE) MAX-X-SQUARE]
[else x])))
(define (calculate-y my)
(local
((define y (- my saved-my)))
(cond
[(<= y HALF-SQUARE-SIDE) HALF-SQUARE-SIDE]
[(>= y MAX-Y-SQUARE) MAX-Y-SQUARE]
[else y])))
;; to-scene : Scene -> Scene
;; RETURNS: a scene like the given one, but with this square painted
;; on it.
(define/public (add-to-scene scene)
(place-image SQUARE-IMG x y scene))
;; in-square? : Integer Integer -> Boolean
;; GIVEN: a location on the canvas
;; RETURNS: true iff the location is inside this square.
(define (in-square? other-x other-y)
(and (<= (abs (- x other-x))
(/ SQUARE-SIDE 2))
(<= (abs (- y other-y))
(/ SQUARE-SIDE 2))))
;; toy-x : -> Integer
;; toy-y : -> Integer
;; RETURNS the respective x/y position of the square
(define/public (toy-x) x)
(define/public (toy-y) y)
;; toy-data : -> Integer
;; RETURNS the speed of square
(define/public (toy-data) speed)
;; test methods, to probe the Square state.
(define/public (for-test:x) x)
(define/public (for-test:y) y)
(define/public (for-test:selected?) selected?)
(define/public (for-test:speed) speed)
))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; make-square-toy : PosInt PosInt PosInt -> Toy<%>
;; GIVEN: an x and a y position, and a speed
;; RETURNS: an object representing a square toy at the given position,
;; travelling right at the given speed.
(define (make-square-toy x y s)
(new Square% [x x][y y][speed s]))
(begin-for-test
(local
((define SPEED-10 10)
(define SQUARE
(make-square-toy TARGET-INITIAL-X TARGET-INITIAL-Y SPEED-10))
(define SQUARE-SEL (new Square%
[x TARGET-INITIAL-X]
[y TARGET-INITIAL-Y]
[selected? true]
[speed SPEED-10]))
(define SQUARE-SEL-1 (new Square%
[x 5]
[y HALF-SQUARE-SIDE]
[selected? false]
[speed SPEED-10]))
(define SQUARE-SEL-2 (new Square%
[x (- MAX-X-SQUARE 5)]
[y MAX-Y-SQUARE]
[selected? false]
[speed SPEED-10]))
(define SQUARE-AFTER-TICK (new Square%
[x (+ SPEED-10 TARGET-INITIAL-X)]
[y TARGET-INITIAL-Y]
[speed SPEED-10]))
(define SQUARE-NEAR-BOUNDARY (new Square%
[x MAX-X-SQUARE]
[y MAX-Y-SQUARE]
[speed SPEED-10]))
(define SQUARE-NEAR-BOUNDARY-AFTER-TICK (new Square%
[x MAX-X-SQUARE]
[y MAX-Y-SQUARE]
[speed (- SPEED-10)]))
(define SQUARE-FOR-DRAG (new Square%
[x TARGET-INITIAL-X]
[y TARGET-INITIAL-Y]
[speed SPEED-10])))
(send SQUARE toy-x)
(check-equal?
(send SQUARE for-test:x)TARGET-INITIAL-X
"the clock's x position")
(send SQUARE toy-y)
(check-equal?
(send SQUARE for-test:y)TARGET-INITIAL-Y
"the clock's y position")
(send SQUARE toy-data)
(check-equal?
(send SQUARE for-test:speed)SPEED-10
"the clock's ticks")
(send SQUARE after-button-down TARGET-INITIAL-X TARGET-INITIAL-Y)
(check-equal?
(send SQUARE after-tick)
SQUARE)
(check-equal?
(send SQUARE after-key-event OTHER-KEY-EVENT)
SQUARE)
(send SQUARE-SEL after-button-up TARGET-INITIAL-X TARGET-INITIAL-Y)
(check-equal?
(send SQUARE-SEL for-test:selected?) false
"the clock should be unselected")
(send SQUARE after-button-up 80 100)
(check-equal?
(send SQUARE for-test:selected?) false
"the clock should be unselected")
(send SQUARE after-button-down 800 800)
(check-equal?
(send SQUARE for-test:selected?) false
"the unselected clock shoule remain unselected")
(send SQUARE after-button-down TARGET-INITIAL-X TARGET-INITIAL-Y)
(check-equal?
(send SQUARE for-test:selected?) true
"the square should be selected after button down")
(send SQUARE-SEL after-tick)
(check-equal?
(send SQUARE-SEL for-test:x) (+ SPEED-10 TARGET-INITIAL-X)
"the square should move in right direction")
(check-equal?
(send SQUARE-SEL for-test:speed) SPEED-10
"should give the square speed on next tick")
(check-equal?
(send SQUARE-SEL-2 for-test:x) (- MAX-X-SQUARE 5))
(check-equal?
(send SQUARE-SEL-2 for-test:speed) 10)
(check-equal?
(send SQUARE-SEL-2 for-test:selected?) false)
(send SQUARE-SEL-2 after-tick)
(check-equal?
(send SQUARE-SEL-2 for-test:x) MAX-X-SQUARE
"the square should move in right direction")
(check-equal?
(send SQUARE-SEL-2 for-test:speed) (* -1 SPEED-10)
"should give the square speed on next tick")
(send SQUARE-SEL-1 after-tick)
(check-equal?
(send SQUARE-SEL-1 for-test:x) HALF-SQUARE-SIDE
"the square should move in left direction")
(check-equal?
(send SQUARE-SEL-1 for-test:speed) (* -1 SPEED-10)
"should give the square speed on next tick")
(send SQUARE-SEL after-button-down TARGET-INITIAL-X TARGET-INITIAL-Y)
(send SQUARE-SEL after-drag -1 -2)
(check-equal?
(send SQUARE-SEL for-test:x) HALF-SQUARE-SIDE
"the clock is dragged to a new x position")
(check-equal?
(send SQUARE-SEL for-test:y) HALF-SQUARE-SIDE
"the clock is dragged to a new y position")
(send SQUARE-SEL after-tick)
(check-equal?
(send SQUARE-SEL for-test:x) HALF-SQUARE-SIDE
"the square should move in right direction")
(check-equal?
(send SQUARE-SEL for-test:speed) SPEED-10
"should give the square speed on next tick")
(send SQUARE-NEAR-BOUNDARY after-button-down MAX-X-SQUARE MAX-Y-SQUARE)
(send SQUARE-NEAR-BOUNDARY after-drag 700 800)
(check-equal?
(send SQUARE-NEAR-BOUNDARY for-test:x) MAX-X-SQUARE
"the clock is dragged to a new x position")
(check-equal?
(send SQUARE-NEAR-BOUNDARY for-test:y) MAX-Y-SQUARE
"the clock is dragged to a new y position")
(send SQUARE-NEAR-BOUNDARY-AFTER-TICK after-tick)
(check-equal?
(send SQUARE-NEAR-BOUNDARY-AFTER-TICK for-test:x)
(+ MAX-X-SQUARE (* -1 SPEED-10))
"the square should move in right direction")
(check-equal?
(send SQUARE-NEAR-BOUNDARY-AFTER-TICK for-test:speed)
(* -1 SPEED-10) "should give the square speed on next tick")
(send SQUARE-FOR-DRAG after-button-down 250 300)
(check-equal? (send SQUARE-FOR-DRAG for-test:selected?) true)
(send SQUARE-FOR-DRAG after-drag 180 100)
(check-equal?
(send SQUARE-FOR-DRAG for-test:x) 180
"the clock is dragged to a new x position")
(send SQUARE-SEL after-button-down 20 40)
(send SQUARE-SEL after-drag 20 40)
(check-equal?
(send SQUARE-SEL for-test:x) 20
"the clock is dragged to a new x position")
(send SQUARE after-button-up TARGET-INITIAL-X TARGET-INITIAL-Y)
(send SQUARE after-drag TARGET-INITIAL-X TARGET-INITIAL-Y)
(check-equal?
(send SQUARE for-test:x)TARGET-INITIAL-X
"the unselected clock is not dragged")
(check-equal?
(send SQUARE for-test:y)TARGET-INITIAL-Y
"the unselected clock is not dragged")
(check-equal? (send SQUARE add-to-scene EMPTY-CANVAS)
(place-image SQUARE-IMG
TARGET-INITIAL-X TARGET-INITIAL-Y
EMPTY-CANVAS)))
)
| false |
c5ecf06f3557e579cf4c67cd4bca7010fb31115a | 616e16afef240bf95ed7c8670035542d59cdba50 | /redex-doc/redex/scribblings/long-tut/wed-mor.scrbl | 096a96137e61f3625304950312fdde0e4a7622b9 | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/redex | bd535d6075168ef7be834e7c1b9babe606d5cd34 | 8df08b313cff72d56d3c67366065c19ec0c3f7d0 | refs/heads/master | 2023-08-19T03:34:44.392140 | 2023-07-13T01:50:18 | 2023-07-13T01:50:18 | 27,412,456 | 102 | 43 | NOASSERTION | 2023-04-07T19:07:30 | 2014-12-02T03:06:03 | Racket | UTF-8 | Racket | false | false | 6,780 | scrbl | wed-mor.scrbl | #lang scribble/manual
@(require "shared.rkt")
@; ---------------------------------------------------------------------------------------------------
@title[#:tag "wed-mor"]{Imperative Extensions}
@goals[
@item{revise the language for assignment statements}
@item{a standard reduction system for expression-store tuples}
@item{revise the language for raising exceptions}
@item{a general reduction system for exceptions}
]
@section{Variable Assignment}
Let's add variable assignments to our language:
@;%
@(begin
#reader scribble/comment-reader
(racketblock
(define-extended-language Assignments Lambda
(e ::= .... n + (void) (set! x e))
(n ::= natural))
))
@;%
This makes it like Racket, Scheme and Lisp, but unlike ML where you can
mutate only data structure (one-slot records in SML and slots in arbitrary
records in OCaml.
For writing programs in this world, you also want blocks and local
declarations. We add a task-specific @racket[let] expression:
@;%
@(begin
#reader scribble/comment-reader
(racketblock
;; (let ((x_1 x_2) ...) e_1 e_2) binds the current value of x_2 to x_1,
;; evaluates e_1, throws away its value, and finally evaluates e_2
(define-metafunction Assignments
let : ((x e) ...) e e -> e
[(let ([x_lhs e_rhs] ...) e_1 e_2)
((lambda (x_lhs ...)
((lambda (x_dummy) e_2) e_1))
e_rhs ...)
(where (x_dummy) ,(variables-not-in (term (e_1 e_2)) '(dummy)))])
))
@;%
Here are some sample programs:
@;%
@(begin
#reader scribble/comment-reader
(racketblock
(define e1
(term
(lambda (x)
(lambda (y)
(let ([tmp x])
(set! x (+ y 1))
tmp)))))
(define p-1 (term ((,e1 1) 2)))
(define e2
(term
((lambda (x)
(let ([tmp x])
(set! x y)
tmp))
(let ([tmp-z z])
(set! z (+ z 1))
(let ([tmp-y y])
(set! y tmp-z)
tmp-y)))))
(define p-2
(term ((lambda (y) ((lambda (z) ,e2) 1)) 2)))
))
@;%
How do they behave?
For a @emph{standard reduction relation}, we need both evaluation contexts
@emph{and} a table that keeps track of the current value of variables:
@;%
@(begin
#reader scribble/comment-reader
(racketblock
(define-extended-language Assignments-s Assignments
(E ::= hole (v ... E e ...) (set! x E))
(σ ::= ((x v) ...))
(v ::= n + (void) (lambda (x ...) e)))
;; (extend σ x v) adds (x v) to σ
(define-metafunction Assignments-s
extend : σ (x ...) (any ...) -> σ
[(extend ((x any) ...) (x_1 ...) (any_1 ...)) ((x_1 any_1) ... (x any) ...)])
;; -----------------------------------------------------------------------------
;; (lookup Γ x) retrieves x's type from Γ
(define-metafunction Assignments-s
lookup : any x -> any
[(lookup ((x_1 any_1) ... (x any_t) (x_2 any_2) ...) x)
any_t
(side-condition (not (member (term x) (term (x_1 ...)))))]
[(lookup any_1 any_2)
,(error 'lookup "not found: ~e in: ~e" (term x) (term any_2))])
))
@;%
Extending this table and looking up values in it, is a routine matter by
now.
Here is the standard reduction relation:
@;%
@(begin
#reader scribble/comment-reader
(racketblock
(define s->βs
(reduction-relation
Assignments-s
#:domain (e σ)
(--> [(in-hole E x) σ]
[(in-hole E (lookup σ x)) σ])
(--> [(in-hole E (set! x v)) σ]
[(in-hole E (void)) (extend σ (x) (v))])
(--> [(in-hole E (+ n_1 n_2)) σ]
[(in-hole E ,(+ (term n_1) (term n_2))) σ])
(--> [(in-hole E ((lambda (x ..._n) e) v ..._n)) σ]
[(in-hole E e) (extend σ (x_new ...) (v ...))]
(where (x_new ...) ,(variables-not-in (term σ) (term (x ...)))))))
))
@;%
The question is what the corresponding calculus looks like. See
@secref{lab-wed-mor}.
@bold{This use of the standard reduction relation is common because most
researchers @emph{do not need} the calculus. Instead they define such a
relation and consider it a semantics.}
The semantics is a function, however, that maps programs to the final
answers and possibly extracts pieces from the store.
@;%
@(begin
#reader scribble/comment-reader
(racketblock
(module+ test
(test-equal (term (eval-assignments ,p-1)) 1)
(test-equal (term (eval-assignments ,p-2)) 2)
(test-equal (term (eval-assignments ,p-c)) (term closure)))
(define-metafunction Assignments-s
eval-assignments : e -> v or closure
[(eval-assignments e) (run-assignments (e ()))])
(define-metafunction Assignments-s
run-assignments : (e σ) -> v or closure
[(run-assignments (n σ)) n]
[(run-assignments (v σ)) closure]
[(run-assignments any_1)
(run-assignments any_again)
(where (any_again) ,(apply-reduction-relation s->βs (term any_1)))]
[(run-assignments any) stuck])
))
@;%
@; -----------------------------------------------------------------------------
@section{Raising Exceptions}
When non-local control operators come such as ML's exceptions come into
play, reductions become (evaluation-) context-sensitive.
Here is a language with a simple construct for raising exceptions:
@;%
@(begin
#reader scribble/comment-reader
(racketblock
(define-extended-language Exceptions Lambda
(e ::= .... n + (raise e))
(n ::= integer))
))
@;%
@bold{History} This form of exception was actually introduced into Lisp as
the @tt{catch} and @tt{throw} combination (contrary to some statements in
Turing-award announcements).
Try to figure out what these expressions ought to compute:
@;%
@(begin
#reader scribble/comment-reader
(racketblock
(define c1
(term
((lambda (x)
(+ 1 (raise (+ 1 x))))
0)))
(define c2
(term
(lambda (y)
((lambda (x)
(+ 1 (raise (+ (raise -1) x))))
0))))
))
@;%
A calculus of exceptions needs both arbitrary term contexts and evaluation
contexts:
@;%
@(begin
#reader scribble/comment-reader
(racketblock
(define-extended-language Exceptions-s Exceptions
(C ::= hole (e ... C e ...) (lambda (x ...) C) (raise C))
(E ::= hole (v ... E e ...) (raise E))
(v ::= n + (lambda (x ...) e)))
))
@;%
The key insight is that an exception-raising construct erases any
surrounding evaluation context, regardless of where it shows up:
@;%
@(begin
#reader scribble/comment-reader
(racketblock
(module+ test
(test-->> ->βc c1 (term (raise 1)))
(test-->> ->βc c2 (term (lambda (y) (raise -1)))))
(define ->βc
(reduction-relation
Exceptions-s
(--> (in-hole C (in-hole E (raise v)))
(in-hole C (raise v))
(where #false ,(equal? (term E) (term hole)))
ζ)
(--> (in-hole C (+ n_1 n_2))
(in-hole C ,(+ (term n_1) (term n_2)))
+)
(--> (in-hole C ((lambda (x_1 ..._n) e) v_1 ..._n))
(in-hole C (subst ([v_1 x_1] ...) e))
β_v)))
))
@;%
The question is what a standard reduction relation for such a calculus
looks like. See @secref{lab-wed-mor}.
| false |
e220690fc2c531d9d96db248487a69030daa16cf | 16d3f8ab4138583b584c0b7929f205de82a789d5 | /src/function/private/dataconver.rkt | 88ed907e1e07725b49f229c6b584c7555c7d7e50 | []
| no_license | pbpf/aqjc | 7926b4cadd54b09cca984690955b5de197014ba2 | 8bb189e94021e7d0188477acbbb56952c666fb50 | refs/heads/master | 2020-09-03T16:33:37.614815 | 2019-11-04T13:44:13 | 2019-11-04T13:44:13 | 219,505,471 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 601 | rkt | dataconver.rkt | #lang racket
(require racket/date
db/base)
(define (postgres-type-to-sqlite-type t)
(case t
[("integer")"integer"]
[("real" "double")"real"]
[("varchar" "char" "text" "date" "timestamp")"text"]
[("bytea") "blob"]
[else (error 'postgres-type-to-sql-type "type ~a can not convert to sqlite3" t)]))
(define(sql-date->text d)
(format "~a-~a-~a" (sql-date-year d)(sql-date-month d)(sql-date-day d)))
(define(text->sql-date t)
(match t
[(pregexp #px"^([0-9]{4})-([0-9]{2})-([0-9]{2})$" (list _ a b c)) (apply sql-date(map string->number(list a b c)))]
[else #f])) | false |
148aa5fe90f57fe4f89487268357c9b11eea4fd7 | 56c17ee2a6d1698ea1fab0e094bbe789a246c54f | /2017/d13/main.rkt | 1d5eb716f515f955645ebf5fa751ebea57a7fd9a | [
"MIT"
]
| permissive | mbutterick/aoc-racket | 366f071600dfb59134abacbf1e6ca5f400ec8d4e | 14cae851fe7506b8552066fb746fa5589a6cc258 | refs/heads/master | 2022-08-07T10:28:39.784796 | 2022-07-24T01:42:43 | 2022-07-24T01:42:43 | 48,712,425 | 39 | 5 | null | 2017-01-07T07:47:43 | 2015-12-28T21:09:38 | Racket | UTF-8 | Racket | false | false | 894 | rkt | main.rkt | #lang reader "../aoc-lang.rkt"
(require (for-syntax racket/string racket/sequence) racket/dict)
(provide (rename-out [#%mb #%module-begin]) ★ ★★)
(define-macro (#%mb (STARS) (DEPTH: RANGE) ...)
(with-pattern ([(DEPTH ...)
(for/list ([id (in-syntax #'(DEPTH: ...))])
(string->number (string-trim (symbol->string (syntax->datum id)) ":")))])
#'(#%module-begin (time (STARS '(DEPTH ...) '(RANGE ...))))))
(define (caught? depth range [delay 0])
(zero? (modulo (+ depth delay) (* 2 (sub1 range)))))
(define (★ ds rs)
(for/sum ([d (in-list ds)]
[r (in-list rs)]
#:when (caught? d r))
(* d r)))
(define (★★ ds rs)
(for/first ([delay (in-naturals)]
#:unless (for/or ([d (in-list ds)]
[r (in-list rs)])
(caught? d r delay)))
delay))
| false |
01f8c45cde0f40784fb335807687180135036b3d | d75682ea540df7c7eb3e69c6a109a857ac81383d | /serval/x32/base.rkt | 257cde94bffe14b38b63e44c62d5b0b27e8caa77 | [
"MIT"
]
| permissive | linusboyle/serval | 33e7185bd8c3dd5f10fbcfc9c96dcaca20fb0105 | 0a84bfb6c08e42c1db0ae742ed2cd19012ea4d0c | refs/heads/master | 2022-07-04T00:20:39.456218 | 2020-05-15T10:49:02 | 2020-05-15T10:49:02 | 250,180,306 | 0 | 0 | MIT | 2020-03-26T06:37:35 | 2020-03-26T06:37:34 | null | UTF-8 | Racket | false | false | 7,930 | rkt | base.rkt | #lang rosette
(require (prefix-in core: "../lib/core.rkt"))
(provide (all-defined-out))
(struct gprs (eax ecx edx ebx esp ebp esi edi) #:mutable #:transparent)
(struct flags (cf pf af zf sf of) #:mutable #:transparent)
(struct cpu (pc gprs flags mregions) #:mutable #:transparent)
(define (init-cpu [symbols null] [globals null])
(define-symbolic* eax ecx edx ebx esp ebp esi edi (bitvector 32))
(define-symbolic* cf pf af zf sf of boolean?)
(define mregions (core:create-mregions symbols globals))
(define reset-vector (bv 0 32))
(cpu reset-vector (gprs eax ecx edx ebx esp ebp esi edi) (flags cf pf af zf sf of) mregions))
(define (cpu-next! cpu size)
(set-cpu-pc! cpu (bvadd size (cpu-pc cpu))))
(define current-pc-debug #f)
(define (set-current-pc-debug! v)
(set! current-pc-debug v))
(define (gpr->idx gpr)
(case gpr
[(eax ax al) 0]
[(ecx cx cl) 1]
[(edx dl) 2]
[(ebx bl) 3]
[(esp ah) 4]
[(ebp ch) 5]
[(esi dh) 6]
[(edi bh) 7]
[else
(core:bug-on #t
#:msg (format "gpr->idx: unknown gpr: ~e" gpr)
#:dbg current-pc-debug)]))
(define (gpr-full gpr)
(case gpr
[(ax ah al) 'eax]
[(cx ch cl) 'ecx]
[(dx dh dl) 'edx]
[(bx bh bl) 'ebx]
[(sp spl) 'esp]
[(bp bpl) 'ebp]
[(si sil) 'esi]
[(di dil) 'edi]
[else gpr]))
(define (gpr-set! cpu gpr val)
(define (gpr-update-16 old new) (concat (extract 31 16 old) new))
(define (gpr-update-8h old new) (concat (extract 31 16 old) new (extract 7 0 old)))
(define (gpr-update-8l old new) (concat (extract 31 8 old) new))
(define rs (cpu-gprs cpu))
(case gpr
[(eax) (set-gprs-eax! rs val)]
[(ecx) (set-gprs-ecx! rs val)]
[(edx) (set-gprs-edx! rs val)]
[(ebx) (set-gprs-ebx! rs val)]
[(esp) (set-gprs-esp! rs val)]
[(ebp) (set-gprs-ebp! rs val)]
[(esi) (set-gprs-esi! rs val)]
[(edi) (set-gprs-edi! rs val)]
;
[(ax) (set-gprs-eax! rs (gpr-update-16 (gprs-eax rs) val))]
[(cx) (set-gprs-ecx! rs (gpr-update-16 (gprs-ecx rs) val))]
[(dx) (set-gprs-edx! rs (gpr-update-16 (gprs-edx rs) val))]
[(bx) (set-gprs-ebx! rs (gpr-update-16 (gprs-ebx rs) val))]
[(sp) (set-gprs-esp! rs (gpr-update-16 (gprs-esp rs) val))]
[(bp) (set-gprs-ebp! rs (gpr-update-16 (gprs-ebp rs) val))]
[(si) (set-gprs-esi! rs (gpr-update-16 (gprs-esi rs) val))]
[(di) (set-gprs-edi! rs (gpr-update-16 (gprs-edi rs) val))]
;
[(ah) (set-gprs-eax! rs (gpr-update-8h (gprs-eax rs) val))]
[(ch) (set-gprs-ecx! rs (gpr-update-8h (gprs-ecx rs) val))]
[(dh) (set-gprs-edx! rs (gpr-update-8h (gprs-edx rs) val))]
[(bh) (set-gprs-ebx! rs (gpr-update-8h (gprs-ebx rs) val))]
;
[(al) (set-gprs-eax! rs (gpr-update-8l (gprs-eax rs) val))]
[(cl) (set-gprs-ecx! rs (gpr-update-8l (gprs-ecx rs) val))]
[(dl) (set-gprs-edx! rs (gpr-update-8l (gprs-edx rs) val))]
[(bl) (set-gprs-ebx! rs (gpr-update-8l (gprs-ebx rs) val))]
[(spl) (set-gprs-esp! rs (gpr-update-8l (gprs-esp rs) val))]
[(bpl) (set-gprs-ebp! rs (gpr-update-8l (gprs-ebp rs) val))]
[(sil) (set-gprs-esi! rs (gpr-update-8l (gprs-esi rs) val))]
[(dil) (set-gprs-edi! rs (gpr-update-8l (gprs-edi rs) val))]
;
[else (core:bug-on #t #:msg (format "gpr-set!: unknown gpr ~e" gpr) #:dbg current-pc-debug)]))
(define (gpr-ref cpu gpr)
(define (gpr-ref-16 x) (extract 15 0 x))
(define (gpr-ref-8h x) (extract 15 8 x))
(define (gpr-ref-8l x) (extract 7 0 x))
(define rs (cpu-gprs cpu))
(case gpr
[(eax) (gprs-eax rs)]
[(ecx) (gprs-ecx rs)]
[(edx) (gprs-edx rs)]
[(ebx) (gprs-ebx rs)]
[(esp) (gprs-esp rs)]
[(ebp) (gprs-ebp rs)]
[(esi) (gprs-esi rs)]
[(edi) (gprs-edi rs)]
;
[(ax) (gpr-ref-16 (gprs-eax rs))]
[(cx) (gpr-ref-16 (gprs-ecx rs))]
[(dx) (gpr-ref-16 (gprs-edx rs))]
[(bx) (gpr-ref-16 (gprs-ebx rs))]
[(sp) (gpr-ref-16 (gprs-esp rs))]
[(bp) (gpr-ref-16 (gprs-ebp rs))]
[(si) (gpr-ref-16 (gprs-esi rs))]
[(di) (gpr-ref-16 (gprs-edi rs))]
;
[(ah) (gpr-ref-8h (gprs-eax rs))]
[(ch) (gpr-ref-8h (gprs-ecx rs))]
[(dh) (gpr-ref-8h (gprs-edx rs))]
[(bh) (gpr-ref-8h (gprs-ebx rs))]
;
[(al) (gpr-ref-8l (gprs-eax rs))]
[(cl) (gpr-ref-8l (gprs-ecx rs))]
[(dl) (gpr-ref-8l (gprs-edx rs))]
[(bl) (gpr-ref-8l (gprs-ebx rs))]
[(spl) (gpr-ref-8l (gprs-esp rs))]
[(bpl) (gpr-ref-8l (gprs-ebp rs))]
[(sil) (gpr-ref-8l (gprs-esi rs))]
[(dil) (gpr-ref-8l (gprs-edi rs))]
;
[else (core:bug-on #t #:msg (format "gpr-ref: unknown gpr ~e" gpr) #:dbg current-pc-debug)]))
(define (flag->idx flag)
(case flag
[(CF) 0] ; carry flag
[(PF) 2] ; parity flag
[(AF) 4] ; auxiliary carry flag
[(ZF) 6] ; zero flag
[(SF) 7] ; sign flag
[(OF) 11] ; overflow flag
[else
(core:bug-on #t
#:msg (format "flag->idx: unknown flag: ~e" flag)
#:dbg current-pc-debug)]))
(define (flag-set! cpu flag [val #t])
(core:bug-on (not (boolean? val))
#:msg (format "flag-set!: not boolean: ~e" val)
#:dbg current-pc-debug)
(define fs (cpu-flags cpu))
(case flag
[(CF) (set-flags-cf! fs val)]
[(PF) (set-flags-pf! fs val)]
[(AF) (set-flags-af! fs val)]
[(ZF) (set-flags-zf! fs val)]
[(SF) (set-flags-sf! fs val)]
[(OF) (set-flags-of! fs val)]
[else
(core:bug-on #t
#:msg (format "flag->set!: unknown flag: ~e" flag)
#:dbg current-pc-debug)]))
(define (flag-clear! cpu flag)
(flag-set! cpu flag #f))
(define (parity x)
(bvnot (apply bvxor (for/list ([i (in-range (core:bv-size x))]) (extract i i x)))))
(define (flag-set-result! cpu val)
(core:bug-on (not ((bitvector 32) val))
#:msg (format "flag-set!: not bv32: ~e" val)
#:dbg current-pc-debug)
(flag-set! cpu 'PF (core:bitvector->bool (parity (extract 7 0 val))))
(flag-set! cpu 'ZF (core:bvzero? val))
(flag-set! cpu 'SF (core:bitvector->bool (core:msb val))))
(define (flag-havoc! cpu flag)
(define-symbolic* havoc boolean?)
(flag-set! cpu flag havoc))
(define (@flag-ref fs flag)
(case flag
[(CF) (flags-cf fs)]
[(PF) (flags-pf fs)]
[(AF) (flags-af fs)]
[(ZF) (flags-zf fs)]
[(SF) (flags-sf fs)]
[(OF) (flags-of fs)]
[else
(core:bug-on #t
#:msg (format "flag->ref: unknown flag: ~e" flag)
#:dbg current-pc-debug)]))
(define (flag-ref cpu flag)
(@flag-ref (cpu-flags cpu) flag))
(define (flags->bitvector fs)
(define (flag->bv32 flag)
(if (@flag-ref fs flag) (bv (arithmetic-shift 1 (flag->idx flag)) 32) (bv 0 32)))
(apply bvor (map flag->bv32 '(CF PF AF ZF SF OF))))
(define (bitvector->flags v)
(define lst
(for/list ([flag '(CF PF AF ZF SF OF)])
(define i (flag->idx flag))
(core:bitvector->bool (extract i i v))))
(apply flags lst))
(struct ModOpcodeR/M (mod+opcode r/m) #:transparent)
(struct ModR/M (mod r/m reg) #:transparent)
(define-generics instruction
(instruction-encode instruction)
(instruction-run instruction cpu))
(define (instruction-size insn)
(define (size-of x)
(cond
[(bv? x) (/ (core:bv-size x) 8)]
[else 1]))
(apply + (map size-of (instruction-encode insn))))
(define (instruction->integer-bytes insn)
(define code (instruction-encode insn))
(define (hex-symbol->integer x)
(string->number (substring (symbol->string x) 2) 16))
(define (->list x)
(cond
[(bv? x)
(map bitvector->natural (core:bitvector->list/le x))]
[(ModOpcodeR/M? x)
(bitwise-ior
(hex-symbol->integer (ModOpcodeR/M-mod+opcode x))
(gpr->idx (ModOpcodeR/M-r/m x)))]
[(ModR/M? x)
(bitwise-ior
(hex-symbol->integer (ModR/M-mod x))
(gpr->idx (ModR/M-r/m x))
(arithmetic-shift (gpr->idx (ModR/M-reg x)) 3))]
[(symbol? x)
(hex-symbol->integer x)]))
(flatten (map ->list code)))
(struct program (base instructions) #:transparent)
| false |
db10b80b56009e1324b557f17af3af533aed3cfc | adc2d3b1a5b837c3dbfe8cbb8a6cb901e4bcac87 | /script-2.rkt | 93646210418376dd45407a207d5228833df4b645 | []
| no_license | sorawee/fishy-completion | 706995d3959d5fb5424d0a01c4b05a6979b33046 | ec8c4ead7f0ce07274e39c440c69e0b539f9e8ef | refs/heads/master | 2022-11-28T11:12:22.495689 | 2020-08-09T06:08:14 | 2020-08-09T06:08:14 | 283,565,842 | 6 | 1 | null | null | null | null | UTF-8 | Racket | false | false | 11,324 | rkt | script-2.rkt | #lang racket/base
(require racket/set
racket/class
racket/list
racket/string
racket/format
syntax/parse
syntax/parse/lib/function-header
quickscript)
;;; Author: sorawee https://github.com/sorawee
;;; License: Apache2.0/MIT
;;; From: https://github.com/Quickscript-Competiton/July2020entries/issues/17
(script-help-string
"A proof-of-concept completion with fishy static analysis.")
(define magic-inkantation '#%fishy-completion-magic-inkantation)
(define magic-word '#%fishy-completion-magic-word)
;; The submodule is to override #%top so that it's lenient re: unbound ids
;; It will be required for runtime eval and for syntax, since they are
;; the most common ones.
(define the-submod
`(module ,magic-inkantation racket/base
(require (for-syntax racket/base))
(provide (rename-out [@#%top #%top]))
(define-syntax (@#%top stx)
#'(void))))
(define-syntax-class lambda-clause
(pattern (f:formals body ...)
#:with (ids ...) #'f.params))
;; visible? :: identifier? -> boolean?
(define (visible? id)
(define scopes (hash-ref (syntax-debug-info id) 'context (λ () '())))
(not (for/or ([scope (in-list scopes)])
(eq? 'macro (vector-ref scope 1)))))
;; id/c = (cons/c identifier? integer?)
;; locals :: (listof ids/c)
(define locals '())
;; phases :: (listof integer?)
(define phases '())
(define-logger fishy-completion)
;; make-id/phase-list :: (listof identifier?) integer? -> (listof ids/c)
(define (make-id/phase-list xs phase)
(for/list ([x (in-list xs)]) (cons x phase)))
;; walk :: syntax? integer? list? -> void?
(define (walk stx phase ids)
(define (toplevel-walk stxs phase ids)
(define current-ids
(append
ids
(let loop ([stxs stxs] [phase phase])
(append*
(for/list ([form (in-list stxs)])
(syntax-parse form
#:literal-sets ([kernel-literals #:phase phase])
[(begin-for-syntax form ...)
(loop (attribute form) (add1 phase))]
[(define-values (id ...) _)
(make-id/phase-list (attribute id) phase)]
[(define-syntaxes (id ...) _)
(make-id/phase-list (attribute id) phase)]
[_ '()]))))))
(for ([form (in-list stxs)]) (walk form phase current-ids)))
(define (get-current-ids new-ids)
(append ids (make-id/phase-list new-ids phase)))
(syntax-parse stx
#:literal-sets ([kernel-literals #:phase phase])
[(quote x)
#:when (eq? (syntax-e #'x) magic-word)
(define the-candidates
(for/list ([id (in-list ids)] #:when (visible? (car id)))
(cons (~s (syntax-e (car id))) (cdr id))))
(log-fishy-completion-debug "at phase: ~s" phase)
(log-fishy-completion-debug "found candidates: ~s" the-candidates)
(set! locals (append the-candidates locals))
(set! phases (cons phase phases))]
[(module _ _ (#%plain-module-begin form ...))
(toplevel-walk (attribute form) 0 '())]
[(module* _ #f (#%plain-module-begin form ...))
(toplevel-walk (attribute form) phase ids)]
[(module* _ _ (#%plain-module-begin form ...))
(toplevel-walk (attribute form) 0 '())]
[({~or* #%provide #%declare #%require #%variable-reference} _ ...) (void)]
[({~or quote quote-syntax #%top} . _) (void)]
[({~or* #%expression begin begin0
if #%plain-app with-continuation-mark}
form ...)
(for ([form (in-list (attribute form))]) (walk form phase ids))]
[(begin-for-syntax form ...)
(for ([form (in-list (attribute form))]) (walk form (add1 phase) ids))]
[(let-values ([(id ...) e] ...) body ...)
(for ([form (in-list (attribute e))]) (walk form phase ids))
(define current-ids (get-current-ids (append* (attribute id))))
(for ([form (in-list (attribute body))])
(walk form phase current-ids))]
[(letrec-values ([(id ...) e] ...) body ...)
(define current-ids (get-current-ids (append* (attribute id))))
(for ([form (in-sequences (attribute e) (attribute body))])
(walk form phase current-ids))]
[(#%plain-lambda . c:lambda-clause)
(define current-ids (get-current-ids (attribute c.ids)))
(for ([form (in-list (attribute c.body))])
(walk form phase current-ids))]
[(case-lambda c:lambda-clause ...)
(for ([c-ids (in-list (attribute c.ids))]
[c-body (in-list (attribute c.body))])
(define current-ids (get-current-ids c-ids))
(for ([form (in-list c-body)])
(walk form phase current-ids)))]
[(set! _ form) (walk #'form phase ids)]
[(define-values _ form) (walk #'form phase ids)]
[(define-syntaxes _ form) (walk #'form (add1 phase) ids)]
[:id (void)]
[_ (error 'fishy-autocompletion
"unexpected ~e at phase ~e"
stx
phase)]))
;; find-candidates :: syntax? (or/c path? #f) -> (listof identifier?)
(define (find-candidates form dir)
(define stx
(with-handlers ([exn:fail? (λ (ex)
(log-fishy-completion-warning
"compile-time error: ~s"
ex)
#f)])
(parameterize ([current-namespace (make-base-namespace)])
(if dir
(parameterize ([current-directory dir])
(expand form))
(expand form)))))
(cond
[stx
(set! locals '())
(set! phases '())
(walk stx 0 '())
(define phase-set (list->set phases))
(filter
values
(for/list ([group (in-list (group-by car locals))])
(and (subset? phase-set (list->set (map cdr group)))
(car (first group)))))]
[else '()]))
;; the-id :: (or/c #f identifier?)
(define the-id #f)
(define-syntax-class idable
(pattern :id)
;; number could potentially be an identifier once completed
(pattern :number))
;; replace :: syntax? exact-positive-integer? any/c -> syntax?
(define (replace top-stx position new-stx)
(syntax-parse top-stx
[(mod name lang {~and mb-pair (mb . mb-body)})
(define mb-body*
(let loop ([stx #'mb-body])
(syntax-parse stx
[() this-syntax]
[(a . b) (datum->syntax this-syntax
(cons (loop #'a) (loop #'b))
this-syntax
this-syntax)]
[x:idable
#:when (and (log-fishy-completion-debug
"found id: ~s at ~a with span ~a"
(syntax-e stx)
(syntax-position stx)
(syntax-span stx))
;; the above should return void? which is truthy
(syntax-source #'x)
(syntax-position #'x)
(syntax-span #'x)
(equal? (syntax-source #'x) (syntax-source top-stx))
(<= (add1 (syntax-position #'x))
position
(+ (syntax-position #'x) (syntax-span #'x))))
(set! the-id #'x)
(datum->syntax this-syntax new-stx this-syntax this-syntax)]
[_ this-syntax])))
(datum->syntax
this-syntax
(list #'mod #'name #'lang
(datum->syntax
#'mb-pair
(list* #'mb
the-submod
`(require ',magic-inkantation
(for-syntax ',magic-inkantation))
mb-body*)
#'mb-pair
#'mb-pair))
this-syntax
this-syntax)]))
;; my-read :: string? -> (or/c #f syntax?)
(define (my-read s)
(define p (open-input-string s))
(port-count-lines! p)
(with-handlers ([exn:fail? (λ (_) #f)])
(parameterize ([read-accept-reader #t])
(read-syntax (string->path "dummy") p))))
;; query :: exact-positive-integer? string? (or/c path? #f) ->
;; (either (values #f #f '()) (values string? string? (listof string?)))
(define (query position code-str dir)
(log-fishy-completion-info "looking for position: ~a" position)
(with-cache (list position code-str dir)
(define orig-stx (my-read code-str))
(cond
[orig-stx
(log-fishy-completion-info "read successfully")
(set! the-id #f)
(define replaced (replace orig-stx position (list 'quote magic-word)))
(cond
[the-id
(log-fishy-completion-info "found an id at the indicated position")
(define as-string (~s (syntax-e the-id)))
(define as-list (string->list (if (= (+ 2 (string-length as-string))
(syntax-span the-id))
(string-append "|" as-string "|")
as-string)))
(define-values (left right)
(split-at as-list (- position (syntax-position the-id))))
(define left* (list->string left))
(define right* (list->string right))
(define candidates (for/list ([x (find-candidates replaced dir)]
#:when (string-prefix? x left*))
x))
(values left* right* (sort candidates string<?))]
[else (values #f #f '())])]
[else (values #f #f '())])))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define cached (cons #f #f))
(define (cache-proc key proc)
(cond
[(equal? (car cached) key) (apply values (cdr cached))]
[else (call-with-values proc
(λ xs
(set! cached (cons key xs))
(apply values xs)))]))
(define-syntax-rule (with-cache key body ...)
(cache-proc key (λ () body ...)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Adapted from https://github.com/Metaxal/quickscript-extra/blob/master/scripts/dynamic-abbrev.rkt
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-script fishy-completion
#:label "Fishy completion v2"
#:shortcut #\m
#:shortcut-prefix (ctl)
#:persistent
(λ (_sel #:editor ed #:definitions d)
(define pos (send ed get-end-position))
(define txt (send ed get-text))
(define fname (send d get-filename))
(define dir (and fname
(let-values ([(base name must-be-dir?) (split-path fname)])
(and (path? base) base))))
(define-values (left right matches)
(query (add1 pos) txt dir))
(unless (empty? matches)
(define mems (member (string-append left right) matches))
(define str
(if (and mems (not (empty? (rest mems))))
(second mems)
(first matches)))
(when str
(define right* (substring str (string-length left)))
(send ed begin-edit-sequence)
(send ed delete pos (+ pos (string-length right)))
(send ed insert right*)
(send ed set-position pos)
(send ed end-edit-sequence)
(set! cached (cons (list (add1 pos) (send ed get-text) dir)
(list left right* matches)))))
#f))
| true |
9de83391071b93f7126655b8bce35ccf1f72b8be | 33f28a03a484663ed2a830c9b329d6854669e5ad | /racket/20120723.rkt | ce78569997f7adc0accb3638f6d9a63bb4805a82 | []
| no_license | raasoft/plp-exercises | e0506fcd852ec0d9d74ab804e4e3849d0c843e2a | 6eab0a480c5c9e629ef02700f9b192ac23a64e6c | refs/heads/master | 2021-01-22T20:34:24.144354 | 2014-02-03T15:08:03 | 2014-02-03T15:08:03 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 828 | rkt | 20120723.rkt | #lang racket
; Consider the proto-oo system presented in class.
; Please implement a chat command for performing a "dialogue" between two objects,
; say o1 and o2.
; For example the command (chat 01 o2 x m1 m2 ...) must send the message m1 with
; argument x to o1, obtaining a result. Such result is then used as argument of method m2 of o2, and so on.
; This means that, using a C++-like notation, it performs the following calls: ...o1.m3(o2.m2(o1.m1(x)))
(define O1 "01")
(define O2 "02")
(define (apply arg func obj) (string-append obj "." func "(" arg ")"))
(define-syntax chat
(syntax-rules()
[
(chat o1 o2 x m1)
(apply x m1 o1)
]
[(chat o1 o2 x m1 m2 ...)
(chat o2 o1 (apply x m1 o1) m2 ... )
]
)
)
(display (chat O1 O2 "x" "m1" "m2" "m3" "m4")) | true |
f4169b0dd05c1cda6b3b62bbbb6e3e983a1ccbc6 | e995fce18dbdd69a757f55a2c023d07fcce3cb6b | /scpcf/lang.rkt | 20bc88997d494d0f0fe014e2e3c7181d803f8ad4 | []
| no_license | dvanhorn/pcf | 883deb8c60547f04027e9381d54849ee2e0acd7f | f04e2ff7f34b89a3dc6c2a70a6a3283f954d3a67 | refs/heads/master | 2021-01-18T21:52:28.126007 | 2016-03-30T09:26:31 | 2016-03-30T09:26:31 | 6,306,139 | 8 | 1 | null | 2015-07-20T20:34:58 | 2012-10-20T06:45:08 | Racket | UTF-8 | Racket | false | false | 621 | rkt | lang.rkt | #lang racket
(require (for-syntax racket/base pcf/private/make-lang)
(for-syntax (only-in scpcf/redex typable/contract/symbolic?))
scpcf/redex
pcf/private/racket-pcf
pcf/private/label
pcf/private/return)
(provide #%top-interaction #%module-begin
(all-from-out pcf/private/label)
(all-from-out pcf/private/racket-pcf))
(define-syntax #%top-interaction (make-#%top-interaction #'-->scv typable/contract/symbolic? #'values #'return))
(define-syntax #%module-begin (make-#%module-begin #'-->scv typable/contract/symbolic? #'values #'return #'pp #'color))
| true |
cc8da4d56e7a00d8cc4f5d82a87e1cbebfdd75ca | 858864eab75ee6bbd408a3957f7bb35dfe713323 | /www/notes/getting-started.scrbl | b5f439c58ad1d7a5657c5241fc3a8a3a1550f4e0 | []
| no_license | fzahid1/cmsc388q | 8f7e7ade208fbdc28e70fb8d9ea638ca670120aa | 1251a276c2b3ecdcea481ad67efce54cf56cf4d5 | refs/heads/main | 2023-02-11T09:26:47.694420 | 2021-01-14T04:59:07 | 2021-01-14T04:59:07 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,219 | scrbl | getting-started.scrbl | #lang scribble/manual
@(require "../utils.rkt")
@title[#:style '(toc unnumbered)]{Getting Started}
To get started with Racket, you should download and install
it. Racket works on every major computing platform. You can
find it here, under @emph{Download}:
@centered{@link["https://racket-lang.org/"]{https://racket-lang.org/}}
We will be using the @bold{Racket} distribution and @bold{
CS} variant (if available for your platform). For more
detailed instructions, you can read the
@link["https://docs.racket-lang.org/getting-started/index.html"]{@emph{
Getting Started}} guide in the documentation for Racket.
We will primarily use Racket in two modes: either from
within the Racket IDE, called DrRacket, or from the command line using the
@tt{racket} executable.
Once you have installed Racket, open up DrRacket and try to
work through these tutorials (you might only skim through
the last one):
@itemlist[
@item{@link["https://docs.racket-lang.org/quick/index.html"]{Quick: An Introduction to Racket with Pictures}}
@item{@link["https://docs.racket-lang.org/more/index.html"]{More: Systems Programming with Racket}}
@item{@link["https://docs.racket-lang.org/guide/index.html"]{The Racket Guide}}]
| false |
8dd25018dd782e979bab871b18c3dd577e88c2da | e59c43242b5c41c538d725180a1e57e0254981dc | /morsel-lib/private/sql/clauses.rkt | 27cf320232ae0d9596f911d4f3f2c540d5752b07 | [
"MIT"
]
| permissive | default-kramer/morsel | 9722ded5160740da1e8024b6722a7816637d29c2 | 10cf376f07755f066cbbfc2d242c104f103b33da | refs/heads/master | 2020-12-04T05:33:11.252802 | 2020-06-22T02:10:49 | 2020-06-22T02:10:49 | 231,633,877 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 3,479 | rkt | clauses.rkt | #lang racket
(provide select where group-by having order-by join-on
scalar aggregate bool subquery sql silence
limit offset distinct join-type
:limit :offset :distinct get-join-type)
(module+ TODO-for-plisqin
(provide clause<%> content-set :limit :offset :distinct :join-type))
(require racket/struct
"sql-token.rkt"
"../_essence.rkt")
(define fragment%
(class* object% (sql-token<%> equal<%> printable<%>)
(init-field key content)
(super-new)
; sql-token<%>
(define/public (token-kind) key)
(define/public (token-content) content)
(define-token-aspect-stuff)
(define/public (sql-token-reduce)
(cons key content))
; equal<%>
(define/public (equal-content)
(list (token-kind) (token-content)))
(define/public (equal-to? other recur)
(recur (equal-content) (send other equal-content)))
(define/public (equal-hash-code-of hasher)
(hasher (equal-content)))
(define/public (equal-secondary-hash-code-of hasher)
(hasher (equal-content)))
; printable<%>
(define/public (custom-print port mode)
(fragment-printer this port mode))
(define/public (custom-write port)
(fragment-printer this port #t))
(define/public (custom-display port)
(fragment-printer this port #f))))
(define (fragment? x)
(is-a? x fragment%))
(define fragment-key (class-field-accessor fragment% key))
(define fragment-content (class-field-accessor fragment% content))
(define fragment-printer
(make-constructor-style-printer fragment-key fragment-content))
(define-syntax-rule (def-clauses id ...)
(begin
(define (id . args)
(new fragment% [key 'id] [content args]))
...))
(def-clauses select where group-by having order-by join-on)
; These are fragments, not clauses, but there is no difference now
(def-clauses scalar aggregate bool subquery sql silence)
;; ==========
;; A setter is a clause<%> that writes a property value into the content
;; ==========
(define setter%
; We don't need to implement equal<%> because anything we do should be captured
; when we modify the content.
(class* object% (clause<%> printable<%>)
(init-field prop val print-name)
(super-new)
(define/public (apply content)
(content-set content prop val))
; printable<%>
(define/public (custom-print port mode)
(setter-printer this port mode))
(define/public (custom-write port)
(setter-printer this port #t))
(define/public (custom-display port)
(setter-printer this port #f))))
(define setter-print-name (class-field-accessor setter% print-name))
(define setter-val (class-field-accessor setter% val))
(define setter-printer
(make-constructor-style-printer
setter-print-name
(λ (me) (list (setter-val me)))))
(define-syntax-rule (define-setters [prop-id id] ...)
(begin
(define prop-id (make-property #:name 'id #:default #f))
...
(define (id x)
(new setter% [prop prop-id] [val x] [print-name 'id]))
...))
(define-setters
[:limit limit]
[:offset offset]
[:distinct distinct]
; join-type of #f means "infer" which is the default
[:join-type join-type])
(define (get-join-type x)
(let ([my-type (property-value x :join-type)])
(or my-type
; infer
(let* ([joins (join-on-joins x)]
[types (map get-join-type joins)])
(if (member 'left types)
'left
'inner)))))
| true |
db95d43af08813a6638711bee2de92fc3df07248 | e872962b1fb9b3c4b78e739e603e878bd29bde7c | /libgit2/scribblings/refspec.scrbl | 0648a5eca8fec56930e3a5fe44674d3ae94dbc2a | [
"MIT"
]
| permissive | LiberalArtist/libgit2 | f0e266a85e205df30f6fab1c7876a6e3d85e9ba6 | af2670e94f8fa9b74aab98590c40bbd282fa0292 | refs/heads/main | 2023-08-06T23:40:18.395064 | 2023-07-08T19:23:25 | 2023-07-08T19:23:25 | 165,514,201 | 0 | 0 | MIT | 2019-01-13T14:21:34 | 2019-01-13T14:21:34 | null | UTF-8 | Racket | false | false | 1,428 | scrbl | refspec.scrbl | #lang scribble/manual
@(require (for-label racket))
@title{Refspec}
@defmodule[libgit2/include/refspec]
@defproc[(git_refspec_direction
[spec refspec?])
_git_direction]{
Get the refspec's direction.
}
@defproc[(git_refspec_dst
[refspec refspec?])
string?]{
Get the destination specifier
}
@defproc[(git_refspec_dst_matches
[refspec refspec?]
[refname string?])
boolean?]{
Check if a refspec's destination descriptor matches a reference
}
@defproc[(git_refspec_force
[refspec refspec?])
boolean?]{
Get the force update setting
}
@defproc[(git_refspec_rtransform
[out buf?]
[spec refspec?]
[name string?])
integer?]{
Transform a target reference to its source reference following the refspec's rules
}
@defproc[(git_refspec_src
[refspec refspec?])
string?]{
Get the source specifier
}
@defproc[(git_refspec_src_matches
[refspec refspec?]
[refname string?])
boolean?]{
Check if a refspec's source descriptor matches a reference
}
@defproc[(git_refspec_string
[refspec refspec?])
string?]{
Get the refspec's string
}
@defproc[(git_refspec_transform
[out buf?]
[spec refspec?]
[name string?])
integer?]{
Transform a reference to its target following the refspec's rules
}
| false |
cb74ddb969996e401408cd22332b3a62899c5960 | 099418d7d7ca2211dfbecd0b879d84c703d1b964 | /whalesong/lang/private/shared-body.rkt | 2ed370e1a2485fc06e6d5afb444452b1c4bc5424 | []
| no_license | vishesh/whalesong | f6edd848fc666993d68983618f9941dd298c1edd | 507dad908d1f15bf8fe25dd98c2b47445df9cac5 | refs/heads/master | 2021-01-12T21:36:54.312489 | 2015-08-19T19:28:25 | 2015-08-19T20:34:55 | 34,933,778 | 3 | 0 | null | 2015-05-02T03:04:54 | 2015-05-02T03:04:54 | null | UTF-8 | Racket | false | false | 19,294 | rkt | shared-body.rkt |
;; Used by ../shared.rkt, and also collects/lang/private/teach.rkt
;; Besides the usual things, this code expects `undefined' and
;; `the-cons', to be bound, it expects `struct-declaration-info?'
;; from the "struct.rkt" library of the "syntax" collection, and it
;; expects `code-insp' for-syntax.
(syntax-case stx ()
[(_ ([name expr] ...) body1 body ...)
(let ([names (syntax->list (syntax (name ...)))]
[exprs (syntax->list (syntax (expr ...)))])
(for-each (lambda (name)
(unless (identifier? name)
(raise-syntax-error
'shared
"not an identifier"
stx
name)))
names)
(let ([dup (check-duplicate-identifier names)])
(when dup
(raise-syntax-error
'shared
"duplicate identifier"
stx
dup)))
(let ([exprs (map (lambda (expr)
(let ([e (local-expand
expr
'expression
(append
(kernel-form-identifier-list)
names))])
;; Remove traced app if present
(let ([removing-traced-app
(syntax-case (syntax-disarm e code-insp) (with-continuation-mark traced-app-key)
[(with-continuation-mark traced-app-key val body)
(syntax/loc e body)]
[else
e])])
;; Remove #%app if present...
(syntax-case (syntax-disarm removing-traced-app code-insp) (#%plain-app)
[(#%plain-app a ...)
(syntax/loc removing-traced-app (a ...))]
[_else removing-traced-app]))))
exprs)]
[temp-ids (generate-temporaries names)]
[placeholder-ids (generate-temporaries names)]
[ph-used?s (map (lambda (x) (box #f)) names)]
[struct-decl-for (lambda (id)
(and (identifier? id)
(let ([get-struct
(lambda (id)
(let ([v (syntax-local-value id (lambda () #f))])
(and v
(struct-declaration-info? v)
(let ([decl (extract-struct-info v)])
(and (cadr decl)
(andmap values (list-ref decl 4))
(append decl
(list
(if (struct-auto-info? v)
(struct-auto-info-lists v)
(list null null)))))))))])
(or (get-struct id)
(let ([s (syntax-property id 'constructor-for)])
(and s
(identifier? s)
(get-struct s)))
(let* ([s (symbol->string (syntax-e id))]
[m (regexp-match-positions "make-" s)])
(and m
(let ([name (datum->syntax
id
(string->symbol (string-append (substring s 0 (caar m))
(substring s (cdar m) (string-length s))))
id)])
(get-struct name))))))))]
[append-ids null]
[same-special-id? (lambda (a b)
;; Almost module-or-top-identifier=?,
;; but handle the-cons specially
(or (free-identifier=? a b)
(free-identifier=?
a
(datum->syntax
#f
(if (eq? 'the-cons (syntax-e b))
'cons
(syntax-e b))))))]
[remove-all (lambda (lst rmv-lst)
(define (remove e l)
(cond
[(free-identifier=? e (car l)) (cdr l)]
[else (cons (car l) (remove e (cdr l)))]))
(let loop ([lst lst] [rmv-lst rmv-lst])
(if (null? rmv-lst)
lst
(loop (remove (car rmv-lst) lst)
(cdr rmv-lst)))))]
[disarm (lambda (stx) (syntax-disarm stx code-insp))])
(with-syntax ([(graph-expr ...)
(map (lambda (expr)
(let loop ([expr expr])
(define (bad n)
(raise-syntax-error
'shared
(format "illegal use of ~a" n)
stx
expr))
(define (cons-elem expr)
(or (and (identifier? expr)
(ormap (lambda (i ph ph-used?)
(and (free-identifier=? i expr)
(set-box! ph-used? #t)
ph))
names placeholder-ids ph-used?s))
(loop expr)))
(syntax-case* (disarm expr) (the-cons mcons append box box-immutable vector vector-immutable) same-special-id?
[(the-cons a d)
(with-syntax ([a (cons-elem #'a)]
[d (cons-elem #'d)])
(syntax/loc expr (cons a d)))]
[(the-cons . _)
(bad "cons")]
[(mcons a d)
(syntax (mcons undefined undefined))]
[(mcons . _)
(bad "mcons")]
[(lst e ...)
(ormap (lambda (x) (same-special-id? #'lst x))
(syntax->list #'(list list*)))
(with-syntax ([(e ...)
(map (lambda (x) (cons-elem x))
(syntax->list (syntax (e ...))))])
(syntax/loc expr (lst e ...)))]
[(lst . _)
(ormap (lambda (x) (same-special-id? #'lst x))
(syntax->list #'(list list*)))
(bad (syntax-e #'lst))]
[(append e0 ... e)
(let ([len-id (car (generate-temporaries '(len)))])
(set! append-ids (cons len-id append-ids))
(with-syntax ([e (cons-elem #'e)]
[len-id len-id])
(syntax/loc expr (let ([ph (make-placeholder e)]
[others (append e0 ... null)])
(set! len-id (length others))
(append others ph)))))]
[(append . _)
(bad "append")]
[(box v)
(syntax (box undefined))]
[(box . _)
(bad "box")]
[(box-immutable v)
(with-syntax ([v (cons-elem #'v)])
(syntax/loc expr (box-immutable v)))]
[(vector e ...)
(with-syntax ([(e ...)
(map (lambda (x) (syntax undefined))
(syntax->list (syntax (e ...))))])
(syntax (vector e ...)))]
[(vector . _)
(bad "vector")]
[(vector-immutable e ...)
(with-syntax ([(e ...)
(map (lambda (x) (cons-elem x))
(syntax->list (syntax (e ...))))])
(syntax/loc expr (vector-immutable e ...)))]
[(vector-immutable . _)
(bad "vector-immutable")]
[(make-x . args)
(struct-decl-for (syntax make-x))
(let ([decl (struct-decl-for (syntax make-x))]
[args (syntax->list (syntax args))])
(unless args
(bad "structure constructor"))
(let ([expected (- (length (list-ref decl 4))
(length (car (list-ref decl 6))))])
(unless (= expected (length args))
(raise-syntax-error
'shared
(format "wrong argument count for structure constructor; expected ~a, found ~a"
expected (length args))
stx
expr)))
(with-syntax ([undefineds (map (lambda (x) (syntax undefined)) args)])
(syntax (make-x . undefineds))))]
[_else expr])))
exprs)]
[(init-expr ...)
(map (lambda (expr temp-id used?)
(let ([init-id
(syntax-case* expr (the-cons mcons list list* append box box-immutable vector vector-immutable) same-special-id?
[(the-cons . _) temp-id]
[(mcons . _) temp-id]
[(list . _) temp-id]
[(list* . _) temp-id]
[(append . _) temp-id]
[(box . _) temp-id]
[(box-immutable . _) temp-id]
[(vector . _) temp-id]
[(vector-immutable . _) temp-id]
[(make-x . _)
(syntax-case (syntax-disarm expr code-insp) ()
[(make-x . _)
(struct-decl-for (syntax make-x))])
temp-id]
[else #f])])
(cond
[init-id
(set-box! used? #t)
init-id]
[(unbox used?)
temp-id]
[else
expr])))
exprs temp-ids ph-used?s)]
[(finish-expr ...)
(let ([gen-n (lambda (l)
(let loop ([l l][n 0])
(if (null? l)
null
(cons (datum->syntax (quote-syntax here) n #f)
(loop (cdr l) (add1 n))))))]
[append-ids (reverse append-ids)])
(map (lambda (name expr)
(let loop ([name name] [expr expr])
(with-syntax ([name name])
(syntax-case* (disarm expr) (the-cons mcons list list* append box box-immutable vector vector-immutable)
same-special-id?
[(the-cons a d)
#`(begin #,(loop #`(car name) #'a)
#,(loop #`(cdr name) #'d))]
[(mcons a d)
(syntax (begin
(set-mcar! name a)
(set-mcdr! name d)))]
[(list e ...)
(let ([es (syntax->list #'(e ...))])
#`(begin
#,@(map (lambda (n e)
(loop #`(list-ref name #,n) e))
(gen-n es)
es)))]
[(list* e ...)
(let* ([es (syntax->list #'(e ...))]
[last-n (sub1 (length es))])
#`(begin
#,@(map (lambda (n e)
(loop #`(#,(if (= (syntax-e n) last-n)
#'list-tail
#'list-ref)
name
#,n)
e))
(gen-n es)
es)))]
[(append e0 ... e)
(with-syntax ([len-id (car append-ids)])
(set! append-ids (cdr append-ids))
(loop #`(list-tail name len-id) #'e))]
[(box v)
(syntax (set-box! name v))]
[(box-immutable v)
(loop #'(unbox name) #'v)]
[(vector e ...)
(with-syntax ([(n ...) (gen-n (syntax->list (syntax (e ...))))])
(syntax (let ([vec name])
(vector-set! vec n e)
...)))]
[(vector-immutable e ...)
(let ([es (syntax->list #'(e ...))])
#`(begin
#,@(map (lambda (n e)
(loop #`(vector-ref name #,n) e))
(gen-n es)
es)))]
[(make-x e ...)
(struct-decl-for (syntax make-x))
(let ([decl (struct-decl-for (syntax make-x))])
(syntax-case (remove-all (reverse (list-ref decl 4)) (cadr (list-ref decl 6))) ()
[()
(syntax (void))]
[(setter ...)
(syntax (begin (setter name e) ...))]))]
[_else (syntax (void))]))))
names exprs))]
[(check-expr ...)
(if make-check-cdr
(map (lambda (name expr)
(syntax-case* expr (the-cons) same-special-id?
[(the-cons a d)
(make-check-cdr name)]
[_else (syntax #t)]))
names exprs)
null)]
[(temp-id ...) temp-ids]
[(placeholder-id ...) placeholder-ids]
[(ph-used? ...) (map unbox ph-used?s)]
[(used-ph-id ...) (filter values
(map (lambda (ph ph-used?)
(and (unbox ph-used?)
ph))
placeholder-ids ph-used?s))]
[(maybe-ph-id ...) (map (lambda (ph ph-used?)
(and (unbox ph-used?)
ph))
placeholder-ids ph-used?s)])
(with-syntax ([(ph-init ...) (filter values
(map (lambda (ph ph-used? graph-expr)
(and (unbox ph-used?)
#`(placeholder-set! #,ph #,graph-expr)))
placeholder-ids ph-used?s
(syntax->list #'(graph-expr ...))))]
[(append-id ...) append-ids])
(syntax/loc stx
(letrec-values ([(used-ph-id) (make-placeholder #f)] ...
[(append-id) #f] ...
[(temp-id ...)
(begin
ph-init ...
(apply values (make-reader-graph
(list maybe-ph-id ...))))]
[(name) init-expr] ...)
finish-expr
...
check-expr
...
body1
body
...))))))])
| false |
08629271dde3c209f74fe6a1e05e04a744a4822e | 4a95afbe4db08093919fed3328ae84f2f37fd0dc | /eval.rkt | a744598f0b7c75fff0887c0735772e149bebaa82 | []
| no_license | rntz/quelle | 2a38dc2cac30b01f55da10fb5d2a42f8e5c7f929 | 243324a9abb2e05cd237789eb2526d4a7ff8ca60 | refs/heads/master | 2021-01-19T21:28:14.372607 | 2015-10-17T17:39:33 | 2015-10-17T17:39:33 | 34,764,582 | 2 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 3,084 | rkt | eval.rkt | #lang racket
(require "util.rkt" "ast.rkt" "types.rkt" "elab.rkt" "sets.rkt")
(provide (all-defined-out))
;;; Evaluation of elaborated expressions
(define make-tuple vector)
(define tuple-ref vector-ref)
(define (make-tag tag exp) (list tag exp))
(define (eval-R σ level-expr)
(define (recur x) (eval-R σ x))
(match-define (cons level expr) level-expr)
(if (F? level)
(set (eval-F σ level-expr))
(match expr
[(e-empty) (set)]
[(e-union a b) (set-union (recur a) (recur b))]
[(e-any e)
(match (car e)
['F (eval-F σ e)]
['R (set-unions (recur e))])]
[(e-tuple es)
(set-apply make-tuple (map recur es))]
[(e-proj i e) (for/set ([v (recur e)]) (tuple-ref v i))]
[(e-tag tag e) (for/set ([v (recur e)]) (make-tag tag v))]
[(e-case subj branches)
(let*/set ([sv (recur subj)])
(let loop ([bs branches])
(match bs
['() (error "no case matched")]
[(cons (cons p e) bs)
(match (pat-match p sv)
[#f (loop bs)]
[σ- (eval-R (append σ- σ) e)])])))]
[(e-app-fun func args)
(match (car func)
['F (set-apply (eval-F σ func) (map recur args))]
['R (set-apply apply (recur func) (map recur args))])]
[(e-app-rel func args)
(match (car func)
['F (set-apply/set (eval-F σ func) (map recur args))]
['R (set-apply/set apply (recur func) (map recur args))])]
[_ (error "internal error: not an R expression")])))
(define (eval-F σ level-expr)
(define (recur x) (eval-F σ x))
(match-define (cons level expr) level-expr)
(unless (F? level) (error "internal error: got R, expected F"))
(match expr
[(e-base v _) v]
[(e-var _ i) (env-ref σ i)]
[(e-set e) (eval-R σ e)]
[(e-tuple es) (apply make-tuple (map recur es))]
[(e-proj i e) (tuple-ref (recur e) i)]
[(e-tag tag e) (make-tag tag (recur e))]
[(e-case subj branches)
(define sv (recur subj))
(let loop ([bs branches])
(match bs
['() (error "no case matched")]
[(cons (cons p e) bs)
(match (pat-match p sv)
[#f (loop bs)]
[σ- (eval-F (append σ- σ) e)])]))]
[(e-app-fun fnc arg) (apply (recur fnc) (map recur arg))]
[(e-fun _ _ body) (lambda as (eval-F (env-extend as σ) body))]
[(e-rel _ _ body) (lambda as (eval-R (env-extend as σ) body))]
[_ (error "internal error: not an F expression")]))
;; returns either #f for no match or an env to be added to the current one
(define/match (pat-match pat val)
[((p-wild) _) '()]
[((p-var _) v) (list v)]
[((p-tuple ps) (? vector? vs))
(let loop ([ps ps] [vs (vector->list vs)] [σ '()])
(match* (ps vs)
[('() '()) σ]
[((cons p ps) (cons v vs))
(define σ- (pat-match p v))
(and σ- (loop ps vs (append σ- σ)))]))]
[((p-tag tag p) (list vtag v)) (and (equal? tag vtag) (pat-match p v))]
[((p-lit l) v) (and (equal? l v) '())])
| false |
119acceef92fb2fa43605e8ddd34597beaed6e7a | 731d6acf8e1c15b91f3d4312a9eab4d0bb6162e1 | /1920_array_permutation.rkt | dac5d61fb120723563436634643f4cd18c76e8f3 | []
| no_license | jrciii/leetcode | 04103494271359597af252a547870872d2f9ab2b | 5f2adaeaaa1f6d8d8734cf23f45b8528be4fdbfa | refs/heads/main | 2023-08-05T10:50:19.886744 | 2021-09-24T21:13:19 | 2021-09-24T21:13:19 | 408,461,147 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 73 | rkt | 1920_array_permutation.rkt | (define (build-array nums)
(map (lambda (x) (list-ref nums x)) nums))
| false |
02e48c0108280e89e4d131723c9deab0f402ecb9 | 6f79b25d38f4d20d0dd85cd8546a19e113a1f850 | /tilda.scrbl | 3c925ecffecbe7b937a458fda262bc3e6610fff0 | []
| no_license | vkz/tilda | 326f529aa0bbd4a52f72171d1734a45a74dafe51 | a1707d5cb6d3c0c5ad17b4fc720e4f812e4fcc24 | refs/heads/master | 2020-05-19T08:47:23.011043 | 2019-09-08T13:28:15 | 2019-09-08T13:28:15 | 184,929,960 | 4 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,972 | scrbl | tilda.scrbl | #lang scribble/manual
@(require (for-label racket/base
racket/math
tilda)
scribble/eval)
@(define eval~>
(make-eval-factory '(tilda
racket/function
racket/list
racket/math)))
@title{Threading with tildas}
@defmodule[tilda]
@defform[#:literals (~ ~foo ~id)
(~> expr clause ...)
#:grammar
([clause thread-option
(expr ...)
(pre-expr ... hole post-expr ...)]
[hole ~
~id]
[thread-option (code:line #:with pat expr/hole)
(code:line #:do (expr/hole ...))
(code:line #:as id)
(code:line #:when expr/hole expr/hole)
(code:line #:unless expr/hole expr/hole)]
[expr/hole (pre-expr ... hole post-expr ...)
(expr ...)
expr])]{
@italic{Threads} the @racket[expr] through the next @racket[clause], then that
@racket[clause] through the one after it and so on. "Threads" here means that the
@racket[expr] will replace a @racket[hole], if there is one, in the
@racket[clause]. Clause with such replacement becomes the new @racket[expr] to be
threaded through the next clause. @racket[hole] is any unbound identifier that
starts with @racket[~].
@(examples
#:eval (eval~>)
(~> '(1 2 3)
(map add1 ~)
(second ~)
(* 2 ~))
(~> "foo"
(string->bytes/utf-8 ~)
(bytes->list ~)
(map (curry * 2) ~)
(list->bytes ~)))
@(examples
#:eval (eval~>)
(~> 6
(range 1 ~upto)
(filter odd? ~)
(findf even? ~)
#:do ((unless ~num (<~ #f)))
(* 2 ~))
(~> '(1 6)
#:with (list from upto) ~
(range from upto)
(filter odd? ~)
(findf even? ~)
#:do ((unless ~num (<~ #f)))
(* 2 ~)))
} | false |
8e492f2310d5725dcb8b0904ddb88c1b1be7e0a9 | b2f2c2f4f3826e380b43ed1da9b8a88a7968c886 | /private/util.rkt | fe5a4d6c1e8852e6b89d773a48660e3b15c897a3 | [
"Apache-2.0",
"MIT"
]
| permissive | rmculpepper/racket-jeremiah | d8eeed3dd3d2bbef06f350066980add50d850726 | 9890d6f0bebcc7cfe4f4072ef878607da6d85ff8 | refs/heads/master | 2021-02-16T10:10:59.047982 | 2020-08-21T11:17:36 | 2020-08-21T11:17:36 | 244,993,339 | 0 | 1 | null | null | null | null | UTF-8 | Racket | false | false | 2,262 | rkt | util.rkt | #lang racket/base
(require racket/string
racket/list
racket/match
net/url)
(provide (all-defined-out))
;; See the notes in this directory's README.md for some terminology
;; definitions and implementation naming conventions.
(define-logger jeremiah)
;; ----------------------------------------
;; URL utils
;; local-url : URL -> URL
(define (local-url u #:who [who 'local-url])
(match u
[(url scheme user host port #t path '() #f)
(url #f #f #f #f #t path '() #f)]
[_ (error who "cannot convert to local URL: ~e" u)]))
;; build-url : URL String ... -> URL
(define (build-url base . paths)
(define (trim-final-/ pps)
(cond [(and (pair? pps) (match (last pps) [(path/param "" '()) #t] [_ #f]))
(drop-right pps 1)]
[else pps]))
(match base
[(url scheme user host post #t pps '() #f)
(define new-pps
(for*/list ([path (in-list paths)] [part (in-list (regexp-split #rx"/" path))])
(path/param part null)))
(define pps* (append (trim-final-/ pps) new-pps))
(url scheme user host post #t pps* '() #f)]))
;; build-link : URL/String String ... -> String
(define (build-link base #:local? [local? #t] . paths)
(let* ([base (if (url? base) base (string->url base))]
[base (if local? (local-url base) base)])
(url->string (apply build-url base paths))))
;; no-end-/ : String -> String
(define (no-end-/ str) (regexp-replace #rx"/$" str ""))
;; slug : String -> String
;; Convert a string into a "slug", in which:
;; - The string is Unicode normalized to NFC form.
;; - Consecutive characters that are neither char-alphabetic? nor char-numeric?
;; are replaced by hyphens.
;; - The string is Unicode normalized to NFD form.
(define (slug s)
(let* ([s (string-normalize-nfc s)]
[s (let ([cleaned-s (string-copy s)])
(for ([c (in-string cleaned-s)] [i (in-naturals)])
(unless (or (char-alphabetic? c) (char-numeric? c))
(string-set! cleaned-s i #\-)))
cleaned-s)]
[s (regexp-replace* #px"-{2,}" s "-")]
[s (regexp-replace #px"-{1,}$" s "")]
[s (regexp-replace #px"^-{1,}" s "")]) ;; breaks compat w/ Frog
(string-normalize-nfd s)))
| false |
ad01228ca5fa0542163fc0c5ec9babedccea1edf | d2d01d48d5c59d54c295f8474c45e3b42f605005 | /accelerack/tests/internal/ffi-tests.rkt | d93cd077000f80064aa9e147793b02d88c02f0d9 | []
| no_license | iu-parfunc/accelerack | 543d73e3a01711ad765f6ee4defef0c9d52447b8 | 9550ecc1e7494d296f3faac3aef71393c1705827 | refs/heads/master | 2021-01-21T04:27:28.653604 | 2016-05-02T14:02:24 | 2016-05-02T14:02:24 | 30,226,648 | 3 | 6 | null | null | null | null | UTF-8 | Racket | false | false | 2,130 | rkt | ffi-tests.rkt | #lang racket/base
;; Test C FFI and load code from ../acc_c
(require ffi/unsafe
ffi/unsafe/define
rackunit
rackunit/text-ui
racket/runtime-path
(only-in '#%foreign ctype-scheme->c ctype-c->scheme))
(require (except-in accelerack ->))
(require accelerack/acc-array/private/manifest-array/structs ;; C data reps.
; (only-in accelerack/private/syntax array)
(only-in accelerack/acc-array/private/manifest-array
manifest-array->sexp)
accelerack/private/racket_ops
; (only-in accelerack/private/paven_old/global_utils add sub mult)
)
(printf "<-------------- Setting up the Haskell environment --------------->")
(define-runtime-path librachs "../../../build/librachs.so")
(define lib-hs (ffi-lib librachs))
(define-ffi-definer define-hs lib-hs)
;;(define lib-ifc (ffi-lib "../../../acc_hs/libhsifc"))
;;(define-ffi-definer define-ifc lib-ifc)
(define-runtime-path librts "../../../acc_c/librts.so")
(define lib-rts (ffi-lib librts))
(define-ffi-definer define-rts lib-rts)
(define-rts ark_init (_fun -> _int))
(define-rts ark_exit (_fun -> _int))
(ark_init)
(printf "!!! init function success !!!\n")
(define-hs entrypoint (_fun _int -> _int))
(printf "calling entrypoint: ")
(entrypoint 0)
(printf "!!! entrypoint function called successfully!!!\n")
(newline)
(printf "########## Ready to call haskell functions ###########\n")
(define-hs accelerateMap (_fun _acc-manifest-array-pointer _acc-manifest-array-pointer _int _int -> _void))
(define-hs accelerateZipWith (_fun _acc-manifest-array-pointer _acc-manifest-array-pointer _acc-manifest-array-pointer _int -> _void))
(define-hs accelerateFold (_fun _acc-manifest-array-pointer _acc-manifest-array-pointer _int _int -> _void))
(define accelerate-test-cases (test-suite
"GPU Test Cases"
))
(display "\n<----------- Accelerate test-cases Run ----------->\n")
(if (run-tests accelerate-test-cases)
(display "\n!!! Test Run Successfull !!!\n")
(display "\n!!! Test Run Failed !!!\n"))
(printf "########## Exiting racket safely ############\n")
| false |
b832ad0f5b81c81db5d5f89f1d0de936543247c9 | fc6465100ab657aa1e31af6a4ab77a3284c28ff0 | /results/all/rbtrees-3-grammar.rktd | eaed44d201579e61d94adb6ee2bf50f133fc6280 | []
| no_license | maxsnew/Redex-Enum-Paper | f5ba64a34904beb6ed9be39ff9a5e1e5413c059b | d77ec860d138cb023628cc41f532dd4eb142f15b | refs/heads/master | 2020-05-21T20:07:31.382540 | 2017-09-04T14:42:13 | 2017-09-04T14:42:13 | 17,602,325 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 165,754 | rktd | rbtrees-3-grammar.rktd | (start 2015-06-23T10:45:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:45:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:45:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:45:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:45:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:46:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:46:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:46:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:46:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:46:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:46:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:47:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:47:19 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T10:47:26 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 315439 #:time 116822))
(new-average 2015-06-23T10:47:26 (#:model "rbtrees-3" #:type grammar #:average 116821.0 #:stderr +nan.0))
(heartbeat 2015-06-23T10:47:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:47:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:47:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:47:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:48:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:48:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:48:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:48:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:48:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:48:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:49:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:49:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:49:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:49:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:49:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:49:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:50:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:50:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:50:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:50:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:50:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:50:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:51:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:51:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:51:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:51:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:51:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:51:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:52:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:52:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:52:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:52:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:52:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:52:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:53:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:53:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:53:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:53:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:53:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:53:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:54:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:54:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:54:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:54:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:54:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:54:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:55:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:55:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:55:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:55:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:55:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:55:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:56:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:56:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:56:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:56:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:56:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:56:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:57:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:57:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:57:29 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T10:57:31 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 1742287 #:time 606064))
(new-average 2015-06-23T10:57:31 (#:model "rbtrees-3" #:type grammar #:average 361442.5 #:stderr 244621.5))
(heartbeat 2015-06-23T10:57:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:57:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:57:59 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T10:58:00 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 88101 #:time 28866))
(new-average 2015-06-23T10:58:00 (#:model "rbtrees-3" #:type grammar #:average 250583.6666666667 #:stderr 179544.53583659342))
(heartbeat 2015-06-23T10:58:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:58:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:58:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:58:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:58:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:58:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:59:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:59:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:59:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:59:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:59:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T10:59:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:00:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:00:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:00:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:00:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:00:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:00:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:01:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:01:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:01:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:01:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:01:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:01:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:02:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:02:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:02:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:02:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:02:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:02:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:03:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:03:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:03:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:03:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:03:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:03:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:04:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:04:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:04:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:04:39 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T11:04:44 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B (R E O E) (s O) (R E (s (s O)) E)) (s (s (s (s O)))) E) #:iterations 1082004 #:time 404238))
(new-average 2015-06-23T11:04:44 (#:model "rbtrees-3" #:type grammar #:average 288997.25 #:stderr 132641.33427742586))
(heartbeat 2015-06-23T11:04:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:04:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:05:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:05:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:05:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:05:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:05:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:05:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:06:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:06:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:06:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:06:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:06:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:06:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:07:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:07:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:07:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:07:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:07:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:07:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:08:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:08:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:08:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:08:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:08:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:08:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:09:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:09:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:09:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:09:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:09:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:09:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:10:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:10:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:10:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:10:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:10:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:10:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:11:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:11:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:11:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:11:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:11:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:12:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:12:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:12:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:12:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:12:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:12:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:13:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:13:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:13:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:13:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:13:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:13:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:14:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:14:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:14:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:14:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:14:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:14:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:15:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:15:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:15:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:15:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:15:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:15:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:16:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:16:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:16:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:16:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:16:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:16:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:17:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:17:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:17:20 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T11:17:24 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B (R E O E) (s O) (R E (s (s O)) E)) (s (s (s (s O)))) E) #:iterations 1719905 #:time 760025))
(new-average 2015-06-23T11:17:24 (#:model "rbtrees-3" #:type grammar #:average 383202.8 #:stderr 139394.83414438282))
(heartbeat 2015-06-23T11:17:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:17:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:17:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:18:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:18:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:18:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:18:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:18:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:18:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:19:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:19:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:19:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:19:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:19:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:19:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:20:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:20:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:20:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:20:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:20:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:20:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:21:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:21:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:21:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:21:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:21:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:21:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:22:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:22:10 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T11:22:18 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 702284 #:time 294098))
(new-average 2015-06-23T11:22:18 (#:model "rbtrees-3" #:type grammar #:average 368352.0 #:stderr 114780.1933468198))
(heartbeat 2015-06-23T11:22:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:22:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:22:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:22:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:23:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:23:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:23:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:23:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:23:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:23:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:24:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:24:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:24:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:24:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:24:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:24:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:25:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:25:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:25:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:25:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:25:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:25:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:26:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:26:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:26:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:26:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:26:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:26:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:27:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:27:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:27:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:27:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:27:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:27:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:28:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:28:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:28:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:28:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:28:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:28:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:29:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:29:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:29:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:29:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:29:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:29:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:30:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:30:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:30:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:30:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:30:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:30:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:31:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:31:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:31:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:31:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:31:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:31:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:32:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:32:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:32:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:32:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:32:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:32:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:33:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:33:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:33:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:33:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:33:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:33:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:34:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:34:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:34:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:34:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:34:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:34:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:35:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:35:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:35:20 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T11:35:24 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B (R E O E) (s O) (R E (s (s O)) E)) (s (s (s (s O)))) E) #:iterations 2211651 #:time 786585))
(new-average 2015-06-23T11:35:24 (#:model "rbtrees-3" #:type grammar #:average 428099.5714285714 #:stderr 113930.34837437954))
(heartbeat 2015-06-23T11:35:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:35:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:35:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:36:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:36:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:36:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:36:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:36:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:36:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:37:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:37:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:37:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:37:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:37:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:37:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:38:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:38:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:38:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:38:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:38:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:38:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:39:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:39:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:39:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:39:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:39:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:39:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:40:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:40:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:40:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:40:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:40:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:40:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:41:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:41:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:41:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:41:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:41:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:41:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:42:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:42:10 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T11:42:10 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 1154274 #:time 406893))
(new-average 2015-06-23T11:42:10 (#:model "rbtrees-3" #:type grammar #:average 425448.75 #:stderr 98702.17862224109))
(heartbeat 2015-06-23T11:42:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:42:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:42:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:42:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:43:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:43:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:43:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:43:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:43:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:43:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:44:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:44:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:44:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:44:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:44:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:44:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:45:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:45:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:45:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:45:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:45:41 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T11:45:48 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B (R E O E) (s O) (R E (s (s O)) E)) (s (s (s (s O)))) E) #:iterations 521867 #:time 217350))
(new-average 2015-06-23T11:45:48 (#:model "rbtrees-3" #:type grammar #:average 402326.6666666667 #:stderr 90065.72729123993))
(heartbeat 2015-06-23T11:45:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:46:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:46:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:46:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:46:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:46:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:46:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:47:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:47:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:47:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:47:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:47:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:47:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:48:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:48:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:48:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:48:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:48:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:48:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:49:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:49:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:49:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:49:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:49:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:49:51 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T11:50:00 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 566971 #:time 252676))
(new-average 2015-06-23T11:50:00 (#:model "rbtrees-3" #:type grammar #:average 387361.60000000003 #:stderr 81935.4709899063))
(heartbeat 2015-06-23T11:50:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:50:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:50:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:50:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:50:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:50:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:51:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:51:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:51:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:51:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:51:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:51:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:52:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:52:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:52:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:52:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:52:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:52:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:53:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:53:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:53:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:53:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:53:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:53:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:54:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:54:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:54:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:54:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:54:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:54:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:55:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:55:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:55:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:55:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:55:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:55:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:56:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:56:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:56:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:56:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:56:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:56:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:57:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:57:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:57:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:57:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:57:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:57:51 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T11:57:53 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 1075842 #:time 472964))
(new-average 2015-06-23T11:57:53 (#:model "rbtrees-3" #:type grammar #:average 395143.6363636364 #:stderr 74520.86568487473))
(heartbeat 2015-06-23T11:58:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:58:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:58:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:58:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:58:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:58:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:59:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:59:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:59:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:59:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:59:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T11:59:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:00:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:00:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:00:21 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T12:00:26 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B (R E O E) (s O) (R E (s (s O)) E)) (s (s (s (s O)))) E) #:iterations 431411 #:time 153149))
(new-average 2015-06-23T12:00:26 (#:model "rbtrees-3" #:type grammar #:average 374977.4166666667 #:stderr 70954.04100932095))
(heartbeat 2015-06-23T12:00:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:00:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:00:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:01:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:01:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:01:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:01:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:01:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:01:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:02:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:02:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:02:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:02:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:02:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:02:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:03:01 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T12:03:11 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 463303 #:time 164743))
(new-average 2015-06-23T12:03:11 (#:model "rbtrees-3" #:type grammar #:average 358805.5384615385 #:stderr 67241.8829370367))
(heartbeat 2015-06-23T12:03:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:03:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:03:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:03:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:03:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:04:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:04:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:04:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:04:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:04:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:04:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:05:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:05:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:05:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:05:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:05:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:05:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:06:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:06:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:06:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:06:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:06:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:06:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:07:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:07:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:07:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:07:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:07:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:07:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:08:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:08:11 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T12:08:17 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 751754 #:time 306121))
(new-average 2015-06-23T12:08:17 (#:model "rbtrees-3" #:type grammar #:average 355042.35714285716 #:stderr 62367.52321174147))
(heartbeat 2015-06-23T12:08:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:08:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:08:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:08:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:09:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:09:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:09:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:09:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:09:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:09:51 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T12:10:00 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 287014 #:time 103651))
(new-average 2015-06-23T12:10:00 (#:model "rbtrees-3" #:type grammar #:average 338282.93333333335 #:stderr 60431.436447586864))
(heartbeat 2015-06-23T12:10:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:10:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:10:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:10:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:10:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:10:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:11:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:11:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:11:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:11:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:11:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:11:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:12:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:12:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:12:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:12:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:12:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:12:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:13:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:13:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:13:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:13:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:13:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:13:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:14:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:14:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:14:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:14:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:14:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:14:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:15:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:15:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:15:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:15:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:15:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:15:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:16:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:16:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:16:21 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:16:31 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:16:41 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:16:51 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:17:01 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:17:11 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:17:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:17:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:17:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:17:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:18:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:18:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:18:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:18:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:18:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:18:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:19:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:19:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:19:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:19:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:19:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:19:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:20:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:20:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:20:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:20:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:20:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:20:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:21:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:21:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:21:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:21:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:21:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:21:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:22:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:22:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:22:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:22:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:22:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:22:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:23:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:23:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:23:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:23:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:23:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:23:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:24:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:24:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:24:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:24:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:24:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:24:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:25:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:25:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:25:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:25:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:25:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:25:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:26:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:26:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:26:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:26:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:26:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:26:52 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T12:26:59 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 3128961 #:time 1019952))
(new-average 2015-06-23T12:26:59 (#:model "rbtrees-3" #:type grammar #:average 380887.25 #:stderr 70785.53168453636))
(heartbeat 2015-06-23T12:27:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:27:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:27:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:27:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:27:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:27:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:28:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:28:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:28:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:28:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:28:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:28:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:29:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:29:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:29:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:29:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:29:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:29:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:30:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:30:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:30:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:30:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:30:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:30:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:31:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:31:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:31:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:31:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:31:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:31:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:32:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:32:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:32:22 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T12:32:30 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 1024365 #:time 330759))
(new-average 2015-06-23T12:32:30 (#:model "rbtrees-3" #:type grammar #:average 377938.5294117647 #:stderr 66556.78099574507))
(heartbeat 2015-06-23T12:32:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:32:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:32:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:33:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:33:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:33:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:33:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:33:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:33:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:34:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:34:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:34:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:34:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:34:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:34:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:35:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:35:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:35:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:35:32 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T12:35:37 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 581857 #:time 187552))
(new-average 2015-06-23T12:35:37 (#:model "rbtrees-3" #:type grammar #:average 367361.5 #:stderr 63635.509594984775))
(heartbeat 2015-06-23T12:35:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:35:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:36:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:36:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:36:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:36:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:36:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:36:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:37:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:37:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:37:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:37:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:37:42 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T12:37:48 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 406690 #:time 131485))
(new-average 2015-06-23T12:37:48 (#:model "rbtrees-3" #:type grammar #:average 354946.94736842107 #:stderr 61460.054895684465))
(heartbeat 2015-06-23T12:37:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:38:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:38:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:38:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:38:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:38:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:38:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:39:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:39:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:39:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:39:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:39:42 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T12:39:47 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 369108 #:time 119223))
(new-average 2015-06-23T12:39:47 (#:model "rbtrees-3" #:type grammar #:average 343160.75 #:stderr 59485.451678623635))
(heartbeat 2015-06-23T12:39:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:40:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:40:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:40:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:40:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:40:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:40:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:41:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:41:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:41:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:41:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:41:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:41:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:42:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:42:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:42:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:42:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:42:42 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T12:42:51 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 569246 #:time 183551))
(new-average 2015-06-23T12:42:51 (#:model "rbtrees-3" #:type grammar #:average 335560.28571428574 #:stderr 57090.1411184079))
(heartbeat 2015-06-23T12:42:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:43:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:43:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:43:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:43:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:43:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:43:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:44:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:44:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:44:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:44:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:44:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:44:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:45:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:45:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:45:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:45:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:45:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:45:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:46:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:46:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:46:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:46:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:46:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:46:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:47:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:47:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:47:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:47:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:47:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:47:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:48:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:48:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:48:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:48:32 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T12:48:36 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 1070612 #:time 345673))
(new-average 2015-06-23T12:48:36 (#:model "rbtrees-3" #:type grammar #:average 336019.9545454546 #:stderr 54435.25460162001))
(heartbeat 2015-06-23T12:48:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:48:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:49:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:49:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:49:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:49:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:49:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:49:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:50:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:50:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:50:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:50:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:50:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:50:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:51:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:51:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:51:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:51:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:51:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:51:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:52:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:52:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:52:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:52:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:52:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:52:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:53:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:53:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:53:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:53:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:53:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:53:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:54:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:54:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:54:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:54:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:54:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:54:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:55:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:55:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:55:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:55:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:55:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:55:52 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T12:56:01 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 1378895 #:time 444830))
(new-average 2015-06-23T12:56:01 (#:model "rbtrees-3" #:type grammar #:average 340750.82608695654 #:stderr 52229.386265270696))
(heartbeat 2015-06-23T12:56:02 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:56:12 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:56:22 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:56:32 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:56:42 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:56:52 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:57:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:57:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:57:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:57:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:57:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:57:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:58:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:58:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:58:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:58:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:58:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:58:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:59:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:59:13 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T12:59:14 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B (R E O E) (s O) (R E (s (s O)) E)) (s (s (s (s O)))) E) #:iterations 600124 #:time 193698))
(new-average 2015-06-23T12:59:14 (#:model "rbtrees-3" #:type grammar #:average 334623.5833333334 #:stderr 50379.81898476913))
(heartbeat 2015-06-23T12:59:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:59:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T12:59:43 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T12:59:46 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 98125 #:time 31702))
(new-average 2015-06-23T12:59:46 (#:model "rbtrees-3" #:type grammar #:average 322506.72000000003 #:stderr 49818.61544745833))
(heartbeat 2015-06-23T12:59:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:00:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:00:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:00:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:00:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:00:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:00:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:01:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:01:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:01:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:01:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:01:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:01:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:02:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:02:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:02:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:02:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:02:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:02:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:03:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:03:13 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T13:03:13 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 641778 #:time 207333))
(new-average 2015-06-23T13:03:13 (#:model "rbtrees-3" #:type grammar #:average 318076.96153846156 #:stderr 48068.724216623305))
(heartbeat 2015-06-23T13:03:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:03:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:03:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:03:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:04:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:04:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:04:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:04:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:04:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:04:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:05:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:05:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:05:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:05:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:05:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:05:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:06:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:06:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:06:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:06:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:06:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:06:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:07:03 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T13:07:11 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 737149 #:time 238231))
(new-average 2015-06-23T13:07:11 (#:model "rbtrees-3" #:type grammar #:average 315119.7037037037 #:stderr 46348.59112912435))
(heartbeat 2015-06-23T13:07:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:07:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:07:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:07:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:07:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:08:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:08:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:08:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:08:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:08:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:08:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:09:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:09:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:09:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:09:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:09:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:09:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:10:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:10:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:10:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:10:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:10:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:10:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:11:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:11:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:11:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:11:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:11:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:11:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:12:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:12:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:12:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:12:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:12:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:12:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:13:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:13:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:13:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:13:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:13:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:13:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:14:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:14:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:14:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:14:33 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T13:14:42 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B (R E O E) (s O) (R E (s (s O)) E)) (s (s (s (s O)))) E) #:iterations 1400279 #:time 452051))
(new-average 2015-06-23T13:14:42 (#:model "rbtrees-3" #:type grammar #:average 320010.10714285716 #:stderr 44929.56339544887))
(heartbeat 2015-06-23T13:14:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:14:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:15:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:15:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:15:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:15:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:15:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:15:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:16:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:16:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:16:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:16:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:16:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:16:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:17:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:17:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:17:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:17:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:17:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:17:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:18:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:18:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:18:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:18:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:18:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:18:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:19:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:19:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:19:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:19:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:19:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:19:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:20:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:20:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:20:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:20:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:20:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:20:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:21:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:21:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:21:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:21:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:21:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:21:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:22:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:22:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:22:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:22:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:22:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:22:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:23:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:23:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:23:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:23:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:23:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:23:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:24:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:24:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:24:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:24:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:24:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:24:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:25:03 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T13:25:09 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 1942296 #:time 627453))
(new-average 2015-06-23T13:25:09 (#:model "rbtrees-3" #:type grammar #:average 330611.5862068966 #:stderr 44630.02020384221))
(heartbeat 2015-06-23T13:25:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:25:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:25:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:25:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:25:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:26:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:26:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:26:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:26:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:26:43 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T13:26:47 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 302432 #:time 97526))
(new-average 2015-06-23T13:26:47 (#:model "rbtrees-3" #:type grammar #:average 322842.0666666667 #:stderr 43811.12747223419))
(heartbeat 2015-06-23T13:26:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:27:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:27:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:27:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:27:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:27:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:27:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:28:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:28:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:28:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:28:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:28:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:28:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:29:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:29:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:29:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:29:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:29:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:29:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:30:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:30:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:30:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:30:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:30:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:30:53 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T13:30:55 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 770672 #:time 248716))
(new-average 2015-06-23T13:30:55 (#:model "rbtrees-3" #:type grammar #:average 320450.870967742 #:stderr 42441.718727263826))
(heartbeat 2015-06-23T13:31:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:31:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:31:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:31:33 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T13:31:42 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 144859 #:time 46876))
(new-average 2015-06-23T13:31:42 (#:model "rbtrees-3" #:type grammar #:average 311901.65625000006 #:stderr 41973.88882128353))
(heartbeat 2015-06-23T13:31:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:31:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:32:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:32:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:32:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:32:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:32:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:32:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:33:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:33:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:33:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:33:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:33:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:33:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:34:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:34:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:34:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:34:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:34:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:34:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:35:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:35:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:35:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:35:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:35:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:35:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:36:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:36:13 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T13:36:20 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 861994 #:time 278385))
(new-average 2015-06-23T13:36:20 (#:model "rbtrees-3" #:type grammar #:average 310886.00000000006 #:stderr 40694.750248733784))
(heartbeat 2015-06-23T13:36:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:36:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:36:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:36:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:37:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:37:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:37:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:37:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:37:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:37:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:38:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:38:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:38:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:38:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:38:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:38:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:39:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:39:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:39:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:39:33 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T13:39:35 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 604160 #:time 194998))
(new-average 2015-06-23T13:39:35 (#:model "rbtrees-3" #:type grammar #:average 307477.52941176476 #:stderr 39626.5683190649))
(heartbeat 2015-06-23T13:39:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:39:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:40:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:40:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:40:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:40:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:40:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:40:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:41:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:41:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:41:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:41:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:41:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:41:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:42:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:42:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:42:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:42:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:42:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:42:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:43:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:43:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:43:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:43:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:43:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:43:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:44:03 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:44:13 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:44:23 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:44:33 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:44:43 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:44:53 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:45:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:45:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:45:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:45:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:45:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:45:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:46:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:46:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:46:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:46:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:46:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:46:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:47:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:47:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:47:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:47:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:47:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:47:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:48:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:48:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:48:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:48:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:48:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:48:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:49:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:49:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:49:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:49:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:49:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:49:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:50:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:50:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:50:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:50:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:50:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:50:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:51:04 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T13:51:05 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 2070241 #:time 691213))
(new-average 2015-06-23T13:51:05 (#:model "rbtrees-3" #:type grammar #:average 318441.4 #:stderr 40009.27331515856))
(heartbeat 2015-06-23T13:51:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:51:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:51:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:51:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:51:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:52:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:52:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:52:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:52:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:52:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:52:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:53:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:53:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:53:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:53:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:53:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:53:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:54:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:54:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:54:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:54:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:54:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:54:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:55:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:55:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:55:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:55:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:55:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:55:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:56:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:56:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:56:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:56:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:56:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:56:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:57:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:57:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:57:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:57:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:57:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:57:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:58:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:58:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:58:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:58:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:58:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:58:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:59:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:59:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:59:24 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T13:59:24 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B (R E O E) (s O) (R E (s (s O)) E)) (s (s (s (s O)))) E) #:iterations 1486004 #:time 499303))
(new-average 2015-06-23T13:59:24 (#:model "rbtrees-3" #:type grammar #:average 323465.3333333334 #:stderr 39205.25154803174))
(heartbeat 2015-06-23T13:59:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:59:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T13:59:54 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T13:59:56 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 93972 #:time 31609))
(new-average 2015-06-23T13:59:56 (#:model "rbtrees-3" #:type grammar #:average 315577.3243243244 #:stderr 38938.2659699855))
(heartbeat 2015-06-23T14:00:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:00:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:00:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:00:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:00:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:00:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:01:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:01:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:01:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:01:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:01:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:01:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:02:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:02:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:02:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:02:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:02:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:02:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:03:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:03:14 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T14:03:22 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 615460 #:time 206653))
(new-average 2015-06-23T14:03:22 (#:model "rbtrees-3" #:type grammar #:average 312710.89473684214 #:stderr 38007.9672911572))
(heartbeat 2015-06-23T14:03:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:03:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:03:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:03:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:04:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:04:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:04:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:04:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:04:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:04:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:05:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:05:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:05:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:05:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:05:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:05:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:06:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:06:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:06:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:06:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:06:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:06:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:07:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:07:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:07:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:07:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:07:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:07:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:08:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:08:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:08:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:08:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:08:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:08:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:09:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:09:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:09:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:09:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:09:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:09:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:10:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:10:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:10:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:10:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:10:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:10:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:11:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:11:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:11:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:11:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:11:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:11:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:12:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:12:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:12:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:12:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:12:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:12:54 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:13:04 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:13:14 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:13:24 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:13:34 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:13:44 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:13:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:14:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:14:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:14:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:14:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:14:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:14:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:15:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:15:15 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T14:15:15 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 2140432 #:time 713387))
(new-average 2015-06-23T14:15:15 (#:model "rbtrees-3" #:type grammar #:average 322984.64102564106 #:stderr 38419.696811650836))
(heartbeat 2015-06-23T14:15:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:15:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:15:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:15:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:16:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:16:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:16:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:16:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:16:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:16:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:17:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:17:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:17:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:17:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:17:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:17:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:18:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:18:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:18:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:18:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:18:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:18:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:19:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:19:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:19:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:19:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:19:45 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T14:19:50 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 837883 #:time 275111))
(new-average 2015-06-23T14:19:50 (#:model "rbtrees-3" #:type grammar #:average 321787.80000000005 #:stderr 37466.009613846945))
(heartbeat 2015-06-23T14:19:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:20:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:20:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:20:25 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T14:20:34 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 135882 #:time 44721))
(new-average 2015-06-23T14:20:34 (#:model "rbtrees-3" #:type grammar #:average 315030.0731707318 #:stderr 37160.402124051456))
(heartbeat 2015-06-23T14:20:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:20:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:20:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:21:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:21:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:21:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:21:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:21:45 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T14:21:51 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 235321 #:time 77099))
(new-average 2015-06-23T14:21:51 (#:model "rbtrees-3" #:type grammar #:average 309365.0238095239 #:stderr 36704.65014654626))
(heartbeat 2015-06-23T14:21:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:22:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:22:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:22:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:22:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:22:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:22:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:23:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:23:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:23:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:23:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:23:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:23:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:24:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:24:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:24:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:24:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:24:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:24:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:25:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:25:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:25:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:25:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:25:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:25:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:26:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:26:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:26:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:26:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:26:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:26:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:27:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:27:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:27:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:27:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:27:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:27:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:28:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:28:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:28:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:28:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:28:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:28:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:29:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:29:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:29:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:29:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:29:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:29:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:30:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:30:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:30:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:30:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:30:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:30:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:31:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:31:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:31:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:31:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:31:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:31:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:32:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:32:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:32:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:32:35 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T14:32:41 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B (R E O E) (s O) (R E (s (s O)) E)) (s (s (s (s O)))) E) #:iterations 1994158 #:time 650329))
(new-average 2015-06-23T14:32:41 (#:model "rbtrees-3" #:type grammar #:average 317294.41860465123 #:stderr 36707.55673285732))
(heartbeat 2015-06-23T14:32:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:32:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:33:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:33:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:33:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:33:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:33:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:33:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:34:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:34:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:34:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:34:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:34:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:34:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:35:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:35:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:35:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:35:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:35:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:35:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:36:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:36:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:36:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:36:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:36:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:36:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:37:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:37:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:37:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:37:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:37:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:37:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:38:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:38:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:38:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:38:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:38:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:38:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:39:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:39:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:39:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:39:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:39:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:39:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:40:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:40:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:40:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:40:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:40:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:40:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:41:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:41:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:41:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:41:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:41:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:41:55 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:42:05 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:42:15 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:42:25 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:42:35 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:42:45 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:42:56 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T14:43:00 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 1894558 #:time 619649))
(new-average 2015-06-23T14:43:00 (#:model "rbtrees-3" #:type grammar #:average 324166.1136363637 #:stderr 36515.988642965254))
(heartbeat 2015-06-23T14:43:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:43:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:43:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:43:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:43:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:43:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:44:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:44:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:44:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:44:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:44:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:44:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:45:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:45:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:45:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:45:36 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T14:45:36 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 478014 #:time 156157))
(new-average 2015-06-23T14:45:36 (#:model "rbtrees-3" #:type grammar #:average 320432.57777777786 #:stderr 35890.02256677931))
(heartbeat 2015-06-23T14:45:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:45:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:46:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:46:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:46:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:46:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:46:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:46:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:47:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:47:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:47:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:47:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:47:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:47:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:48:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:48:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:48:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:48:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:48:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:48:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:49:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:49:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:49:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:49:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:49:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:49:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:50:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:50:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:50:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:50:36 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T14:50:46 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 949277 #:time 309774))
(new-average 2015-06-23T14:50:46 (#:model "rbtrees-3" #:type grammar #:average 320200.86956521746 #:stderr 35101.89928997964))
(heartbeat 2015-06-23T14:50:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:50:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:51:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:51:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:51:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:51:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:51:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:51:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:52:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:52:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:52:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:52:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:52:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:52:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:53:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:53:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:53:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:53:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:53:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:53:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:54:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:54:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:54:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:54:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:54:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:54:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:55:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:55:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:55:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:55:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:55:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:55:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:56:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:56:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:56:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:56:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:56:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:56:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:57:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:57:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:57:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:57:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:57:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:57:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:58:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:58:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:58:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:58:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:58:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:58:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:59:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:59:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:59:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:59:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:59:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T14:59:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:00:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:00:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:00:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:00:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:00:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:00:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:01:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:01:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:01:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:01:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:01:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:01:56 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:02:06 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:02:16 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:02:26 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:02:36 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:02:46 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:02:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:03:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:03:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:03:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:03:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:03:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:03:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:04:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:04:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:04:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:04:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:04:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:04:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:05:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:05:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:05:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:05:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:05:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:05:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:06:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:06:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:06:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:06:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:06:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:06:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:07:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:07:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:07:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:07:37 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T15:07:42 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 3120308 #:time 1017406))
(new-average 2015-06-23T15:07:42 (#:model "rbtrees-3" #:type grammar #:average 335035.0212765958 #:stderr 37413.41683856299))
(heartbeat 2015-06-23T15:07:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:07:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:08:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:08:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:08:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:08:37 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T15:08:40 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 180203 #:time 58466))
(new-average 2015-06-23T15:08:40 (#:model "rbtrees-3" #:type grammar #:average 329273.16666666674 #:stderr 37076.127603909226))
(heartbeat 2015-06-23T15:08:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:08:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:09:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:09:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:09:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:09:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:09:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:09:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:10:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:10:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:10:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:10:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:10:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:10:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:11:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:11:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:11:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:11:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:11:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:11:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:12:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:12:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:12:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:12:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:12:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:12:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:13:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:13:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:13:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:13:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:13:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:13:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:14:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:14:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:14:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:14:37 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T15:14:46 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 1121907 #:time 366070))
(new-average 2015-06-23T15:14:46 (#:model "rbtrees-3" #:type grammar #:average 330024.12244897964 #:stderr 36319.35363802902))
(heartbeat 2015-06-23T15:14:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:14:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:15:07 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T15:15:08 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B (R E O E) (s O) (R E (s (s O)) E)) (s (s (s (s O)))) E) #:iterations 67477 #:time 21981))
(new-average 2015-06-23T15:15:08 (#:model "rbtrees-3" #:type grammar #:average 323863.26000000007 #:stderr 36114.92567972541))
(heartbeat 2015-06-23T15:15:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:15:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:15:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:15:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:15:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:16:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:16:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:16:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:16:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:16:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:16:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:17:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:17:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:17:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:17:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:17:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:17:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:18:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:18:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:18:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:18:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:18:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:18:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:19:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:19:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:19:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:19:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:19:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:19:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:20:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:20:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:20:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:20:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:20:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:20:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:21:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:21:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:21:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:21:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:21:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:21:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:22:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:22:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:22:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:22:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:22:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:22:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:23:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:23:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:23:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:23:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:23:47 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T15:23:51 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B (R E O E) (s O) (R E (s (s O)) E)) (s (s (s (s O)))) E) #:iterations 1601216 #:time 523345))
(new-average 2015-06-23T15:23:51 (#:model "rbtrees-3" #:type grammar #:average 327774.66666666674 #:stderr 35615.14306524923))
(heartbeat 2015-06-23T15:23:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:24:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:24:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:24:27 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T15:24:30 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 118918 #:time 38874))
(new-average 2015-06-23T15:24:30 (#:model "rbtrees-3" #:type grammar #:average 322218.8846153847 #:stderr 35362.67858708436))
(heartbeat 2015-06-23T15:24:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:24:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:24:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:25:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:25:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:25:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:25:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:25:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:25:57 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T15:26:04 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 289670 #:time 94438))
(new-average 2015-06-23T15:26:04 (#:model "rbtrees-3" #:type grammar #:average 317921.13207547175 #:stderr 34954.26034306335))
(heartbeat 2015-06-23T15:26:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:26:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:26:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:26:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:26:47 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T15:26:56 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 158508 #:time 51706))
(new-average 2015-06-23T15:26:56 (#:model "rbtrees-3" #:type grammar #:average 312991.22222222225 #:stderr 34653.318221079826))
(heartbeat 2015-06-23T15:26:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:27:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:27:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:27:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:27:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:27:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:27:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:28:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:28:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:28:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:28:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:28:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:28:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:29:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:29:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:29:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:29:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:29:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:29:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:30:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:30:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:30:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:30:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:30:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:30:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:31:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:31:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:31:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:31:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:31:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:31:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:32:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:32:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:32:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:32:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:32:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:32:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:33:07 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T15:33:13 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 1159783 #:time 377481))
(new-average 2015-06-23T15:33:13 (#:model "rbtrees-3" #:type grammar #:average 314163.76363636367 #:stderr 34037.62557496915))
(heartbeat 2015-06-23T15:33:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:33:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:33:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:33:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:33:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:34:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:34:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:34:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:34:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:34:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:34:57 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:35:07 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:35:17 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:35:27 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:35:37 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:35:47 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:35:57 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T15:36:07 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 533482 #:time 173816))
(new-average 2015-06-23T15:36:07 (#:model "rbtrees-3" #:type grammar #:average 311657.5535714286 #:stderr 33518.113049949105))
(heartbeat 2015-06-23T15:36:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:36:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:36:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:36:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:36:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:36:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:37:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:37:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:37:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:37:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:37:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:37:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:38:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:38:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:38:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:38:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:38:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:38:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:39:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:39:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:39:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:39:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:39:48 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T15:39:57 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 710052 #:time 230951))
(new-average 2015-06-23T15:39:57 (#:model "rbtrees-3" #:type grammar #:average 310241.649122807 #:stderr 32955.256057063925))
(heartbeat 2015-06-23T15:39:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:40:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:40:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:40:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:40:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:40:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:40:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:41:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:41:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:41:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:41:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:41:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:41:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:42:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:42:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:42:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:42:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:42:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:42:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:43:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:43:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:43:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:43:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:43:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:43:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:44:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:44:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:44:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:44:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:44:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:44:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:45:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:45:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:45:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:45:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:45:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:45:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:46:08 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T15:46:10 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 1146872 #:time 372963))
(new-average 2015-06-23T15:46:10 (#:model "rbtrees-3" #:type grammar #:average 311323.0517241379 #:stderr 32400.12918557949))
(heartbeat 2015-06-23T15:46:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:46:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:46:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:46:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:46:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:47:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:47:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:47:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:47:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:47:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:47:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:48:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:48:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:48:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:48:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:48:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:48:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:49:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:49:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:49:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:49:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:49:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:49:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:50:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:50:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:50:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:50:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:50:48 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T15:50:53 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B (R E O E) (s O) (R E (s (s O)) E)) (s (s (s (s O)))) E) #:iterations 871808 #:time 283422))
(new-average 2015-06-23T15:50:53 (#:model "rbtrees-3" #:type grammar #:average 310850.1525423729 #:stderr 31849.750962317867))
(heartbeat 2015-06-23T15:50:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:51:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:51:18 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T15:51:20 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 83440 #:time 27309))
(new-average 2015-06-23T15:51:20 (#:model "rbtrees-3" #:type grammar #:average 306124.4666666667 #:stderr 31668.994123781828))
(heartbeat 2015-06-23T15:51:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:51:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:51:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:51:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:52:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:52:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:52:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:52:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:52:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:52:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:53:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:53:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:53:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:53:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:53:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:53:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:54:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:54:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:54:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:54:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:54:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:54:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:55:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:55:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:55:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:55:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:55:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:55:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:56:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:56:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:56:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:56:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:56:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:56:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:57:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:57:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:57:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:57:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:57:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:57:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:58:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:58:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:58:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:58:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:58:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:58:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:59:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:59:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:59:28 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:59:38 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:59:48 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T15:59:58 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:00:08 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:00:18 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:00:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:00:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:00:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:00:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:01:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:01:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:01:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:01:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:01:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:01:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:02:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:02:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:02:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:02:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:02:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:02:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:03:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:03:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:03:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:03:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:03:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:03:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:04:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:04:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:04:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:04:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:04:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:04:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:05:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:05:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:05:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:05:39 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T16:05:46 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 2668213 #:time 866890))
(new-average 2015-06-23T16:05:46 (#:model "rbtrees-3" #:type grammar #:average 315317.3442622951 #:stderr 32473.85708881111))
(heartbeat 2015-06-23T16:05:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:05:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:06:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:06:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:06:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:06:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:06:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:06:59 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T16:07:08 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 251628 #:time 81720))
(new-average 2015-06-23T16:07:08 (#:model "rbtrees-3" #:type grammar #:average 311549.64516129036 #:stderr 32167.20634170414))
(heartbeat 2015-06-23T16:07:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:07:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:07:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:07:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:07:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:07:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:08:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:08:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:08:29 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T16:08:33 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 262003 #:time 85180))
(new-average 2015-06-23T16:08:33 (#:model "rbtrees-3" #:type grammar #:average 307956.4761904762 #:stderr 31855.7919725614))
(heartbeat 2015-06-23T16:08:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:08:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:08:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:09:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:09:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:09:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:09:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:09:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:09:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:10:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:10:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:10:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:10:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:10:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:10:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:11:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:11:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:11:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:11:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:11:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:11:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:12:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:12:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:12:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:12:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:12:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:12:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:13:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:13:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:13:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:13:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:13:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:13:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:14:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:14:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:14:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:14:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:14:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:14:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:15:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:15:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:15:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:15:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:15:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:15:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:16:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:16:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:16:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:16:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:16:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:16:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:17:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:17:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:17:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:17:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:17:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:17:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:18:09 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T16:18:12 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 1781913 #:time 578972))
(new-average 2015-06-23T16:18:12 (#:model "rbtrees-3" #:type grammar #:average 312191.09375 #:stderr 31638.761579047507))
(heartbeat 2015-06-23T16:18:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:18:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:18:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:18:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:18:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:19:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:19:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:19:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:19:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:19:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:19:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:20:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:20:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:20:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:20:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:20:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:20:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:21:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:21:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:21:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:21:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:21:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:21:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:22:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:22:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:22:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:22:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:22:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:22:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:23:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:23:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:23:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:23:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:23:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:23:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:24:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:24:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:24:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:24:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:24:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:24:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:25:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:25:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:25:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:25:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:25:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:25:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:26:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:26:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:26:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:26:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:26:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:26:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:27:09 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:27:19 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:27:29 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:27:39 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:27:49 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:27:59 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:28:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:28:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:28:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:28:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:28:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:29:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:29:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:29:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:29:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:29:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:29:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:30:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:30:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:30:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:30:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:30:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:30:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:31:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:31:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:31:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:31:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:31:40 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T16:31:42 (#:model "rbtrees-3" #:type grammar #:counterexample (R (B E O E) (s O) (B (R E (s (s O)) E) (s (s (s O))) E)) #:iterations 2497254 #:time 811477))
(new-average 2015-06-23T16:31:42 (#:model "rbtrees-3" #:type grammar #:average 319872.41538461536 #:stderr 32081.3589275893))
(heartbeat 2015-06-23T16:31:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:32:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:32:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:32:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:32:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:32:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:32:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:33:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:33:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:33:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:33:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:33:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:33:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:34:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:34:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:34:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:34:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:34:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:34:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:35:00 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:35:10 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:35:20 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:35:30 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:35:40 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:35:50 (#:model "rbtrees-3" #:type grammar))
(heartbeat 2015-06-23T16:36:00 (#:model "rbtrees-3" #:type grammar))
(counterexample 2015-06-23T16:36:08 (#:model "rbtrees-3" #:type grammar #:counterexample (B (B (R E O E) (s O) (R E (s (s O)) E)) (s (s (s (s O)))) E) #:iterations 817535 #:time 265503))
(new-average 2015-06-23T16:36:08 (#:model "rbtrees-3" #:type grammar #:average 319048.63636363635 #:stderr 31602.277004841588))
(finished 2015-06-23T16:36:08 (#:model "rbtrees-3" #:type grammar #:time-ms 21057223 #:attempts 62121101 #:num-counterexamples 66 #:rate-terms/s 2950.108900874536 #:attempts/cexp 941228.803030303))
| false |
ec6dfee204b0c5621e225c02375ff809f18fec13 | 00d4882c98aadb8010fcee2688e32d795fcc514e | /rule-systems/numb++-cards.rkt | c5bad43b0f6bf9fb410c5719784d8f11a3ce5040 | []
| no_license | thoughtstem/morugamu | dae77f19b9eecf156ffe501a6bfeef12f0c1749d | a9095ddebe364adffb036c3faed95c873a4d9f3c | refs/heads/master | 2020-03-22T04:09:18.238849 | 2018-08-20T18:55:55 | 2018-08-20T18:55:55 | 139,476,760 | 13 | 5 | null | 2018-08-02T22:29:48 | 2018-07-02T17:56:26 | Racket | UTF-8 | Racket | false | false | 316 | rkt | numb++-cards.rkt | #lang racket
(require "./common.rkt")
(require "./redex/clock-numbers++.rkt")
(module+ test
(require-lang list)
(require-lang numb)
(render numb:theme))
(make-generator generate clock-numbers++-lang cn++-e)
(make-simulator simulate clock-numbers++-red)
(make-renderer render
(S++ P++))
| false |
d3829e71f96b8af668e9b00497f0046a562ef715 | e0bd011b957ae2ab6e947400342eee49dd3ac095 | /ground.rkt | 5a67aba770aaa33ecc403e99601362643ef8091f | []
| no_license | LeifAndersen/marketplace | aa9a59d480dc65ecdc714a535c1e087071370bc8 | d511d4104044a7ce15bf20a2f7a11100ef127dab | refs/heads/master | 2020-05-28T00:02:47.376582 | 2014-08-06T16:52:26 | 2014-08-06T16:52:26 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 2,473 | rkt | ground.rkt | #lang typed/racket/base
(require racket/match)
(require "types.rkt")
(require "roles.rkt")
(require "vm.rkt")
(require "log-typed.rkt")
(require "process.rkt")
(require "actions.rkt")
(require "action-send-message.rkt")
(require (rename-in "tr-struct-copy.rkt" [tr-struct-copy struct-copy])) ;; PR13149 workaround
(require "support/event.rkt")
(require/typed typed/racket/base
[sync (Evt Evt * -> (vm -> vm))]
[never-evt Evt]
[always-evt Evt]
[wrap-evt (Evt (Any -> (vm -> vm)) -> Evt)])
(provide run-ground-vm)
(: run-ground-vm : process-spec -> Void)
(define (run-ground-vm boot)
(let loop ((state (make-vm boot)))
(match (run-vm state)
[(transition state actions)
(define is-blocking?
(match (quasiqueue->list (action-tree->quasiqueue actions))
['()
;; no "yield" action -> certainly blocking
#t]
[(list (yield (== run-vm)))
;; single "yield", with k statically known to be run-vm -> poll
#f]
[_
;; uh-oh
(error 'ground-vm
"Cannot process meta-actions ~v because no further metalevel exists"
actions)]))
(define active-events
((inst endpoint-fold (Listof Evt)) extract-ground-event-subscriptions '() state))
(if (and is-blocking?
(null? active-events))
(begin
;; Not polling, and no events that could wake us from blocking, so quit
(marketplace-log 'debug "Ground VM returning normally.")
(sleep 0.2) ;; give the log-receivers a chance to drain (!)
(void))
(let ((interruptk (apply sync
(if is-blocking?
never-evt
(wrap-evt always-evt (lambda (dummy) (inst values vm))))
active-events)))
(loop (interruptk state))))])))
(: extract-ground-event-subscriptions :
(All (State) (process State) (endpoint State) (Listof Evt) -> (Listof Evt)))
(define (extract-ground-event-subscriptions old-p ep acc)
(define pid (process-pid old-p))
(match (endpoint-role ep)
[(role 'subscriber (cons (? evt? evt) _) 'participant)
(: evt-handler : Any -> (vm -> vm))
(define ((evt-handler message) state)
(let-values (((state wp) (extract-process state pid)))
(if (not wp)
state
(unwrap-process State vm (p wp)
(let-values
(((p state)
(do-send-message 'publisher (cast (cons evt message) Message) p state)))
(if p
(inject-process state (mkProcess p))
state))))))
(cons (wrap-evt evt evt-handler) acc)]
[_ acc]))
| false |
e09a88de78e3202bca661754185c517aa1d3500f | 6858cbebface7beec57e60b19621120da5020a48 | /7/1/2.rkt | b6902f34701cd9274fba6a1e4ea30df0b7f266fa | []
| no_license | ponyatov/PLAI | a68b712d9ef85a283e35f9688068b392d3d51cb2 | 6bb25422c68c4c7717b6f0d3ceb026a520e7a0a2 | refs/heads/master | 2020-09-17T01:52:52.066085 | 2017-03-28T07:07:30 | 2017-03-28T07:07:30 | 66,084,244 | 2 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 75 | rkt | 2.rkt | <fun-type-take-1> ::=
[fdC (name : symbol) (arg : symbol) (body : ExprC)] | false |
b6e319800689c3a45b61636cd6fe10936b71b393 | 00d4882c98aadb8010fcee2688e32d795fcc514e | /marketing/research/display/k-means/k-means-research.rkt | 2eacab104b972648e4cb437858b210203269a080 | []
| no_license | thoughtstem/morugamu | dae77f19b9eecf156ffe501a6bfeef12f0c1749d | a9095ddebe364adffb036c3faed95c873a4d9f3c | refs/heads/master | 2020-03-22T04:09:18.238849 | 2018-08-20T18:55:55 | 2018-08-20T18:55:55 | 139,476,760 | 13 | 5 | null | 2018-08-02T22:29:48 | 2018-07-02T17:56:26 | Racket | UTF-8 | Racket | false | false | 3,646 | rkt | k-means-research.rkt | #lang racket
;NOTE: INSTALL UNSTABLE.PKG BEFORE RUNNING
(require "k-means.rkt"
plot
"../display-util.rkt"
"../../../../util/util.rkt"
(prefix-in game: "../../data/games/database.rkt")
(prefix-in util: "../../data/stephens-database-util.rkt")
)
;(plot-new-window? #t)
;finds the centroids
(define (make-3d-cluster)
(map list
(map third (util:success? (game:table))) ;asked for list
(map fourth (util:success? (game:table))) ;recieved amount list
))
;defining the clusters here, feel free to add/subtract as many as needed/wanted
(define c1 (make-3d-cluster))
(define c2 (make-3d-cluster))
(define c3 (make-3d-cluster))
(define c4 (make-3d-cluster))
(define c5 (make-3d-cluster))
;remember to change the lines below to accomodate the amount of clusters
(define points1 (shuffle (append c1 c2 c3 c4 c5)))
(define-values (centers clusters) (cluster points1 5))
(printf "centroid locations: ~a\n"
(map (curry map exact-round) centers))
;Defining vectors
(define vector-successful
(map list->vector (elements->lst (util:success? (game:table)) 2 3))
)
(define vector-centroids
(map list->vector (map (curry map exact-round) centers)))
;start of partitioning functions finding distances between centroids
(define (get-x p) (car p))
(define (get-y p) (car p))
(define (get-first-point pt-list)
(get-x pt-list))
(define (get-rest-points pt-list)
(get-y pt-list))
;finds the distance between points and b and returns an int
(define (distance a b)
(let ((square (lambda (x)
(* x x))))
(sqrt (+ (square (- (car a) (car b)))
(square (- (cdr a) (cdr b)))))))
(define successes-points (map cons (map first (map vector->list vector-successful))
(map second (map vector->list vector-successful))
))
(define centroids-points (map cons (map first (map vector->list vector-centroids))
(map second (map vector->list vector-centroids))
))
(define points-colors '())
(for ([i (in-range 1 (+ (length successes-points) 1))])
(define min-distance 10000000)
(define jndex 1)
(for ([j (in-range 1 (+ (length centroids-points) 1))])
(if (> min-distance (distance (list-ref successes-points (- i 1)) (list-ref centroids-points (- j 1))))
(set! min-distance (distance (list-ref successes-points (- i 1)) (list-ref centroids-points (- j 1))))
(set! jndex j)
)
)
(set! points-colors (flatten (cons points-colors jndex)))
)
(define new-list '())
(for ([kndex (in-range 1 (length points-colors))])
(if (equal? (list-ref points-colors kndex) 1)
(set! new-list (flatten (cons new-list "green") ))
(if (equal? (list-ref points-colors kndex) 2)
(set! new-list (flatten (cons new-list "red")))
(if (equal? (list-ref points-colors kndex) 3)
(set! new-list (flatten (cons new-list "purple")))
(if (equal? (list-ref points-colors kndex) 4)
(set! new-list (flatten (cons new-list "yellow")))
(set! new-list (flatten (cons new-list "black")))
)))))
;TODO: graph the colors, reference the pseudocode file
;after you finish this, you are done with k-means
(plot (list (points
vector-successful)
(points vector-centroids
#:color "blue"
#:line-width 6))
#:x-label "Received"
#:y-label "Asked for")
| false |
f1b45997c514d4a1113d2bda9694bb4db1ef98d8 | ddcff224727303b32b9d80fa4a2ebc1292eb403d | /4. Metalinguistic Abstraction/4.1/4.11.rkt | 12ee9e7a09104940dcb934d93662b80c03e6a2e5 | []
| no_license | belamenso/sicp | 348808d69af6aff95b0dc5b0f1f3984694700872 | b01ea405e8ebf77842ae6a71bb72aef64a7009ad | refs/heads/master | 2020-03-22T02:01:55.138878 | 2018-07-25T13:59:18 | 2018-07-25T13:59:18 | 139,345,220 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 2,686 | rkt | 4.11.rkt | #lang sicp
(define (displayln x)
(display x)
(newline))
#|
(lookup-variable-value ⟨var⟩ ⟨env⟩)
returns the value that is bound to the symbol ⟨var⟩ in the environment ⟨env⟩, or signals an error if the variable is unbound.
(extend-environment ⟨variables⟩ ⟨values⟩ ⟨base-env⟩)
returns a new environment, consisting of a new frame in which the symbols in the list ⟨variables⟩ are bound to the corresponding elements in the list ⟨values⟩, where the enclosing environment is the environment ⟨base-env⟩.
(define-variable! ⟨var⟩ ⟨value⟩ ⟨env⟩)
adds to the first frame in the environment ⟨env⟩ a new binding that associates the variable ⟨var⟩ with the value ⟨value⟩.
(set-variable-value! ⟨var⟩ ⟨value⟩ ⟨env⟩)
|#
(define enclosing-environment cdr)
(define first-frame car)
(define the-empty-environment '())
(define (make-frame variables values)
(map cons variables values))
(define (frame-variables frame) (car frame))
(define (frame-values frame) (cdr frame))
(define (add-binding-to-frame! var val frame)
(set-cdr! frame (cons (cons var val) (cdr frame))))
; environment is a list of frames (cons)
; frames are a-lists (mcons of mcons)
(define (search-frame var frame)
(cond
[(null? frame) #f]
[(eq? var (car (car frame))) (list (cdr (car frame)))]
[else (search-frame var (cdr frame))]))
(define (lookup-variable-value var env)
(let loop-frames ([env env])
(if (eq? the-empty-environment env)
(error "Variable not found" var)
(let ([result (search-frame var (car env))])
(if result
(car result)
(loop-frames (cdr env)))))))
(define (extend-environment vars vals env)
(cons (make-frame vars vals) env))
; define-variable!
; set-variable!
(define (define-variable! var val env)
(let ([frame (first-frame env)])
(let scan ([alist frame])
(cond
[(null? alist) (add-binding-to-frame! var val frame)]
[(eq? var (caar alist)) (set-cdr! (car alist) val)]
[else (scan (cdr alist))]))))
(define (set-variable-value! var val env)
(define (update frame)
(cond
[(null? frame) #f]
[(eq? (caar frame) var) (set-cdr! (car frame) val)
#t]
[else (update (cdr frame))]))
(let frame-loop ([env env])
(if (null? env)
(error "Not found")
(if (not (update (car env)))
(frame-loop (cdr env))))))
(define e `(((a . 10) (b . 20)) ((c . 100) (d . 200))))
(lookup-variable-value 'd e)
(define-variable! 'xs 101 e)
e
(lookup-variable-value 'xs e)
(set-variable-value! 'xs 999 e)
(lookup-variable-value 'xs e)
| false |
df28648c3446d37f499a3a3d7aecc491d3a36da7 | d9276fbd73cdec7a5a4920e46af2914f8ec3feb1 | /data/scheme/merge.rkt | fd7ddff67fdc3546556afe49fdcb1c1c20e57501 | []
| no_license | CameronBoudreau/programming-language-classifier | 5c7ab7d709b270f75269aed1fa187e389151c4f7 | 8f64f02258cbab9e83ced445cef8c1ef7e5c0982 | refs/heads/master | 2022-10-20T23:36:47.918534 | 2016-05-02T01:08:13 | 2016-05-02T01:08:13 | 57,309,188 | 1 | 1 | null | 2022-10-15T03:50:41 | 2016-04-28T14:42:50 | C | UTF-8 | Racket | false | false | 10,357 | rkt | merge.rkt | #lang racket/base
(require racket/list
racket/match
racket/contract
compiler/zo-parse
"util.rkt"
"mpi.rkt"
"nodep.rkt"
"update-toplevels.rkt")
(define MODULE-TOPLEVEL-OFFSETS (make-hasheq))
(define current-get-modvar-rewrite (make-parameter #f))
(define (merge-compilation-top get-modvar-rewrite top)
(parameterize ([current-get-modvar-rewrite get-modvar-rewrite])
(match top
[(struct compilation-top (max-let-depth binding-namess prefix form))
(define-values (new-max-let-depth new-prefix gen-new-forms)
(merge-form max-let-depth prefix form))
(define total-tls (length (prefix-toplevels new-prefix)))
(define total-stxs (length (prefix-stxs new-prefix)))
(define total-lifts (prefix-num-lifts new-prefix))
(log-debug (format "max-let-depth ~S to ~S" max-let-depth new-max-let-depth))
(log-debug (format "total toplevels ~S" total-tls))
(log-debug (format "total stxs ~S" total-stxs))
(log-debug (format "num-lifts ~S" total-lifts))
(for ([i (in-naturals)]
[p (in-list (prefix-toplevels new-prefix))])
(log-debug (format "new-prefix tls\t~v ~v" i p)))
(make-compilation-top
new-max-let-depth #hash() new-prefix
(make-splice (gen-new-forms new-prefix)))]
[else (error 'merge "unrecognized: ~e" top)])))
(define (merge-forms max-let-depth prefix forms)
(if (empty? forms)
(values max-let-depth prefix (lambda _ empty))
(let*-values ([(fmax-let-depth fprefix gen-fform) (merge-form max-let-depth prefix (first forms))]
[(rmax-let-depth rprefix gen-rforms) (merge-forms fmax-let-depth fprefix (rest forms))])
(values rmax-let-depth
rprefix
(lambda args
(append (apply gen-fform args)
(apply gen-rforms args)))))))
(define (merge-form max-let-depth prefix form)
(match form
[(? mod?)
(merge-module max-let-depth prefix form)]
[(struct seq (forms))
(merge-forms max-let-depth prefix forms)]
[(struct splice (forms))
(merge-forms max-let-depth prefix forms)]
[else
(values max-let-depth prefix (lambda _ (list form)))]))
(define (index-of v l)
(for/or ([e (in-list l)]
[i (in-naturals)]
#:when (eq? e v))
i))
(define (merge-prefix root-prefix mod-prefix)
(match-define (struct prefix (root-num-lifts root-toplevels root-stxs root-src-insp-desc)) root-prefix)
(match-define (struct prefix (mod-num-lifts mod-toplevels mod-stxs src-insp-desc)) mod-prefix)
(make-prefix (+ root-num-lifts mod-num-lifts)
(append root-toplevels mod-toplevels)
(append root-stxs mod-stxs)
root-src-insp-desc))
(struct toplevel-offset-rewriter (rewrite-fun meta) #:transparent)
(define (compute-new-modvar mv rw)
(match mv
[(struct module-variable (modidx sym pos phase constantness))
(match rw
[(struct modvar-rewrite (self-modidx provide->toplevel))
(log-debug (format "Rewriting ~a@~a of ~S" sym pos (mpi->path* modidx)))
(define tl (provide->toplevel sym pos))
(log-debug (format "Rewriting ~a@~a of ~S to ~S" sym pos (mpi->path* modidx) tl))
(match-define (toplevel-offset-rewriter rewrite-fun meta)
(hash-ref MODULE-TOPLEVEL-OFFSETS self-modidx
(lambda ()
(error 'compute-new-modvar "toplevel offset not yet computed: ~S" self-modidx))))
(log-debug (format "Rewriting ~a@~a of ~S (which is ~a) with ~S" sym pos (mpi->path* modidx) tl meta))
(define res (rewrite-fun tl))
(log-debug (format "Rewriting ~a@~a of ~S (which is ~a) with ~S and got ~S"
sym pos (mpi->path* modidx) tl meta res))
res])]))
(define (filter-rewritable-module-variable? name new-#f-idx toplevel-offset mod-toplevels)
(define-values
(i new-toplevels remap)
(for/fold ([i 0]
[new-toplevels empty]
[remap empty])
([tl (in-list mod-toplevels)]
[idx (in-naturals)])
(log-debug (format "[~S] mod-prefix tls\t~v ~v"
name idx tl))
(match tl
[(and mv (struct module-variable (modidx sym pos phase constantness)))
(define rw ((current-get-modvar-rewrite) modidx))
;; XXX We probably don't need to deal with #f phase
(unless (or (not phase) (zero? phase))
(error 'eliminate-module-variables "Non-zero phases not supported: ~S" mv))
(cond
; Primitive module like #%paramz
[(symbol? rw)
(log-debug (format "~S from ~S" sym rw))
(values (add1 i)
(list* tl new-toplevels)
(list* (+ i toplevel-offset) remap))]
[(module-path-index? rw)
(values (add1 i)
(list* tl new-toplevels)
(list* (+ i toplevel-offset) remap))]
[(modvar-rewrite? rw)
(values i
new-toplevels
(list* (compute-new-modvar mv rw) remap))]
[else
(error 'filter-rewritable-module-variable? "Unsupported module-rewrite: ~S" rw)])]
[tl
(cond
[(and new-#f-idx (not tl))
(log-debug (format "[~S] dropping a #f at ~v that would have been at ~v but is now at ~v"
name idx (+ i toplevel-offset) new-#f-idx))
(values i
new-toplevels
(list* new-#f-idx remap))]
[else
(values (add1 i)
(list* tl new-toplevels)
(list* (+ i toplevel-offset) remap))])])))
; XXX This would be more efficient as a vector
(values (reverse new-toplevels)
(reverse remap)))
(define (merge-module max-let-depth top-prefix mod-form)
(match mod-form
[(struct mod (name srcname self-modidx
mod-prefix provides requires body syntax-bodies
unexported mod-max-let-depth dummy lang-info
internal-context binding-names
flags pre-submodules post-submodules))
(define top-toplevels (prefix-toplevels top-prefix))
(define toplevel-offset (length top-toplevels))
(define topsyntax-offset (length (prefix-stxs top-prefix)))
(define lift-offset (prefix-num-lifts top-prefix))
(define mod-toplevels (prefix-toplevels mod-prefix))
(define new-#f-idx
(index-of #f top-toplevels))
(when new-#f-idx
(log-debug (format "[~S] found a #f entry in prefix already at ~v, squashing"
name new-#f-idx)))
(define-values (new-mod-toplevels toplevel-remap)
(filter-rewritable-module-variable? name new-#f-idx toplevel-offset mod-toplevels))
(define num-mod-toplevels
(length toplevel-remap))
(define mod-stxs
(length (prefix-stxs mod-prefix)))
(define mod-num-lifts
(prefix-num-lifts mod-prefix))
(define new-mod-prefix
(struct-copy prefix mod-prefix
[toplevels new-mod-toplevels]))
(define offset-meta (vector name srcname self-modidx))
(log-debug "Setting toplevel offsets rewriter for ~S and it is currently ~S"
offset-meta
(hash-ref MODULE-TOPLEVEL-OFFSETS self-modidx #f))
(hash-set! MODULE-TOPLEVEL-OFFSETS self-modidx
(toplevel-offset-rewriter
(lambda (n)
(log-debug "Finding offset ~a in ~S of ~S" n toplevel-remap offset-meta)
(list-ref toplevel-remap n))
offset-meta))
(unless (= (length toplevel-remap)
(length mod-toplevels))
(error 'merge-module "Not remapping everything: ~S ~S"
mod-toplevels toplevel-remap))
(log-debug (format "[~S] Incrementing toplevels by ~a"
name
toplevel-offset))
(log-debug (format "[~S] Incrementing lifts by ~a"
name
lift-offset))
(log-debug (format "[~S] Filtered mod-vars from ~a to ~a"
name
(length mod-toplevels)
(length new-mod-toplevels)))
(values (max max-let-depth mod-max-let-depth)
(merge-prefix top-prefix new-mod-prefix)
(lambda (top-prefix)
(log-debug (format "[~S] Updating top-levels" name))
(define top-lift-start (prefix-lift-start top-prefix))
(define mod-lift-start (prefix-lift-start mod-prefix))
(define total-lifts (prefix-num-lifts top-prefix))
(define max-toplevel (+ top-lift-start total-lifts))
(define update
(update-toplevels
(lambda (n)
(define new-idx
(cond
[(mod-lift-start . <= . n)
(log-debug (format "[~S] ~v is a lift"
name n))
(define which-lift (- n mod-lift-start))
(define lift-tl (+ top-lift-start lift-offset which-lift))
(when (lift-tl . >= . max-toplevel)
(error 'merge-module "[~S] lift error: orig(~a) which(~a) max(~a) lifts(~a) now(~a)"
name n which-lift num-mod-toplevels mod-num-lifts lift-tl))
lift-tl]
[else
;; xxx maybe change this to a vector after it is made to make this efficient
(list-ref toplevel-remap n)]))
(log-debug (format "[~S] ~v is remapped to ~v"
name n new-idx))
new-idx)
(lambda (n)
(+ n topsyntax-offset))
(prefix-syntax-start top-prefix)))
(map update body)))]))
(provide/contract
[merge-compilation-top (-> get-modvar-rewrite/c
compilation-top?
compilation-top?)])
| false |
1a4a07226fcab81523492ad627c06f34353785de | ee9546eb2f533d606a90cd4ce2c0be8b1d4309b3 | /scheme/Prepared/20181023.rkt | 45d948ce448b4b5d978e4d25d5536d23eed6a51e | [
"Apache-2.0"
]
| permissive | riccardotommasini/ppl | 679544073e757263b85672188feea3e0971bf53d | 53b2f5b9a2d238070963eb26457fd4e4311e190b | refs/heads/master | 2021-10-10T20:00:46.190489 | 2019-01-16T13:00:34 | 2019-01-16T13:00:34 | 72,336,096 | 18 | 13 | Apache-2.0 | 2023-06-24T13:55:23 | 2016-10-30T07:43:46 | Haskell | UTF-8 | Racket | false | false | 94 | rkt | 20181023.rkt | #lang racket
;;simple exercise on map, foldr, foldl,
;; Structs usually trees, leaves and
| false |
517d723ebfae22d78604a923568a5bb5acd81c66 | e64dac395cdcc4fb26458041fcdb650bf2ef77bc | /date-at-compile-time.rkt | 9ff37897d7f5f528bcca46fc427bc38a927b9b24 | []
| no_license | dyoo/outer-tutorial | 82a0039f0e7c425052840d245441df09aec075d0 | 6e562a735ad3fccb7adbec25beb2c0c4e23a3b0a | refs/heads/master | 2020-05-18T03:37:05.860402 | 2012-05-09T18:20:34 | 2012-05-09T18:20:34 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 213 | rkt | date-at-compile-time.rkt | #lang racket
(require (for-syntax racket/date
(planet dyoo/stardate)))
(begin-for-syntax
(printf "This program is being compiled at Stardate ~a\n"
(date->stardate (current-date)))) | false |
541ca9abb804294685b5b23df0ee60bcae157030 | f683575352e3720842178d594b35ad60fc03f9d3 | /Tiny Percussion Tracker/tiny-percussion-tracker.rkt | ae77f6f57b4b35241c7e2fa17f7c07df60f0ddaa | []
| no_license | ajfite/CPE-123 | e1a9fc8cccf4a0fe3889622ed54684148b963c7c | c62804f3ec535fb0e532b79f6912c908d4833ba5 | refs/heads/master | 2021-09-06T21:40:51.060519 | 2018-02-11T23:59:15 | 2018-02-11T23:59:15 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 2,366 | rkt | tiny-percussion-tracker.rkt | #lang racket
(require (planet clements/rsound)
racket/runtime-path
rackunit)
;Adding my sound
(define clip1 (rs-read "clip1.wav"))
(define clip2 (rs-read "clip2.wav"))
(define clip3 (rs-read "clip3.wav"))
;; locate the pattern file
(define-runtime-path src-file "percussion.txt")
;; define some constants
(define tempo 150)
(define secondsperbeat (/ 60 tempo))
(define framesperbeat (* (default-sample-rate)
secondsperbeat))
(define colsperbeat 4)
(define framespercol (/ framesperbeat colsperbeat))
;; here's the list of sounds to be used.
(define raw-sounds (list clip1
clip2
clip3
crash-cymbal))
;; make the sounds quieter, so they won't cause clipping
(define sounds (map (lambda (s) (scale 0.2 s)) raw-sounds))
;; convert a file to a list of list of booleans
(define (file->bool-rows file)
(map line->bools (file->lines file)))
;; convert a string to a list of booleans,
;; where every non-space character produces true
(define (line->bools str)
(for/list ([ch (in-list (string->list str))])
(not (equal? ch #\space))))
;; convert a list of booleans to a list of
;; sound/offset lists, for use with assemble
(define (bools->overlay-list bools sound)
(for/list ([b (in-list bools)]
[t (in-naturals)]
#:when b)
(list sound (* t framespercol))))
;; read the file and play the resulting sound
(define (go)
(define bool-rows (file->bool-rows src-file))
;; take only enough rows to match the sounds given
(define num-taken (min (length bool-rows)
(length sounds)))
(define used-bool-rows (take bool-rows num-taken))
(define used-sounds (take sounds num-taken))
(define sound/offsets (map
bools->overlay-list
used-bool-rows
used-sounds))
(define s (assemble (apply append sound/offsets)))
(play s)
(rs-write s "Lab5Music.wav"))
;; a test case for line->bools
(check-equal? (line->bools "x x ")
(list #t #f #t #f))
;; a test case for bools->overlay-list
(check-equal? (bools->overlay-list (list false true false true)
kick)
(list (list kick (* 1 framespercol))
(list kick (* 3 framespercol))))
| false |
e2b26970d671d8a2d22774f59d8794d323a99d49 | 1397f4aad672004b32508f67066cb7812f8e2a14 | /plot-gui-lib/plot/private/gui/lazy-snip-untyped.rkt | 3e2dbf4d3c886c59c7e9bb908aaf09aedcf81b1d | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/plot | 2da8d9f8159f28d0a9f540012e43457d490d36da | b0da52632c0369058887439345eb90cbf8e99dae | refs/heads/master | 2023-07-14T07:31:23.099585 | 2023-07-04T12:53:33 | 2023-07-04T12:53:33 | 27,409,837 | 39 | 29 | NOASSERTION | 2023-07-04T12:56:50 | 2014-12-02T01:50:35 | Racket | UTF-8 | Racket | false | false | 998 | rkt | lazy-snip-untyped.rkt | #lang racket/base
(require racket/lazy-require)
(provide (rename-out [-make-2d-plot-snip make-2d-plot-snip]
[-make-3d-plot-snip make-3d-plot-snip]
[-make-snip-frame make-snip-frame]))
;; Require lazily, in case someone wants to just (require plot) in a headless setup
(lazy-require ["snip2d.rkt" (make-2d-plot-snip)]
["snip3d.rkt" (make-3d-plot-snip)]
["gui.rkt" (make-snip-frame)])
(define (-make-2d-plot-snip
init-bm saved-plot-parameters
make-bm plot-bounds-rect area width height)
(make-2d-plot-snip
init-bm saved-plot-parameters
make-bm plot-bounds-rect area width height))
(define (-make-3d-plot-snip
init-bm saved-plot-parameters
make-bm angle altitude area width height)
(make-3d-plot-snip
init-bm saved-plot-parameters
make-bm angle altitude area width height))
(define (-make-snip-frame snip width height label)
(make-snip-frame snip width height label))
| false |
69f7e41e35a0d8da6bfc34f0fcfd0e46256653e2 | 10b9611a25668507c6207f529d221459ee34ea50 | /main.rkt | 013b0cd817b1c3728f3db5c6009086cee3535653 | []
| no_license | jjsimpso/magic | b9090d363442f382d8bf21a309e73facad17c74d | d1751718be07d22589acdceb8f15f8c892ebb3f8 | refs/heads/master | 2022-04-28T15:27:20.660268 | 2022-03-13T03:40:34 | 2022-03-13T03:40:34 | 199,348,299 | 7 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,249 | rkt | main.rkt | #lang racket/base
;;Copyright 2019 Jonathan Simpson
;;
;; Licensed under the Apache License, Version 2.0 (the "License");
;; you may not use this file except in compliance with the License.
;; You may obtain a copy of the License at
;;
;; http://www.apache.org/licenses/LICENSE-2.0
;;
;; Unless required by applicable law or agreed to in writing, software
;; distributed under the License is distributed on an "AS IS" BASIS,
;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
;; See the License for the specific language governing permissions and
;; limitations under the License.
(module reader racket/base
(provide (rename-out (magic-read-syntax read-syntax)))
(require magic/reader)
;; stub out for DrRacket features (see jsonic example in Beautiful Racket)
(define (get-info port src-mod src-line src-col src-pos)
(define (handle-query key default)
(case key
#;[(color-lexer)
(dynamic-require 'magic/colorer 'color-magic)]
#;[(drracket:indentation)
(dynamic-require 'magic/indenter 'indent-magic)]
#;[(drracket:toolbar-buttons)
(dynamic-require 'magic/buttons 'button-list)]
[else default]))
handle-query))
| false |
12666bc2937df54217afbccd41554c4dd85fc281 | a87aea13754811d034ac977797e7536a62a2a50f | /2021/2021-09-23-S2.rkt | 61eb684351b3bf89077f6b606d4b469c2e2d3577 | []
| no_license | michiari/ppl | f255d549772cf05acf7bdf0b123cc02cb2a8a272 | dbcc17d183bb2490f7e3986142dfecc01b12eac4 | refs/heads/master | 2021-12-19T14:29:46.063514 | 2021-12-15T09:04:01 | 2021-12-15T09:04:01 | 212,059,532 | 15 | 12 | null | 2019-11-21T10:31:59 | 2019-10-01T09:37:35 | Haskell | UTF-8 | Racket | false | false | 2,035 | rkt | 2021-09-23-S2.rkt | #lang racket
(define (hello-world)
(display "Hello world"))
(define (hello name)
(display (string-append "Hello " (~a name))))
(define n 42)
(define hello2 (λ (name)
(display (string-append "Hello " (~a name)))))
;; n + (n-1) + ... + 2 + 1 + 0
;; f(0) = 0
;; f(n) = n + f(n-1)
(define (sum-range n)
(if (<= n 0)
0
(+ n (sum-range (- n 1)))))
;; n OP ((n-1) OP (... OP ((e+2) OP ((e+1) OP e))))
;; f(0) = 0
;; f(n) = n OP f(n-1)
(define (fold-range op n e)
(if (<= n e)
e
(op n (fold-range op (- n 1) e))))
;; (((((n OP (n-1)) OP ...) OP (e+2)) OP (e+1)) OP e
(define (fold-range-tail op n e)
(define (fold-range-tail-aux x acc)
(if (<= x e)
(op acc e)
(fold-range-tail-aux (- x 1) (op acc x))))
(fold-range-tail-aux (- n 1) n))
(define (fold-range-it op n e)
(let count ((x (- n 1)) (acc n))
(if (<= x e)
(op acc e)
(count (- x 1) (op acc x)))))
(define (riap p)
(if (not (pair? p))
(error (string-append (~a p) " is not a pair."))
(let ((fst (car p))
(snd (cdr p)))
(cons snd fst))))
(define (tsil l)
(cond [(not (list? l)) (error (string-append (~a l) " is not a list."))]
[(null? l) l]
[else (append (tsil (cdr l)) (list (car l)))]))
(define (fold-range2 op n start e)
(if (<= n start)
e
(op n (fold-range2 op (- n 1) start e))))
;; '(((1) 2) 3 (((4)) 3) 4 (((3))))
;; '(1 2 3 4 3 4 3)
(define (flatten l)
(cond [(null? l) l]
[(not (list? l)) (list l)]
[else (append (flatten (car l)) (flatten (cdr l)))]))
;; '(3 5 1 3 73 44 4 3)
;; '(3 5 1 3) '(73 44 4 3)
;; ...
;; '(1 3 3 5) '(3 4 44 73)
;; '() '(44 73)
;; '(1 3 3 3 4 5 44 73)
(define (merge l1 l2)
(cond [(null? l1) l2]
[(null? l2) l1]
[else (let ((f1 (car l1))
(f2 (car l2)))
(if (<= f1 f2)
(cons f1 (merge (cdr l1) l2))
(cons f2 (merge l1 (cdr l2)))))]))
;; Try to code merge sort.
| false |
c26f6f14b586b988e8ae44eaad4b3df97343ab58 | 6ed02f3ebc64478e266db7c07d96a88d4979bed7 | /λ/private/pair.rkt | b3ce0dcd341ecf93a8a5433e02a057b524eaecfd | [
"MIT"
]
| permissive | AlexKnauth/gnal-lambda | 2dd09c8515857fc0d1c1a1a0c5addf47a0013039 | 366160d5752f338e69e11d99fd1b3e5c09363d31 | refs/heads/master | 2022-01-22T16:01:26.495995 | 2022-01-07T14:57:10 | 2022-01-07T14:57:10 | 64,271,526 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,192 | rkt | pair.rkt | #lang gnal λ/adt
(provide Pair pair fst snd pair-ref/bit
pair-set-fst pair-set-snd pair-set/bit)
(require "byte.rkt")
(define-adt Pair
(pair fst snd))
;; fst : (Pairof A B) -> A
(define fst
(λ (p)
(match-adt Pair p
[(pair fst snd) fst])))
;; snd : (Pairof A B) -> B
(define snd
(λ (p)
(match-adt Pair p
[(pair fst snd) snd])))
;; pair-set-fst : (Pairof A B) C -> (Pairof C B)
(define pair-set-fst
(λ (p v)
(match-adt Pair p
[(pair a b)
(pair v b)])))
;; pair-set-snd : (Pairof A B) C -> (Pairof A C)
(define pair-set-snd
(λ (p v)
(match-adt Pair p
[(pair a b)
(pair a v)])))
;; pair-ref/bit : (Pairof A B) (0-bit) -> A
;; (Pairof A B) (1-bit) -> B
;; (Pairof A A) Bit -> A
(define pair-ref/bit
(λ (p b)
(match-adt Bit b
[(0-bit) (fst p)]
[(1-bit) (snd p)])))
;; pair-set/bit : (Pairof A B) (0-bit) C -> (Pairof C B)
;; (Pairof A B) (1-bit) C -> (Pairof A C)
;; (Pairof A A) Bit A -> (Pairof A A)
(define pair-set/bit
(λ (p b v)
(match-adt Bit b
[(0-bit) (pair-set-fst p v)]
[(1-bit) (pair-set-snd p v)])))
| false |
0ed61d6f6eb28cefe8d2c48488b46f9c3187a80f | d9276fbd73cdec7a5a4920e46af2914f8ec3feb1 | /data/scheme/tc-metafunctions.rkt | 6e6c44da9d8e6bc5128dbce0122167d1f572c39c | []
| no_license | CameronBoudreau/programming-language-classifier | 5c7ab7d709b270f75269aed1fa187e389151c4f7 | 8f64f02258cbab9e83ced445cef8c1ef7e5c0982 | refs/heads/master | 2022-10-20T23:36:47.918534 | 2016-05-02T01:08:13 | 2016-05-02T01:08:13 | 57,309,188 | 1 | 1 | null | 2022-10-15T03:50:41 | 2016-04-28T14:42:50 | C | UTF-8 | Racket | false | false | 5,960 | rkt | tc-metafunctions.rkt | #lang racket/base
(require "../utils/utils.rkt"
racket/match racket/list
(except-in (types abbrev union utils filter-ops tc-result)
-> ->* one-of/c)
(rep type-rep filter-rep object-rep rep-utils)
(typecheck tc-subst check-below)
(contract-req))
(provide abstract-results
combine-props
merge-tc-results
tc-results->values)
;; Objects representing the rest argument are currently not supported
(define/cond-contract (abstract-results results arg-names #:rest-id [rest-id #f])
((tc-results/c (listof identifier?)) (#:rest-id (or/c #f identifier?))
. ->* . SomeValues/c)
(define positional-arg-objects
(for/list ([(nm k) (in-indexed (in-list arg-names))])
(list nm (make-Path null (list 0 k)))))
(define arg-objects
(if rest-id
(cons (list rest-id -empty-obj) positional-arg-objects)
positional-arg-objects))
(tc-results->values (replace-names arg-objects results)))
(define (tc-results->values tc)
(match (fix-results tc)
[(tc-any-results: f)
(-AnyValues f)]
[(tc-results: ts fs os)
(make-Values (map -result ts fs os))]
[(tc-results: ts fs os dty dbound)
(make-ValuesDots (map -result ts fs os) dty dbound)]))
(define/cond-contract (resolve atoms prop)
((listof Filter/c)
Filter/c
. -> .
Filter/c)
(for/fold ([prop prop])
([a (in-list atoms)])
(match prop
[(AndFilter: ps)
(let loop ([ps ps] [result null])
(if (null? ps)
(apply -and result)
(let ([p (car ps)])
(cond [(contradictory? a p) -bot]
[(implied-atomic? p a) (loop (cdr ps) result)]
[else (loop (cdr ps) (cons p result))]))))]
[_ prop])))
(define (flatten-props ps)
(let loop ([ps ps])
(match ps
[(list) null]
[(cons (AndFilter: ps*) ps) (loop (append ps* ps))]
[(cons p ps) (cons p (loop ps))])))
(define/cond-contract (combine-props new-props old-props exit)
((listof Filter/c) (listof Filter/c) (-> none/c)
. -> .
(values (listof (or/c ImpFilter? OrFilter?)) (listof (or/c TypeFilter? NotTypeFilter?))))
(define (atomic-prop? p) (or (TypeFilter? p) (NotTypeFilter? p)))
(define-values (new-atoms new-formulas) (partition atomic-prop? (flatten-props new-props)))
(let loop ([derived-formulas null]
[derived-atoms new-atoms]
[worklist (append old-props new-formulas)])
(if (null? worklist)
(values derived-formulas derived-atoms)
(let* ([p (car worklist)]
[p (resolve derived-atoms p)])
(match p
[(ImpFilter: a c)
(if (for/or ([p (in-list (append derived-formulas derived-atoms))])
(implied-atomic? a p))
(loop derived-formulas derived-atoms (cons c (cdr worklist)))
(loop (cons p derived-formulas) derived-atoms (cdr worklist)))]
[(OrFilter: ps)
(let ([new-or
(let or-loop ([ps ps] [result null])
(cond
[(null? ps) (apply -or result)]
[(for/or ([other-p (in-list (append derived-formulas derived-atoms))])
(contradictory? (car ps) other-p))
(or-loop (cdr ps) result)]
[(for/or ([other-p (in-list derived-atoms)])
(implied-atomic? (car ps) other-p))
-top]
[else (or-loop (cdr ps) (cons (car ps) result))]))])
(if (OrFilter? new-or)
(loop (cons new-or derived-formulas) derived-atoms (cdr worklist))
(loop derived-formulas derived-atoms (cons new-or (cdr worklist)))))]
[(or (? TypeFilter?) (? NotTypeFilter?)) (loop derived-formulas (cons p derived-atoms) (cdr worklist))]
[(AndFilter: ps) (loop derived-formulas derived-atoms (append ps (cdr worklist)))]
[(Top:) (loop derived-formulas derived-atoms (cdr worklist))]
[(Bot:) (exit)])))))
(define (unconditional-prop res)
(match res
[(tc-any-results: f) f]
[(tc-results (list (tc-result: _ (FilterSet: f+ f-) _) ...) _)
(apply -and (map -or f+ f-))]))
(define (merge-tc-results results)
(define/match (merge-tc-result r1 r2)
[((tc-result: t1 (FilterSet: f1+ f1-) o1)
(tc-result: t2 (FilterSet: f2+ f2-) o2))
(tc-result
(Un t1 t2)
(-FS (-or f1+ f2+) (-or f1- f2-))
(if (equal? o1 o2) o1 -empty-obj))])
(define/match (same-dty? r1 r2)
[(#f #f) #t]
[((cons t1 dbound) (cons t2 dbound)) #t]
[(_ _) #f])
(define/match (merge-dty r1 r2)
[(#f #f) #f]
[((cons t1 dbound) (cons t2 dbound))
(cons (Un t1 t2) dbound)])
(define/match (number-of-values res)
[((tc-results rs #f))
(length rs)]
[((tc-results rs (cons _ dbound)))
(format "~a and ... ~a" (length rs) dbound)])
(define/match (merge-two-results res1 res2)
[((tc-result1: (== -Bottom)) res2) res2]
[(res1 (tc-result1: (== -Bottom))) res1]
[((tc-any-results: f1) res2)
(tc-any-results (-or f1 (unconditional-prop res2)))]
[(res1 (tc-any-results: f2))
(tc-any-results (-or (unconditional-prop res1) f2))]
[((tc-results results1 dty1) (tc-results results2 dty2))
;; if we have the same number of values in both cases
(cond
[(and (= (length results1) (length results2))
(same-dty? dty1 dty2))
(tc-results (map merge-tc-result results1 results2)
(merge-dty dty1 dty2))]
;; otherwise, error
[else
(tc-error/expr "Expected the same number of values, but got ~a and ~a"
(length results1) (length results2))])])
(for/fold ([res (ret -Bottom)]) ([res2 (in-list results)])
(merge-two-results res res2)))
| false |
8b26db752e8d02553b167da1b5e2e68dfa8f1a04 | b62560d3387ed544da2bbe9b011ec5cd6403d440 | /crates/steel-core/tests/modules/main.rkt | 4b9877c23f74a5e40365b8727ca2b6ca90176efa | [
"LicenseRef-scancode-unknown-license-reference",
"MIT",
"Apache-2.0"
]
| permissive | mattwparas/steel | c6fb91b20c4e613e6a8db9d9310d1e1c72313df2 | 700144a5a1aeb33cbdb2f66440bbe38cf4152458 | refs/heads/master | 2023-09-04T03:41:35.352916 | 2023-09-01T03:26:01 | 2023-09-01T03:26:01 | 241,949,362 | 207 | 10 | Apache-2.0 | 2023-09-06T04:31:21 | 2020-02-20T17:39:28 | Rust | UTF-8 | Racket | false | false | 103 | rkt | main.rkt | (require "a.rkt")
(require "b.rkt")
; (require "sort_export.rkt")
(a 10)
(b 20)
; (capture-func 10)
| false |
bb61a750c680929254d16eb96971dd88dce5a53d | 24338514b3f72c6e6994c953a3f3d840b060b441 | /cur-lib/cur/curnel/racket-impl/equiv.rkt | 460cf17f99453dcbd6c8be65fd8d40477785cc31 | [
"BSD-2-Clause"
]
| permissive | graydon/cur | 4efcaec7648e2bf6d077e9f41cd2b8ce72fa9047 | 246c8e06e245e6e09bbc471c84d69a9654ac2b0e | refs/heads/master | 2020-04-24T20:49:55.940710 | 2018-10-03T23:06:33 | 2018-10-03T23:06:33 | 172,257,266 | 1 | 0 | BSD-2-Clause | 2019-02-23T19:53:23 | 2019-02-23T19:53:23 | null | UTF-8 | Racket | false | false | 2,450 | rkt | equiv.rkt | #lang racket/base
(require
"eval.rkt"
"stxutils.rkt"
syntax/parse
(for-template
"runtime.rkt"))
(provide
cur-α-equal?
cur-equal?
cur-subtype?
(rename-out
[cur-current-identifier=?
unsafe-I-promise-I-know-what-I-am-doing-please-give-me-the-ability-to-introduce-bugs-by-using-cur-current-identifier=?]))
(define cur-current-identifier=? (make-parameter free-identifier=?))
; t1 and t2 must both be cur-runtime-terms?
(define (cur-α-equal? t1 t2 (fail (lambda _ #f)))
(let cur-α-equal? ([t1 t1] [t2 t2])
(syntax-parse #`(#,t1 #,t2)
[(x:cur-runtime-identifier y:cur-runtime-identifier)
(or ((cur-current-identifier=?) #'x #'y) (fail t1 t2))]
#;[(e1:cur-runtime-constant e2:cur-runtime-constant)
(and (cur-α-equal? #'e1.name #'e2.name)
(andmap cur-α-equal? (attribute e1.rand-ls) (attribute e2.rand-ls)))]
[(A:cur-runtime-universe B:cur-runtime-universe)
(or (eq? (attribute A.level) (attribute B.level)) (fail t1 t2))]
[(e1:cur-runtime-pi e2:cur-runtime-pi)
(and (cur-α-equal? #'e1.ann #'e2.ann)
(cur-α-equal? #'e1.result (subst #'e1.name #'e2.name #'e2.result)))]
[(e1:cur-runtime-elim e2:cur-runtime-elim)
(and (cur-α-equal? #'e1.target #'e2.target)
(cur-α-equal? #'e1.motive #'e2.motive)
(andmap cur-α-equal? (attribute e1.method-ls) (attribute e2.method-ls)))]
[(e1:cur-runtime-app e2:cur-runtime-app)
(and (cur-α-equal? #'e1.rator #'e2.rator)
(cur-α-equal? #'e1.rand #'e2.rand))]
[(e1:cur-runtime-lambda e2:cur-runtime-lambda)
(and (cur-α-equal? #'e1.ann #'e2.ann)
(cur-α-equal? #'e1.body (subst #'e1.name #'e2.name #'e2.body)))]
[(e1:cur-runtime-term e2:cur-runtime-term)
(fail t1 t2)])))
(define (cur-equal? t1 t2 (fail (lambda _ #f)))
(cur-α-equal? (cur-eval t1) (cur-eval t2) fail))
(define (cur-subtype? t1 t2 (fail (lambda _ #f)))
(let cur-subtype? ([t1 (cur-eval t1)]
[t2 (cur-eval t2)])
(syntax-parse #`(#,t1 #,t2)
[(A:cur-runtime-universe B:cur-runtime-universe)
(or (<= (attribute A.level) (attribute B.level)) (fail t1 t2))]
[(e1:cur-runtime-pi e2:cur-runtime-pi)
(and (cur-α-equal? #'e1.ann #'e2.ann fail)
(cur-subtype? #'e1.result (subst #'e1.name #'e2.name #'e2.result)))]
[(e1 e2)
(cur-α-equal? #'e1 #'e2 fail)])))
| false |
64ec08ded6ad9d18c38c8bd2533ffe56615609cc | 98fd4b7b928b2e03f46de75c8f16ceb324d605f7 | /drracket/drracket/private/tools-drs.rkt | 8eb3573dfcd9f398da3e63b2b1927df6c6f64ece | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/drracket | 213cf54eb12a27739662b5e4d6edeeb0f9342140 | 2657eafdcfb5e4ccef19405492244f679b9234ef | refs/heads/master | 2023-08-31T09:24:52.247155 | 2023-08-14T06:31:49 | 2023-08-14T06:32:14 | 27,413,460 | 518 | 120 | NOASSERTION | 2023-09-11T17:02:44 | 2014-12-02T03:36:22 | Racket | UTF-8 | Racket | false | false | 2,392 | rkt | tools-drs.rkt | #lang racket/unit
#|
This file sets up the right lexical environment to
invoke the tools that want to use the drscheme: names.
|#
(require racket/class
racket/list
racket/runtime-path
racket/contract
racket/struct-info
setup/getinfo
mred
framework
framework/splash
drracket/private/drsig
"language-object-contract.rkt"
"wrap-tool-inputs.rkt"
mrlib/switchable-button
string-constants
net/url)
(import [prefix drscheme:frame: drracket:frame^]
[prefix drscheme:unit: drracket:unit^]
[prefix drscheme:rep: drracket:rep^]
[prefix drscheme:get/extend: drracket:get/extend^]
[prefix drscheme:language: drracket:language^]
[prefix drscheme:language-configuration: drracket:language-configuration^]
[prefix drscheme:help-desk: drracket:help-desk^]
[prefix drscheme:init: drracket:init/int^]
[prefix drscheme:debug: drracket:debug^]
[prefix drscheme:eval: drracket:eval^]
[prefix drscheme:modes: drracket:modes^]
[prefix drscheme:tracing: drracket:tracing^]
[prefix drscheme:module-language: drracket:module-language^]
[prefix drscheme:module-language-tools: drracket:module-language-tools^]
[prefix drscheme: drracket:interface^])
(export drracket:tools-drs^)
;; these two definitions are a hack. They give bindings for the drracket: based names that
;; appear in the source of language-object-contract.rkt.
(define (drracket:language:capability-registered? . args)
(apply drscheme:language:capability-registered? args))
(define (drracket:language:get-capability-contract . args)
(apply drscheme:language:get-capability-contract args))
;; invoke-drs-tool : unit/sig string -> (values (-> void) (-> void))
;; invokes the tools and returns the two phase thunks.
;; this is the same as the invoke-tool function in tools.rkt, but
;; supplies names prefixed with `drscheme:'
(define (invoke-drs-tool unit tool-name)
(define-unit-binding unit@ unit (import drscheme:tool^) (export drracket:tool-exports^))
(language-object-abstraction drscheme:language:object/c #f)
(wrap-tool-inputs
(let ()
(define-values/invoke-unit unit@
(import drscheme:tool^) (export drracket:tool-exports^))
(values phase1 phase2))
tool-name
#t))
| false |
059cd19019a99c087ba5a6b3d9ab8ee19f8f6214 | 320eb8a018f3063eeb2373425fea6144704f4bfc | /neuron-doc/scribblings/main.scrbl | 998595b2054506696ef936b657afb77e4b0f2440 | [
"Apache-2.0"
]
| permissive | dedbox/racket-neuron | 583f458dfa363d652d7e5424ae89e854aeff8508 | a8ecafec0c6398c35423348cb02ec229869c8b15 | refs/heads/master | 2022-06-06T07:54:53.445496 | 2018-04-17T18:33:57 | 2018-04-17T18:33:57 | 115,617,919 | 17 | 3 | Apache-2.0 | 2022-05-16T21:13:56 | 2017-12-28T11:44:22 | Racket | UTF-8 | Racket | false | false | 534 | scrbl | main.scrbl | #lang scribble/manual
@title{Neuron: Decentralized Software Organisms}
Neuron is a framework for creating and participating in Internet-scale
software ecosystems. Neuron provides a unified API for IPC and distributed
messaging, along with components for building dynamic data-flow networks.
@; , decentralized run time environments and programs, and mobile software agents.
@local-table-of-contents[#:style 'immediate-only]
@include-section["guide.scrbl"]
@include-section["reference.scrbl"]
@include-section["tech-report.scrbl"]
| false |
e9cd48752636d3889a59b24b2cb7b1b28dab13a2 | e29bd9096fb059b42b6dde5255f39d443f69caee | /metapict/examples/stream-plot.rkt | 5eb47b82362dfe7277d9f96a7ddef12784bc8ef8 | []
| no_license | soegaard/metapict | bfe2ccdea6dbc800a6df042ec00c0c77a4915ed3 | d29c45cf32872f8607fca3c58272749c28fb8751 | refs/heads/master | 2023-02-02T01:57:08.843234 | 2023-01-25T17:06:46 | 2023-01-25T17:06:46 | 16,359,210 | 52 | 12 | null | 2023-01-25T17:06:48 | 2014-01-29T21:11:46 | Racket | UTF-8 | Racket | false | false | 12,423 | rkt | stream-plot.rkt | #lang racket/base
;;;
;;; Stream Plots
;;;
;; Given a differential equation of the form
;; y' = f(x,y)
;; a stream plot shows multiple solutions curves.
;; The stream plot attempts to plot solutions curves that
;; doesn't lie too close to each other.
;; First a set of starting points is generated.
;; Then a solution curve through each starting point is drawn.
;; When a solution curve gets too close to an already drawn
;; curve the curve is cut off.
;; This is done by dividing the plot window into 30x30 (when density=1)
;; rectangular cells. When a curve is drawn, the cells that
;; it touch are marked. Only starting points that lie in
;; untouched cells are drawn. If the option #:unbroken-trajectories?
;; is true, then curves aren't cut off, but are allowed to continue.
;; The default is to cut the curves.
;; The starting points are generated by `generate-start-points`.
;; The order of the starting points affect the visual esthetic.
;; Two orderings that produce nice looking figures are:
;; - random order
;; - sorted according to their distance from the mid point
;; Notes:
;; - as an experiment you can choose betwen rectangular and
;; hexagonal cells in make-buckets.
;; Simply uncomment the `repr`, you don't neeed.
;; TODO:
;; - an option to discard short trajectories would
;; in some cases make the figures prettier.
(require metapict metapict/system metapict/axis
(except-in metapict ellipse first-value label table)
racket/list racket/match)
(provide stream-plot)
;;;
;;; Buckets
;;;
;; An instance of buckets keeps track of which rectangular cells
;; have been touched by a solution curve.
;; The hash table ht is map from cell representatives to booleans.
;; The functions `touch!` and `touched?` are used to query the hash table.
;; They both take an x and y coordinate from the domain.
;; The `info` field holds the window and the size of the rectangles.
(struct buckets (ht touch! touched? info) #:transparent)
(define (make-buckets xmin xmax ymin ymax dx dy)
; We divide the rectange [xmin,xmax]x[ymin,ymax] into
; small rectangles of size dx*dy. The rectangles are buckets.
; hexagonal cells
(define (repr x y)
(vec-round (vec->hex (vec x y) (* 0.5 dx))))
; rectangular cells
#;(define (repr x y)
(cond
[(or (< x xmin) (> x xmax)
(< y ymin) (> y ymax))
'out-of-bounds]
[else
(cons (inexact->exact (floor (/ (- x xmin) dx)))
(inexact->exact (floor (/ (- y ymin) dy))))]))
; The hash tables stores for each bucket, whether it is touched.
; A bucket is touched, when we draw in it.
(define ht (make-hash))
(define (touch! x y) (hash-set! ht (repr x y) #t))
(define (touched? x y) (hash-ref ht (repr x y) #f))
(buckets ht touch! touched? (list xmin xmax ymin ymax dx dy)))
;;;
;;; Hexagonal Cells
;;;
(define 180deg 3.141592653589793)
(define 90deg (/ 180deg 2.))
(define 60deg (/ 180deg 3.))
(define 30deg (/ 180deg 6.))
(define (vec->hex v size)
(define height (* 2 size))
(define width (* (sqrt 3) size))
(define g (vec width 0)) ; vector from center of tile (0,0) to tile (1,0)
(define h (vec (* width (cos 60deg)) ; vector from center of tile (0,0) to tile (0,1)
(* width (sin 60deg))))
; Convert the vector into hex coordinates.
; That is, find i and h such that:
; v = i g + j h
; To isolate j, we take the dot product with g^ on both sides:
; v*g^ = i g*g^ + j h*g^
; v*g^ = j h*g^
; Thus
; j = v*g^ / h*g^
; Similarly
; i = v*h^ / g*h^
(def g^ (rot90 g))
(def h^ (rot90 h))
(def i (/ (dot v h^) (dot g h^)))
(def j (/ (dot v g^) (dot h g^)))
(vec i j))
(define (vec-round v)
; round down
(define (r x) (inexact->exact (ceiling (- x 0.5))))
(defm (vec x y) v)
(vec (r x) (r y)))
;;;
;;; Runge-Kutta
;;;
; Returns a table of points before and after (x0,y0).
; Here f : RxR -> R comes from the differential equation y'=f(x,y).
(define (runge-kutta f x0 y0 xmin xmax h)
(values (runge-kutta/backward f x0 y0 xmin h)
(runge-kutta/forward f x0 y0 xmax h)))
; Initial value problem:
; dy/dx = f(x,y); y(x0)=y0
; where y is an unknown function.
(define (runge-kutta/forward f x0 y0 xmax h)
; RK4 - forward
; y_{n+1} := y_n + 1/6 (k₁ + 2k₂ + 2 k₃ + k₄) h,
; k₁ = f(x_n, y_n )
; k₂ = f(x_n + h/2, y_n + h/2 k₁)
; k₃ = f(x_n + h/2, y_n + h/2 k₂)
; k₄ = f(x_n + h , y_n + h k₃)
; Use this page to produce test cases:
; https://homepages.bluffton.edu/~nesterd/apps/slopefields.html
(define (next xn yn)
(define h/2 (/ h 2))
(define k₁ (f xn yn))
(define k₂ (f (+ xn h/2) (+ yn (* h/2 k₁))))
(define k₃ (f (+ xn h/2) (+ yn (* h/2 k₂))))
(define k₄ (f (+ xn h) (+ yn (* h k₃))))
(+ yn (/ (* h (+ k₁ (* 2. k₂) (* 2. k₃) k₄)) 6.)))
(for/fold ([yn y0] [pts '()] #:result (reverse pts))
([xn (in-range x0 (+ xmax h) h)])
(define y+ (next xn yn))
(values y+ (cons (list xn yn) pts))))
(define (runge-kutta/backward f x0 y0 xmin h)
; RK4 - backwards
; y_{n+1} := y_n - 1/6 (k₁ + 2k₂ + 2 k₃ + k₄) h,
; k₁ = f(x_n, y_n )
; k₂ = f(x_n - h/2, y_n - h/2 k₁)
; k₃ = f(x_n - h/2, y_n - h/2 k₂)
; k₄ = f(x_n - h , y_n - h k₃)
; Use this page to produce test cases:
; https://homepages.bluffton.edu/~nesterd/apps/slopefields.html
(define (next xn yn)
(define h/2 (/ h 2))
(define k₁ (f xn yn))
(define k₂ (f (- xn h/2) (- yn (* h/2 k₁))))
(define k₃ (f (- xn h/2) (- yn (* h/2 k₂))))
(define k₄ (f (- xn h) (- yn (* h k₃))))
(- yn (/ (* h (+ k₁ (* 2. k₂) (* 2. k₃) k₄)) 6.)))
(for/fold ([yn y0] [pts '()] #:result (reverse pts))
([xn (in-range x0 (- xmin h) (- h))])
(define y+ (next xn yn))
(values y+ (cons (list xn yn) pts))))
;;;
;;; Stream Plot
;;;
(define (stream-plot f xmin xmax ymin ymax
#:samples [n 50]
#:pts [pts #f]
#:draw-solution? [draw-solution? #f]
#:unbroken-trajectories? [unbroken-trajectories? #f]
#:draw-starting-points? [draw-starting-points? #f] ; for debug
)
(define win (window xmin xmax ymin ymax))
(with-window win
; coordinate system
(def s (system (pt 0 0) (vec 1 0) (vec 0 1) "" "")) ; todo: x-pict and y-pict
(defm (system: _ a1 a2) s)
; convert from s to device coordinats
(def (Pt x y) (point->pt (point s x y)))
; ticks in visible range
(defv (vxmin vxmax) (visible-range a1 win))
(defv (vymin vymax) (visible-range a2 win))
(def x-gap (find-gap-size vxmin vxmax #:at-least 5))
(def y-gap (find-gap-size vymin vymax #:at-least 5))
(defv (tick-x-min tick-x-max) (find-first/last-tick-in-range vxmin vxmax x-gap))
(defv (tick-y-min tick-y-max) (find-first/last-tick-in-range vymin vymax y-gap))
#;(define (slope-segment x y)
(def u (px 4))
(def slope (f x y))
(def α (atan slope))
(def c (* u (cos α)))
(def s (* u (sin α)))
;; (define (c dx) (/ dx u))
(defm (pt x1 y1) (Pt x y))
(def sc (curve (Pt (- x c) (- y1 s)) .. (Pt (+ x c) (+ y1 s))))
sc)
;; The function `rk4` computes the solutions that passes through (x0,y0).
;; Only if the point (x0,y0) is untouched according to `bs` an instance of `buckets`,
;; the solution curve is drawn.
;; After the curve is drawn, the buckets instance `bs` is updates, so that
;; later curves doesn't come too close to this curve.
(define (rk4 bs x0 y0)
(define touched? (buckets-touched? bs))
(define touch! (buckets-touch! bs))
(define (untouched? x y) (not (touched? x y)))
(cond
; Ignore starting points that lie in a touched cell.
[(touched? x0 y0) (draw)]
[else
; Compute the solution curve through (x0,y0).
(defv (before after) (runge-kutta f
x0 y0 ; (x0,y0)
vxmin vxmax ; interval
0.1)) ; step size h
; Now `before` and `after` are lists of points.
;; Helper functions
; Turn a list of (list x y) into a curve
(define (points->curve xys)
(def pts (map (λ (xy) (apply Pt xy)) xys))
(and (not (empty? xys))
(curve* (add-between pts --))))
; drop points in touched buckets
(define (drop-touched xys)
(dropf xys (λ (xy) (not (apply untouched? xy)))))
; take points in untouched buckets
(define (take-untouched xys)
(takef xys (λ (xy) (apply untouched? xy))))
; only keep points until first point in a touched cell
(define (cut-off xys)
(if unbroken-trajectories?
xys
(take-untouched xys)))
; find the untouched points, turn them into curves
(define untouched-points-before (cut-off before))
(define untouched-points-after (cut-off after))
(define curve-before (points->curve untouched-points-before))
(define curve-after (points->curve untouched-points-after))
(define (touch-segment! x y X Y)
(match-define (list xmin xmax ymin ymax dx dy) (buckets-info bs))
(define (sqr x) (* x x))
(define dist (sqrt (+ (sqr (- x X)) (sqr (- y Y)))))
(define d (sqrt (+ (sqr dx) (sqr dy))))
(for ([t (in-range 0 1 (max 0.1 (min 0 (/ d (* 20 dist)))))])
(touch! (+ (* t x) (* (- 1 t) X))
(+ (* t y) (* (- 1 t) Y)))))
(define (mark-points-as-touched xys)
(define prev-x #f)
(define prev-y #f)
(for ([xy xys])
(match-define (list x y) xy)
(touch! x y)
(when prev-x (touch-segment! prev-x prev-y x y))
(set! prev-x x)
(set! prev-y y)))
(mark-points-as-touched untouched-points-before)
(mark-points-as-touched untouched-points-after)
; draw
(draw curve-before curve-after)]))
(define buckets (make-buckets xmin xmax ymin ymax 0.2 0.2))
(draw
s
(system-ticks s #:size 4)
(tick-labels-in-range a1 tick-x-min tick-x-max x-gap #:fill #f #:opposite #t #:omit '(0) #:omit-last #t)
(tick-labels-in-range a2 tick-y-min tick-y-max y-gap #:fill #f #:opposite #t #:omit '(0) #:omit-last #t)
(for/draw ([p pts])
(defm (pt x0 y0) p)
(draw (color "red" (rk4 buckets x0 y0))
(and draw-starting-points?
(penwidth 4 (color "blue" (draw (Pt x0 y0))))))))))
(define (generate-start-points win #:density [density 1])
; density: A density of 1 divides the window into 30x30 rectangles.
; A density of 2 divides the window into (2*30)x(2*30) rectangles.
(match-define (window xmin xmax ymin ymax) win)
(define dx (/ (- xmax xmin) (* density 30)))
(define dy (/ (- ymax ymin) (* density 30)))
(define pts (append* (for/list ([x (in-range xmin (+ xmax dx) dx)])
(for/list ([y (in-range ymin (+ ymax dy) dy)]
[row (in-naturals 0)])
; every second row is shifted slightly
(if (even? row)
(pt x y)
(pt (+ x (/ dx 2)) y))))))
(define mid (pt (/ (+ xmin xmax) 2.) (/ (+ ymin ymax) 2.)))
(define (compare p q) (> (dist p mid) (dist q mid)))
#;(sort pts compare)
(shuffle pts))
;;;
;;; Example
;;;
(set-curve-pict-size 300 300)
(define (f x y) (+ x y))
(define (g x y) (- (* x x) y))
(define pts (generate-start-points (window -5.5 5.5 -5.5 5.5) #:density 0.4))
(draw (stream-plot f -3.5 3.5 -3.5 3.5 #:samples 5 #:pts pts
#:unbroken-trajectories? #t))
(blank 30 10)
(draw (stream-plot f -3.5 3.5 -3.5 3.5 #:samples 5 #:pts pts))
| false |
57a405c07a3f04c635ac08ac432e2b7811ab27fa | d3f8b9ab079af1830b1a45babf12a4ab081ec5c0 | /pkg-build.scrbl | c530011b417338169b5106e68a1a09c51662cc6c | [
"MIT",
"Apache-2.0"
]
| permissive | racket/pkg-build | 1112a2435029510d898446930463c57d01ad83c0 | 71c379d2997049780186d104e5464780c28efb27 | refs/heads/master | 2023-02-09T15:06:58.952063 | 2023-01-28T13:19:26 | 2023-01-28T13:20:08 | 27,197,246 | 5 | 10 | NOASSERTION | 2020-07-02T17:38:54 | 2014-11-26T21:36:14 | Racket | UTF-8 | Racket | false | false | 23,005 | scrbl | pkg-build.scrbl | #lang scribble/manual
@(require (for-label racket/base
pkg-build))
@title{Pkg-Build: Building and Testing All Racket Packages}
The @racketmodname[pkg-build] library supports building all packages
from a given catalog and using a given snapshot (i.e., installer plus
snapshot's packages). The build of each package is isolated through a
virtual machine, using either Docker or VirtualBox, and the result is
a set of built packages, a set of documentation, and package test
results. For example, @racketmodname[pkg-build] is used to drive
@url{https://pkg-build.racket-lang.org/} and generate the content of
@url{https://docs.racket-lang.org/}.
To successfully build, a package must
@;
@itemlist[
@item{install without error;}
@item{correctly declare its dependencies (but incorrect declaration
may work, anyway, if the build order happens to accommodate);}
@item{depend on packages that build successfully on their own;}
@item{refer only to other packages in the snapshot and catalog
(and, in particular, must not use PLaneT packages);}
@item{build without special system libraries.}
]
@;
A successful build does not require that its declared dependencies are
complete if the needed packages end up installed, anyway, but the
declared dependencies are checked. Even when a build is unsuccessful,
any documentation that is built along the way is extracted, if
possible.
@section{Building Packages with Docker}
First, install @hyperlink["https://www.docker.com/"]{Docker}. As long
as @exec{docker} is in your path, that may be all you need, because
suitable starting images @tt{racket/pkg-build:pkg-build-deps} and/or
@tt{racket/pkg-build:pkg-build-deps-min} can be downloaded automatically by
Docker. See @secref["starting-image"] for more information about the
content of a suitable starting image.
In the @filepath{pkg-build} package sources, see the
@filepath{examples/docker} directory for an example use of
@racket[build-pkgs] with Docker.
@section{Building Packages with VirtualBox}
First, install @hyperlink["https://www.virtualbox.org/"]{VirtualBox}
and ensure that @exec{VBoxManage} is in your path.
You will need to create a suitable VirtualBox virtual machine
containing a Linux distribution (we recommend any recent version of
Ubuntu). See @secref["starting-image"] for more information about the
content of a suitable starting image. With those dependencies in
place, you will need to configure the virtual machine:
@;
@itemlist[
@item{Create a @tt{racket} user.}
@item{Ensure that the @tt{racket} user can run @tt{sudo} without a password.}
@item{Install the OpenSSH server, and add your public key from
@filepath{~/.ssh/id_rsa.pub} on your host to the @tt{racket}
user's list of authorized keys in
@filepath{~/.ssh/authorized_keys} on the virtual machine.}
@item{Switch the virtual machine to host-only networking and take
note of its IP address.}
@item{Take a snapshot of the virtual machine called @tt{init}.}
@item{Shut down the virtual machine.}
]
In the @filepath{pkg-build} package sources, see the
@filepath{examples/vbox} directory for an example use of
@racket[build-pkgs] with VirtualBox.
@section[#:tag "starting-image"]{Starting Image Requirements}
The @racket[build-pkgs] function expects a Docker image or VirtualBox
machine with just Linux installed. The installation can be minimal,
but CA certificates and timezone information are recommended. (Even
though network access in the virtual machine should be disabled, basic
configuration is helpful to some libraries.)
Some Racket packages may try to use a C compiler or run tests that
need an GUI context (i.e., an X11 server). To support those packages,
consider including @tt{gcc} and having an X11 server set up. If you
are interested in distinguishing packages that have minimal system
dependencies from those that require more, @racket[build-pkgs] allows
you to specify ``full'' and ``minimal'' starting variants.
See the @filepath{examples/docker/pkg-build-deps} and
@filepath{examples/docker/pkg-build-deps-min} directories of the
@filepath{pkg-build} package source for @filepath{Dockerfile}s that
create suitable starting images.
@section[#:tag "work-dir"]{Work Directory Content}
The @racket[build-pkgs] function needs a work directory where it will
assemble packages and results. The generated content of the work
directory can be used as a catalog of built packages plus web-friendly
files that report build and test results.
If the work directory content persists across calls to
@racket[build-pkgs], then @racket[build-pkgs] will incrementally
rebuild changed packages and other packages that depends on them.
However, a work directory must be reused only when the configuration
supplied to @racket[build-pkgs] does not change.
The work directory will include the following files and directories,
most of which are output, some of which record state for the purpose
of incremental builds, and very few of which are treated as extra
inputs:
@itemlist[
@item{@filepath{installer/} --- Holds an installer downloaded
from a snapshot site.}
@item{@filepath{install-uuids.rktd} --- Holds a mapping of @tech{VM}
names to IDs for prepared Docker containers or VirtualBox
snapshots.}
@item{@filepath{install-list.rktd} --- A list of packages found in
the installation.}
@item{@filepath{install-adds.rkt} --- A table of documentation,
libraries, etc. in the installation, which is used to detect
conflicts.}
@item{@filepath{install-doc.tgz} --- A copy of installation's
documentation.}
@item{@filepath{server/archive} --- Archived packages from the
snapshot site plus additional specified catalogs.}
@item{@filepath{state.sqlite} --- Records the state of
@filepath{server/archive} for incremental updates.}
@item{@filepath{all-pkgs.rktd} --- A list of available package at
most recent build, which is used to avoid re-building packages
that will fail again due to missing dependencies.}
@item{@filepath{force-pkgs.rktd} --- A list of packages to force a
rebuild; this file is an input, and it is deleted after it is
used.}
@item{@filepath{server/built} --- Built packages. For each package
@italic{P}, this directory contains one of the following:
@itemlist[
@item{@filepath{pkgs/@italic{P}.orig-CHECKSUM} (same as the
checksum in the archived catalog),
@filepath{pkgs/@italic{P}.zip} (built package), and
@filepath{pkgs/@italic{P}.zip.CHECKSUM} (built
package's checksum) --- An up-to-date package that
successfully built.
Additional files:
@itemlist[
@item{@filepath{docs/@italic{P}-adds.rktd} --- a
listing of documentation, executables, etc.}
@item{@filepath{success/@italic{P}.txt} --- records success}
@item{@filepath{install/@italic{P}.txt} --- records installation}
@item{@filepath{install/@italic{P}.txt} --- records dependency-checking failure}
@item{@filepath{test-success/@italic{P}.txt}
or @filepath{test-fail/@italic{P}.txt} --- records @exec{raco test} result}
@item{possibly @filepath{min-fail/@italic{P}.txt} --- records failure on minimal-host attempt}
]}
@item{@filepath{pkgs/@italic{P}.orig-CHECKSUM} (same as the
checksum in the archived catalog) and
@filepath{fail/@italic{P}.txt} --- An up-to-date
package that failed to build.
An @filepath{install/@italic{P}.txt} file may
nevertheless report installation success in the sense that
@exec{raco pkg install} failed only in its @exec{raco setup} step.}
@item{@filepath{archive-fail/@italic{P}.orig-CHECKSUM} --- Archiving failure.}
]}
@item{@filepath{dumpster/} --- Saved builds of failed packages if
the package at least installs (and failure was in the
@exec{raco setup} step), because maybe the attempt built some
documentation.}
@item{@filepath{doc/} --- Unpacked documentation with non-conflicting
packages installed.}
@item{@filepath{all-doc.tgz} --- The same content as
@filepath{doc/}, but still packed.}
@item{@filepath{summary.rktd} ---A summary of build results as a
hash table mapping each package name to another hash table
with the following keys:
@itemlist[
@item{@racket['success-log] --- @racket[#f] or relative path}
@item{@racket['failure-log] --- @racket[#f] or relative path}
@item{@racket['dep-failure-log] --- @racket[#f] or relative path}
@item{@racket['test-success-log] --- @racket[#f] or relative path}
@item{@racket['test-failure-log] --- @racket[#f] or relative path}
@item{@racket['min-failure-log] --- @racket[#f] or relative path}
@item{@racket['docs] --- a list of elements, each one of
@itemlist[
@item{@racket[(list 'docs/none _name)]}
@item{@racket[(list 'docs/main _name _path)]}
]}
@item{@racket['conflict-log] --- @racket[#f], a relative path, or
@racket[(list 'conflicts/indirect _path)]}
]}
@item{@filepath{index.html} (and @filepath{robots.txt}, etc.) --- A summary of results in
web-page form.}
@item{@filepath{site.tgz} or @filepath{site.tar} --- All files meant to populate a
web site, including a @filepath{doc/} directory of documentation and a
@filepath{server/built/catalog/} catalog of built packages that are in
@filepath{server/built/pkgs/}. The packed form @filepath{site.tgz} is
created unless @racket[#:compress-site?] is provided as @racket[#f].}
]
Using this information, the @racket[build-pkgs] rebuilds a package is
if its checksum changes or if one of its declared dependencies
changes.
@section{Package-Building API}
@defmodule[pkg-build]
The @racket[build-pkgs] function drive a package build, but it relies
on a set of @deftech{VMs} that are created by @racket[docker-vm] or
@racket[vbox-vm].
@defproc[(build-pkgs
[#:work-dir work-dir path-string? (current-directory)]
[#:snapshot-url snapshot-url string?]
[#:installer-name installer-name (or/c string? #f) #f]
[#:installer-platform-name installer-platform-name (or/c string? #f) #f]
[#:vms vms (listof vm?)]
[#:pkg-catalogs pkg-catalogs (listof string?) (list "https://pkgs.racket-lang.org/")]
[#:pkgs-for-version pkgs-for-version string? (version)]
[#:extra-packages extra-packages (listof string?) null]
[#:only-packages only-packages (or/c #f (listof string?)) #f]
[#:only-sys+subpath only-sys+subpath (or/c #f (cons string? string?)) null]
[#:compile-any? compile-any? any/c #f]
[#:steps steps (listof symbol?) (steps-in 'download 'summary)]
[#:timeout timeout real? 600]
[#:test-timeout test-timeout (or/c #f real?) #f]
[#:jobs jobs (or/c #f exact-positive-integer?) #f]
[#:on-empty-pkg-updates on-empty-pkg-updates (-> any) void]
[#:install-doc-list-file install-doc-list-file (or/c #f path-string?) #f]
[#:run-tests? run-tests? any/c t]
[#:built-at-site? built-at-site? any/c #f]
[#:site-url site-url (or/c #f string?) #f]
[#:site-starting-point site-starting-point (or/c #f string?) #f]
[#:compress-site? compress-site? any/c #t]
[#:summary-omit-pkgs summary-omit-pkgs (listof string?) null]
[#:max-build-together max-build-together exact-positive-integer? 1]
[#:server-port server-port (or/c #f (integer-in 1 65535)) 18333])
void?]{
Builds packages by
@;
@itemlist[
@item{using @racket[work-dir] as the @seclink["work-dir"]{work directory};}
@item{downloading initial packages from @racket[snapshot-url],
which can be something like @racket["https://mirror.racket-lang.org/releases/7.6/"];}
@item{using either @racket[installer-name] or
@racket[installer-platform-name] (exactly one of them must be supplied as non-@racket[#f])
to locate an installer at @racket[snapshot-url], where @racket[installer-name]
is something like @racket["racket-x86_64-linux-natipkg.tgz"], or @racket[installer-platform-name] is something like
@racket["{1} Racket | {3} Linux | {3} x64_64 (64-bit), natipkg; built on Debian 8 (Jessie)"];
in the latter case, the name should be one of the entries in @filepath{installers/table.rktd} relative
to @racket[snapshot-url]; in both cases, it should be a @tt{natipkg} option consistent with
the @tech{VMs} specified by @racket[vms];
if a minimal installer is used and package tests will be run, include
@racket["compiler-lib"] in @racket[extra-packages];}
@item{running the @tech{VMs} machines specified by @racket[vms], which is
a list of results from @racket[docker-vm] and/or
@racket[vbox-vm];}
@item{installing additional packages from @racket[pkg-catalogs]
individually in @tech{VMs}.}
]
Additional configuration options:
@itemlist[
@item{@racket[pkgs-for-version] --- The Racket version to use in
queries to archived catalogs. This version should be
consistent with @racket[snapshot-url].}
@item{@racket[extra-packages] --- Extra packages to install within an
installation so that they're treated like packages that are included in
the installer. These should be built packages (normally from
the snapshot site), or else the generated built packages will
not work right (especially when using multiple @tech{VMs}).}
@item{@racket[only-packages] --- When not @racket[#f], specifies a
subset of packages available from @racket[pkg-catalogs] to be
built and recorded in a catalog. Any dependencies of a
specified package are also included.}
@item{@racket[only-sys+subpath] --- When not @racket[#f] and when
@racket[only-packages] is not @racket[#f], considers only
dependencies for the indicated specific platform. The platform is described
by @racket[cons]ing a symbol matching the result of
@racket[(system-type)] to a string matching the result of
@racket[(system-library-subpath #f)].}
@item{@racket[compile-any?] --- When not @racket[#f],
compiles bytecode in built packages to machine-independent
form. The installer specified by @racket[installer-name] or
@racket[installer-platform-name] and the packages provided by
@racket[pkg-catalogs] must also have machine-independent
bytecode.}
@item{@racket[steps] --- Steps to perform the package-build process.
The possible steps, in order, are
@itemlist[
@item{@racket['download]: download installer from snapshot
site.}
@item{@racket['archive]: archive catalogs byt downloading
all packages to the work directory.}
@item{@racket['install]: run the installer to set up each @tech{VM}.}
@item{@racket['build]: build packages that have changed.}
@item{@racket['docs]: extract and assemble documentation.}
@item{@racket['summary]: summarize the results as a web page.}
@item{@racket['site]: assemble web-friendly pieces to an archive.}
]
You can skip steps at the beginning if you know that they're already
done, and you can skip tests at the end if you don't want them,
but any included steps must be contiguous and in order.}
@item{@racket[timeout] --- Timeout in seconds for any one package
or step.}
@item{@racket[test-timeout] --- If not @racket[#f], supplied with
@DFlag{timeout} to @exec{raco test} to configure the default
testing timeout.}
@item{@racket[jobs] --- If not @racket[#f], supplied with
@DFlag{jobs} to @exec{raco pkg install}, @exec{raco setup},
and/or @exec{raco test} to configure the number of concurrent
jobs that run.}
@item{@racket[on-empty-pkg-updates] --- A thunk that is called in the
case that no packages need to be rebuilt.}
@item{@racket[install-doc-list-file] --- If not @racket[#f], save a
list of files in the original installation's @filepath{doc}
directory to the specified file as part of the
@racket['install] step.}
@item{@racket[run-tests?] --- Determines whether each package's
tests are run after building the package.}
@item{@racket[built-at-site?] --- Determines whether to include a
catalog of built packages in an assembled site.}
@item{@racket[site-url] --- The URL where the assemble site will be
made available (for, e.g., showing help about the catalog).}
@item{@racket[site-starting-point] --- Text for help to describes
the starting point, where @racket[#f] means ``the current
release.''}
@item{@racket[compress-site?] --- Selects whether the
@racket['site] step produces @filepath{site.tgz} (if true) or
@filepath{site.tar} (otherwise).}
@item{@racket[summary-omit-pkgs] --- A list of packages to omit from
the build summary.}
@item{@racket[max-build-together] --- Number of packages to build
at once in a single @tech{VM}. Building more than one package
at a time can be faster, but it is not recommended: building
multiple packages risks success when a build should have
failed due to missing dependencies, and it risks corruption
due to broken or nefarious packages.}
@item{@racket[server-port] --- A TCP port to use for serving
packages from the build machine to VirtualBox @tech{VMs}.
This server is not started if @racket[vms] contains only
Docker @tech{VMs}.}
]}
@defproc[(vm? [v any/c]) boolean?]{
Recognizes a @tech{VM} crreated by @racket[docker-vm] or @racket[vbox-vm].}
@defproc[(docker-vm
[#:name name string?]
[#:from-image from-image string?]
[#:dir dir string? "/home/root/"]
[#:env env (listof (cons/c string? string?)) null]
[#:shell shell (listof string?) '("/bin/sh" "-c")]
[#:memory-mb memory-mb (or/c #f exact-positive-integer?) #f]
[#:swap-mb swap-mb (or/c #f exact-positive-integer?) #f]
[#:minimal-variant minimal-variant (or/c #f vm?) #f])
vm?]{
Creates a @tech{VM} that specifies a Docker image and container. The
given @racket[name] will be used to name a new image (replacing any
existing @racket[name] image) that is built starting with
@racket[from-image] and that holds the Racket installation.
@margin-note*{At the time of writing, @racket["racket/pkg-build:pkg-build-deps"]
and/or @racket["racket/pkg-build:pkg-build-deps-min"] is suitable as
@racket[from-image].} The given @racket[name] is also used for a
container that is an instance of the image; the container is created
fresh (replacing any existing @racket[name] container) for each
package to build.
The @racket[dir] argument specifies a working directory within the
Docker container; it must be a @racket[complete-path?], when viewed
as a unix path, i.e.,
@racket[(complete-path? (bytes->path (string->bytes/utf-8 dir) 'unix))]
must return @racket[#t].
The @racket[env] argument specifies environment variable settings that
prefix every command.
The @racket[shell] argument determines the shell command that is used
to run shell-command strings in the container.
The @racket[memory-mb] and @racket[swap-mb] arguments set memory-use
constraints on the created container. The @racket[memory-mb] value
corresponds to ``real'' memory in megabytes, and @racket[swap-mb] is
additional swap space. If either is non-@racket[#f], the same value is
used in place of a @racket[#f] for the other. If both are @racket[#f],
no specific limit is imposed.
The @racket[minimal-variant] argument, if not @racket[#f], specifies a
@tech{VM} to try before this one. If installation fails with the
@racket[minimal-variant] @tech{VM}, it is tried again with this one.
Tests run in this @tech{VM}, however, instead of
@racket[minimal-variant].}
@defproc[(vbox-vm
[#:name name string?]
[#:host host string?]
[#:user user string? "racket"]
[#:ssh-key ssh-key (or/c #f path-string?) #f]
[#:dir dir string? "/home/racket/build-pkgs"]
[#:env env (listof (cons/c string? string?)) null]
[#:shell shell (listof string?) '("/bin/sh" "-c")]
[#:init-shapshot init-snapshot string? "init"]
[#:installed-shapshot installed-snapshot string? "installed"]
[#:minimal-variant minimal-variant (or/c #f vm?) #f])
vm?]{
Creates a @tech{VM} that specifies a VirtualBox virtual machine with
the given @racket[name]. The @racket[host] string specifies the IP
address of the machine to access it using @exec{ssh}, and
@racket[user] is the user for that @exec{ssh}. You must configure the
virtual machine and the host's SSH settings so that @exec{ssh} works
without a password. The @racket[ssh-key] argument can name a file
containing private key to use for @exec{ssh} as @racket[user].
The @racket[dir] argument specifies a working directory
within the virtual machine, with the same checks as
@racket[docker-vm]'s @racket[_dir] argument.
The @racket[env] argument specifies environment variable settings that
prefix every command.
The @racket[shell] argument determines the shell command that is used
to run shell-command strings in the virtual machine.
The @racket[init-snapshot] string names a snapshot that exists as the
starting point in the virtual machine, so that it can be reset to a
state before any Racket installation. You must configure the virtual
machine to have this snapshot.
The @racket[installed-snapshot] string names a snapshot that will be
created by @racket[build-pkgs] after it installs Racket in the virtual
machine. If a snapshot using this name already exists, it may be
replaced.
The @racket[minimal-variant] argument, if not @racket[#f], specifies a
@tech{VM} to try before this one. If installation fails with the
@racket[minimal-variant] @tech{VM}, it is tried again with this one.
Tests run in this @tech{VM}, however, instead of
@racket[minimal-variant].}
@defproc[(steps-in [start symbol?] [end symbol?]) (listof symbol?)]{
A helper to generate a @racket[#:steps] argument to @racket[build-pkgs]
that has steps @racket[start] through @racket[end] inclusive. See
@racket[build-pkgs] for the allowed step symbols.}
| false |
6ea05e9819fbeb861ebe9bbc636c686ccf7e77e4 | ffdacfd412f359cb1b6994c1677f8169b88dde9a | /racket/monadic.rkt | 3520be557e10bacfffad14cee2fe7c80db4beff8 | []
| no_license | StarGazerM/my-foolish-code | 16a0153da4420eec31c319e46f7c71f56102b181 | 2991997f9be4523bf190ef4143df8b0d89e528cf | refs/heads/master | 2021-06-10T10:43:36.083650 | 2021-05-13T21:24:11 | 2021-05-13T21:24:11 | 166,916,376 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 2,685 | rkt | monadic.rkt | #lang racket
(require racket/control)
;; monadic perform Maybe chain
(define do-tag (make-continuation-prompt-tag 'do))
;; a monad-like adt is a algebra contian
;; it's just Monad like because no real type class here
;; return :: a -> M a
;; bind :: M a -> (a -> M b) -> M b
;; fail :: String -> M a
(define (do-block thnk freturn fbind ffail)
(let/ec return-do-main
(letrec ([do-helper
(λ (pthnk calculated)
(define next (call/prompt pthnk do-tag))
(match next
;; continuation execute rest of stack
;; >>
[(? continuation?)
(do-helper (λ () (next calculated))
calculated)]
;; >>=
[`(bind ,(? continuation? next-c) ,v)
(do-helper (λ () (fbind v next-c))
v)]
[`(return ,(? continuation? next-c) ,v)
;; things in (next-c lambda) is a side effect
;; for example IO
(do-helper (λ () (next-c v))
(freturn v))]
;; give up stack when fail
['fail
(return-do-main (ffail calculated))]
;; default value case, return it
[else calculated]
))])
(do-helper thnk 'empty))))
;; s :: string
(define (fail s)
(call/comp
(λ (ccc)
(abort/cc do-tag (λ () 'fail)))
do-tag))
;; v :: a
(define (return v)
(call/comp
(λ (ccc)
(abort/cc do-tag (λ () `(return ,ccc ,v))))
do-tag))
;; ⟵ can be witted by define
;; cause this is syntax sugar, so just use
;; x :: a
;; m :: M a
(define-syntax-rule (⟵ x m)
(define x (>>= m)))
;; bind is something a repackage function, the data type in whole
;; monad may change, so many be a value/type guard needed
;; in do block each 'line' will cause a bind call
;; f :: a -> b
(define (>>= v)
(call/cc
(λ (ccc)
;; abort/cc is used to replace function call with
;; wrapper continuation
`(bind ,ccc ,v)
#;(abort/cc do-tag (λ () `(bind ,ccc ,v))))
do-tag))
;; define maybe
(define (maybe? m)
(match m
['Nothing #t]
[`(Just ,x) #t]
[else #f]))
;; def of maybe monad
(define (maybe-return v)
`(Just ,v))
(define (maybe-fail v)
'Nothing)
(define (maybe-bind m f)
(match m
['Nothing 'Nothing]
[`(Just ,x) (f x)]))
;; test
(do-block
(λ ()
(⟵ a '(Just 2))
(>>= '(Just 1))
(⟵ b '(Just 4))
(>>= '(Just 2))
;; (>>= 'Nothing)
(>>= `(Just ,(+ a b)))
)
maybe-return
maybe-bind
maybe-fail)
| true |
7051aa86116481e084d76bb027b21068e924c1e9 | fc6465100ab657aa1e31af6a4ab77a3284c28ff0 | /results/all/stlc-sub-3-ordered.rktd | 57a3d6fd11d5179704553238036c1edec7724ec9 | []
| no_license | maxsnew/Redex-Enum-Paper | f5ba64a34904beb6ed9be39ff9a5e1e5413c059b | d77ec860d138cb023628cc41f532dd4eb142f15b | refs/heads/master | 2020-05-21T20:07:31.382540 | 2017-09-04T14:42:13 | 2017-09-04T14:42:13 | 17,602,325 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,860 | rktd | stlc-sub-3-ordered.rktd | (start 2015-06-21T19:45:22 (#:model "stlc-sub-3" #:type ordered))
(counterexample 2015-06-21T20:00:02 (#:model "stlc-sub-3" #:type ordered #:counterexample ((λ (a int) (cons a)) 0) #:iterations 946815 #:time 879529))
(new-average 2015-06-21T20:00:02 (#:model "stlc-sub-3" #:type ordered #:average 879528.0 #:stderr +nan.0))
(counterexample 2015-06-21T20:14:46 (#:model "stlc-sub-3" #:type ordered #:counterexample ((λ (a int) (cons a)) 0) #:iterations 946815 #:time 883200))
(new-average 2015-06-21T20:14:46 (#:model "stlc-sub-3" #:type ordered #:average 881364.0 #:stderr 1836.0))
(counterexample 2015-06-21T20:30:13 (#:model "stlc-sub-3" #:type ordered #:counterexample ((λ (a int) (cons a)) 0) #:iterations 946815 #:time 927666))
(new-average 2015-06-21T20:30:13 (#:model "stlc-sub-3" #:type ordered #:average 896798.0 #:stderr 15470.35836688989))
(counterexample 2015-06-21T20:42:36 (#:model "stlc-sub-3" #:type ordered #:counterexample ((λ (a int) (cons a)) 0) #:iterations 946815 #:time 743944))
(new-average 2015-06-21T20:42:36 (#:model "stlc-sub-3" #:type ordered #:average 858584.5 #:stderr 39748.42860101516))
(counterexample 2015-06-21T20:55:08 (#:model "stlc-sub-3" #:type ordered #:counterexample ((λ (a int) (cons a)) 0) #:iterations 946815 #:time 752343))
(new-average 2015-06-21T20:55:08 (#:model "stlc-sub-3" #:type ordered #:average 837336.2 #:stderr 37409.2608673307))
(counterexample 2015-06-21T21:09:04 (#:model "stlc-sub-3" #:type ordered #:counterexample ((λ (a int) (cons a)) 0) #:iterations 946815 #:time 836133))
(new-average 2015-06-21T21:09:04 (#:model "stlc-sub-3" #:type ordered #:average 837135.6666666666 #:stderr 30545.19186458721))
(finished 2015-06-21T21:09:04 (#:model "stlc-sub-3" #:type ordered #:time-ms 5022818 #:attempts 5680890 #:num-counterexamples 6 #:rate-terms/s 1131.016493131943 #:attempts/cexp 946815.0))
| false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.