torstenanders

> :path nil will give you the shortest path Nice.

Nice! However, what happened to what Bruckner (according to Schönberg) called the "law of the shortest path" (Gesetz des nächsten Weges)? Of course, for expressiveness one should not always choose a "shortest path" voice leading, that tends to become boring. But here, there are predominantly skips. Steps should be more likely, at least that would be more common (e.g., more easy to perform and also to follow by the audience). Is there perhaps a way to control the likelihood of steps vs. skips? Thanks! Best, Torsten

The code is impressively concise for this dense network of relationships

Thanks a lot for working on this. Just to confirm: is the pitch resolution of the actual pitch parameter limited to expressing quarter and eighth tones and for other subdivisions articulations are used? The main/only advantage of 24-ET (equal temperament) and 48-ET is that they contain all 12 tones from 12-ET in the same "grey" approximation of just intervals (i.e. intervals that can relatively easily tuned by ear -- much more easily than anyhow tempered intervals) than 12-ET. They only add 11-limit intervals like 11/8 rather well (nicely used for that, e.g., by Wyschnegradsky). From a harmonic point of view, various other equal subdivisions of the octave are much more interesting, because they either approximate more novel just intervals or/and approximate standard intervals better (e.g., more just thirds). For example, 19-ET and 22-ET have less tones than 24-ET, but are harmonically more interesting in this regard (e.g., https://en.wikipedia.org/wiki/22_equal_temperament) and so is 31-ET (extended meantone with septimal intervals, https://en.wikipedia.org/wiki/31_equal_temperament) or 41-ET. For a good compromise between a tuning that would include 12-ET and additionally is harmonically interesting I would instead propose 72-ET (https://en.wikipedia.org/wiki/72_equal_temperament). This temperament is already relatively widely used by multiple independent communities because of that, and there already exist ASCII notations for this temperament (besides various other notations – their number is just a testament to how useful this temperament has been for many), examples copied below (e.g., see http://tonalsoft.com/enc/number/72edo.aspx). Tuning list standard, based on Sims/Maneri 72edo notation lower raise inflection cents b # semitone 100 ] [ 1/4-tone 50 < > 1/6-tone 331/3 v ^ 1/12-tone 162/3 Monzo 72-edo HEWM notation lower raise inflection cents b # semitone 100 v ^ 1/4-tone 50 < > 1/6-tone 331/3 - + 1/12-tone 162/3 Just my 2 Euro cent... Best, Torsten

Just for the record, when I start Opusmodus without any of my extensions, I run into the same problem. ? (length-divide '(1000 2) '(q ab3 num1+leg c4 leg e ab3 leg g3 leg ab3 num1+leg c4 leg)) length-divide, set: nil ignore: nil section: nil exclude: nil seed: 35424 > Error: The value ab3 is not of the expected type sequence. > While executing: ccl::sequence-type, in process Listener-1(7). > Type cmd-. to abort, cmd-\ for a list of available restarts. > Type :? for other options. 1 >

> You will need to wait for the upgrade. No worries, I already applied a workaround (disabling certain code...). Here is another issue I ran into with length-divide: if the argument ignore is set to either min or max, and all note values are of the same length, then that also causes an error. Now, perhaps that should be expected, but then at least the error message could be more helpful. On the other hand, perhaps it would be preferable in this situation if a warning was printed and the effect of the argument ignore was, well, ignored? (length-divide '(1 4) '(1/8 c4 mf num1+leg 1/8 d4 mf num1+leg 1/8 fs3 mf leg 1/8 gs3 mf) :ignore 'min) Error: The value nil is not of the expected type number. > We have started work on microtonality

Revising some older code of my I noticed that the function length-divide changed its behaviour somewhat and became more likely to cause an error. In a previous version, where the arguments count and divide where given separately, it was possible to set the count to some very high number, say, 1000, simply to mean that all notes the function can split (depending on its other arguments) will be split. Meanwhile, the function have been revised to introduce control over intervals (thank you ), but since then it seems it is not possible anymore to set an arbitrarily high count value anymore. For example, the following code now results in an error. I would prefer the previous behaviour, if only because it is more forgiving and stable. (length-divide '(1000 2) '(q ab3 num1+leg c4 leg e ab3 leg g3 leg ab3 num1+leg c4 leg)) Error: The value ab3 is not of the expected type sequence. In case it helps: my debugger tells me the functions gen-repeat and then maybe-section are called (perhaps within a nested function of length-divide* ?) with an argument sequence bound to ab3 (i.e. a plain pitch), and a call (length ab3) then causes this error. Thank you! Best, Torsten

For a generic solution, you could use some function split-if that expects a Boolean function as argument comparing two consecutive pairs, and always splits a sublist if the Boolean function returns True. I don't have such a Lisp function at hand right now, but of an algorithm idea here is a similar Python function, only that this expects a Boolean function of a single argument only. If you port this function to Lisp, you could then generalise it by checking the number of arguments the given Boolean function expects, and it apply it always to the corresponding consecutive number of elements of xs. def split_if(fun, xs): """ Splits `xs` (list) into sublists based on a test. Starts a new sublist at every element for which Boolean function `fun` returns true. Examples -------- >>> split_if(lambda x: x % 3 == 0, [0, 1, 2, 3, 4, 5]) [[0, 1, 2], [3, 4, 5]] >>> split_if(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7]) [[1, 2], [3, 4, 5], [6, 7]] NOTE: Internally, `split_if` skips the first element of `xs`. So, if `fun` is stateful, it should initialise its state using that first element. For an example, see implementation of `format_api.split_into_sections`. """ result_list = [] start = 0 # Collect new list up to x whenever fun(x) == true, but not before first element for index, x in enumerate(xs[1:]): if fun(x): result_list.append(xs[start:index+1]) start = index+1 if start == 0: return [xs] result_list.append(xs[start:]) return result_list Here is another approach as well with a Lisp function from my toolbox expecting a list of positions where to split the list. You could find those positions by iterating over conservative pairs of your list elements with the function positions-if listed below. OK, none of this is a ready made solution, but all the necessary pieces are there I need to head back to work now .... Torsten (defun subseqs (sequence positions &optional end) "Splits `sequence' into a list of subsequences split at `positions'. Each element in `positions' specifies a position at which a new sublist starts. ; (subseqs '(0 1 2 3 4 5 6) '(0 2 4)) => ((0 1) (2 3) (4 5 6)) ; (subseqs '(0 1 2 3 4 5 6) '(2 4 6) 5) => ((2 3) (4)) `positions' are implicitly sorted and positions beyond end are excluded. " (let* ((updated-pos (sort (if end (remove-if #'(lambda (x) (>= x end)) positions) positions) #'<)) (full-pos (append updated-pos (list (if end end (length sequence)))))) (mapcar #'(lambda (start end) (subseq sequence start end)) (butlast full-pos) (rest full-pos)) )) (defun positions-if (predicate sequence &key key (start 0)) "Like the Common Lisp function `position-if', but returns all positions in `sequence' that match `predicate'. ; (positions-if #'oddp '((1) (2) (3) (4)) :key #'car) ; => (0 2)" (labels ((aux (predicate sequence &key key (start 0) accum) (let ((pos (position-if predicate sequence :start start :key key))) (if pos (aux predicate sequence :start (1+ pos) :key key :accum (cons pos accum)) (reverse accum))))) (aux predicate sequence :start start :key key))) #| ;; comparison (position-if #'oddp '((1) (2) (3) (4)) :key #'car) |#

> if you have the article of ERES HOLZ as pdf, would be nice (the link seems to be dead)... See attached. > isn't it - in general - a question about complexity and information? I think it is also a question of memory -- we can only perceive a form if we can remember the form parts (Schönberg talks about comprehensibility/Fasslichkeit) which then allows us to compare etc. Obviously, that is more easy in a visual form, where you can see the whole picture together and move between parts at your own pace. Best, Torsten Holz_2012_Das Wachstumprinzip von L-Systemen in der Musik von Hanspeter Kyburz.pdf

> the GAP is between visual L-systems and acoustic ones Yes, of course, there is a completely different way of perception at play. If you come up with a good answer to that, I would be interested. BTW, if you want some other examples of compositional applications, you might want to have a look at ”Cells” (1993/94) by Hanspeter Kyburz, discussed in the following two publications. Supper, M. (2001) A Few Remarks on Algorithmic Composition. Computer Music Journal. 25 (1), 48–53. Holz, E. (2012) Das Wachstumprinzip von L-Systemen in der Musik von Hanspeter Kyburz. Master’s thesis. Hochschule für Musik Hanns Eisler. Available from: http://www.eresholz.de/de/text/Eres Holz_Ausschnitt aus der Masterarbeit.pdf(Accessed 20 September 2016).

Just a brief follow-up. While Partch's book is obviously available in English, the other authors all wrote in German. More recent Neo-Riemannian theory is often pretty math-heavy, so also somewhat hard to digest for us composers. To get a taste of these harmonic theories in a highly developed form (with dualism throughout, but that is only one facet) delivered by a practicing composers, you might want to have a look at the recent English translation and discussion of Sigfrid Karg-Elert's book Acoustic Determination of Pitch, Chord and Function from 1930. Byrne, D. A. (2018) The Harmonic Theories of Sigfrid Karg-Elert: Acoustics, Function, Transformation, Perception. PhD Thesis thesis. University of Cincinnati. Online available (with a somewhat slow download speed) at https://etd.ohiolink.edu/!etd.send_file?accession=ucin1522417315389199&disposition=attachment Warning: this is not for the faint of heart Best, Torsten

If you want more control over the L-system generation, have a look at the original documentation of the system L-Lisp, from which Janusz derived the Opusmodus functionality: Erstad, K. A. (2002) L-systems, twining plants, Lisp. Master’s thesis thesis. University of Bergen. [online]. Available from: http://www.vcn.bc.ca/~griffink/lisp_lsystems.pdf Also, the original website: http://www.ii.uib.no/~knute/lsystems/llisp.html Best, Torsten

Are you simply looking for an invert function, e.g., pitch-invert? (pitch-invert '(c4 d4 e4)) => (c4 bb3 gs3) This function inverts (mirrors) around the first pitch by default. If you are looking for retaining the original ambitus, you might want to instead you my function invert-in-ambitus (https://tanders.github.io/tot/sources/pitch.html#_g251910). (invert-in-ambitus '(c4 e4 g4)) => (g4 eb4 c4) BTW, when you are specifically talking about a harmonic context in which you are "mirroring" chords, there exist extensive music theories based on this idea already. The notion of minor chords as the mirror image of major chords, and its implications on harmonic functions (tonic, dominant, subdominant etc.) was in detail explored under the label of dualism by theorists like Hugo Riemann, Arthur von Öttingen and Sigfrid Karg-Elert. They also already generalised this notion for microtonal music. Likely independently of these theorists exploring the notion of dualism, Harry Partch's concept of otonality and utonality is also based on this idea, now firmly in the field of microtonal music. In microtonal harmonic theory I came across this notion also elsewhere (e.g., discussed by the composers and theorists of ekmelic music like Franz Richter Herf, which may have arrived there independently as well. Anyway, this harmonic concept in general is so basic and fundamental that I would not be surprised it would have been studied by the likes of Pythagoras already... Best, Torsten

> but SLEEP is not very precise The Common Lisp standard actually says that the number of seconds specified as arguments for sleep is approximate: > Causes execution to cease and become dormant for approximately the seconds of real time indicated by seconds, whereupon execution is resumed. CLHS: Function SLEEP WWW.LISPWORKS.COM Anyway, it seems that at least on a Mac the imprecision is rather regular, see the following discussion with empirical tests. Time to sleep under different platforms LISP-HUG.LISPWORKS.NARKIVE.COM Anyway, for realtime scheduling in a musical context one needs likely a proper scheduler for that. Best, Torsten

> Do you consider the inconsistency of the integer-to-pitch results a bug? I cannot speak for Janusz, but for me the format of the result makes sense. If there are individual values in the integer pitch list it is assume that the overall result is considered flat and hence sublists are chords. If everything is nested, then sublists are considered bars and the nesting is preserved. Best, Torsten