;Scala-Lib, by Thorin Kerr, 17/10/2007. thorin.kerr@gmail.com

;A library for accessing pitch data from scala formatted scale files.

;The scala program and scale archive can be downloaded from the scala download page: http://www.xs4all.nls/~huygensf/scala/downloads.html

;See 'scala:' prefixed procedures and usage examples at the end of this file.

;Internal procedures

;return string representation of character.

(define (tkerr:char->string char)

(if (char? char)

(atom->string char)

#f))

;end of line predicate

(define tkerr:char-eol?

(lambda (char)

(if (char=? char (integer->char 10))

#f)))

;space or tab predicate

(define tkerr:char-space?

(lambda (char)

(if (or (char=? char (integer->char 32)) (char=? char (integer->char 9)))

#f)))

;reads from a file port, returning each line in the file as a string.

;note, this ignores whitespace.

(define tkerr:read-linedata

(lambda (p)

(let loop ((char (read-char p))

(result ""))

(cond ((eof-object? char) char)

((not (char? char)) (loop (read-char p) result))

((tkerr:char-space? char) (loop (read-char p) result))

((tkerr:char-eol? char) result)

(else (loop (read-char p) (string-append result (tkerr:char->string char))))))))

;returns a list of strings for each line of a file. Whitespace removed.

;template borrowed from schematics cookbook http://schemecookbook.org/Cookbook/FileRead

(define (tkerr:read-lines filename)

(call-with-input-file filename

(lambda (p)

(let loop ((line (tkerr:read-linedata p))

(result '()))

(cond ((eof-object? line) (reverse result))

(else (loop (tkerr:read-linedata p) (cons line result))))))))

;from Schematics cookbook http://schemecookbook.org/Cookbook/ListRecipefilterElements

;this procedure removes elements according to a predicate test.

(define (tkerr:filter pred? lst)

(cond

((null? lst) '())

((pred? (car lst)) (cons (car lst) (tkerr:filter pred? (cdr lst))))

(else (tkerr:filter pred? (cdr lst)))))

;---------------------------

;list helpers

;---------------------------

;returns the last value in a list

(define (tkerr:last lst)

(if (null? lst) '()

(list-ref lst (- (length lst) 1))))

;returns head of a list up to ndx. opposite of list-tail.

(define (tkerr:list-head list-of-items ndx)

(cond

((<= (length list-of-items) ndx)'())

(else (cons (car list-of-items) (tkerr:list-head (cdr list-of-items) ndx)))))

;returns a slice of a list between ndx1 and ndx2

(define tkerr:slice

(lambda (list-of-items ndx1 ndx2)

(let ((tail (list-tail list-of-items ndx1)))

(tkerr:list-head tail (- (length tail) (- ndx2 ndx1))))))

;----------------------------

;scala format procedures

;----------------------------

;just beware if the description line is left blank in the scala file. It will confuse the slice.

(define tkerr:remove-scala-comments

(lambda (lines-lst)

(let ((declamation (tkerr:filter (lambda (line) (not (string=? (substring line 0 1) "!"))) lines-lst)))

(tkerr:slice declamation 2 (length declamation)))))

;returns the numerator from a string representation of a ratio

;e.g. "7/9" returns 7. "34/67" returns 34.

(define tkerr:get-numerator

(lambda (str-rat)

(let* ((ndx (cl:position #\/ (string->list str-rat))))

(string->atom (substring str-rat 0 ndx)))))

;returns the denominator from a string representation of a ratio

;e.g. "7/9" returns 9. "34/67" returns 67.

(define tkerr:get-denominator

(lambda (str-rat)

(let* ((ndx (cl:position #\/ (string->list str-rat))))

(string->atom (substring str-rat (+ ndx 1) (string-length str-rat))))))

;converts a numerator and denominator into a cent value.

(define tkerr:ratio->cent

(lambda (numerator denominator)

(* 1200 (/ (log (/ numerator denominator)) (log 2)))))

;convert a string represenation of a ratio into a cent vale

(define (tkerr:str-rat->cent str-rat)

(tkerr:ratio->cent (tkerr:get-numerator str-rat) (tkerr:get-denominator str-rat)))

;predicate, to test if a value is a cent representation.

(define tkerr:str-cent?

(lambda (str)

(let loop ((ndx 0))

(cond

((>= ndx (string-length str)) #f)

((char=? (string-ref str ndx) #\.) #t)

(else (loop (+ ndx 1)))))))

;predicate, to test if a value is a ratio representation.

(define tkerr:str-rat?

(lambda (str)

(let loop ((ndx 0))

(cond

((>= ndx (string-length str)) #f)

((char=? (string-ref str ndx) #\/) #t)

(else (loop (+ ndx 1)))))))

;A procedure to step through a scale-list and convert all to cents

(define tkerr:str-scale->cent-scale

(lambda (str-scale)

(if (null? str-scale)

()

(cons (if (tkerr:str-cent? (car str-scale))

(string->number (car str-scale))

(tkerr:str-rat->cent (car str-scale)))

(tkerr:str-scale->cent-scale (cdr str-scale))))))

;-----------------------------------------------------------------------------------------------------

;USAGE PROCEDURES

;-----------------------------------------------------------------------------------------------------

;read a scala scale file, and return a list of cent equivalent values in a list

(define scala:read-scale

(lambda (path)

(let ((scale (tkerr:remove-scala-comments (tkerr:read-lines path))))

(tkerr:str-scale->cent-scale scale))))

;produces a list of 128 real midi equivalents from a list of cent values

;index number 69 is used as a reference for A4 - 440 hz.

;be aware that some scales may produce negative values

(define (scala:cscale->mscale cscale)

(define cs->ms

(lambda (cs deg oct)

(if (> deg 126) '()

(cons (/ (+ (list-ref cs (fmod deg (length cs))) (* oct (tkerr:last cs))) 100)

(if (< (fmod deg (length cs)) (- (length cs) 1)) (cs->ms cs (+ deg 1) oct)

(cs->ms cs (+ deg 1) (+ oct 1)))))))

(let* ((sc (cons 0 (cs->ms cscale 0 0)))

(a440diff (- 69 (list-ref sc 69))))

(map (lambda (c) (+ c a440diff)) sc)))

;a handy conversion utility

(define scala:midi->hz

(lambda (midi-pitch)

(* 440 (exp (/ (* (log 2.0) (- midi-pitch 69.0)) 12.0)))))

;produces a list of 128 hertz values, with index 69 used as a reference value for A4 - 440 hertz.

(define (scala:cscale->hzscale cscale)

(define cs->ms

(lambda (cs deg oct)

(if (> deg 126) '()

(cons (/ (+ (list-ref cs (fmod deg (length cs))) (* oct (tkerr:last cs))) 100)

(if (< (fmod deg (length cs)) (- (length cs) 1)) (cs->ms cs (+ deg 1) oct)

(cs->ms cs (+ deg 1) (+ oct 1)))))))

(let* ((sc (cons 0 (cs->ms cscale 0 0)))

(a440diff (- 69 (list-ref sc 69))))

(map scala:midi->hz (map (lambda (c) (+ c a440diff)) sc))))

;a handy utility to obtain the index in the scale closest to the value.

(define (scala:get-index lst value)

(define interval-distances

(lambda (lst ref-val)

(if (null? lst) '()

(cons (abs (- ref-val (car lst))) (interval-distances (cdr lst) ref-val)))))

(let ((ilst (interval-distances lst value)))

(cl:position (apply min ilst) ilst)))

;-------------------------------------------------------------------------------------------------------------

;Examples

;-------------------------------------------------------------------------------------------------------------

;return a list of 'real' midi values

;(define myscale (scala:cscale->mscale (scala:read-scale "/Users/... wherever .../meanhalf.scl")))

;return a list of hertz values

;(define hertzscale (scala:cscale->hzscale (scala:read-scale "/Users/... wherever .../meanhalf.scl")))

;check index 69 returns value 69 (A4 - 440hz)

;(list-ref myscale 69)

;check index position of A4 440 hz

;(scala:get-index hertzscale 440)