strudel music programming language

• https://github.com/search?q=strudel.json&type=code&p=1
  
• https://github.com/vasilymilovidov/samples
  
• https://github.com/yaxu/mrid
  
• https://github.com/Bubobubobubobubo?tab=repositories
  
• https://github.com/search?q=path%3Astrudel.json+%22_base%22&type=code
  

Sí!: https://strudel.cc/?b34hJOXUeHUA

Como tener 2 secciones diferenciadas dentro de un bucle mas grande → con seq, o cat, of TimeCat (alternar entre una y otra) → slowcat es la mejor

  seq(
  n("[0 1 2 3]").fast(4),
  n("[0 1 2 3]").rev().fast(4)
    ).slow(4)
    .scale("C5:minor").piano().pianoroll()

  // !Ojo! que no es lo mismo que esto, si "factorizamos" los .fast(4):
  seq(
  n("[0 1 2 3]"),
  n("[0 1 2 3]").rev()
    ).fast(4).slow(4)
    .scale("C5:minor").piano().pianoroll()

  stack(
  seq(
  n("[0 1 2]").fast(4),
  n("[0 1 2]").rev().fast(4),
    ).slow(4),
  n("[-7 -5]").color("red").slow(4)
    )
    .scale("C5:minor").piano().pianoroll()

Modular parámetros de una pista con parámetros de otra
Por ejemplo sidechaining es bajar el volumen de una pista cuando suena otra
https://forum.toplap.org/t/sidechain-in-tidal/1016 tidal parece que sí
De todas maneras esto es un poco un “hack”, y hacerlo por midi te da más control

Se puede usar una lista global para los niveles de cada pista.
Se podrían hacer cues con esta estructura, es decir, activarla y que no hiciese nada hasta el siguiente bucle?

Tidal tiene esto:
https://tidalcycles.org/docs/reference/transitions/

Tener otra pista que suena por otro canal distinto para ir haciendo pruebas, o aplicar una función en un canal de audio sólamente, para ver cómo va a quedar (y si va a dar un error de sintaxis!)
https://github.com/tidalcycles/strudel/releases/tag/v1.1.0 → Clock sync between multiple instances
Con esto sí que se puede

function filterKick(x) {
  return stack(...x.filter(x=>!x.value.s.includes('bd')));
}

stack(
  .
  .
  .
).arpWith(filterKick)

// Más sencilllo
stack(
  .
  .
  .
).filterHaps(x=>!x.value.s.includes('bd'))

Funciona a cualquier nivel porque trabaja a cualquier nivel (puedes meter stacks dentro de stacks y aun así los filtra)
Si quieres quitar el bombo una de cada 32*4 = 128 veces:

.someCyclesBy("<0 1>/32/4", y=>y.filterHaps(x=>!x.value.s.includes('bd')))

https://strudel.cc/?9fB3wx3kuSwh

const strt = "<0 1>/4";
stack(
  stack(
    s("[bd bd ~ ~ [~ bd] bd ~ ~ ]/4"),
    s("[hh]*4").velocity(0.5),
    s("[~ sd]/2"),
    ).bank('RolandTR909').fast(2),
)
.someCyclesBy(strt, y=>stack(y.filterHaps(x=>!x.value.s.includes('bd')),
                                  s("cr*4").bank('RolandTR909').struct(strt) // En teoría este struct no debería de ser necesario, es igual que el primero
                                 )
             )

Dada una secuencia de acordes, generar escalas
Dada una secuencia de escalas, generar una línea
Se me ocurre hacer un choose aleatorio, pero sería “demasiado aleatorio” y habría que constreñirlo un poco más, como que por ejemplo no haga saltos muy grandes. Se puede constreñir en strudel? Se pueden utilizar los voicings para esto?
Una buena idea es comprimir en un acorde la secuencia, y luego expandirla con .arp
renderVoicing quizás es una manera mejor de hacer esto porque no te hace el stack
Estadística de transiciones de notas
Generación aleatoria
https://strudel.cc/?ENbS7h4ebnjK

`[[b4 [e4 g#4 b4]] [~ c5] d5 e5]`.note()

