;;;; This file is part of LilyPond, the GNU music typesetter.
;;;;
-;;;; Copyright (C) 1998--2010 Jan Nieuwenhuizen <janneke@gnu.org>
+;;;; Copyright (C) 1998--2011 Jan Nieuwenhuizen <janneke@gnu.org>
;;;; Han-Wen Nienhuys <hanwen@xs4all.nl>
;;;;
;;;; LilyPond is free software: you can redistribute it and/or modify
(or (equal? a b)
(ly:moment<? a b)))
+(define-public (fraction->moment fraction)
+ (if (null? fraction)
+ ZERO-MOMENT
+ (ly:make-moment (car fraction) (cdr fraction))))
+
+(define-public (moment->fraction moment)
+ (cons (ly:moment-main-numerator moment)
+ (ly:moment-main-denominator moment)))
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; arithmetic
(define-public (average x . lst)
(map-alist-vals func (cdr list)))))
(define (map-alist-keys func list)
- "map FUNC over the keys of an alist LIST, leaving the vals. "
+ "map FUNC over the keys of an alist LIST, leaving the vals."
(if (null? list)
'()
(cons (cons (func (caar list)) (cdar list))
(cons (cdar alist)
(flatten-alist (cdr alist))))))
+(define (assoc-remove key alist)
+ "Remove key (and its corresponding value) from an alist.
+ Different than assoc-remove! because it is non-destructive."
+ (define (assoc-crawler key l r)
+ (if (null? r)
+ l
+ (if (equal? (caar r) key)
+ (append l (cdr r))
+ (assoc-crawler key (append l `(,(car r))) (cdr r)))))
+ (assoc-crawler key '() alist))
+
+(define-public (map-selected-alist-keys function keys alist)
+ "Returns alist with function applied to all of the values in list keys.
+ For example:
+ @code{guile> (map-selected-alist-keys - '(a b) '((a . 1) (b . -2) (c . 3) (d . 4)))}
+ @code{((a . -1) (b . 2) (c . 3) (d . 4))}"
+ (define (map-selected-alist-keys-helper function key alist)
+ (map
+ (lambda (pair)
+ (if (equal? key (car pair))
+ (cons key (function (cdr pair)))
+ pair))
+ alist))
+ (if (null? keys)
+ alist
+ (map-selected-alist-keys
+ function
+ (cdr keys)
+ (map-selected-alist-keys-helper function (car keys) alist))))
+
;;;;;;;;;;;;;;;;
;; vector
(helper lst 0))
(define-public (count-list lst)
- "Given lst (E1 E2 .. ) return ((E1 . 1) (E2 . 2) ... ) "
+ "Given lst (E1 E2 .. ), return ((E1 . 1) (E2 . 2) ... )."
(define (helper l acc count)
(if (pair? l)
(lambda (x) x)
(map proc lst)))
-(define (flatten-list x)
+(define-public (flatten-list x)
"Unnest list."
(cond ((null? x) '())
((not (pair? x)) (list x))
(lset-difference eq? a b))
(define-public (uniq-list lst)
- "Uniq LST, assuming that it is sorted. Uses equal? for comparisons."
+ "Uniq LST, assuming that it is sorted. Uses equal? for comparisons."
(reverse!
(fold (lambda (x acc)
(define (split-at-predicate pred lst)
"Split LST into two lists at the first element that returns #f for
- (PRED previous_element element). Return the two parts as a pair.
+ (PRED previous_element element). Return the two parts as a pair.
Example: (split-at-predicate < '(1 2 3 2 1)) ==> ((1 2 3) . (2 1))"
(if (null? lst)
(list lst)
(define-public (split-list-by-separator lst pred)
"Split LST at each element that satisfies PRED, and return the parts
- (with the separators removed) as a list of lists. Example:
+ (with the separators removed) as a list of lists. Example:
(split-list-by-separator '(a 0 b c 1 d) number?) ==> ((a) (b c) (d))"
(let loop ((result '()) (lst lst))
(if (and lst (not (null? lst)))
(cons (cons (car coords) (cadr coords))
(ly:list->offsets accum (cddr coords)))))
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; numbers
-
-(if (not (defined? 'nan?)) ;; guile 1.6 compat
- (define-public (nan? x) (not (or (< 0.0 x)
- (> 0.0 x)
- (= 0.0 x)))))
-
-(if (not (defined? 'inf?))
- (define-public (inf? x) (= (/ 1.0 x) 0.0)))
-
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; intervals
(define-public interval-end cdr)
-(define-public (interval-translate iv amount)
- (cons (+ amount (car iv))
- (+ amount (cdr iv))))
-
(define (other-axis a)
(remainder (+ a 1) 2))
(define-public (interval-widen iv amount)
- (cons (- (car iv) amount)
- (+ (cdr iv) amount)))
+ (cons (- (car iv) amount)
+ (+ (cdr iv) amount)))
(define-public (interval-empty? iv)
(> (car iv) (cdr iv)))
(define-public (interval-union i1 i2)
- (cons (min (car i1) (car i2))
- (max (cdr i1) (cdr i2))))
+ (cons
+ (min (car i1) (car i2))
+ (max (cdr i1) (cdr i2))))
(define-public (interval-intersection i1 i2)
- (cons (max (car i1) (car i2))
- (min (cdr i1) (cdr i2))))
+ (cons
+ (max (car i1) (car i2))
+ (min (cdr i1) (cdr i2))))
(define-public (interval-sane? i)
(not (or (nan? (car i))
(cons (min (interval-start interval) p)
(max (interval-end interval) p)))
+(define-public (reverse-interval iv)
+ (cons (cdr iv) (car iv)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; coordinates
+
+(define coord-x car)
+(define coord-y cdr)
+
+(define (coord-operation operator operand coordinate)
+ (if (pair? operand)
+ (cons (operator (coord-x operand) (coord-x coordinate))
+ (operator (coord-y operand) (coord-y coordinate)))
+ (cons (operator operand (coord-x coordinate))
+ (operator operand (coord-y coordinate)))))
+
+(define (coord-apply function coordinate)
+ (if (pair? function)
+ (cons
+ ((coord-x function) (coord-x coordinate))
+ ((coord-y function) (coord-y coordinate)))
+ (cons
+ (function (coord-x coordinate))
+ (function (coord-y coordinate)))))
+
+(define-public (coord-translate coordinate amount)
+ (coord-operation + amount coordinate))
+
+(define-public (coord-scale coordinate amount)
+ (coord-operation * amount coordinate))
+
+(define-public (coord-rotate coordinate degrees-in-radians)
+ (let*
+ ((coordinate
+ (cons
+ (exact->inexact (coord-x coordinate))
+ (exact->inexact (coord-y coordinate))))
+ (radius
+ (sqrt
+ (+ (* (coord-x coordinate) (coord-x coordinate))
+ (* (coord-y coordinate) (coord-y coordinate)))))
+ (angle (angle-0-2pi (atan (coord-y coordinate) (coord-x coordinate)))))
+ (cons
+ (* radius (cos (+ angle degrees-in-radians)))
+ (* radius (sin (+ angle degrees-in-radians))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; trig
+
+(define-public PI (* 4 (atan 1)))
+
+(define-public TWO-PI (* 2 PI))
+
+(define-public PI-OVER-TWO (/ PI 2))
+
+(define-public THREE-PI-OVER-TWO (* 3 PI-OVER-TWO))
+
+(define-public (cyclic-base-value value cycle)
+ "Takes a value and modulo-maps it between 0 and base."
+ (if (< value 0)
+ (cyclic-base-value (+ value cycle) cycle)
+ (if (>= value cycle)
+ (cyclic-base-value (- value cycle) cycle)
+ value)))
+
+(define-public (angle-0-2pi angle)
+ "Takes an angle in radians and maps it between 0 and 2pi."
+ (cyclic-base-value angle TWO-PI))
+
+(define-public (angle-0-360 angle)
+ "Takes an angle in radians and maps it between 0 and 2pi."
+ (cyclic-base-value angle 360.0))
+
+(define-public PI-OVER-180 (/ PI 180))
+
+(define-public (degrees->radians angle-degrees)
+ "Convert the given angle from degrees to radians"
+ (* angle-degrees PI-OVER-180))
+
+(define-public (ellipse-radius x-radius y-radius angle)
+ (/
+ (* x-radius y-radius)
+ (sqrt
+ (+ (* (expt y-radius 2)
+ (* (cos angle) (cos angle)))
+ (* (expt x-radius 2)
+ (* (sin angle) (sin angle)))))))
+
+(define-public (polar->rectangular radius angle-in-degrees)
+ "Convert polar coordinate @code{radius} and @code{angle-in-degrees}
+ to (x-length . y-length)"
+ (let ((complex (make-polar
+ radius
+ (degrees->radians angle-in-degrees))))
+ (cons
+ (real-part complex)
+ (imag-part complex))))
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; string
(define-public (car< a b)
(< (car a) (car b)))
+(define-public (car<= a b)
+ (<= (car a) (car b)))
+
(define-public (symbol<? lst r)
(string<? (symbol->string lst) (symbol->string r)))
(define-public (eval-carefully symbol module . default)
"Check if all symbols in expr SYMBOL are reachable
- in module MODULE. In that case evaluate, otherwise
- print a warning and set an optional DEFAULT."
+in module MODULE. In that case evaluate, otherwise
+print a warning and set an optional DEFAULT."
(let* ((unavailable? (lambda (sym)
(not (module-defined? module sym))))
(sym-unavailable (if (pair? symbol)
;;; FONT may be font smob, or pango font string...
(define-public (font-name-style font)
- ;; FIXME: ughr, barf: feta-alphabet is actually emmentaler
- (if (and (string? font)
- (string-prefix? "feta-alphabet" font))
- (string-append "emmentaler"
- "-"
- (substring font
- (string-length "feta-alphabet")
- (string-length font)))
+ (if (string? font)
+ (string-downcase font)
(let* ((font-name (ly:font-name font))
(full-name (if font-name font-name (ly:font-file-name font))))
- (if (string-prefix? "Aybabtu" full-name)
- "aybabtu"
- (string-downcase full-name)))))
+ (string-downcase full-name))))
(define-public (modified-font-metric-font-scaling font)
(let* ((designsize (ly:font-design-size font))
projects / lilypond.git / blobdiff