torstenanders

Note that MOZ’Lib seemingly supports arbitrary libraries from the PatchWork / Open Music / PWGL family. Perhaps it is possible to see how they do that to add such functionality to Opusmodus as well? Best, Torsten PS: I was working in a similar direction some time ago, first by porting some library (OM-Tristan) to load directly into a plain Lisp compiler (by replacing all OpusModus dependencies) and that works, but that is a lot of work for each library. I then started to instead port the whole of OpenMusic to ClozureCL, but leaving out all GUI dependencies, but got only half-way with that so far (it is a lot of code ). Of course, if this works already in Julien's library, that would save some work... Unfortunately, I will not be able to take anything like this on in the foreseeable future due to my new job.

Its a great development, but note that it will not work with Opusmodus for multiple reasons, one being that MOZ’Lib depends on SBCL [1], which is called from the shell, and Opusmodus depends on ClozureCL, and I don't think there are plans to make Opusmodus callable from a shell. [1]

> Achim Bornhoeft and I spent some time talking and playing with the Neo-Riemann theory with an outcome of a diagram and a function Thanks for sharing. Do I understand correctly that these transformations always assume triads? Of course, one can always extend the triads afterwards... Best, Torsten

Hi Julio, Could you perhaps share your final setup files for the old VSL instrument library with the community? Thanks! Best, Torsten

> :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