Si quiero que “[e4 g#4 b4]” ocupe el ~ que tiene después, no sé cómo hacerlo. Es como una ligadura?

`[[b4 [e4 g#4 b4]] [b4 c5] d5 e5]`.note()

note("c3 eb3 g3 c4").legato("<.25 .5 1 2>")

https://github.com/tidalcycles/strudel/issues/52

https://club.tidalcycles.org/t/dotted-notes-and-patterns/4971
Pregunta:
https://strudel.cc/?nTbrkqN9d_ba
Respuesta:
https://strudel.cc/?NfRhJu5NSOUU
Operador as:
https://strudel.cc/?9Vx2l3N8UIJF

Se me ocurre hacer algo parecido a lo del bombo, que tenga algún tipo de inteligencia y me filtre los eventos que quiero y me aplique cosas extrañas. Por ejemplo cambiarle el patrón rítmico a una pista únicamente, o cambiarle la escala en un momento determinado, etc
Diccionarios con valores por defecto, para que sea fácil de cambiar en un caso especifico sin generar cambios en cascada

https://strudel.cc/?cqkc2h2GLql7

setcps(1)
const lead =  n("<-2 -3 -7 -5>/2".add(14)
                .superimpose(x=>x.add(2).clip(1.05))
               ).layer(x=>x.clip(1.05));


lead

  // .scale("<C3:minor C3:harmonic_minor C3:minor C3:minor >/2")
  .scale(slowcat('C minor', 'C harmonic minor', 'C minor', 'C minor').slow(2))
  .sound('gm_voice_oohs')
  .lpf(3000)
  .pianoroll()

https://strudel.cc/?8HCI02weDnb-

For drum sounds, strudel uses the comprehensive tidal-drum-machines library, with the following naming convention:
https://github.com/geikha/tidal-drum-machines/tree/main/machines
https://github.com/sgossner/VCSL

El equivalente sería “[x]” = 120, de tal manera que todos los “x” que están a un cierto nivel de anidación de corchetes/llaves duran lo mismo
Parece que lo que es fijo es el ciclo más que la longitud de la nota y puede ser lioso

Con inhabit se pueden hacer cosas, definir tu propio lenguaje
Con el operador as puedes definir modificaciones a notas

.mask(0) .mask(“~”) eliminan una nota
Con ellas o con .gain se pueden utilizar para silenciar y activar a la vez pistas

// A veces con .cpm no es suficiente, y hay que utilizar setCps
setCps(2*0.5625); // Valor por defecto
setCps(2*0.7);

Si estás trabajando con un tempo global, sin sincronización MIDI, es mejor hacer un .fast/.slow global porque es más preciso que un setCps, creo que por problemas de precisión en javascript

Por ejemplo cuando tengo que aplicar cambios a patrones, no sé si tener una matriz y luego hacer chooseInWith, o un when o algo…
La cosa es aplicar una función en cada momento, y unas veces puede ser la identidad, una función que no suene, o cosas mas complicadas
Idealmente podrías tener una matriz 3d que sean tiempo (X), pistas (Y) y capas(Z)
O en cada celda 2x2 puedes tener una suma de sonidos apilados

function I(...args) { return args}

También puedes verlo como 2 tipos de matrices, una más lenta y otra más rápida. Ejemplo:

Con más estructura:
https://strudel.cc/?xjZiTFc0kRLW

mini('[' + [...Array(8).keys()].map(x=>0).join(' ') + ']');
signal(x=>x>4 && x<5? 1:0)

Quizás proponer un operador en notación mini que sea un puntillo como . para cuando quieres aplicarlo a clip para hacer ligaduras

Un Pattern de Patterns es un Pattern (es completamente plano). Puedes conseguir estructura mediante pure:

pure([note("d e a d"),
      note("f g c f"),
      pure([s("bd*2"), s("~ sd")])
      ])
  .fmap(x=>stack(
    x[0],
    slowcat(x[1], x[0].s("sawtooth")),
    x[2].fmap(y=>stack(...y)).innerJoin())
       )
  .innerJoin()
// También puede ser un diccionario
pure({dead: note("d e a d"),
      fgcg: note("f g c f"),
      drums: pure([s("bd*2"), s("~ sd")])
      })
  .fmap(x=>stack(
    x['dead'],
    slowcat(x['fgcg'], x['dead'].s("sawtooth")),
    x['drums'].fmap(y=>stack(...y)).innerJoin())
       )
  .innerJoin()

• strudel/website/src/pages/learn/samples.mdx at 8a741952df594183d7d32fc72b4acd8242456173 · tidalcycles/strudel
  
• tidal-drum-machines/machines at main · geikha/tidal-drum-machines
  
• sgossner/VCSL: Open CC0 sample library.
  
• csound-live-code/doc/cheatsheet.md at main · kunstmusik/csound-live-code
  

• Lil Data - YouTube
  
• Mike Hodnick - YouTube
  
• kindohm’s Videos - Twitch
  
• https://www.youtube.com/live/WT7zXVp21BQ?si=ryrCv_WB8dXHJG9L
  
• TOP 10 DROPS 😱 Making EDM from Code 2023 | Tidal Cycles FoxDot SuperCollider (My own routines) - YouTube (regular EDM)
  
  • SleepyAstroboi - YouTube
    

• jarmitage/Stenophone: The Stenophone is a musical instrument combining stenotype and live coding
  
  • Day 1: paper presentation by Jack Armitage & Andrew McPherson - YouTube
    
• International Conference on Live Coding - Home
  
• Hybrid Live Coding Interfaces
  

• De primeras, lo que hay me sirve para generar datos (estructuras complejas de Tidal), sobre todo la librería de haskell
  
• Feat: functional enumeration of algebraic types - Haskell12.pdf
  
• How to enumerate trees from a context-free grammar
  
• galoisenne/latex/lafi2024/acmart.pdf at master · breandan/galoisenne
  
• Se pueden enumerar todas las funciones de simplificación?
  

Hacerlo en Haskell

1. Generar strings en base a gramática: Generating the language of a context-free grammar in Haskell
   
2. Sacar con queries los eventos (notas): https://mzadel.github.io/tidalfundamentals/
   
3. ?? Aprender Haskell ??
   

1. Utilizar PonyGE2: Grammatical Evolution in Python https://github.com/PonyGE/PonyGE2 para buscar con
   Convertir Mini (notación PEG) https://github.com/tidalcycles/strudel/tree/main/packages/mini a BNF que es lo que acepta PonyGE2
   Puede estar interesante quitar ciertas instrucciones para generar modelos más sencillos y que tarde menos ( se pueden comentar con # pero hay que asegurarse de que no se rompe nada)
   Las reglas de generación tienen que ser lo más sencillas posibles (no tienen que aceptar todo el código válido) para reducir el espacio de búsqueda: luego se puede expandir con un formatter en una forma más bonita
   
2. Producir notas, todas de la misma longitud
   https://strudel.cc/?JesRwge1T_f0
   
3. Generar Train y Test
   PonyGE2 necesita conjuntos de train y test, pero no está bien definido cuáles son las variables independientes en este caso, incluso diría que no tiene ninguna. Una opción natural parece pasarle la longitud de esa nota como única variable, o incluso mejor la longitud que le queda a esa nota en ese momento, a modo de “predicción” de cuando va a terminar. También puedo entrenarlo múltiples epochs, es decir, repitiendo patrones para generar más datos: no me preocupa sobreajustar a los datos, sino que es justo lo que busco. Train y Test pueden ser iguales por la misma razón
   Los números 1|2|3|4 … son variables independientes o expresiones terminales del lenguaje?
   Para pasarle sólo un ciclo como conjunto de train/test necesito detectar qué es un ciclo: https://en.wikipedia.org/wiki/Cycle_detection#Algorithms pero estos algoritmos podrían detectar un subciclo en vez de un ciclo (en general no saben cuándo parar)
   

Puedo utilizar la simplificación de expresiones estilo CAS (Computer Algebra System)
Automated simplification of large symbolic expressions
Understanding Expression Simplification
Macsyma’s General Simplifier: Philosophy and Operation
Lo que sí que tiene más sentido es utilizar regresión simbólica con qué simplificaciones aplicar y en qué orden. El árbol ahí ya es plano y no crece tanto

• Un objetivo más simple puede ser refactorizar el lenguaje mini
  No está claro si el lenguaje tiene las mismas propiedades que Haskell porque está dentro de una string. Por ejemplo puede que chooseCycles | no se pueda utilizar porque no es determinista
  
• https://trevanhaskell.com/projects/entropy/
  Entropía de lenguajes de programación
  
• Utilizar esta entropía para seleccionar entre dos construcciones iguales (que dan la misma salida). Creo que Tidal Cycles es mejor que strudel
  
• Dos expresiones en un lenguaje “declarativo” (mini/strudel/tidal) se define como que produzcan el mismo MIDI
  Este concepto es Observational Equivalence
  
• Creo que el problema puede tener que ver con “pretty printing”, convertir de un árbol a texto sería pasar de una estructura de código a MIDI, o a una representación nota a nota
  prettier.pdf
  
• https://en.wikipedia.org/wiki/Kolmogorov_complexity
  
• Hacerlo relativo a la primera nota, para que tenga simetría de transposición/traslación. Para ello puedo hacer que el código mini se ejecute por ejemplo siempre en un .add()
  Aun así no expresa todas las simetrías que quiero, porque por ejemplo puedo sumarle o restarle un número constante y me sigue quedando lo mismo.
  Puedo hacer la derivada entre valores consecutivos de eso y creo que ya tiene las simetrías que quiero, pero entonces no sé cómo representarlo en strudel (tendría que “integrarlo” antes de pasarlo a strudel, o tendria que “integrarlo” en strudel)
  https://strudel.cc/?Vpi01bcTw7_J
  
• Las reglas que defina de igualdad son las que definen el mecanismo de optimización: no siempre resultan en un objetivo que reduce la entropía, pero siempre se pueden aplicar, y ese espacio de posibles aplicaciones de reglas que dan el mismo resultado es el espacio de búsqueda. Puedo buscarlas yo o puede buscarlas un algoritmo de prueba de teoremas (?) Cómo asegurarse de que las transformaciones que descubres son exhaustivas?
  Siempre se empieza con seq(n1 n2 n3 n4 …)
  Como mucho puedes tener un árbol de funciones arbitrarias compuesto de cada nota individual
  

• El grupo de la universidad de St. Andrews y Kent parece el bueno
  Christopher Brown1, Huiqing Li2, and Simon Thompson2
  1 School of Computer Science, University of St. Andrews, UK
  chrisb@cs.st-andrews.ac.uk
  2 School of Computing, University of Kent, UK
  {H.Li,S.J.Thompson}@kent.ac.uk
  
• Fully funded PhD scholarship: Trustworthy Refactoring Tools for Haskell Programs | Computer Science Blog
  
• An Expression Processor: A Case Study in Refactoring Haskell Programs | SpringerLink
  
• HaRe - HaskellWiki
  
• Thesis.dvi - RefactoringHaskellPrograms.pdf
  
• RefactoringTools/HaRe: The Haskell Refactoring Tool
  
• Retrie: Haskell refactoring made easy - Engineering at Meta
  
  • facebookincubator/retrie: Retrie is a powerful, easy-to-use codemodding tool for Haskell.
    
• Data-Driven Refactorings for Haskell - Kent Academic Repository
  

• gAldeia/AInet-based-Symbolic-Regression: Haskell implementation of a symbolic regression algorithm. The regression search is done by means of the IT data structure, and the general structure of the algorithm is based on the AInet algorithm (artificial imunne network).
  
• folivetti/ITEA: Interaction-Transformation Evolutionary Algorithm
  
• folivetti/srtree: Haskell library for representing and manipulating Symbolic Regression Tree
  

• Mini en strudel está basado en un PEG. Fuente: https://github.com/tidalcycles/strudel/tree/main/packages/mini
  
• Generating Strings at Random from a Context Free Grammar
  
• Uniform Random Sampling of Strings from Context-Free Grammar
  
• Idealmente, en vez de generar strings aleatorias, debería de poder tener en cuenta la estructura de alguna manera
  
• https://en.wikipedia.org/wiki/Genetic_programming
  

En Javascript más sencillo para que se pueda ejecutar todo en node(?)

• https://github.com/gAldeia/gAldeia.github.io
  
  • https://folivetti.github.io/files/presentationIT.pdf
    
• https://github.com/zekenie/GPJS
  
• https://github.com/trevorstephens/gplearn
  functions.make_function() factory function.
  
• El problema que tienen estos algoritmos es que aunque puedes definir funciones custom, al final tienen se evalúan todas a un número. Puedo codificar secuencias más largas si lo trato como una secuencia de bits, se me ocurre
  Otra manera de codificarlo es como una serie temporal, como una serie de funciones rectangulares
  
• Aquí tendría que definir qué reglas de mutación y demás aplico
  
• En Rust compilado a Javascript: https://github.com/louisbourque/wasm-genetic-programming/
  https://www.louisbourque.ca/wasm-genetic-programming/
  
• El problema de Symbolic Regression es que no se puede precomputar, sino que siempre hay que hacer la búsqueda completa (no puedes preentrenar un modelo)
  Las entradas son los números naturales (hasta un límite para la melodía) y tienen que combinar patrones de manera muy compleja. Normalmente es al revés, combinaciones relativamente simples de bastantes parámetros
  
• Algo más de ML: MMSR: Symbolic Regression is a Multimodal Task - 2402.18603v1.pdf
  
• Este tipo de algoritmos dan pie a representarlo como árbol de funciones, lo que generaliza mejor para luego aplicarlo al lenguaje completo
  
• Igual que existe un Symbolic Regression existe un Symbolic Autoencoder?
  Why Is Auto-Encoding Difficult for Genetic Programming?
  jmmcd/GPAE: Genetic programming auto-encoder
  schofield2023genetic.pdf
  James McDermott
  PonyGE2: Grammatical Evolution in Python
  https://github.com/PonyGE/PonyGE2
  https://pypi.org/project/evoltree/
  

Los operadores de sonido en paralelo y en secuencial de strudel tienen propiedades distributivas como producto y suma
“a b,c d” = “<a,c> <b,d>”
El elemento neutro de “,” sería “~” y el de “ ” sería “” (string vacía)
https://strudel.cc/?Sd0AqY_doVWa
“<a b,c d>*2” = “<a,c> <b,d>”
https://strudel.cc/?2yHX6HbiwP7R Hay un desajuste de velocidad por el alineamineto de patrones

Parto de una secuencia seq(n1 n2 n3 n4 …)
Luego seq(n1 n4 n8 n16 …).add(seq(t1 t2 t3 t4 … ).slow(4))

Modelar el lenguaje mini y las maneras en las que tienes operaciones que son equivalentes

• segovia_aguas_GenPlan22 - Representation and Synthesis of C++ Programs for Generalized Planning
  

Es interesante porque pasas de una búsqueda sin tener información de la estructura a una especie de planificación en la que tienes información de la estructura interna

Para poder identificar distintas voces. Creo que tiene que haber cosas ya hechas con inteligencia artificial

• Cuantizar más o menos de entrada
  
• Utilizar más o menos números en la BNF
  

Smoothing is the quantization of manual knob modulation
Lo de renardo pero en sentido inverso, cambiar algo (midi, cc) en el daw y que se refleje en el código, como una variación global o como una variación de ese patrón en concreto, o con los patrones que cumplan una condición (los pares, uno de cada cuatro, etc)
Un suavizado te deja ponerlo en términos de funciones más matemáticamente simples, y luego podrías utilizar la misma estrategia para simplificarlo
Es algo parecido a expresar una curva en series de fourier o en otro tipo de bases. Por ejemplo esto:
https://github.com/MilesCranmer/PySR

Audio → Jointist → Modelo → Código Mini / Strudel / Tidal