Jump to content

torstenanders

Members
  • Posts

    465
  • Joined

  • Last visited

Everything posted by torstenanders

  1. If you are looking for something fun to read that still covers the big ideas, there is also The Little Schemer (and a number of related books). Note that this book again uses Scheme for clarity, but the fundamental ideas are the same in Common Lisp. Some incomplete preview: https://books.google.com/books?id=xyO-KLexVnMC&printsec=frontcover&dq=the+little+schemer&hl=en&sa=X&ved=2ahUKEwi8ysjBndrvAhXU_7sIHXmKBmkQ6AEwA3oECAIQAg#v=onepage&q=the little schemer&f=false Quote: What you need to know to read this book.The reader must be comfortable reading English, recognizing numbers, and counting.
  2. SICP is a really excellent book! (Even though meanwhile it is not used for teaching at MIT anymore.) What I alluded to above (higher-order functions) is already covered relatively early in the book in section 1.3 (link). This book provides a really solid foundation for programming. If you just study the first two chapters that might already be enough for your purposes (well organising code for algorithmic composition). (Fun fact: I read this book during our honey moon ~20 years ago.) Note that the book uses the (smaller & more clean) Lisp dialect Scheme, instead of Common Lisp (which is a huge language, a unification effort of multiple Lisp dialects that includes features of multiple older Lisp dialects). Opusmodus is based on Common Lisp. If you want to study higher-order functions and other matters directly for Common Lisp, there are of course also suitable books, e.g., Practical Common Lisp. Functions incl. higher-order functions are discussed in chapter 5 (link).
  3. I understand that builtin functions of Opusmodus are not working on this level of abstraction / expressive power, as it would be a rather steep learning curve for users, but using and defining functions at this flexibility level reduces the length of your code substantially, which then helps to solve bigger problems by very small teams or individuals. I try to have my own libraries work at this kind of level.
  4. > I would like to SORT an (single-event)-list by pitch... Apologies for a late response. Anyway, such functionality is actually built into Common Lisp. Hardly any coding required. Just specify a key attribute to the builtin sort function to tell it what data to look at for the sorting -- and specify a sort function. (setf events '((e e4 mf) (e a4 mf) (e d5 mf) (e g5 mf) (e b5 mf) (e d6 mf) (e b4 mf 2c) (e e5 mf 2c) (e a5 mf 2c) (e d6 mf 2c) (e fs6 mf 2c) (e a6 mf 2c) (e e5 mf) (e a5 mf) (e d6 mf) (e g6 mf) (e b6 mf) (e d7 mf) (e gs5 mf -14c) (e cs6 mf -14c) (e fs6 mf -14c) (e b6 mf -14c) (e eb7 mf -14c) (e fs7 mf -14c) (e b5 mf 2c) (e e6 mf 2c) (e a6 mf 2c) (e d7 mf 2c) (e fs7 mf 2c) (e a7 mf 2c) (e d6 mf -31c) (e g6 mf -31c) (e c7 mf -31c) (e f7 mf -31c) (e a7 mf -31c) (e c8 mf -31c) (e e6 mf) (e a6 mf) (e d7 mf) (e g7 mf) (e b7 mf) (e d8 mf))) (sort events #'< :key #'(lambda (event) (pitch-to-integer (second event)))) See also CLHS: Function SORT, STABLE-SORT CLHS.LISP.SE Note that this high level of programming and flexibility is what makes programming with Lisp so fun and productive. There are a bunch of other functions builtin doing other sequence operations on the same high level, like count (http://clhs.lisp.se/Body/f_countc.htm ), find (http://clhs.lisp.se/Body/f_find_.htm ) etc.
  5. I am aiming for some state-of-the-art microtonal/xenharmonic support for Opusmodus. Here is a first preview. It has been easier than expected to do what I planned when using some unifying ideas proposed by tuning math guys around 20 years ago. The core idea is that just intonation (JI), arbitrary equal temperaments (subdividing the octave or other intervals) and very many other tunings (https://en.xen.wiki/w/Tour_of_Regular_Temperaments ) can all be expressed as regular temperaments. You can find an informal discussion of regular temperaments, its context and motivation -- how it extends/generalises many other tone systems -- at this link: http://x31eq.com/paradigm.html Importantly, regular temperaments can all be mapped to JI. Therefore, they can also all by notated by pitch notation capable of notating JI for arbitrary prime limits. So, as a unifying pitch notation for all these temperaments I am using such a JI notation. Many recent JI staff notations (I found so far 5 of them, one highly developed one is http://sagittal.org ) are all based on the same fundamental idea, which I am also using: the traditional pitch nominals (A, B, C...) and the traditional accidentals (sharp, double-sharp, flat...) are denoting Pythagorean tuning (when the notation is read as a JI notation), i.e. they notate all the pitches we can reach when stacking just fifths (plus their octaves). We can express this in OMN with our standard pitch notation. Here is a dominant seventh chord, which in a JI interpretation would be tuned in Pythagorean tuning. (setf pythagorean-seventh '(h c4e4g4bb4)) We can play this chord in JI with the new macro def-tempered-score, which does pretty much what the Opusmodus builtin def-score does, but it receives a temperament as one of its arguments. Also, there are multiple MIDI channels specified here, as simultaneous tones are played on different MIDI channels, so they can be tuned individually by pitch bend (I am simply using the def-score tuning argument in the background). Using multiple channels instead of multiple ports is more widely supported by existing MIDI MPE-supporting plugins. (def-tempered-score score-name (:temperament '11-limit-JI :time-signature '(4 4)) (instr1 :omn pythagorean-seventh :channel '(1 2 3 4) :sound 'gm)) OK, how about instead of the Pythagorean third we want to use a just major third -- and also a harmonic seventh. All pitches that go beyond Pythagorean tuning are expressed using new JI accidentals that express some microtonal inflection. The core idea of all the above-mentioned JI pitch notations is to introduce a new accidental for every prime limit (https://en.wikipedia.org/wiki/Limit_(music) ) comma (https://en.wikipedia.org/wiki/Comma_(music) ). These different notations mainly differ in what kind of symbols they propose for these commas. When extending OMN by microtonal accidentals, I am restricted to plain ASCII letters and numbers (most of the ASCII special characters are already used for something else, and OMN does also not really support unicode). So, I suggest to use the letter K for denoting that something is a Komma (similar to the Greek kappa, from where the word comma comes -- the letter C is already used for cent values) and then simply complement that letter with the prime of the comma in question. So, the 5-limit comma (syntonic comma, https://en.wikipedia.org/wiki/Syntonic_comma) is notated 5K and the 7-limit comma is 7K. These accidentals raise the pitch by that comma, for a comma flat, put a minus in front of the accidental. So, here is how we can notate and play the just harmonic seventh chord (1K is the natural sign and multiple accidental attributes for a chord are assigned in ascending order of chord tones). (setf 7-limit-seventh '(h c4e4g4bb4 1K+-5K+1K+-7K)) (def-tempered-score score-name (:temperament '11-limit-JI :time-signature '(4 4)) (instr1 :omn 7-limit-seventh :channel '(1 2 3 4) :sound 'gm)) JI leads to an infinite number of different pitches. Temperaments reduce that number. So, how about we want to play the above chord in, say, 22-tone equal temperament (https://en.xen.wiki/w/22edo ). For that, we only need to define that temperament. Each regular temperament (including equal temperaments and also JI) is specified by only two settings: a small number of generator intervals, and a val for each generator. The vals together specify how each prime (up to the prime limit of the temperament) it is mapped to JI. I will explain these details in a later message and for now simply show the definition of 22-EDO, which is pretty brief. (deftemperament 7-limit-22-EDO ;; List of vals (list (list 22 (+ 13 22) (+ 7 (* 2 22)) (+ 18 (* 2 22)))) ;; List of generators (list (/ 1200.0 22))) Now, we can play the above chord (and any other 7-limit OMN intervals) in 22-EDO. (def-tempered-score score-name (:temperament '7-limit-22-EDO :time-signature '(4 4)) (instr1 :omn 7-limit-seventh :channel '(1 2 3 4) :sound 'gm)) Similarily, we can define arbitrary other regular temperaments by simply specifying their vals and generators.
  6. > The best way to work with microtonality is to get a MTS compatible instrument Yes, I understand. I already have Pianoteq, and might get Vienna Instruments just for this, but still the options (i.e. available instruments) would be limited. (By contrast, the microtonal support for Dorico currently only works for VST3 instruments supporting the VST tuning of note expressions. Also very restricted.) Anyway, I would like to use microtonal tuning for electronic music at some stage, not just some mockups for acoustic compositions. In that area, there are simply very many more plugins etc. available where I can tune with pitchbend messages... I very much hope that in the medium term MIDI 2 will solve such problems.
  7. Here is a link to a related discussion. For supporting chords I would need something similar to what André suggests here, by automatically splitting polyphonic parts into multiple monophonic parts, with some custom tuning for each.
  8. Of course, it would be good to have also playback for microtonal pitches with high precision. > In other systems this will end up in a mess: 100 cents equal 100 channels No, you need only as many channels per instrument as there are tones sounding simultaneously. With the MIDI MPE standard the tuning of tones is simply changed on the fly with pitchbend messages. For example, my Tonal Plexus has 205 pitches/keys per octave in its default tuning and each of these pitches requires a custom tuning, but I can play it with just 3 MIDI channels if I play only 3 notes at a time. For higher polyphony more MIDI channels are needed. (Of course, MIDI MPE is only a fancy name for something that was always possible with MIDI, but now that many instruments exist that have built-in support setting this up is considerably simplified.) Anyway, the following specifies some tuning parameter per note, which does work. So, I guess I have to perhaps implement my own version of MPE support in Opusmodus by transforming my scores automatically into this representation with the tuning added. Thanks again! Best, Torsten (def-score test-playback (:key-signature 'chromatic :tempo '(q 60) :time-signature '(4 4)) (inst1 :omn '((h c4) (h c4) (h c4) (h c4)) :channel 1 :sound 'gm :program 0 :port 0 ) (inst2 :omn '((h eb4) (h eb4 -33c) (h eb4-) (h eb4 -33c)) :channel 2 :sound 'gm :program 0 :port 0 :tuning '(0 -0.33 0 -0.33) ) (inst3 :omn '((h bb4) (h bb4 -33c) (h bb4-) (h bb4 -33c)) :channel 3 :sound 'gm :program 0 :port 0 :tuning '(0 -0.33 0 -0.33) ))
  9. Thanks for the quick response. > Cent annotations display only. I thought when we discussed microtonality at the Opusmodus Convention, and Achim Bornhoeft was talking about the importance of having the flexibility of the cent annotations, you mentioned that this is already implemented (again), and just lacked documentation. Did I perhaps misunderstand, and microtonal playback with cent resolution was never implemented so far? Thanks!
  10. > The cents attribute is an additional display of the remain cents values and is not a part of the audition. Could proper audition for cent values be implemented? Pretty please? If polyphonic microtonal playback with 1/8 note resolution is already implemented, what would be missing to get the same support for arbitrary cent values? For me, flexible tuning support is the one missing Opusmodus feature I would be willing to pay extra for, seriously. > To make cents audition we would end up with 100 possible ports - if MTS is not supported - for a one instrument. This problem is solved in MIDI MPE (https://www.midi.org/midi-articles/midi-polyphonic-expression-mpe ), which splits polyphonic chords or multiple voices for a single instrument into multiple MIDI channels (not ports!!) and then then can tune each note of a chord independently via pitch bend (plus independent timbre changes etc.). So, the tuning can change on the fly from note to note. There are already quite a number of synthesisers and samplers supporting MPE, including some of the big players such as EastWest Play (competitor in the league of Vienna Instruments), with which I already used orchestral instruments for microtonal music this way (e.g., played with a Tonal Plexus, https://hpi.zentral.zone/tonalplexus). Below are links with several lists for sampler and synthesiser plugins supporting MPE. Besides, every synth/sampler plugin can be turned into an MPE-supporting plugin when running multiple instances in parallel (e.g., with the help of something like bidule). https://www.kvraudio.com/plugins/mpe https://roli.com/mpe (scroll down to list of DAWs, plugins etc) https://support.roli.com/support/solutions/articles/36000037202-compatible-synths-daws-and-instruments Also, please note that the score example above is only monophonic within each channel, and even for GM with MTS support the cent annotations are not working for me there. Thanks!
  11. Briefly sharing some news: I started to work on greatly improving Opusmodus' support for microtonal/xenharmonic music. I am aiming for supporting arbitrary equal temperaments (both equal divisions of the octave and other intervals), just intonation (JI) for arbitrary prime limits, and arbitrary regular temperaments (https://en.xen.wiki/w/Tour_of_Regular_Temperaments ). I aim to have this whole tuning universe controlled by a single uniform notation embedded in OMN. Still, I try to keep things relatively clear and simple by introducing only a single actual new accidental symbol, and that symbol will then be combined with numbers (for prime limits) to express arbitrary JI pitches, which are then mapped to all the possible tunings. I also aim for some support for dynamic temperaments, so that the tuning can change during the course of a piece. Now, this is all claiming rather a lot, and the result may not necessarily be perfect (e.g., controlling a non-octave-repeating equal temperament with a notation suitable for JI is possible and may actually work well for some situations, but is perhaps not to everyones liking). Anyway, I already have some rather solid foundation for all this. Will update you on more details at a later time. (Technically, pitch deflections will be expressed by articulations, as I cannot change the underlying OMN pitch format. All this depends of course on getting the cent articulations working properly, but I trust that will be sorted at some stage. ) Best, Torsten
  12. I have no luck with the cent annotations in the score (see example below, the cent annotations are seemingly ignored in the playback, but the other microtonal accidentals are not). Am I perhaps missing something? Also, what would be truly great would be some way to have cent annotations for individual pitches of chords. For example, the following does work already. '(c4e4-g4) Would be great if we could also use something like the following. '(h c4e4g4bb4 0c+-14c+-0c+-31c) Thanks! Torsten (def-score test-playback (:key-signature 'chromatic :tempo '(q 60) :time-signature '(4 4)) (inst1 :omn '((h c4) (h c4) (h c4) (h c4)) :channel 1 :sound 'gm :program 0 :port 0 ) (inst2 :omn '((h eb4) (h eb4 -33c) (h eb4-) (h eb4 -33c)) :channel 2 :sound 'gm :program 0 :port 0 ) (inst3 :omn '((h bb4) (h bb4 -33c) (h bb4-) (h bb4 -33c)) :channel 3 :sound 'gm :program 0 :port 0 ))
  13. Ah, great. I just noted that this was already documented and I simply missed it. So, thanks for sharing -- very much appreciated! I hope I soon find some time to play with this! Best, Torsten
  14. > artistic-research with a focus on non-octave scales Could you share some more information on what kind of notation schemes exist for these kind of tunings, and what you would like to do in principle -- independent of Opusmodus, e.g., what you are doing with MaxScore so far? Does there perhaps exist any notation scheme that provides principles suitable for a certain or even wide range of such tunings, or do you use custom/independent notations for each such tuning? Officially, microtonality support in the Opusmodus notation OMN is limited to quarter tones (e.g., c4+) and eighth notes (e.g., c4.) and explained at the front page (https://opusmodus.com ). (Seemingly, there is not even a separate eighth flat accidental symbol, those pitch deviations depend on combinations with standard accidentals). However, according to Janusz Opusmodus additionally supports (or will support) arbitrary microtonal deviations of 12 EDO (or 24/48 EDO?) expressed by cent values to be added as technique, but this is not yet documented. So far, I have not yet delved into the existing microtonality support, but instead I am waiting for this feature (arbitrary cent deviations) to be documented. Then I would add for my own purposes by and by a richer microtonal notation on top of the builtin OMN with custom functions. For example, I plan to define for myself tuning table support, which would allow to arbitrarily detune (in an octave repeating way and/or freely for each octave) the supported pitches incl. all quarter and eighth tones. For example, 31-EDO (septimal meantone) and various other temperaments can be notated with only the accidentals already available in Opusmodus, but we would need to tune all pitches differently. That could be done simply by a function that maps OMN pitches (incl. their cent value deviations relative the the tuning table) to 12 EDO pitches with cent value deviations. The tricky bit with this approach is that enharmonically distinct pitches (like C# vs Db) could be tuned differently in such tuning table (e.g., these are different pitches in 31 EDO), while many pitch-processing functions in Opusmodus seemingly disregard enharmonic distinctions. So, such Opusmodus functions must then be avoided. At a next stage, I might define my own pitch representation from scratch that would support regular temperaments (i.e. incl. just intonation for arbitrary limits, arbitrary equal temperaments, but also things listed at https://en.xen.wiki/w/Tour_of_Regular_Temperaments ) using perhaps accidentals like sagittal notation (which was designed to support a wide range of tunings). For example, I might represent additional accidentals as custom OMN techniques, which could be translated into cent deviations for MIDI playback, but would be included as some ASCII technique text of these accidentals for MusicXML output (which I could then manually translate into proper accidentals with notation software like Dorico). Now, all of this would not directly cover those non-octave scales you are interested in, but perhaps you can use a similar approach, where you translate some custom OMN notation developed for your purposes into the relevant OMN with cent deviations for playback etc. Perhaps we might even work together on something like this at some stage.
  15. > C-c C-l shortcut which loads a lisp file and make its variables available in the REPL Beyond that, you can also (re)-evaluate at any time just individual expressions or definitions (not necessarily a whole file or even a whole program) and that way make your whole development process rather interactive. I use the shortcut for evaluating the last expression (before the point/cursor), C-x C-e, much more often than the one for loading a file. > general Lisp tutorials As a Python developer, this might be helpful for you, even though it is written originally for the opposite "direction" of learning. https://norvig.com/python-lisp.html Best, Torsten
  16. > running in Emacs, I just can't find any documentation on what command to give the REPL to load/compile/run a file Are you using Slime? If you just open a Lisp file in Emacs without having a connection to a Lisp compiler, then Emacs acts as a mere text editor. In order to turn it into an IDE that is connected to a compiler and REPL etc., you need to use some interface for a Lisp compiler. For Common Lisp, Slime is recommended for that. Attached is some code that defines how to let Emacs Slime and CCL of Opusmodus talk to each other. Of course, it requires you to install Slime first (which you can do via the Emacs packages system, as far as I remember, if it is not already part of your Emacs installation, as it is, e.g., for Aquamacs). The most important part here AFAIK is to start swank, which is the Common Lisp side of the Emacs Slime interface. I have this file put into my Extensions folder, to have this connection set up when I start Opusmodus. Then, start Opusmodus and start Emacs. After that, you have to start Slime in Emacs and tell it to which Common Lisp compiler to connect (it works with many Lisp implementations). I do that via the following. I guess you know what M-x stands for. M-x slime-connect ;; You will be asked for a host (Slime can use a networked computer) host: 127.0.0.1 ;; You will be asked for a port. Port: 4005 After that, you will be greeted by a REPL, and some friendly message in the mini buffer, like "Connected. Are we consing yet?" (some Lisp hacker humour, https://stackoverflow.com/questions/2256261/why-is-consing-in-lisp-slow ). You can type Lisp expressions directly in the REPL, but you usually want to execute individual code blocks or whole files from a source buffer. After you did the above, Emacs should show a Slime menu, where you can check the standard shortcuts for how to evaluate code etc. Have fun. Torsten The mentioned attachment... opusmodus-setup.lisp
  17. > Like Cmd-S for save Exactly, Aquamacs works with standard Mac shortcuts like that. See https://aquamacs.org/features.html and scroll slightly down to see a table of some of them. > finishing a traditional composition I like that.
  18. I am using Opusmodus mainly via Emacs these days (when I find the time to use it ), but this editor is only something I would recommend for developers. For me, it has several benefits over the builtin Opusmodus editor. > my Emacs shortcuts are rusty There are some easy workarounds for that. If you are on a Mac (likely) I would recommend Aquaemacs (https://aquamacs.org), which for many standard tasks uses the standard Mac shortcuts instead. I use it every day, it works well. For Linux or Windows, there is also ErgoEmacs, which works well for me too. For me, the main benefits of using Emacs is that I can use the full Slime functionality (https://common-lisp.net/project/slime/ ). Some of that functionality is also available in the Opusmodus editor, but hidden and only accessible via shortcuts (e.g., I am regularly jumping to the definition of various functions -- works with my own definitions and the CCL builtins, if things are set up properly, though of course not with Opusmodus definitions). However, much of the Emacs Slime functionality does not have an equivalent in the Opusmodus editor. Most important for me is perhaps having full access to the Lisp debugger (something blocked in the Opusmodus editor to simplify things for users, I guess). If you are coming from other programming languages, it is worth checking out what a Lisp debugger can do, because the interface is a bit for nerds, but its functionality/power goes beyond what you find in debuggers for pretty much all other languages. There are some YouTube videos out there (e.g., look for presentations by Rainer Joswig, though these are of course not music-specific). For some general intro, you might want to read about conditions and restarts in Lisp, which is the foundation built into the language that allows the debugger to do what it can do (https://lispcookbook.github.io/cl-cookbook/error_handling.html ). Another thing I like about using Opusmodus from within Emacs is that I can use it with other Emacs modi. For example, I commonly organise larger composition projects as org mode files (https://orgmode.org ). Then I can integrate any notes to myself in a wiki-syntax (which tend to be lengthy in my case...) alongside my code (e.g., I commonly have different versions of some code together with different results in the file hidden in closed subsections), have links to files and relevant background research, integrate with the code links to resulting files. I may export the whole thing into various formats (e.g., slides for presentations or just PDF files for articles), have TODO lists integrated etc. Anyway, this is all mainly something for nerds... The main downside of using Emacs over the Opusmodus editor is that Opusmodus-specific functionality is missing by default, like shortcuts for notating or playing back some musical results, but -- we can add our own shortcuts to Emacs. So, I started to add shortcuts for the most important functions for me (like notating and playback), and -- importantly -- I can also add my custom shortcuts, e.g., for playing back some custom data representation that first needs translating into a standard Opusmodus score. My current Emacs Lisp definitions for this purpose depend on some custom functions I defined in my libraries, but if you are trying to do something like that I might be able to help.
  19. After our recent Opusmodus Convention I have been asked whether there would be any Opusmodus tutorials for the libraries I shared. While there is no bespoke Opusmodus tutorial for any of them (you might consider my presentation at he Opusmodus convention as that tutorial, and additionally there are some nods to Opusmodus in the docs here and there), these libraries are all documented. For all libraries I write I tend to create detailed reference documentation for my own good Much of the documentation is simply at the Common Lisp level, but that means in Opusmodus it would be largely used the same way. Fenv (Function Envelopes) There is some short intro doc at the github project page of this library at https://github.com/tanders/fenv for plain Common Lisp but with a few Opusmodus-specific notes. In the fenv library, pretty much every definition has a very short docstring (e.g., see https://github.com/tanders/fenv/blob/master/sources/fenv.lisp ). These docstrings were also used for creating some HTML documentation. Check out the doc directory in this library. Further, there is a test file, which can also be considered a file with a bunch of examples, though without further documentation (see https://github.com/tanders/fenv/blob/master/tests/test-fenv.lisp ). Cluster Engine and Cluster Rules Concerning the constraint libraries, the situation is a bit more complex. The Github landing page of Cluster Engine (https://github.com/tanders/cluster-engine ) also starts with something like a mini tutorial and some very brief consideration of Opusmodus, like the fenv library. Nevertheless, these libraries where originally written for PWGL and they are still best documented when used from within PWGL. You might want start looking into these libraries by watching some video tutorial I did for my students (as part of a collection/playlist of videos on PWGL) where I am showing them how to get started with these libraries in PWGL at Both libraries feature some PWGL tutorial that consists of a number of PWGL patches accessible from the PWGL docs menu after installing and loading them. These PWGL tutorials go much further than I do in the above-mentioned video. Beyond these PWGL tutorials, there is also some reference doc for the top-level Cluster Engine functions (e.g., the rule applicators) and the predefined rules in Cluster Rules, again written as docstrings but also part of HTML docs of these libraries, but these are best understood after you followed the PWGL tutorials. So, unfortunately I have to encourage you to check these libraries out in PWGL first, that is still more easy. You can then rather easily port your first PWGL Cluster Engine patches to Opusmodus, as the boxes in PWGL and the functions for Opusmodus at called the same, as long as you only used definitions from the Cluster Engine package. Note that unfortunately, the original PWGL site is meanwhile down (this software is not developed any further), but it seems that some version of the software can still be downloaded at fdsdbmascagni SITES.GOOGLE.COM Apologies that there are no bespoke Opusmodus tutorials. Janusz already also mentioned some interest in these libraries, so I may give some dedicated talk on those at some later stage (e.g., as part of our next convention). I would likely cover largely what is already covered in the above-mentioned docs, only from within Opusmodus then. TOT Again, this library has a github landing page with some initial documentation (https://github.com/tanders/tot ) and some detailed reference documentation in HTML in the doc folder (https://tanders.github.io/tot/ ). This reference documentation features many examples that can be directly executed within Opusmodus. In some earlier version of Opusmodus, the HTML doc files could also be directly opened and the code could be evaluated without copying, but that is currently not possible any more (due to some changes by Apple as I understand, sigh). Note that all of these libraries might have some problems here and there. I try to test all my definitions carefully (for Cluster Engine I even defined a suit of regression tests), but things on which these libraries depends can change (e.g., some updates of Opusmodus break some TOT code every now and then). Anyway, if case you run into problems just get in touch. I have currently rather little time to look into these matters and thus may not be very response, but I will try to help at some stage... Best, Torsten
  20. I am sharing here the score of some piece I did some time ago with Opusmodus and which I will touch upon in my presentation at the forthcoming Opusmodus convention. Unfortunately, I only have a score for this and no recording. Torsten Torsten Anders - 2017 - Aschenputtel - for Flute Solo.pdf
  21. It looks like conTimbre would be a considerably larger collection of articulations and also better documented (e.g., I guess if you play a certain multiphonic you are able to learn how it was produced or vice versa, which is not the case with the IRCAM Solo Instruments), but its playability as a plugin from Opusmodus or a DAW seems to be less developed. In case you played already with it: how well does the latter work, now that they have support for VST and AU plugins?
  22. Update: It seems the samples are the same as in version 1 (which are now > 10 years old and with the original problems like rel. few samples i.e. few velocity layers or no round robins to avoid machine gun effect and all very closely miked), but now the scripting and instrument is much improved, e.g., with legato phrasing now supported, streching/shrinking notes like transitions, a timbre control (e.g., could be used for avoiding the machine gun effect). However, reviews report that these new scripts are not perfect, e.g., key switches can result the occasional glitch. How does conTimbre compare with that, i.e., how well is their current playback incl. switches between techniques and ideally also expressive playing from Opusmodus or a DAW working (i.e. when used as an AU or VST pluging)?
  23. I would very much appreciate some feedback, but I am already almost decided to get it in any case. We might perhaps work on an Opusmodus sound set together. I will only use a few instruments (currently I just need the cello), but would like to make a wide range of techniques available in Opusmodus. However, instrument key-switches etc. hopefully share patterns, so once one instrument is reasonably covered it should be possible to scale that at least for the other instruments in the same family. One problem might be that they keep standard (what they call classic) and extended techniques in separate key-switch groups (and even subgroups), so one might need multiple sampler instruments on different MIDI channels to cover a single acoustic instrument. Not sure whether it would be necessary in Opusmodus then also to have different instruments. I guess currently that would be necessary, as currently AFAIK in Opusmodus a single instrument can only be allocated to a single MIDI channel (different articulations cannot be assigned to different MIDI channels, at least not yet). If there are other ideas how the multiple key-switch groups could be merged into a single Opusmodus instruments, I would be all ears.
  24. Hi guys, Did anyone of you already look into the rather new IRCAM Solo Instruments 2 by UVI? That might be nice to control from within Opusmodus with its wide range of extended techniques available. From what I can tell from the videos, this seems to be a clear improvement over the former version and also conTimbre in terms of sounds and playability. Anyone already tried it? UVI IRCAM Solo Instruments 2 - Avant-Garde Solo Instrument Collection WWW.UVI.NET 16 instruments, 550+ playing techniques, experience unparalleled depth and detail with classical and avant-garde articulations recorded at IRCAM Labs Some videos that give some impression: https://www.youtube.com/watch?v=AFNzya5iOUc&vl=en https://www.youtube.com/watch?v=ugMPNtWtLvk Some review: https://soundbytesmag.net/review-ircam-solo-instruments-2-from-uvi/
  25. BTW: Common Lisp has built-in tracing mechanisms, which happen to be more fine-grained and work automatically without any need to sprinkle explicit function calls like do-verbose in any definition at all. For example, there is the builtin trace: CLHS: Macro TRACE, UNTRACE CLHS.LISP.SE In case of an error (and only in case of an error), a full stack trace is usually automatically printed. This happens to be disabled in the standard Opusmodus editor, but works as normally in Common Lisp when using the Emacs Slime interface. For example, consider the following code. (defun function-causing-error (x) (/ x 0)) (defun test (x) (function-causing-error x)) (test 1) When I evaluate the code above in Slime, I get not only a stack trace showing which function called which, I can also get interactively further information on the function calls, like looking at which arguments they were called. Best of all, I can evaluate arbitrary code for testing in the context of any function of the stack trace, where all its local variations are bound, which can be very helpful for debugging. Here is a screenshot of the stack trace I get. You can see that the function test (frame 3 -- the leading number in the trace) calls the function function-causing-error (frame 4) which just a few frames up causes the error DIVISION-BY-ZERO. Now, in this case the error is rather obviously, but in case you have some local variables in the function that might contain a bug, it would be useful to be able to look at these. Indeed, you can. Just click on any frame, and all local variables are shown. Here it is simply the argument x, which we already know, as arguments are shown in the stack trace as well. Now, sometimes just seeing the local variables is not enough, you want to play with them a bit. Again, you can do that. Move the cursor into/on the frame, press the shortcut e (for evaluate), and you are prompted to enter an arbitrary expression that is executed in the context of this frame (e.g, can use the local variable x). I cannot easily show this in a screenshot and would instead need to do a little video. Let me know if the explanation so far is not sufficient. Best, Torsten
×
×
  • Create New...

Important Information

Terms of Use Privacy Policy