December.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39184fdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "106b7222",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'  # or any {'0', '1', '2'}\n",
    "import tensorflow as tf\n",
    "tf.get_logger().setLevel('ERROR')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "505ba113",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import librosa\n",
    "\n",
    "from composition.instrument import Score, Part, Phrase, show\n",
    "import composition.common as k\n",
    "from utils import QuantileTransformer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a67f4e5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    first = 0\n",
    "    second = 1\n",
    "    fibs = []\n",
    "    for _ in range(n):\n",
    "        first, second = second, first + second\n",
    "        fibs.append(first)\n",
    "    \n",
    "    return fibs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c32670f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n, first=None, second=None):\n",
    "    if not first:\n",
    "        first = [1]\n",
    "    if not second:\n",
    "        second = [2]\n",
    "    \n",
    "    while len(second) < n:\n",
    "        first, second = second, second + first\n",
    "\n",
    "    return np.array(second[:n])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b7bf8d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fill_with_silence(part, n):\n",
    "    pitches = part.phrases[-1].pitch[-1] * np.ones(n)\n",
    "    amps = np.ones(n) * -120\n",
    "    \n",
    "    part.add_phrase(Phrase(pitches, amps))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c28f5c51",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_harm(n, stretch=0, base=36):\n",
    "    f_base = librosa.midi_to_hz(base)\n",
    "    f_harm = f_base * n ** (1 + stretch)\n",
    "    return librosa.hz_to_midi(f_harm)\n",
    "\n",
    "v_get_harm = np.vectorize(get_harm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07585174",
   "metadata": {},
   "outputs": [],
   "source": [
    "fibonacci(15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b352ab5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "phi = (np.sqrt(5) + 1) / 2\n",
    "dur = 7 * 60\n",
    "b = dur / phi\n",
    "a = dur - b\n",
    "a2 = a / phi\n",
    "a1 = a - a2\n",
    "\n",
    "b1 = b / phi\n",
    "b2 = b - b1\n",
    "\n",
    "print(f'A: {a1:.2f}\\\" B: {a2:.2f}\\\" development: {b1:.2f}\\\" A\\'/B\\': {b2:.2f}\\\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "217bb4a2",
   "metadata": {},
   "source": [
    "## Sections\n",
    "\n",
    "|           | A   | B   | D    | R   | Total |\n",
    "| --------- | --- | --- | ---- | --- | ----- |\n",
    "| Rounded   | 61\" | 99\" | 160\" | 99\" | 7'    |\n",
    "| Fibonacci | 55\" | 89\" | 144\" | 89\" | 6'17\" |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5618cb00",
   "metadata": {},
   "source": [
    "* violin: mean: -43.36, std: 5.23\n",
    "* viola: mean: -42.76, std: 7.77\n",
    "* cello: mean: -57.26, std: 6.12\n",
    "* flute: mean: -55.27, std: 8.37\n",
    "* flute2: mean: -55.27, std: 8.37\n",
    "- Violin 55-103\n",
    "- Viola 48-91\n",
    "- Cello 36-76\n",
    "- Flute 60-96\n",
    "- Flute2 55-91"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cddfc6b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "dur = 16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5af0be15",
   "metadata": {},
   "outputs": [],
   "source": [
    "seed_p = np.array((0, 0.7, 0.3, 1.0))\n",
    "seed_a = np.array((0, 0.375, 0.625, 1.))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a8ce5a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "COPPER = 4.236067978"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "beb0c28b",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1, figsize=(4 * COPPER, 4))\n",
    "ax.plot(seed_a, seed_p)\n",
    "ax.set_xticks(seed_a)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ece50b6",
   "metadata": {},
   "source": [
    "# Fractal I (F♯)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8349e014",
   "metadata": {},
   "outputs": [],
   "source": [
    "vln1 = Part('Vln. 1', 'violin')\n",
    "for i, dr in enumerate([2, 4, 8]):\n",
    "    seed_d = k.to_delta(seed_a * dr)\n",
    "    pitches, durs = k.fractal_bpc_floor(seed_p, seed_d, i)\n",
    "    pitches = np.pad(pitches, (0, k.time_to_step(dr) - len(pitches)), constant_values=pitches[-1])\n",
    "    pitches = (pitches - min(pitches)) / (max(pitches) - min(pitches))\n",
    "    pitches = k.rescale(pitches, 66, 66+12)\n",
    "    pitches = k.autotune(pitches, 0.95)\n",
    "    pitches += k.sinusoid(dr, 4, 0, 0.125)\n",
    "    \n",
    "    if i < 2:\n",
    "        amp_segments = []\n",
    "        for d in durs:\n",
    "            aa = k.triangle(d, 1/d, 1e-7)\n",
    "            aa = np.pad(aa, (0, k.time_to_step(d) - len(aa)), constant_values=aa[-1])\n",
    "            amp_segments.append(aa)\n",
    "        amps = np.concatenate(amp_segments)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -55, -44)\n",
    "        amps += k.line_segment(dr, -8, 4)\n",
    "    else:\n",
    "        amps = k.line_segment(dr, 0, 1)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -59, -44)\n",
    "    \n",
    "    amps += np.random.randn(*amps.shape) * 0.5\n",
    "    vln1.add_phrase(Phrase(pitches, amps))\n",
    "    \n",
    "    breathe_p = k.constant(1 + i, pitches[-1])\n",
    "    vib = k.sinusoid(1+i, 4, 0, 0.125) * (k.phasor(1+i, 1/(1+i)) ** 2)\n",
    "    breathe_p += vib\n",
    "    if i == 2:\n",
    "        breath_amp = (1 - k.phasor(1+i, 1/(1+i)))\n",
    "        breath_amp = k.rescale(breath_amp, -58, -46)\n",
    "        breath_amp[-1] = breath_amp[-2]\n",
    "    else:\n",
    "        breath_amp = k.line_segment(1+i, 0, 1) * 9 - 55\n",
    "    \n",
    "    breath_amp += np.random.randn(*breath_amp.shape) * 0.5\n",
    "    vln1.add_phrase(Phrase(breathe_p, breath_amp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7832e574",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln1.show()\n",
    "# vln1.play()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31b07491",
   "metadata": {},
   "outputs": [],
   "source": [
    "vln2 = Part('Vln. 2', 'violin')\n",
    "for i, dr in enumerate([2, 4, 8]):\n",
    "    seed_d = k.to_delta(seed_a * dr)\n",
    "    pitches, durs = k.fractal_bpc_floor(seed_p[::-1], np.roll(seed_d, 1), i)\n",
    "    pitches = np.pad(pitches, (0, k.time_to_step(dr) - len(pitches)), constant_values=pitches[-1])\n",
    "    pitches = (pitches - min(pitches)) / (max(pitches) - min(pitches))\n",
    "    pitches = k.rescale(pitches, 61, 61+12)\n",
    "    pitches = k.autotune(pitches, 0.95)\n",
    "    pitches += k.sinusoid(dr, 4, 0, 0.125)\n",
    "    \n",
    "    if i < 2:\n",
    "        amp_segments = []\n",
    "        for d in durs:\n",
    "            aa = k.triangle(d, 1/d, 1e-7)\n",
    "            aa = np.pad(aa, (0, k.time_to_step(d) - len(aa)), constant_values=aa[-1])\n",
    "            amp_segments.append(aa)\n",
    "        amps = np.concatenate(amp_segments)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -55, -44)\n",
    "        amps += k.line_segment(dr, -12, 4)\n",
    "    else:\n",
    "        amps = k.line_segment(dr, 0, 1)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -59, -44)\n",
    "    \n",
    "    amps += np.random.randn(*amps.shape) * 0.5\n",
    "    vln2.add_phrase(Phrase(pitches, amps))\n",
    "    \n",
    "    breathe_p = k.constant(1 + i, pitches[-1])\n",
    "    vib = k.sinusoid(1+i, 4, 0, 0.125) * (k.phasor(1+i, 1/(1+i)) ** 2)\n",
    "    breathe_p += vib\n",
    "    if i == 2:\n",
    "        breath_amp = (1 - k.phasor(1+i, 1/(1+i)))\n",
    "        breath_amp = k.rescale(breath_amp, -58, -46)\n",
    "        breath_amp[-1] = breath_amp[-2]\n",
    "    else:\n",
    "        breath_amp = k.phasor(1+i, 1/(1+i)) * 9 - 55\n",
    "    \n",
    "    breath_amp += np.random.randn(*breath_amp.shape) * 0.5\n",
    "    vln2.add_phrase(Phrase(breathe_p, breath_amp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9bf1da30",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln2.show()\n",
    "# vln2.play()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e9189ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "volume = -4\n",
    "\n",
    "vlc = Part('Vlc', 'cello')\n",
    "for i, dr in enumerate([2, 4, 8]):\n",
    "    seed_d = k.to_delta(seed_a * dr)\n",
    "    pitches, durs = k.fractal_bpc_floor(seed_p, seed_d, i)\n",
    "    pitches = np.pad(pitches, (0, k.time_to_step(dr) - len(pitches)), constant_values=pitches[-1])\n",
    "    pitches = (pitches - min(pitches)) / (max(pitches) - min(pitches))\n",
    "    pitches = k.rescale(pitches, 42, 42+12)\n",
    "    pitches = k.autotune(pitches, 0.95)\n",
    "    pitches += k.sinusoid(dr, 4, 0, 0.125)\n",
    "    \n",
    "    if i < 2:\n",
    "        amps = np.concatenate([k.triangle(d, 1/d, 0.01) for d in durs])\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -55, -44)\n",
    "        amps += k.line_segment(dr, -8, 4)\n",
    "    else:\n",
    "        amps = k.line_segment(dr, 0, 1)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -59, -44)\n",
    "    \n",
    "    amps += volume\n",
    "    amps += np.random.randn(*amps.shape) * 0.5\n",
    "    vlc.add_phrase(Phrase(pitches, amps))\n",
    "    \n",
    "    breathe_p = k.constant(1 + i, pitches[-1])\n",
    "    vib = k.sinusoid(1+i, 4, 0, 0.125) * (k.phasor(1+i, 1/(1+i)) ** 2)\n",
    "    breathe_p += vib\n",
    "    \n",
    "    if i == 2:\n",
    "        breath_amp = (1 - k.phasor(1+i, 1/(1+i))) * 9 - 55\n",
    "        breath_amp = k.rescale(breath_amp, -59, -46)\n",
    "        breath_amp[-1] = breath_amp[-2]\n",
    "    else:\n",
    "        breath_amp = k.phasor(1+i, 1/(1+i)) * 9 - 55\n",
    "    \n",
    "    breath_amp += volume\n",
    "    breath_amp += np.random.randn(*breath_amp.shape) * 0.5\n",
    "    vlc.add_phrase(Phrase(breathe_p, breath_amp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8ee00e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vlc.show()\n",
    "# vlc.play()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66c7a477",
   "metadata": {},
   "outputs": [],
   "source": [
    "volume = 4\n",
    "\n",
    "vla = Part('Vla', 'viola')\n",
    "for i, dr in enumerate([2, 4, 8]):\n",
    "    seed_d = k.to_delta(seed_a * dr)\n",
    "    pitches, durs = k.fractal_bpc_floor(seed_p[::-1], np.roll(seed_d, 1), i)\n",
    "    pitches = np.pad(pitches, (0, k.time_to_step(dr) - len(pitches)), constant_values=pitches[-1])\n",
    "    pitches = (pitches - min(pitches)) / (max(pitches) - min(pitches))\n",
    "    pitches = k.rescale(pitches, 49, 49+12)\n",
    "    # pitches = k.autotune(pitches, 0.95, list(np.random.randint(0, 11, 5)))\n",
    "    pitches = k.autotune(pitches, 0.95)\n",
    "    pitches += k.sinusoid(dr, 4, 0, 0.125)\n",
    "    \n",
    "    if i < 2:\n",
    "        # amps = k.sinusoid(dr, 2/dr, -43.36, 5.23/2)\n",
    "        amps = np.concatenate([k.triangle(d, 1/d, 0.01) for d in durs])\n",
    "        # amps += np.random.normal(0, .5, len(amps))\n",
    "        # amps = k.to_db_loudness(amps, 'violin', min_loudness=-0.1)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -55, -44)\n",
    "        amps += k.line_segment(dr, -8, 4)\n",
    "        amps = k.rescale(amps, -60, -48)\n",
    "    else:\n",
    "        amps = k.line_segment(dr, 0, 1)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -60, -48)\n",
    "    \n",
    "    amps += volume\n",
    "    amps += np.random.randn(*amps.shape) * 0.5\n",
    "    vla.add_phrase(Phrase(pitches, amps))\n",
    "    \n",
    "    breathe_p = k.constant(1 + i, pitches[-1])\n",
    "    vib = k.sinusoid(1+i, 4, 0, 0.125) * (k.phasor(1+i, 1/(1+i)) ** 2)\n",
    "    breathe_p += vib\n",
    "    \n",
    "    if i == 2:\n",
    "        breath_amp = (1 - k.phasor(1+i, 1/(1+i))) * 9 - 55\n",
    "        breath_amp = k.rescale(breath_amp, -66, -47)\n",
    "        breath_amp[-1] = breath_amp[-2]\n",
    "    else:\n",
    "        breath_amp = k.phasor(1+i, 1/(1+i)) * 9 - 55\n",
    "        breath_amp = k.rescale(breath_amp, -55, -47)\n",
    "\n",
    "    breath_amp += volume\n",
    "    breath_amp += np.random.randn(*breath_amp.shape) * 0.5\n",
    "    vla.add_phrase(Phrase(breathe_p, breath_amp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4c04782",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vla.show()\n",
    "# vla.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fef19e81",
   "metadata": {},
   "source": [
    "# Fractal I-II (F♯ - B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a40be809",
   "metadata": {},
   "outputs": [],
   "source": [
    "flt1 = Part('Flt. 1', 'flute')\n",
    "silence = Phrase(k.constant(17, 66), k.constant(17, -120))\n",
    "flt1.add_phrase(silence)\n",
    "for i, dr in enumerate([1, 2, 4]):\n",
    "    seed_d = k.to_delta(seed_a * dr)\n",
    "    pitches, durs = k.fractal_bpc_floor(np.roll(seed_p, 1), np.roll(seed_d, 2), i)\n",
    "    pitches = np.pad(pitches, (0, k.time_to_step(dr) - len(pitches)), constant_values=pitches[-1])\n",
    "    pitches = (pitches - min(pitches)) / (max(pitches) - min(pitches))\n",
    "    pitches = k.rescale(pitches, 71, 71+12)\n",
    "    # pitches = k.autotune(pitches, 0.95, list(np.random.randint(0, 11, 5)))\n",
    "    pitches = k.autotune(pitches, 0.95)\n",
    "    pitches += k.sinusoid(dr, 4, 0, 0.125)\n",
    "\n",
    "    # amps = k.sinusoid(dr, 2/dr, -43.36, 5.23/2)\n",
    "    amps = np.concatenate([k.triangle(d, 1/d, 0.01) for d in durs])\n",
    "    # amps += np.random.normal(0, .5, len(amps))\n",
    "    # amps = k.to_db_loudness(amps, 'violin', min_loudness=-0.1)\n",
    "    amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "    amps = k.rescale(amps, -55, -54)\n",
    "    amps += k.line_segment(dr, 0, 6)\n",
    "    \n",
    "    amps += np.random.randn(*amps.shape) * 0.2\n",
    "    flt1.add_phrase(Phrase(pitches, amps))\n",
    "    flt1.add_phrase(Phrase(pitches[::-1], amps))\n",
    "    \n",
    "    if i == 2:\n",
    "        i = 3\n",
    "    breathe_p = k.constant(1 + i, pitches[-1])\n",
    "    vib = k.sinusoid(1+i, 4, 0, 0.125) * (k.phasor(1+i, 1/(1+i)) ** 2)\n",
    "    breathe_p += vib\n",
    "    breath_amp = k.phasor(1+i, 1/(1+i)) * 9 - 55\n",
    "    \n",
    "    breath_amp += np.random.randn(*breath_amp.shape) * 0.2\n",
    "    flt1.add_phrase(Phrase(breathe_p, breath_amp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c837651e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# flt1.show(17)\n",
    "# flt1.play(17)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f492ca3",
   "metadata": {},
   "outputs": [],
   "source": [
    "flt2 = Part('Flt. 2', 'flute2')\n",
    "silence = Phrase(k.constant(17, 66), k.constant(17, -120))\n",
    "flt2.add_phrase(silence)\n",
    "for i, dr in enumerate([1, 2, 4]):\n",
    "    seed_d = k.to_delta(seed_a * dr)\n",
    "    pitches, durs = k.fractal_bpc_floor(np.roll(seed_p, 2), np.roll(seed_d, 3), i)\n",
    "    pitches = np.pad(pitches, (0, k.time_to_step(dr) - len(pitches)), constant_values=pitches[-1])\n",
    "    pitches = (pitches - min(pitches)) / (max(pitches) - min(pitches))\n",
    "    pitches = k.rescale(pitches, 66, 66+12)\n",
    "    # pitches = k.autotune(pitches, 0.95, list(np.random.randint(0, 11, 5)))\n",
    "    pitches = k.autotune(pitches, 0.95)\n",
    "    pitches += k.sinusoid(dr, 4, 0, 0.125)\n",
    "\n",
    "    # amps = k.sinusoid(dr, 2/dr, -43.36, 5.23/2)\n",
    "    amps = np.concatenate([k.triangle(d, 1/d, 0.01) for d in durs])\n",
    "    # amps += np.random.normal(0, .5, len(amps))\n",
    "    # amps = k.to_db_loudness(amps, 'violin', min_loudness=-0.1)\n",
    "    amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "    amps = k.rescale(amps, -58, -57)\n",
    "    amps += k.line_segment(dr, 0, 6)\n",
    "    \n",
    "    amps += np.random.randn(*amps.shape) * 0.2\n",
    "    flt2.add_phrase(Phrase(pitches, amps))\n",
    "    flt2.add_phrase(Phrase(pitches[::-1], amps))\n",
    "    \n",
    "    if i == 2:\n",
    "        i = 3\n",
    "    breathe_p = k.constant(1 + i, pitches[-1])\n",
    "    vib = k.sinusoid(1+i, 4, 0, 0.125) * (k.phasor(1+i, 1/(1+i)) ** 2)\n",
    "    breathe_p += vib\n",
    "    breath_amp = k.phasor(1+i, 1/(1+i)) * 9 - 55\n",
    "    \n",
    "    breath_amp += np.random.randn(*breath_amp.shape) * 0.2\n",
    "    flt2.add_phrase(Phrase(breathe_p, breath_amp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "728f1d16",
   "metadata": {},
   "outputs": [],
   "source": [
    "# flt2.show(17)\n",
    "# flt2.play(17)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06297e1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# silence, self, retro, chord, self, retro, chord\n",
    "# skip slience, first self, first retro\n",
    "_, idx = np.unique(flt1.phrases[4].pitch.round(), return_index=True)\n",
    "chord = flt1.phrases[4].pitch.round()[np.sort(idx)]\n",
    "for idx in range(7):\n",
    "    dur = 2\n",
    "    pitches = k.constant(dur, chord[(2*idx)%len(chord)])\n",
    "    attack = k.triangle(dur, 1/dur, ratio=0.01)\n",
    "#     silence = k.constant(dur/2, 0)\n",
    "#     amps = np.concatenate([attack, silence])\n",
    "    amps = k.rescale(attack, -90, -42)\n",
    "    if idx == 2:\n",
    "        amps = k.line_segment(dur, -58, -46)\n",
    "    \n",
    "    phrase = Phrase(pitches, amps)\n",
    "    vln1.add_phrase(phrase)\n",
    "\n",
    "amps = k.line_segment(4, -58, -42)\n",
    "pitches = k.constant(4, chord[(2*(idx+1))%len(chord)])\n",
    "phrase = Phrase(pitches, amps)\n",
    "vln1.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1fc8ecea",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln1.show(17)\n",
    "# vln1.play(17)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4465e355",
   "metadata": {},
   "outputs": [],
   "source": [
    "# silence, self, retro, chord, self, retro, chord\n",
    "# skip slience, first self, first retro\n",
    "_, idx = np.unique(flt1.phrases[4].pitch.round(), return_index=True)\n",
    "chord = flt1.phrases[4].pitch.round()[np.sort(idx)]\n",
    "for idx in range(7):\n",
    "    dur = 2\n",
    "    pitches = k.constant(dur, chord[(3*idx + 1)%len(chord)])\n",
    "    attack = k.triangle(dur, 1/dur, ratio=0.01)\n",
    "#     silence = k.constant(dur/2, 0)\n",
    "#     amps = np.concatenate([attack, silence])\n",
    "    amps = k.rescale(attack, -90, -42)\n",
    "    if idx == 2:\n",
    "        amps = k.line_segment(dur, -58, -46)\n",
    "    \n",
    "    phrase = Phrase(pitches, amps)\n",
    "    vln2.add_phrase(phrase)\n",
    "\n",
    "amps = k.line_segment(4, -58, -42)\n",
    "pitches = k.constant(4, chord[(3*(idx + 1) + 1)%len(chord)])\n",
    "phrase = Phrase(pitches, amps)\n",
    "vln2.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70910867",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln2.show(17)\n",
    "# vln2.play(17)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea1449bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# silence, self, retro, chord, self, retro, chord\n",
    "# skip slience, first self, first retro\n",
    "_, idx = np.unique(flt1.phrases[4].pitch.round(), return_index=True)\n",
    "chord = flt1.phrases[4].pitch.round()[np.sort(idx)]\n",
    "for idx in range(7):\n",
    "    dur = 2\n",
    "    pitches = k.constant(dur, chord[(5*idx + 2)%len(chord)] - 24)\n",
    "    pitches[pitches < 48] += 12\n",
    "    attack = k.triangle(dur, 1/dur, ratio=0.01)\n",
    "#     silence = k.constant(dur/2, 0)\n",
    "#     amps = np.concatenate([attack, silence])\n",
    "    amps = k.rescale(attack, -90, -38)\n",
    "    if idx == 2:\n",
    "        amps = k.line_segment(dur, -58, -42)\n",
    "    \n",
    "    phrase = Phrase(pitches, amps)\n",
    "    vla.add_phrase(phrase)\n",
    "\n",
    "amps = k.line_segment(4, -58, -42)\n",
    "pitches = k.constant(4, chord[(5*(idx+1) + 2)%len(chord)] - 24)\n",
    "pitches[pitches < 48] += 12\n",
    "phrase = Phrase(pitches, amps)\n",
    "vla.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b9ae409",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vla.show(17)\n",
    "# vla.play(17)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "364bbdcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# silence, self, retro, chord, self, retro, chord\n",
    "# skip slience, first self, first retro\n",
    "_, idx = np.unique(flt1.phrases[4].pitch.round(), return_index=True)\n",
    "chord = flt1.phrases[4].pitch.round()[np.sort(idx)]\n",
    "for idx in range(7):\n",
    "    dur = 2\n",
    "    pitches = k.constant(dur, chord[(3*idx + 3)%len(chord)] - 36)\n",
    "    pitches[pitches < 36] += 12\n",
    "    attack = k.triangle(dur, 1/dur, ratio=0.01)\n",
    "#     silence = k.constant(dur/2, 0)\n",
    "#     amps = np.concatenate([attack, silence])\n",
    "    amps = k.rescale(attack, -90, -38)\n",
    "    if idx == 2:\n",
    "        amps = k.line_segment(dur, -58, -42)\n",
    "    \n",
    "    phrase = Phrase(pitches, amps)\n",
    "    vlc.add_phrase(phrase)\n",
    "\n",
    "amps = k.line_segment(4, -58, -42)\n",
    "pitches = k.constant(4, chord[(3*(idx+1) + 3)%len(chord)] - 36)\n",
    "pitches[pitches < 36] += 12\n",
    "phrase = Phrase(pitches, amps)\n",
    "vlc.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf80d372",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vlc.show(17)\n",
    "# vlc.play(17)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d0cfc5f",
   "metadata": {},
   "source": [
    "# Fractal II (B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2ebbd35",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_seed = np.array([0.0, 0.7, 0.3, 1.0])\n",
    "new_seed2 = np.array([0.0, 0.8, 0.4, 1.0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21ee73d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# -55 -49\n",
    "# 10 pitches\n",
    "n_steps = 10*4\n",
    "pitches = k.fractal(new_seed[::-1], 1)\n",
    "pitches = np.tile(pitches, 1 + n_steps//len(pitches))[:n_steps]\n",
    "durs = fib(len(pitches))\n",
    "durations = durs * 0.06\n",
    "dur = sum(durations)\n",
    "silence_dur = sum(durations)\n",
    "pitches = k.figure(pitches, durations)\n",
    "pitches = k.rescale(pitches, 66, 66+24)\n",
    "pitches = k.pad_to_dur(pitches, dur)\n",
    "\n",
    "amps = k.line_segment(dur, -49, -55)\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "flt1.add_phrase(phrase)\n",
    "\n",
    "n_steps = 82\n",
    "pitches = k.fractal(new_seed[::-1], 1)\n",
    "pitches = np.tile(pitches, 1 + n_steps//len(pitches))[:n_steps]\n",
    "durs = fib(len(pitches))\n",
    "durations = durs * 0.06\n",
    "dur = sum(durations)\n",
    "pitches = k.figure(pitches, durations)\n",
    "pitches = k.rescale(pitches, 66, 66+24)\n",
    "pitches = k.pad_to_dur(pitches, dur)\n",
    "\n",
    "amps = k.constant(dur, -57)\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "flt1.add_phrase(phrase)\n",
    "\n",
    "n_steps = 28*2\n",
    "pitches = k.fractal(new_seed2[::-1], 2)\n",
    "pitches = np.tile(pitches, 1 + n_steps//len(pitches))[:n_steps]\n",
    "durs = fib(len(pitches))\n",
    "durations = durs * 0.06\n",
    "dur = sum(durations)\n",
    "silence_dur2 = sum(durations)\n",
    "pitches = k.figure(pitches, durations)\n",
    "pitches = k.rescale(pitches, 64, 64+24)\n",
    "pitches = k.pad_to_dur(pitches, dur)\n",
    "\n",
    "amps = k.line_segment(dur, -49, -55)\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "flt1.add_phrase(phrase)\n",
    "\n",
    "n_steps = 82\n",
    "pitches = k.fractal(new_seed2[::-1], 1)\n",
    "pitches = np.tile(pitches, 1 + n_steps//len(pitches))[:n_steps]\n",
    "durs = fib(len(pitches))\n",
    "durations = durs * 0.06\n",
    "dur = sum(durations)\n",
    "\n",
    "last_flt1_pitches = k.rescale(pitches, 64, 64+24)[-10:]\n",
    "\n",
    "pitches = k.figure(pitches, durations)\n",
    "pitches = k.rescale(pitches, 64, 64+24)\n",
    "pitches = k.pad_to_dur(pitches, dur)\n",
    "\n",
    "amps = k.constant(dur, -57)\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "flt1.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "242e8db3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# flt1.show(38)\n",
    "# flt1.play(38)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e099fc23",
   "metadata": {},
   "outputs": [],
   "source": [
    "# -51 -58\n",
    "# 10 pitches\n",
    "n_steps = 10 * 4\n",
    "pitches = k.fractal(new_seed, 1)\n",
    "pitches = np.tile(pitches, 1 + n_steps//len(pitches))[:n_steps]\n",
    "durs = fib(len(pitches))\n",
    "durs = np.roll(durs, 1)\n",
    "durations = durs * 0.06\n",
    "dur = sum(durations)\n",
    "pitches = k.figure(pitches, durations)\n",
    "pitches = k.rescale(pitches, 68, 68+24)\n",
    "\n",
    "amps = k.line_segment(dur, -51, -58)\n",
    "\n",
    "pitches = k.pad_to_dur(pitches, dur)\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "flt2.add_phrase(phrase)\n",
    "\n",
    "n_steps = 82\n",
    "pitches = k.fractal(new_seed, 1)\n",
    "pitches = np.tile(pitches, 1 + n_steps//len(pitches))[:n_steps]\n",
    "durs = fib(len(pitches))\n",
    "durs = np.roll(durs, 1)\n",
    "durations = durs * 0.06\n",
    "dur = sum(durations)\n",
    "pitches = k.figure(pitches, durations)\n",
    "pitches = k.rescale(pitches, 68, 68+24)\n",
    "\n",
    "amps = k.constant(dur, -60)\n",
    "\n",
    "pitches = k.pad_to_dur(pitches, dur)\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "flt2.add_phrase(phrase)\n",
    "\n",
    "n_steps = 28 * 2\n",
    "pitches = k.fractal(new_seed2, 2)\n",
    "pitches = np.tile(pitches, 1 + n_steps//len(pitches))[:n_steps]\n",
    "durs = fib(len(pitches))\n",
    "durs = np.roll(durs, 1)\n",
    "durations = durs * 0.06\n",
    "dur = sum(durations)\n",
    "pitches = k.figure(pitches, durations)\n",
    "pitches = k.rescale(pitches, 70, 70+24)\n",
    "\n",
    "amps = k.line_segment(dur, -51, -58)\n",
    "\n",
    "pitches = k.pad_to_dur(pitches, dur)\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "flt2.add_phrase(phrase)\n",
    "\n",
    "n_steps = 82\n",
    "pitches = k.fractal(new_seed2, 1)\n",
    "pitches = np.tile(pitches, 1 + n_steps//len(pitches))[:n_steps]\n",
    "durs = fib(len(pitches))\n",
    "durs = np.roll(durs, 1)\n",
    "durations = durs * 0.06\n",
    "dur = sum(durations)\n",
    "\n",
    "last_flt2_pitches = k.rescale(pitches, 70, 70+24)[-10:]\n",
    "\n",
    "pitches = k.figure(pitches, durations)\n",
    "pitches = k.rescale(pitches, 70, 70+24)\n",
    "\n",
    "amps = k.constant(dur, -60)\n",
    "\n",
    "pitches = k.pad_to_dur(pitches, dur)\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "flt2.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d8bb9f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# flt2.show(38)\n",
    "# flt2.play(38)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc7add3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "silence_steps = int(silence_dur*k.SECOND)\n",
    "# part.add_phrase(Phrase(np.zeros(silence_steps)+55, np.zeros(silence_steps)-100))\n",
    "pitches = k.constant(silence_dur, np.round(vln1.phrases[-1].pitch[-1]))\n",
    "amps = k.triangle(silence_dur, 4/silence_dur, 0.05, -90, -44)\n",
    "vln1.add_phrase(Phrase(pitches, amps))\n",
    "\n",
    "# 82 pitches\n",
    "pitches = k.fractal(new_seed, 3)\n",
    "durs = fib(len(pitches))\n",
    "durations = durs * 0.06\n",
    "dur = sum(durations)\n",
    "pitches = k.figure(pitches, durations)\n",
    "pitches = k.rescale(pitches, 55, 55+24)\n",
    "pitches = k.pad_to_dur(pitches, dur)\n",
    "\n",
    "amps = k.constant(dur, -44)\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "vln1.add_phrase(phrase)\n",
    "\n",
    "silence_steps = int(silence_dur2*k.SECOND)\n",
    "# part.add_phrase(Phrase(np.zeros(silence_steps)+55, np.zeros(silence_steps)-100))\n",
    "pitches = k.constant(silence_dur2, np.round(vln1.phrases[-1].pitch[-1]))\n",
    "amps = k.triangle(silence_dur2, 2/silence_dur2, 0.05, -90, -44)\n",
    "vln1.add_phrase(Phrase(pitches, amps))\n",
    "\n",
    "# 82 pitches\n",
    "new_seed = np.array([0.0, 0.7, 0.3, 1.0])\n",
    "pitches = k.fractal(new_seed2, 3)\n",
    "durs = fib(len(pitches))\n",
    "durations = durs * 0.06\n",
    "dur = sum(durations)\n",
    "\n",
    "last_vln1_pitches = k.rescale(pitches, 57, 57+24)[-10:]\n",
    "\n",
    "pitches = k.figure(pitches, durations)\n",
    "pitches = k.rescale(pitches, 57, 57+24)\n",
    "pitches = k.pad_to_dur(pitches, dur)\n",
    "\n",
    "amps = k.constant(dur, -44)\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "vln1.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "867676bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln1.show(38)\n",
    "# vln1.play(38)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4fba8942",
   "metadata": {},
   "outputs": [],
   "source": [
    "silence_steps = int(silence_dur*k.SECOND)\n",
    "# part2.add_phrase(Phrase(np.zeros(silence_steps)+55, np.zeros(silence_steps)-100))\n",
    "pitches = k.constant(silence_dur, np.round(vln2.phrases[-1].pitch[-1]))\n",
    "amps = k.triangle(silence_dur, 4/silence_dur, 0.2, -90, -44)\n",
    "vln2.add_phrase(Phrase(pitches, amps))\n",
    "\n",
    "# 82 pitches\n",
    "pitches = k.fractal(new_seed[::-1], 3)\n",
    "durs = fib(len(pitches))\n",
    "durs = np.roll(durs, 1)\n",
    "durations = durs * 0.06\n",
    "dur = sum(durations)\n",
    "pitches = k.figure(pitches, durations)\n",
    "pitches = k.rescale(pitches, 60, 60+24)\n",
    "\n",
    "amps = k.constant(dur, -44)\n",
    "\n",
    "pitches = k.pad_to_dur(pitches, dur)\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "vln2.add_phrase(phrase)\n",
    "\n",
    "silence_steps = int(silence_dur2*k.SECOND)\n",
    "# part2.add_phrase(Phrase(np.zeros(silence_steps)+55, np.zeros(silence_steps)-100))\n",
    "pitches = k.constant(silence_dur2, np.round(vln2.phrases[-1].pitch[-1]))\n",
    "amps = k.triangle(silence_dur2, 2/silence_dur2, 0.2, -90, -44)\n",
    "vln2.add_phrase(Phrase(pitches, amps))\n",
    "\n",
    "# 82 pitches\n",
    "pitches = k.fractal(new_seed2[::-1], 3)\n",
    "durs = fib(len(pitches))\n",
    "durs = np.roll(durs, 1)\n",
    "durations = durs * 0.06\n",
    "dur = sum(durations)\n",
    "\n",
    "last_vln2_pitches = k.rescale(pitches, 62, 62+24)[-10:]\n",
    "\n",
    "pitches = k.figure(pitches, durations)\n",
    "pitches = k.rescale(pitches, 62, 62+24)\n",
    "\n",
    "amps = k.constant(dur, -44)\n",
    "\n",
    "pitches = k.pad_to_dur(pitches, dur)\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "vln2.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e144fd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln2.show(38)\n",
    "# vln2.play(38)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ec6a93c",
   "metadata": {},
   "outputs": [],
   "source": [
    "fill_with_silence(vla, len(vln1) - len(vla))\n",
    "fill_with_silence(vlc, len(vln1) - len(vlc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03700f0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "for p in (last_flt1_pitches, last_flt2_pitches, last_vln1_pitches, last_vln2_pitches):\n",
    "    print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec57abf1",
   "metadata": {},
   "source": [
    "# Transition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4d4e00a",
   "metadata": {},
   "outputs": [],
   "source": [
    "n_repeat = 32\n",
    "pitches = n_repeat * [last_flt1_pitches[1], last_flt1_pitches[3]]\n",
    "durs = fib(n_repeat) * 0.06\n",
    "pitches = k.figure(pitches, durations)\n",
    "\n",
    "amps = n_repeat * [-48, -50]\n",
    "amps = k.figure(amps, durations)\n",
    "amps += np.linspace(0, -24, len(amps))\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "flt1.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f43ffed5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# flt1.show(63.312)\n",
    "# flt1.play(63.312)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c70cb0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "n_repeat = 32\n",
    "pitches = n_repeat * [last_flt2_pitches[2], last_flt2_pitches[4]]\n",
    "durs = fib(n_repeat) * 0.06\n",
    "pitches = k.figure(pitches, durations)\n",
    "\n",
    "amps = n_repeat * [-48, -50]\n",
    "amps = k.figure(amps, durations)\n",
    "amps += np.linspace(0, -24, len(amps))\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "flt2.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88b7f960",
   "metadata": {},
   "outputs": [],
   "source": [
    "# flt2.show(63.312)\n",
    "# flt2.play(63.312)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f37d1917",
   "metadata": {},
   "outputs": [],
   "source": [
    "n_repeat = 32\n",
    "pitches = n_repeat * [last_vln1_pitches[3], last_vln1_pitches[5]]\n",
    "durs = fib(n_repeat) * 0.06\n",
    "pitches = k.figure(pitches, durations)\n",
    "\n",
    "amps = n_repeat * [-48, -50]\n",
    "amps = k.figure(amps, durations)\n",
    "amps += np.linspace(0, -24, len(amps))\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "vln1.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bbd78c2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln1.show(63.312)\n",
    "# vln1.play(63.312)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72456629",
   "metadata": {},
   "outputs": [],
   "source": [
    "n_repeat = 32\n",
    "pitches = n_repeat * [last_vln2_pitches[4], last_vln2_pitches[6]]\n",
    "durs = fib(n_repeat) * 0.06\n",
    "pitches = k.figure(pitches, durations)\n",
    "\n",
    "amps = n_repeat * [-48, -50]\n",
    "amps = k.figure(amps, durations)\n",
    "amps += np.linspace(0, -24, len(amps))\n",
    "\n",
    "phrase = Phrase(pitches, amps)\n",
    "vln2.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f433b4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln2.show(63.312)\n",
    "# vln2.play(63.312)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4a0ec9a",
   "metadata": {},
   "source": [
    "# Harmonics I (C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3971ba98",
   "metadata": {},
   "outputs": [],
   "source": [
    "higher_harms = k.harmonics_to_pitches(36, [2, 11, 13, 15, 17, 19, 21, 23, 25, 27])[1:]\n",
    "stretched_higher_harms = k.harmonics_to_pitches(36, [n ** 1.02 for n in [2, 11, 13, 15, 17, 19, 21, 23, 25, 27]])[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe0bd229",
   "metadata": {},
   "outputs": [],
   "source": [
    "p1, p2 = higher_harms[0], stretched_higher_harms[0]\n",
    "\n",
    "pitch = np.concatenate([\n",
    "    k.constant(4, p1) + k.sinusoid(4, 2, amp=k.line_segment(4, 0.3, 0), phase=np.random.uniform(0, 1)),\n",
    "    k.line_segment(6, p1, p2),\n",
    "    k.constant(2, p2) + np.concatenate([\n",
    "        k.sinusoid(1, 2, amp=k.line_segment(1, 0, 0.3), phase=np.random.uniform(0, 1)),\n",
    "        k.sinusoid(1, 2, amp=k.line_segment(1, 0.3, 0), phase=np.random.uniform(0, 1))\n",
    "    ]),\n",
    "    k.line_segment(4, p2, p1),\n",
    "    k.constant(6, p1) + np.concatenate([\n",
    "        k.sinusoid(3, 2, amp=k.line_segment(3, 0, 0.3), phase=np.random.uniform(0, 1)),\n",
    "        k.sinusoid(3, 2, amp=k.line_segment(3, 0.3, 0), phase=np.random.uniform(0, 1))\n",
    "    ]),\n",
    "    k.line_segment(6, p1, p2),\n",
    "    k.constant(4, p2) + np.concatenate([\n",
    "        k.sinusoid(2, 2, amp=k.line_segment(2, 0, 0.3), phase=np.random.uniform(0, 1)),\n",
    "        k.sinusoid(2, 2, amp=k.line_segment(2, 0.3, 0), phase=np.random.uniform(0, 1))\n",
    "    ]),\n",
    "    k.line_segment(8, p2, p1),\n",
    "    k.constant(4, p1) + k.sinusoid(4, 2, amp=k.line_segment(4, 0, 0.3), phase=np.random.uniform(0, 1)),\n",
    "])\n",
    "\n",
    "loudness = np.concatenate([\n",
    "    k.constant(4, 0.01),\n",
    "    k.line_segment(12, 0.01, 0.2),\n",
    "    k.line_segment(12, 0.2, 0.05),\n",
    "    k.line_segment(12, 0.05, 0.9),\n",
    "    k.constant(4, 0.9)\n",
    "])\n",
    "loudness *= 10.\n",
    "loudness += k.sweeping_triangle(44, 0.05, 4.25, 0.1, highest=8, phase=0.5)\n",
    "loudness += np.random.randn(*loudness.shape) * 0.05\n",
    "\n",
    "loudness[:k.SECOND//10] = k.line_segment(1/10, 0, loudness[-k.SECOND//10])\n",
    "loudness[-k.SECOND//10:] = k.line_segment(1/10, loudness[k.SECOND//10], 0)\n",
    "\n",
    "loudness = k.to_db_loudness(loudness, 'viola', -2, 0.)\n",
    "loudness = np.clip(loudness, -np.inf, -30)\n",
    "# loudness -= 6\n",
    "\n",
    "phrase = Phrase(pitch, loudness)\n",
    "vla.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d12b8a5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vla.phrases[-1].show()\n",
    "# vla.phrases[-1].play('viola')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbb859cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vla.show(63.312)\n",
    "# vla.play(63.312)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f52ef1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "pitch = k.constant(44, 36)\n",
    "pitch += k.sinusoid(44, 4, 0, 0.125)\n",
    "\n",
    "loudness = k.line_segment(44, 0.01, 200)\n",
    "loudness += k.sweeping_triangle(44, 0.2, 4, ratio=0.1, lowest=0, highest=75)\n",
    "loudness[-8*k.SECOND:] = k.line_segment(8, 1, 0)**2 * 50\n",
    "loudness[-k.SECOND//10:] = k.line_segment(1/10, loudness[-k.SECOND//10], 0)\n",
    "loudness[:k.SECOND//10] = k.line_segment(1/10, 0, loudness[k.SECOND//10])\n",
    "\n",
    "loudness = k.to_db_loudness(loudness, 'cello', 7)\n",
    "loudness = np.clip(loudness, -np.inf, -30)\n",
    "# loudness -= 6\n",
    "\n",
    "phrase = Phrase(pitch, loudness)\n",
    "vlc.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "182961d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vlc.phrases[-1].show()\n",
    "# vlc.phrases[-1].play('cello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "862bdc97",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vlc.show(63.312)\n",
    "# vlc.play(63.312)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea772766",
   "metadata": {},
   "outputs": [],
   "source": [
    "p1, p2 = higher_harms[1], stretched_higher_harms[1]\n",
    "\n",
    "pitch = np.concatenate([\n",
    "    k.constant(4, p1) + k.sinusoid(4, 2, amp=k.line_segment(4, 0.3, 0), phase=np.random.uniform(0, 1)),\n",
    "    k.line_segment(6, p1, p2),\n",
    "    k.constant(2, p2) + np.concatenate([\n",
    "        k.sinusoid(1, 2, amp=k.line_segment(1, 0, 0.3), phase=np.random.uniform(0, 1)),\n",
    "        k.sinusoid(1, 2, amp=k.line_segment(1, 0.3, 0), phase=np.random.uniform(0, 1))\n",
    "    ]),\n",
    "    k.line_segment(4, p2, p1),\n",
    "    k.constant(6, p1) + np.concatenate([\n",
    "        k.sinusoid(3, 2, amp=k.line_segment(3, 0, 0.3), phase=np.random.uniform(0, 1)),\n",
    "        k.sinusoid(3, 2, amp=k.line_segment(3, 0.3, 0), phase=np.random.uniform(0, 1))\n",
    "    ]),\n",
    "    k.line_segment(6, p1, p2),\n",
    "    k.constant(4, p2) + np.concatenate([\n",
    "        k.sinusoid(2, 2, amp=k.line_segment(2, 0, 0.3), phase=np.random.uniform(0, 1)),\n",
    "        k.sinusoid(2, 2, amp=k.line_segment(2, 0.3, 0), phase=np.random.uniform(0, 1))\n",
    "    ]),\n",
    "    k.line_segment(8, p2, p1),\n",
    "    k.constant(4, p1) + k.sinusoid(4, 2, amp=k.line_segment(4, 0, 0.3), phase=np.random.uniform(0, 1)),\n",
    "])\n",
    "\n",
    "pitch[:4*k.SECOND] += k.sinusoid(4, 2, amp=k.line_segment(4, 0.3, 0), phase=np.random.uniform(0, 1))\n",
    "pitch[-4*k.SECOND:] += k.sinusoid(4, 2, amp=k.line_segment(4, 0, 0.3), phase=np.random.uniform(0, 1))\n",
    "\n",
    "loudness = np.concatenate([\n",
    "    k.constant(4, 0.0),\n",
    "    k.line_segment(12, 0.0, 0.2),\n",
    "    k.line_segment(12, 0.2, 0.05),\n",
    "    k.line_segment(12, 0.05, 0.9),\n",
    "    k.line_segment(2, 0.9, 0.),\n",
    "    k.constant(2, 0.)\n",
    "])\n",
    "loudness *= 10.\n",
    "loudness += k.sweeping_triangle(44, 0.1, 4, 0.1, highest=8, lowest=-10)\n",
    "loudness += np.random.randn(*loudness.shape) * 0.3\n",
    "loudness += k.line_segment(44, 10, 0)\n",
    "\n",
    "loudness[:k.SECOND//10] = k.line_segment(1/10, loudness.min(), loudness[-k.SECOND//10])\n",
    "loudness[-k.SECOND//10:] = k.line_segment(1/10, loudness[k.SECOND//10], loudness.min())\n",
    "\n",
    "loudness = loudness.clip(min=2.)\n",
    "loudness = k.to_db_loudness(loudness, 'violin', 8, 0.)\n",
    "\n",
    "phrase = Phrase(pitch, loudness)\n",
    "vln1.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d0568b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln1.show(69.552)\n",
    "# vln1.play(69.552)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62fb82c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "p1, p2 = higher_harms[2], stretched_higher_harms[2]\n",
    "\n",
    "pitch = np.concatenate([\n",
    "    k.constant(4, p1) + k.sinusoid(4, 2, amp=k.line_segment(4, 0.3, 0), phase=np.random.uniform(0, 1)),\n",
    "    k.line_segment(6, p1, p2),\n",
    "    k.constant(2, p2) + np.concatenate([\n",
    "        k.sinusoid(1, 2, amp=k.line_segment(1, 0, 0.3), phase=np.random.uniform(0, 1)),\n",
    "        k.sinusoid(1, 2, amp=k.line_segment(1, 0.3, 0), phase=np.random.uniform(0, 1))\n",
    "    ]),\n",
    "    k.line_segment(4, p2, p1),\n",
    "    k.constant(6, p1) + np.concatenate([\n",
    "        k.sinusoid(3, 2, amp=k.line_segment(3, 0, 0.3), phase=np.random.uniform(0, 1)),\n",
    "        k.sinusoid(3, 2, amp=k.line_segment(3, 0.3, 0), phase=np.random.uniform(0, 1))\n",
    "    ]),\n",
    "    k.line_segment(6, p1, p2),\n",
    "    k.constant(4, p2) + np.concatenate([\n",
    "        k.sinusoid(2, 2, amp=k.line_segment(2, 0, 0.3), phase=np.random.uniform(0, 1)),\n",
    "        k.sinusoid(2, 2, amp=k.line_segment(2, 0.3, 0), phase=np.random.uniform(0, 1))\n",
    "    ]),\n",
    "    k.line_segment(8, p2, p1),\n",
    "    k.constant(4, p1) + k.sinusoid(4, 2, amp=k.line_segment(4, 0, 0.3), phase=np.random.uniform(0, 1)),\n",
    "])\n",
    "\n",
    "loudness = np.concatenate([\n",
    "    k.constant(4, 0.01),\n",
    "    k.line_segment(12, 0.01, 0.2),\n",
    "    k.line_segment(12, 0.2, 0.05),\n",
    "    k.line_segment(12, 0.05, 0.9),\n",
    "    k.constant(4, 0.9)\n",
    "])\n",
    "loudness *= 10.\n",
    "loudness += k.sweeping_triangle(44, 0.15, 3.75, 0.1, highest=8, phase=0.25)\n",
    "loudness += np.random.randn(*loudness.shape) * 0.3\n",
    "\n",
    "loudness[:k.SECOND//10] = k.line_segment(1/10, 0, loudness[-k.SECOND//10])\n",
    "loudness[-k.SECOND//10:] = k.line_segment(1/10, loudness[k.SECOND//10], 0)\n",
    "\n",
    "loudness = k.to_db_loudness(loudness, 'violin', -6, 0.)\n",
    "loudness = np.clip(loudness, -np.inf, -30)\n",
    "loudness -= 4\n",
    "\n",
    "phrase = Phrase(pitch, loudness)\n",
    "vln2.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ac36821",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln2.phrases[-1].show()\n",
    "# vln2.phrases[-1].play('viola')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "527ad996",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln2.show(69.552)\n",
    "# vln2.play(69.552)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77b795f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "silence = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cee565e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "pitch = k.constant(silence, flt1.phrases[-1].pitch[-1])\n",
    "loudness = k.constant(silence, -120)\n",
    "\n",
    "phrase = Phrase(pitch, loudness)\n",
    "flt1.add_phrase(phrase)\n",
    "\n",
    "ps = np.array(higher_harms[-5:])\n",
    "\n",
    "amp = (ps[-1] - ps[0]) / 2\n",
    "center = ps[0] + amp\n",
    "\n",
    "pitch = k.sinusoid(44, (1/2)*phi, center, amp / 3)\n",
    "pitch += k.sinusoid(44, (1/3)*phi, 0, amp / 3)\n",
    "pitch += k.sinusoid(44, (1/5)*phi, 0, amp / 3)\n",
    "pitch = k.autotune_explicit(pitch, 0.9, ps)\n",
    "\n",
    "loudness = k.bpc([0, 2, 1, 1.5, 0.], [12, 24, 4, 4])\n",
    "\n",
    "loudness = k.to_db_loudness(loudness, 'flute')\n",
    "\n",
    "phrase = Phrase(pitch, loudness)\n",
    "flt1.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4872394",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 76.552\n",
    "# flt1.phrases[-1].show()\n",
    "# flt1.phrases[-1].play('flute')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12456bcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "pitch = k.constant(silence, flt2.phrases[-1].pitch[-1])\n",
    "loudness = k.constant(silence, -120)\n",
    "\n",
    "phrase = Phrase(pitch, loudness)\n",
    "flt2.add_phrase(phrase)\n",
    "\n",
    "ps = np.array(higher_harms[-9:-4])\n",
    "\n",
    "amp = (ps[-1] - ps[0]) / 2\n",
    "center = ps[0] + amp\n",
    "\n",
    "pitch = k.sinusoid(44, 1/2, center, amp / 3)\n",
    "pitch += k.sinusoid(44, 1/3, 0, amp / 3)\n",
    "pitch += k.sinusoid(44, 1/5, 0, amp / 3)\n",
    "pitch = k.autotune_explicit(pitch, 0.9, ps)\n",
    "\n",
    "loudness = k.bpc([0, 1, 0.5, 0.75, 0.], [12, 24, 4, 4])\n",
    "loudness += k.sweeping_triangle(44, 0.1, 0.5, 0.5, lowest = 0.2)\n",
    "loudness[-k.SECOND//10:] = k.line_segment(1/10, loudness[-k.SECOND//10], 0)\n",
    "loudness[:k.SECOND//10] = k.line_segment(1/10, 0, loudness[1*k.SECOND//10])\n",
    "\n",
    "loudness = k.to_db_loudness(loudness, 'flute2', 4)\n",
    "\n",
    "phrase = Phrase(pitch, loudness)\n",
    "flt2.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d8de982",
   "metadata": {},
   "outputs": [],
   "source": [
    "# flt2.phrases[-1].show()\n",
    "# flt2.phrases[-1].play('flute2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "366eeb72",
   "metadata": {},
   "outputs": [],
   "source": [
    "for p in (vln1, vln2, vla, vlc, flt1, flt2):\n",
    "    fill_with_silence(p, k.SECOND*121 - len(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e34053f",
   "metadata": {},
   "source": [
    "### Note: early entry of cello (not sure)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee7fd40e",
   "metadata": {},
   "outputs": [],
   "source": [
    "vlc.phrases[-1].loudness[-k.time_to_step(6):] = k.line_segment(6, -68, -54)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f551ffd",
   "metadata": {},
   "source": [
    "# Harmonics II (C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae684d12",
   "metadata": {},
   "outputs": [],
   "source": [
    "omegas = [(phi ** n) / 4 for n in range(6)]\n",
    "adsr = np.array([0.1, 0.3, 0.4, 0.2])\n",
    "cello_dur = 8/phi\n",
    "first_stretch = k.time_to_step(26)\n",
    "second_stretch = k.time_to_step(38)\n",
    "third_stretch = k.time_to_step(44)\n",
    "emphasis = (-8, 8)\n",
    "breathe = (-8, 0)\n",
    "dur = 60\n",
    "stop = 58\n",
    "\n",
    "for idx, (w, p) in enumerate(zip(omegas, [vlc, vla, flt1, flt2, vln1, vln2])):\n",
    "    # base pitches\n",
    "    n_harm = 2 * idx + 1\n",
    "    pitch = k.constant(dur, get_harm(n_harm))\n",
    "    \n",
    "    # base amplitudes\n",
    "    # TODO: there are audio artifacts if both attack and decay are close to zero\n",
    "    amp = np.concatenate([k.rescale(k.random_adsr(1/w, 0.6), -76, -36) for _ in range(int(dur*w) + 1)])\n",
    "    amp = k.pad_to_dur(amp, dur)\n",
    "    amp = amp[:len(pitch)]\n",
    "    amp += k.triangle(dur, 1/4, 0.5, *breathe, idx/6)\n",
    "    \n",
    "    # part specific modifications\n",
    "    if p.part_name == 'Vla':\n",
    "        amp += 4\n",
    "        amp[:int(cello_dur * 2 * k.SECOND)] = -120\n",
    "        # amp[k.time_to_step(stop):] = -120\n",
    "    elif p.part_name == 'Vln. 1':\n",
    "        amp[:int(cello_dur * 3 * k.SECOND)] = -120\n",
    "        # amp[k.time_to_step(stop):] = -120\n",
    "    elif p.part_name == 'Vln. 2':\n",
    "        amp[:int(cello_dur * 4 * k.SECOND)] = -120\n",
    "        # amp[k.time_to_step(stop):] = -120\n",
    "    elif p.part_name == 'Flt. 1':\n",
    "        amp += 4\n",
    "        # amp[k.time_to_step(stop):] = -120\n",
    "    elif p.part_name == 'Flt. 2':\n",
    "        # amp[k.time_to_step(stop):] = -120\n",
    "        pass\n",
    "    \n",
    "    # harmonic stretching after 28 seconds\n",
    "    amount = 0.05\n",
    "    stretch = k.line_segment(3, 0, amount)\n",
    "    relax = k.line_segment(3, amount, 0)\n",
    "    p_stretch = v_get_harm(n_harm, stretch)\n",
    "    p_relax = v_get_harm(n_harm, relax)\n",
    "    \n",
    "    end = first_stretch + len(p_stretch)\n",
    "    end2 = end + len(p_relax)\n",
    "    pitch[first_stretch:end] = p_stretch\n",
    "    pitch[end:end2] = p_relax\n",
    "    \n",
    "    # amp[first_stretch:end] += k.line_segment(3, *emphasis)\n",
    "    #amp[end:end2] += k.line_segment(3, *emphasis[::-1])\n",
    "    amp[first_stretch - k.time_to_step(1): first_stretch] -= 6\n",
    "    amp[first_stretch:end2] += 12\n",
    "    amp[end:end2] += k.line_segment(3, 12, 0)\n",
    "    \n",
    "    # second stretch at 38\n",
    "    amount = 0.025\n",
    "    stretch = k.line_segment(1, 0, amount)\n",
    "    relax = k.line_segment(2, amount, 0)\n",
    "    p_stretch = v_get_harm(n_harm, stretch)\n",
    "    p_relax = v_get_harm(n_harm, relax)\n",
    "    \n",
    "    end = second_stretch + len(p_stretch)\n",
    "    end2 = end + len(p_relax)\n",
    "    pitch[second_stretch:end] = p_stretch\n",
    "    pitch[end:end2] = p_relax\n",
    "    \n",
    "    # amp[second_stretch:end] += k.line_segment(1, *emphasis)\n",
    "    # amp[end:end2] += k.line_segment(2, *emphasis[::-1])\n",
    "    amp[second_stretch - k.time_to_step(1): first_stretch] -= 6\n",
    "    amp[second_stretch:end2] += 12\n",
    "    \n",
    "    # third stretch at 46\n",
    "    amount = -0.05\n",
    "    stretch = k.line_segment(8, 0, amount)\n",
    "    relax = k.line_segment(6, amount, 0)\n",
    "    p_stretch = v_get_harm(n_harm, stretch)\n",
    "    p_relax = v_get_harm(n_harm, relax)\n",
    "    \n",
    "    end = third_stretch + len(p_stretch)\n",
    "    end2 = end + len(p_relax)\n",
    "    pitch[third_stretch:end] = p_stretch\n",
    "    pitch[end:end2] = p_relax\n",
    "    \n",
    "    # amp[third_stretch:end] += k.line_segment(8, *emphasis[::-1])\n",
    "    # amp[end:end2] += k.line_segment(4, *emphasis)\n",
    "    amp[third_stretch:end] += k.line_segment(8, 6, -8)\n",
    "    \n",
    "    # build phrase\n",
    "    phrase = Phrase(pitch, amp)\n",
    "    p.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c68e8dd8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln1.phrases[-1].show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f9e22ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "durs = [1, 2, 1, 2, 14]\n",
    "stop = 0.3\n",
    "\n",
    "for i, d in enumerate(durs):\n",
    "    for idx, (w, p) in enumerate(zip(omegas, [vlc, vla, flt1, flt2, vln1, vln2])):\n",
    "        # silence\n",
    "        if i % 2 == 1:\n",
    "            pitch = k.constant(stop, pitch[-1])\n",
    "            amp = k.constant(stop, -120)\n",
    "\n",
    "            phrase = Phrase(pitch, amp)\n",
    "            p.add_phrase(phrase)\n",
    "\n",
    "        # base pitches\n",
    "        n_harm = 2 * idx + 1\n",
    "        pitch = k.constant(d, get_harm(n_harm + i + 1))\n",
    "\n",
    "        # base amplitudes\n",
    "        # TODO: there are audio artifacts if both attack and decay are close to zero\n",
    "        amp = np.concatenate([k.rescale(k.random_adsr(1/w, 0.6), -76, -36) for _ in range(int(d*w) + 1)])\n",
    "        amp = k.pad_to_dur(amp, d)\n",
    "        amp = amp[:len(pitch)]\n",
    "        if i == 4:\n",
    "            amp += k.line_segment(d, 0, -14)\n",
    "\n",
    "        phrase = Phrase(pitch, amp)\n",
    "        p.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78923ce8",
   "metadata": {},
   "source": [
    "# Transition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34919437",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(vln1.phrases[-1].pitch[-1], get_harm(14, 0, 36))\n",
    "for (p, i) in zip([66, 78, 71], [6, 12, 8]):\n",
    "    print(p, get_harm(i, 0, 36))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e3f14cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(vln1.phrases[-1].pitch[-1], get_harm(14, 0, 36))\n",
    "for (p, i) in zip([61, 49, 56], [4, 2, 3]):\n",
    "    print(p, get_harm(i, 0, 36))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edfc0e6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln1 overtones of B  (3, 6, 5)\n",
    "# vln2 overtones of C# (2, 4, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a185d0a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "seed_d = np.array([0.375, 0.25, 0.375])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8425e898",
   "metadata": {},
   "outputs": [],
   "source": [
    "pp = []\n",
    "aa = []\n",
    "for i in range(10, -1, -2):\n",
    "    seed_x = seed_d * (2 - i / 10)\n",
    "    harms = np.array([3, 6, 4]) + i\n",
    "    pitches = k.figure(harms, seed_x)\n",
    "    renj = 2 if i != 0 else 1\n",
    "    for _ in range(renj):\n",
    "        pp.append(pitches)\n",
    "\n",
    "        amps = np.concatenate([k.random_adsr(d, 0.6) for d in seed_x])\n",
    "        amps = k.rescale(amps, -66, -50)\n",
    "        aa.append(amps)\n",
    "    \n",
    "pitches = np.concatenate(pp)\n",
    "amps = np.concatenate(aa)\n",
    "\n",
    "funda = np.linspace(36, 35+12, len(pitches))\n",
    "pitches = v_get_harm(pitches, 0 , funda)\n",
    "\n",
    "phrase = Phrase(pitches, amps)    \n",
    "vln1.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2122318",
   "metadata": {},
   "outputs": [],
   "source": [
    "pp = []\n",
    "aa = []\n",
    "seed_y = np.roll(seed_d, 1)\n",
    "for i in range(10, -1, -2):\n",
    "    seed_x = seed_y * (2 - i / 10)\n",
    "    harms = np.array([4, 2, 3]) + i\n",
    "    pitches = k.figure(harms, seed_x)\n",
    "    renj = 2 if i != 0 else 1\n",
    "    for _ in range(renj):\n",
    "        pp.append(pitches)\n",
    "\n",
    "        amps = np.concatenate([k.random_adsr(d, 0.6) for d in seed_x])\n",
    "        amps = k.rescale(amps, -66, -50)\n",
    "        aa.append(amps)\n",
    "    \n",
    "pitches = np.concatenate(pp)\n",
    "amps = np.concatenate(aa)\n",
    "\n",
    "funda = np.linspace(36, 37+12, len(pitches))\n",
    "pitches = v_get_harm(pitches, 0 , funda)\n",
    "\n",
    "phrase = Phrase(pitches, amps)    \n",
    "vln2.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1fb15ee5",
   "metadata": {},
   "outputs": [],
   "source": [
    "beat = sum(seed_d)\n",
    "dur = len(pitches) / k.SECOND\n",
    "n = int(dur / beat)\n",
    "\n",
    "aa = []\n",
    "for _ in range(n):\n",
    "    amp = k.random_adsr(beat, 0.6)\n",
    "    amp = k.rescale(amp, -66, -48)\n",
    "    aa.append(amp)\n",
    "\n",
    "amp = np.concatenate(aa)\n",
    "amp = k.pad_to_dur(amp, dur)\n",
    "pitch = k.line_segment(dur, 72, 61)\n",
    "\n",
    "phrase = Phrase(pitch, amp)\n",
    "vla.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89b290e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "beat = sum(seed_d)\n",
    "dur = len(pitches) / k.SECOND\n",
    "n = int(dur / beat)\n",
    "\n",
    "aa = []\n",
    "for _ in range(n):\n",
    "    amp = k.random_adsr(beat, 0.6)\n",
    "    amp = k.rescale(amp, -66, -48)\n",
    "    aa.append(amp)\n",
    "\n",
    "amp = np.concatenate(aa)\n",
    "amp = k.pad_to_dur(amp, dur)\n",
    "pitch = k.line_segment(dur, 67, 42)\n",
    "\n",
    "phrase = Phrase(pitch, amp)\n",
    "vlc.add_phrase(phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3458f2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "flt1.add_phrase(vln1.phrases[-1])\n",
    "flt2.add_phrase(vln2.phrases[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6dc5afb",
   "metadata": {},
   "source": [
    "# Finale"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de6d7ae1",
   "metadata": {},
   "source": [
    "fill_with_silence(flt1, len(vln1) - len(flt1))\n",
    "fill_with_silence(flt2, len(vln1) - len(flt2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4dea8059",
   "metadata": {},
   "outputs": [],
   "source": [
    "final = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19420a5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, dr in enumerate([2, 4]):\n",
    "    seed_d = k.to_delta(seed_a * dr)\n",
    "    pitches, durs = k.fractal_bpc_floor(seed_p, seed_d, i)\n",
    "    pitches = np.pad(pitches, (0, k.time_to_step(dr) - len(pitches)), constant_values=pitches[-1])\n",
    "    pitches = (pitches - min(pitches)) / (max(pitches) - min(pitches))\n",
    "    pitches = k.rescale(pitches, 66, 66+12)\n",
    "    pitches = k.autotune(pitches, 0.95)\n",
    "    pitches += k.sinusoid(dr, 4, 0, 0.125)\n",
    "    \n",
    "    if i < 2:\n",
    "        amp_segments = []\n",
    "        for d in durs:\n",
    "            aa = k.triangle(d, 1/d, 1e-7)\n",
    "            aa = np.pad(aa, (0, k.time_to_step(d) - len(aa)), constant_values=aa[-1])\n",
    "            amp_segments.append(aa)\n",
    "        amps = np.concatenate(amp_segments)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -55, -44)\n",
    "        amps += k.line_segment(dr, -8, 4)\n",
    "    else:\n",
    "        amps = k.line_segment(dr, 0, 1)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -59, -44)\n",
    "    \n",
    "    amps += np.random.randn(*amps.shape) * 0.5\n",
    "    vln1.add_phrase(Phrase(pitches, amps))\n",
    "    \n",
    "    breathe_p = k.constant(1 + i, pitches[-1])\n",
    "    vib = k.sinusoid(1+i, 4, 0, 0.125) * (k.phasor(1+i, 1/(1+i)) ** 2)\n",
    "    breathe_p += vib\n",
    "    if i == 2:\n",
    "        breath_amp = (1 - k.phasor(1+i, 1/(1+i)))\n",
    "        breath_amp = k.rescale(breath_amp, -58, -46)\n",
    "        breath_amp[-1] = breath_amp[-2]\n",
    "    else:\n",
    "        breath_amp = k.line_segment(1+i, 0, 1) * 9 - 55\n",
    "    \n",
    "    breath_amp += np.random.randn(*breath_amp.shape) * 0.5\n",
    "    vln1.add_phrase(Phrase(breathe_p, breath_amp))\n",
    "    \n",
    "sonp = k.constant(final, pitches[0])\n",
    "sona = k.phasor(final, 1/final)\n",
    "sona = k.rescale(sona, -58, -46)\n",
    "\n",
    "vln1.add_phrase(Phrase(sonp, sona))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6e8b8f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln1.show()\n",
    "# vln1.play()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac1d2bcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "for i, dr in enumerate([2, 4]):\n",
    "    seed_d = k.to_delta(seed_a * dr)\n",
    "    pitches, durs = k.fractal_bpc_floor(seed_p[::-1], np.roll(seed_d, 1), i)\n",
    "    pitches = np.pad(pitches, (0, k.time_to_step(dr) - len(pitches)), constant_values=pitches[-1])\n",
    "    pitches = (pitches - min(pitches)) / (max(pitches) - min(pitches))\n",
    "    pitches = k.rescale(pitches, 61, 61+12)\n",
    "    pitches = k.autotune(pitches, 0.95)\n",
    "    pitches += k.sinusoid(dr, 4, 0, 0.125)\n",
    "    \n",
    "    if i < 2:\n",
    "        amp_segments = []\n",
    "        for d in durs:\n",
    "            aa = k.triangle(d, 1/d, 1e-7)\n",
    "            aa = np.pad(aa, (0, k.time_to_step(d) - len(aa)), constant_values=aa[-1])\n",
    "            amp_segments.append(aa)\n",
    "        amps = np.concatenate(amp_segments)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -55, -44)\n",
    "        amps += k.line_segment(dr, -12, 4)\n",
    "    else:\n",
    "        amps = k.line_segment(dr, 0, 1)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -59, -44)\n",
    "    \n",
    "    amps += np.random.randn(*amps.shape) * 0.5\n",
    "    vln2.add_phrase(Phrase(pitches, amps))\n",
    "    \n",
    "    breathe_p = k.constant(1 + i, pitches[-1])\n",
    "    vib = k.sinusoid(1+i, 4, 0, 0.125) * (k.phasor(1+i, 1/(1+i)) ** 2)\n",
    "    breathe_p += vib\n",
    "    if i == 2:\n",
    "        breath_amp = (1 - k.phasor(1+i, 1/(1+i)))\n",
    "        breath_amp = k.rescale(breath_amp, -58, -46)\n",
    "        breath_amp[-1] = breath_amp[-2]\n",
    "    else:\n",
    "        breath_amp = k.phasor(1+i, 1/(1+i)) * 9 - 55\n",
    "    \n",
    "    breath_amp += np.random.randn(*breath_amp.shape) * 0.5\n",
    "    vln2.add_phrase(Phrase(breathe_p, breath_amp))\n",
    "    \n",
    "sonp = k.constant(final, pitches[0])\n",
    "sona = k.phasor(final, 1/final)\n",
    "sona = k.rescale(sona, -58, -46)\n",
    "\n",
    "vln2.add_phrase(Phrase(sonp, sona))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b87714c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vln2.show()\n",
    "# vln2.play()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2172bf79",
   "metadata": {},
   "outputs": [],
   "source": [
    "volume = -4\n",
    "\n",
    "for i, dr in enumerate([2, 4]):\n",
    "    seed_d = k.to_delta(seed_a * dr)\n",
    "    pitches, durs = k.fractal_bpc_floor(seed_p, seed_d, i)\n",
    "    pitches = np.pad(pitches, (0, k.time_to_step(dr) - len(pitches)), constant_values=pitches[-1])\n",
    "    pitches = (pitches - min(pitches)) / (max(pitches) - min(pitches))\n",
    "    pitches = k.rescale(pitches, 42, 42+12)\n",
    "    pitches = k.autotune(pitches, 0.95)\n",
    "    pitches += k.sinusoid(dr, 4, 0, 0.125)\n",
    "    \n",
    "    if i < 2:\n",
    "        amps = np.concatenate([k.triangle(d, 1/d, 0.01) for d in durs])\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -55, -44)\n",
    "        amps += k.line_segment(dr, -8, 4)\n",
    "    else:\n",
    "        amps = k.line_segment(dr, 0, 1)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -59, -44)\n",
    "    \n",
    "    amps += volume\n",
    "    amps += np.random.randn(*amps.shape) * 0.5\n",
    "    vlc.add_phrase(Phrase(pitches, amps))\n",
    "    \n",
    "    breathe_p = k.constant(1 + i, pitches[-1])\n",
    "    vib = k.sinusoid(1+i, 4, 0, 0.125) * (k.phasor(1+i, 1/(1+i)) ** 2)\n",
    "    breathe_p += vib\n",
    "    \n",
    "    if i == 2:\n",
    "        breath_amp = (1 - k.phasor(1+i, 1/(1+i))) * 9 - 55\n",
    "        breath_amp = k.rescale(breath_amp, -59, -46)\n",
    "        breath_amp[-1] = breath_amp[-2]\n",
    "    else:\n",
    "        breath_amp = k.phasor(1+i, 1/(1+i)) * 9 - 55\n",
    "    \n",
    "    breath_amp += volume\n",
    "    breath_amp += np.random.randn(*breath_amp.shape) * 0.5\n",
    "    vlc.add_phrase(Phrase(breathe_p, breath_amp))\n",
    "    \n",
    "sonp = k.constant(final, pitches[0])\n",
    "sona = k.phasor(final, 1/final)\n",
    "sona = k.rescale(sona, -58, -46)\n",
    "\n",
    "vlc.add_phrase(Phrase(sonp, sona))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dec52187",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vlc.show()\n",
    "# vlc.play()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "449840d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "volume = 4\n",
    "\n",
    "for i, dr in enumerate([2, 4]):\n",
    "    seed_d = k.to_delta(seed_a * dr)\n",
    "    pitches, durs = k.fractal_bpc_floor(seed_p[::-1], np.roll(seed_d, 1), i)\n",
    "    pitches = np.pad(pitches, (0, k.time_to_step(dr) - len(pitches)), constant_values=pitches[-1])\n",
    "    pitches = (pitches - min(pitches)) / (max(pitches) - min(pitches))\n",
    "    pitches = k.rescale(pitches, 49, 49+12)\n",
    "    # pitches = k.autotune(pitches, 0.95, list(np.random.randint(0, 11, 5)))\n",
    "    pitches = k.autotune(pitches, 0.95)\n",
    "    pitches += k.sinusoid(dr, 4, 0, 0.125)\n",
    "    \n",
    "    if i < 2:\n",
    "        # amps = k.sinusoid(dr, 2/dr, -43.36, 5.23/2)\n",
    "        amps = np.concatenate([k.triangle(d, 1/d, 0.01) for d in durs])\n",
    "        # amps += np.random.normal(0, .5, len(amps))\n",
    "        # amps = k.to_db_loudness(amps, 'violin', min_loudness=-0.1)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -55, -44)\n",
    "        amps += k.line_segment(dr, -8, 4)\n",
    "        amps = k.rescale(amps, -60, -48)\n",
    "    else:\n",
    "        amps = k.line_segment(dr, 0, 1)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -60, -48)\n",
    "    \n",
    "    amps += volume\n",
    "    amps += np.random.randn(*amps.shape) * 0.5\n",
    "    vla.add_phrase(Phrase(pitches, amps))\n",
    "    \n",
    "    breathe_p = k.constant(1 + i, pitches[-1])\n",
    "    vib = k.sinusoid(1+i, 4, 0, 0.125) * (k.phasor(1+i, 1/(1+i)) ** 2)\n",
    "    breathe_p += vib\n",
    "    \n",
    "    if i == 2:\n",
    "        breath_amp = (1 - k.phasor(1+i, 1/(1+i))) * 9 - 55\n",
    "        breath_amp = k.rescale(breath_amp, -66, -47)\n",
    "        breath_amp[-1] = breath_amp[-2]\n",
    "    else:\n",
    "        breath_amp = k.phasor(1+i, 1/(1+i)) * 9 - 55\n",
    "        breath_amp = k.rescale(breath_amp, -55, -47)\n",
    "\n",
    "    breath_amp += volume\n",
    "    breath_amp += np.random.randn(*breath_amp.shape) * 0.5\n",
    "    vla.add_phrase(Phrase(breathe_p, breath_amp))\n",
    "    \n",
    "sonp = k.constant(final, pitches[0])\n",
    "sona = k.phasor(final, 1/final)\n",
    "sona = k.rescale(sona, -55, -47)\n",
    "\n",
    "vla.add_phrase(Phrase(sonp, sona))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c135e0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# vla.show()\n",
    "# vla.play()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86c2f556",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, dr in enumerate([2, 4]):\n",
    "    seed_d = k.to_delta(seed_a * dr)\n",
    "    pitches, durs = k.fractal_bpc_floor(seed_p, seed_d, i)\n",
    "    pitches = np.pad(pitches, (0, k.time_to_step(dr) - len(pitches)), constant_values=pitches[-1])\n",
    "    pitches = (pitches - min(pitches)) / (max(pitches) - min(pitches))\n",
    "    pitches = k.rescale(pitches, 66+12, 66+12+12)\n",
    "    pitches = k.autotune(pitches, 0.95)\n",
    "    pitches += k.sinusoid(dr, 4, 0, 0.125)\n",
    "    \n",
    "    if i < 2:\n",
    "        amp_segments = []\n",
    "        for d in durs:\n",
    "            aa = k.triangle(d, 1/d, 1e-7)\n",
    "            aa = np.pad(aa, (0, k.time_to_step(d) - len(aa)), constant_values=aa[-1])\n",
    "            amp_segments.append(aa)\n",
    "        amps = np.concatenate(amp_segments)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -55, -44)\n",
    "        amps += k.line_segment(dr, -8, 4)\n",
    "    else:\n",
    "        amps = k.line_segment(dr, 0, 1)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -59, -44)\n",
    "    \n",
    "    amps += np.random.randn(*amps.shape) * 0.5\n",
    "    flt1.add_phrase(Phrase(pitches, amps))\n",
    "    \n",
    "    breathe_p = k.constant(1 + i, pitches[-1])\n",
    "    vib = k.sinusoid(1+i, 4, 0, 0.125) * (k.phasor(1+i, 1/(1+i)) ** 2)\n",
    "    breathe_p += vib\n",
    "    if i == 2:\n",
    "        breath_amp = (1 - k.phasor(1+i, 1/(1+i)))\n",
    "        breath_amp = k.rescale(breath_amp, -58, -46)\n",
    "        breath_amp[-1] = breath_amp[-2]\n",
    "    else:\n",
    "        breath_amp = k.line_segment(1+i, 0, 1) * 9 - 55\n",
    "    \n",
    "    breath_amp += np.random.randn(*breath_amp.shape) * 0.5\n",
    "    flt1.add_phrase(Phrase(breathe_p, breath_amp))\n",
    "\n",
    "sonp = k.constant(final, pitches[0])\n",
    "sona = k.phasor(final, 1/final)\n",
    "sona = k.rescale(sona, -58, -46)\n",
    "\n",
    "flt1.add_phrase(Phrase(sonp, sona))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ff665b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, dr in enumerate([2, 4]):\n",
    "    seed_d = k.to_delta(seed_a * dr)\n",
    "    pitches, durs = k.fractal_bpc_floor(seed_p[::-1], np.roll(seed_d, 1), i)\n",
    "    pitches = np.pad(pitches, (0, k.time_to_step(dr) - len(pitches)), constant_values=pitches[-1])\n",
    "    pitches = (pitches - min(pitches)) / (max(pitches) - min(pitches))\n",
    "    pitches = k.rescale(pitches, 61+12, 61+12+12)\n",
    "    pitches = k.autotune(pitches, 0.95)\n",
    "    pitches += k.sinusoid(dr, 4, 0, 0.125)\n",
    "    \n",
    "    if i < 2:\n",
    "        amp_segments = []\n",
    "        for d in durs:\n",
    "            aa = k.triangle(d, 1/d, 1e-7)\n",
    "            aa = np.pad(aa, (0, k.time_to_step(d) - len(aa)), constant_values=aa[-1])\n",
    "            amp_segments.append(aa)\n",
    "        amps = np.concatenate(amp_segments)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -55, -44)\n",
    "        amps += k.line_segment(dr, -12, 4)\n",
    "    else:\n",
    "        amps = k.line_segment(dr, 0, 1)\n",
    "        amps = np.pad(amps, (0, k.time_to_step(dr) - len(amps)), constant_values=amps[-1])\n",
    "        amps = k.rescale(amps, -59, -44)\n",
    "    \n",
    "    amps += np.random.randn(*amps.shape) * 0.5\n",
    "    flt2.add_phrase(Phrase(pitches, amps))\n",
    "    \n",
    "    breathe_p = k.constant(1 + i, pitches[-1])\n",
    "    vib = k.sinusoid(1+i, 4, 0, 0.125) * (k.phasor(1+i, 1/(1+i)) ** 2)\n",
    "    breathe_p += vib\n",
    "    if i == 2:\n",
    "        breath_amp = (1 - k.phasor(1+i, 1/(1+i)))\n",
    "        breath_amp = k.rescale(breath_amp, -58, -46)\n",
    "        breath_amp[-1] = breath_amp[-2]\n",
    "    else:\n",
    "        breath_amp = k.phasor(1+i, 1/(1+i)) * 9 - 55\n",
    "    \n",
    "    breath_amp += np.random.randn(*breath_amp.shape) * 0.5\n",
    "    flt2.add_phrase(Phrase(breathe_p, breath_amp))\n",
    "    \n",
    "sonp = k.constant(final, pitches[0])\n",
    "sona = k.phasor(final, 1/final)\n",
    "sona = k.rescale(sona, -58, -46)\n",
    "\n",
    "flt2.add_phrase(Phrase(sonp, sona))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18f14a96",
   "metadata": {},
   "outputs": [],
   "source": [
    "score = Score([vln1, vln2, vla, vlc, flt1, flt2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "883fdd70",
   "metadata": {},
   "outputs": [],
   "source": [
    "score.save('fractus-duo', './audio-data/december/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36ec3434",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}