clumsy-math

a little library of helpful math utensils 🙂

documentation

• rhythm (concepts)

  • rhythm slot

  • rhythm resolution

  • rhythm point

  • rhythm density

  • rhythm phase

  • rhythm orientation

  • relative rhythm point

  • rhythm interval

  • rhythm

  • euclidean rhythm

  • recursive euclidean rhythm

  • aligned recursive euclidean rhythm

  • phased recursive euclidean rhythm

  • rhythm component

  • rhythm group

  • rhythm lineage

  • rhythm slot weight

  • rhythm point weight

  • rhythm weight

• rhythm (encodings)

  • RhythmSlot

  • RhythmResolution

  • RhythmDensity

  • RhythmPoint

  • RelativeRhythmPoint

  • RhythmInterval

  • RhythmPhase

  • RhythmOrientation

  • Rhythm

  • RhythmString

  • RhythmMap

  • EuclideanRhythm

  • SimpleRhythmStructure

  • GeneralRhythmStructure

  • RecursiveEuclideanRhythm

  • RecursiveRhythmStructure

  • StackRhythmStructure

  • AlignedRecursiveEuclideanRhythm

  • AlignedRhythmStructure

  • AlignedRecursiveEuclideanRhythmId

  • AlignedRhythmComponent

  • PhasedRecursiveEuclideanRhythm

  • PhasedRhythmStructure

  • PhasedRecursiveEuclideanRhythmId

  • PhasedRhythmComponent

  • RhythmGroup

  • RhythmGroupStructure

  • RhythmGroupId

  • RhythmLineage

  • RhythmSlotWeight

  • RhythmPointWeight

  • RhythmWeight

• rhythm (functions)

  • getSimpleRhythm

  • getRhythmMap

  • getRhythmString

  • getStackRhythmStructure

  • getPhasedRhythmMap

  • getRhythmIntervals

  • getRelativeRhythmPoints

  • getPhasedRhythmId

  • getPhasedRhythmComponents

  • getAlignedRhythmId

  • getAlignedRhythmComponents

  • getRhythmGroup

  • getRhythmGroupId

  • getRhythmLineage

  • getRhythmPointWeights

  • getRhythmSlotWeights

  • getRhythmWeight

• primes (functions)

  • getPrime

  • getPrimes

  • getPrimesLessThanInclusive

  • getNearestPrimes

  • getPrimesRangeInclusive

  • getPrimesSlice

  • isPrime

  • getNumberGreaterThanPrime

  • getPrimeContainer

  • getPrimeContainers

  • isPrimeContainer

rhythm (concepts)

rhythm slot

a rhythm's building block

const rhythm = [true, true, false, true, false];
const rhythmSlotZero = true; // rhythm[0]
const rhythmSlotTwo = false; // rhythm[2]

^rhythm

^RhythmSlot

rhythm resolution

the number of slots that make up a rhythm

const rhythm = [true, true, false, true, false];
const rhythmResolution = 5; // rhythm.length

^{rhythm slot}

^{RhythmResolution, RhythmMap}

^getRhythmMap

rhythm point

the index of a slot whose value is true/1

const rhythm = [true, true, false, true, false];
const rhythmPoints = [0, 1, 3];

^{rhythm slot}

^{RhythmPoint, RhythmMap}

^getRhythmMap

rhythm density

the number of points in a rhythm

const rhythm = [true, true, false, true, false];
const rhythmPoints = [0, 1, 3];
const rhythmDensity = 3; // rhythmPoints.length

^{rhythm point}

^{RhythmDensity}

rhythm phase

an offset measured in slots applied to points relative to a base rhythm

const rhythm = [true, true, false, true, false];
const rhythmPhase = -1;
const phasedRhythm = [false, true, true, false, true];

^{rhythm point, rhythm slot}

^RhythmPhase

^{getPhasedRhythmMap}

rhythm orientation

the point index relative to a base rhythm that indicates a reoriented rhythm's anchor/starting point

const rhythm = [true, true, false, true, false];
const reorientedRhythm = [true, false, true, false, true];
const reorientedRhythmOrientation = 1;

^{rhythm point, rhythm resolution}

^{RhythmOrientation}

relative rhythm point

a point whose value is normalized within the range of [0, 1)

const rhythm = [true, true, false, true, false];
const rhythmPoints = [0, 1, 3];
const relativeRhythmPoints = [0, 0.2, 0.6];

^{rhythm point, rhythm resolution}

^{RelativeRhythmPoint}

^{getRelativeRhythmPoints}

rhythm interval

the length/distance between two points measured in slots

const rhythm = [true, true, false, true, false];
const rhythmPoints = [0, 1, 3];
const rhythmIntervals = [1, 2, 2];

^{rhythm point, rhythm slot}

^{RhythmInterval}

^{getRhythmIntervals}

rhythm

a discrete sequence/cycle of binary values

const rhythm = [true, true, false, true, false];

^Rhythm

^{getRhythmString}

euclidean rhythm - white paper

a rhythm who's points are as evenly distributed as possible throughout a discrete space

const rhythmAaa = [true, false, true, false];
const rhythmBbb = [true, true, false, true, false];
const rhythmCcc = [true, false, true, false, true];

^{rhythm, rhythm point}

^{getSimpleRhythm}

recursive euclidean rhythm

a rhythm composed by stacking euclidean rhythms on top of each other where the base rhythm's density/points determines the next rhythm's resolution/space

const baseRhythm = [true, true, false, true, false];
const terminalRhythm = [true, false, true];
const resultRhythm = [true, false, false, true, false];

^{rhythm component, euclidean rhythm, rhythm point, rhythm resolution}

aligned recursive euclidean rhythm

a recursive euclidean rhythm where rhythm layers have a phase of zero such that one of it's points remains anchored to the zero slot

const baseRhythm = [true, true, false, true, false];
const terminalRhythm = [true, false, true];
const resultRhythm = [true, false, false, true, false];

^{recursive euclidean rhythm, rhythm slot, rhythm phase}

^{AlignedRecursiveEuclideanRhythm, AlignedRecursiveEuclideanRhythmId}

^{getAlignedRhythmId, getAlignedRhythmComponents}

phased recursive euclidean rhythm

a recursive euclidean rhythm where rhythm layers can be phased

const baseRhythm = [true, true, false, true, false];
const terminalRhythm = [false, true, true]; // phase === -1
const resultRhythm = [false, true, false, true, false];

^{recursive euclidean rhythm, rhythm phase}

rhythm component

a recursive euclidean rhythm of a recursive euclidean rhythm

const terminalComponentRhythm = [true, false, false, false, true, false, false];
const interposedComponentRhythm = [true, true, false, false, true, false, false];
const initialComponentRhythm = [true, true, true, false, true, true, false];

^{recursive euclidean rhythm}

^{PhasedRhythmComponent, AlignedRhythmComponent}

^{getPhasedRhythmComponents, getAlignedRhythmComponents}

rhythm group

a set of recursive euclidean rhythms that share a static base structure and a dynamic member structure where the density structure is the same but orientations are different

const groupBaseRhythm = [true, true, false, true, false];
const memberRhythmBase = [true, true, false];
const memberBaseRhythmAaa = [true, true, false]; // memberRhythmBase with orientation 0
const memberBaseRhythmBbb = [true, false, true]; // memberRhythmBase with orientation 1
const groupMemberRhythmAaa = [true, true, false, false, false]; // 11010 -> 110 === 11000
const groupMemberRhythmBbb = [true, false, false, true, false]; // 11010 -> 101 === 10010

^{rhythm lineage}

^{RhythmGroup, RhythmGroupStructure, RhythmGroupId}

^{getRhythmGroup, getRhythmGroupId, getRhythmLineage}

rhythm lineage

all rhythm groups an aligned recursive euclidean rhythm belongs to

const rhythm = [true, false, false, true, false];
const rhythmLineage = [
  [
    [true, true, false, false, false],
    [true, false, false, true, false],
    [true, false, true, false, false],
    [true, false, false, false, true],
    [true, false, true, false, false],
    [true, false, false, true, false],
  ],
  [
    [true, true, false, false, false],
    [true, false, false, true, false],
  ],
];

^{rhythm group, aligned recursive euclidean rhythm}

^{RhythmLineage}

^{getRhythmLineage}

rhythm slot weight

the number/count of points that exist at a slot in the context of a set of rhythms which all have the same resolution

const rhythmAaa = [true, true, false, true, false]; // 1, 1, 0, 1, 0
const rhythmBbb = [true, false, true, false, true]; // 1, 0, 1, 0, 1
const rhythmCcc = [true, false, true, true, false]; // 1, 0, 1, 1, 0
const rhythmSlotWeights = [3, 1, 2, 2, 1];
const rhythmSlotWeightZero = 3; // rhythmSlotWeights[0]

^{rhythm slot, rhythm point}

^{RhythmSlotWeight, RhythmPointWeight, RhythmWeight}

^{getRhythmSlotWeights, getRhythmPointWeights, getRhythmWeight}

rhythm point weight

a point's corresponding slot weight

const rhythmAaa = [true, true, false, true, false];
const rhythmBbb = [true, false, true, false, true];
const rhythmCcc = [true, false, true, true, false];
const rhythmSlotWeights = [3, 1, 2, 2, 1];
const rhythmAaaPoints = [0, 1, 3];
const rhythmAaaPointZeroWeight = 3; // rhythmSlotWeights[rhythmAaaPoints[0]]

^{rhythm slot weight, rhythm point}

^{RhythmPointWeight}

^{getRhythmPointWeights}

rhythm weight

the sum of a rhythm's point weights

const rhythmAaa = [true, true, false, true, false];
const rhythmBbb = [true, false, true, false, true];
const rhythmCcc = [true, false, true, true, false];
const rhythmSlotWeights = [3, 1, 2, 2, 1];
const rhythmAaaPoints = [0, 1, 3];
const rhythmAaaWeight = 6;

^{rhythm point weight, rhythm point}

^RhythmWeight

^{getRhythmWeight}

rhythm (encodings)

RhythmSlot

rhythm slot as boolean

^{rhythm slot}

^{getRhythmSlotWeights}

RhythmResolution

rhythm resolution as number

^{rhythm resolution}

RhythmDensity

rhythm density as number

^{rhythm density}

RhythmPoint

rhythm point as number

^{rhythm point}

RelativeRhythmPoint

relative rhythm point as number

^{relative rhythm point}

^{getRelativeRhythmPoints}

RhythmInterval

rhythm interval as number

^{rhythm interval}

^{getRhythmIntervals}

RhythmPhase

rhythm phase as number

^{rhythm phase}

^{getPhasedRhythmMap}

RhythmOrientation

rhythm orientation as number

^{rhythm orientation}

Rhythm

rhythm as Array<RhythmSlot>

const rhythm: Rhythm = [true, true, false, true, false];

^rhythm

^RhythmMap

^{getSimpleRhythm}

RhythmString

rhythm as binary string

const rhythmString: RhythmString = "11010";

^rhythm

^{getRhythmString}

RhythmMap

the defacto encoding for Rhythm

const rhythmMap: RhythmMap = {
  rhythmResolution: 5,
  rhythmPoints: [0, 1, 3],
};

^{rhythm resolution, rhythm point}

^{getRhythmMap, getRhythmString, getPhasedRhythmMap, getRelativeRhythmPoints, getRhythmSlotWeights, getRhythmPointWeights, getRhythmWeight}

EuclideanRhythm

euclidean rhythm as Rhythm

^{euclidean rhythm}

SimpleRhythmStructure

minimal encoding for EuclideanRhythm

const simpleRhythmStructure: SimpleRhythmStructure = {
  rhythmResolution: 5,
  rhythmDensity: 3,
};

^{euclidean rhythm, rhythm resolution, rhythm density}

^{getSimpleRhythm}

GeneralRhythmStructure

generalized encoding for EuclideanRhythm

const generalRhythmStructure: GeneralRhythmStructure = {
  rhythmResolution: 5,
  rhythmDensity: 3,
  rhythmOrientation: 0,
  rhythmPhase: 0,
};

^{euclidean rhythm, rhythm resolution, rhythm density, rhythm orientation, rhythm phase}

RecursiveEuclideanRhythm

recursive euclidean rhythm as Rhythm

^{recursive euclidean rhythm}

RecursiveRhythmStructure

foundational encoding for RecursiveEuclideanRhythm

^{recursive euclidean rhythm}

^{getRhythmMap, getStackRhythmStructure}

StackRhythmStructure

utilitarian encoding that encompasses both AlignedRhythmStructure and PhasedRhythmStructure

const stackRhythmStructure: StackRhythmStructure = [
  {
    rhythmResolution: 5,
    rhythmDensity: 3,
    rhythmOrientation: 0,
    rhythmPhase: 0,
  },
  {
    rhythmResolution: 3,
    rhythmDensity: 2,
    rhythmOrientation: 0,
    rhythmPhase: 0,
  },
];

^{aligned recursive euclidean rhythm, phased recursive euclidean rhythm}

^{GeneralRhythmStructure}

^{getStackRhythmStructure}

AlignedRecursiveEuclideanRhythm

aligned recursive euclidean rhythm as RecursiveEuclideanRhythm

^{aligned recursive euclidean rhythm}

AlignedRhythmStructure

a human-centric encoding for AlignedRecursiveEuclideanRhythm

const alignedRhythmStructure: AlignedRhythmStructure = {
  structureType: "initial",
  rhythmResolution: 5,
  subStructure: {
    structureType: "interposed",
    rhythmDensity: 3,
    rhythmOrientation: 0,
    subStructure: {
      structureType: "terminal",
      rhythmDensity: 2,
      rhythmOrientation: 0,
    },
  },
};

^{aligned recursive euclidean rhythm}

^{getRhythmMap, getAlignedRhythmId, getRhythmLineage}

AlignedRecursiveEuclideanRhythmId

aligned recursive euclidean rhythm as string

^{aligned recursive euclidean rhythm}

^{getAlignedRhythmId}

AlignedRhythmComponent

aligned rhythm component as AlignedRhythmStructure

^{rhythm component}

^{getAlignedRhythmComponents}

PhasedRecursiveEuclideanRhythm

phased recursive euclidean rhythm as RecursiveEuclideanRhythm

^{phased recursive euclidean rhythm}

PhasedRhythmStructure

a human-centric encoding for PhasedRecursiveEuclideanRhythm

const phasedRhythmStructure: PhasedRhythmStructure = {
  structureType: "initial",
  rhythmResolution: 5,
  rhythmPhase: 0,
  subStructure: {
    structureType: "interposed",
    rhythmDensity: 3,
    rhythmOrientation: 0,
    rhythmPhase: 0,
    subStructure: {
      structureType: "terminal",
      rhythmDensity: 2,
      rhythmOrientation: 0,
    },
  },
};

^{phased recursive euclidean rhythm}

^{getPhasedRhythmId}

PhasedRecursiveEuclideanRhythmId

phased recursive euclidean rhythm as string

^{phased recursive euclidean rhythm}

^{getPhasedRhythmId}

PhasedRhythmComponent

phased rhythm component as PhasedRhythmStructure

^{rhythm component}

^{getPhasedRhythmComponents}

RhythmGroup

rhythm group as Array<AlignedRecursiveEuclideanRhythm>

^{rhythm group, aligned recursive euclidean rhythm}

^{getRhythmGroup}

RhythmGroupStructure

compact encoding for RhythmGroup

const rhythmGroupStructure: RhythmGroupStructure = {
  baseStructure: {
    structureType: "initial",
    rhythmResolution: 5,
  },
  memberStructure: {
    structureType: "terminal",
    rhythmDensity: 3,
  },
};

^{rhythm group}

^{RhythmLineage}

^{getRhythmGroup, getRhythmGroupId}

RhythmGroupId

rhythm group as string

^{rhythm group}

^{getRhythmGroupId}

RhythmLineage

rhythm lineage as Array<RhythmGroupStructure>

^{rhythm lineage}

^{getRhythmLineage}

RhythmSlotWeight

rhythm slot weight as number

^{rhythm slot weight}

^{getRhythmSlotWeights, getRhythmPointWeights, getRhythmWeight}

RhythmPointWeight

rhythm point weight as number

^{rhythm point weight}

^{getRhythmPointWeights}

RhythmWeight

rhythm weight as number

^{rhythm weight}

^{getRhythmWeight, getRhythmWeight}

rhythm (functions)

getSimpleRhythm

transforms SimpleRhythmStructure to Rhythm

const simpleRhythm = getSimpleRhythm({
  rhythmResolution: 5,
  rhythmDensity: 3,
});
// simpleRhythm === [true,true,false,true,false]

^{euclidean rhythm, rhythm}

getStackRhythmStructure

transforms RecursiveRhythmStructure to StackRhythmStructure

const stackRhythmStructure = getStackRhythmStructure({
  structureType: "initial",
  rhythmResolution: 5,
  subStructure: {
    structureType: "interposed",
    rhythmDensity: 3,
    rhythmOrientation: 0,
    subStructure: {
      structureType: "terminal",
      rhythmDensity: 2,
      rhythmOrientation: 0,
    },
  },
});
// stackRhythmStructure ===
//   [
//     {
//       rhythmResolution: 5,
//       rhythmDensity: 3,
//       rhythmOrientation: 0,
//       rhythmPhase: 0,
//     },
//     {
//       rhythmResolution: 3,
//       rhythmDensity: 2,
//       rhythmOrientation: 0,
//       rhythmPhase: 0,
//     },
//   ];

^{recursive euclidean rhythm}

getPhasedRhythmMap

computes RhythmMap from RhythmMap and RhythmPhase

const phasedRhythmMap = getPhasedRhythmMap(
  getRhythmMap({
    structureType: "initial",
    rhythmResolution: 5,
    subStructure: {
      structureType: "terminal",
      rhythmDensity: 3,
      rhythmOrientation: 0,
    },
  }),
  -1
);
// phasedRhythmMap ===
//   {
//     rhythmResolution: 5,
//     rhythmPoints: [1, 2, 4],
//   };

^{rhythm phase}

getRelativeRhythmPoints

transforms RhythmMap to Array<RelativeRhythmPoint>

const relativeRhythmPoints = getRelativeRhythmPoints(
  getRhythmMap({
    structureType: "initial",
    rhythmResolution: 5,
    subStructure: {
      structureType: "terminal",
      rhythmDensity: 3,
      rhythmOrientation: 0,
    },
  })
);
// relativeRhythmPoints === [0, 0.2, 0.6];

^{relative rhythm point}

getPhasedRhythmComponents

computes Array<PhaseRhythmComponent> from PhasedRhythmStructure

const phasedRhythmComponents = getPhasedRhythmComponents({
  structureType: "initial",
  rhythmResolution: 7,
  rhythmPhase: 0,
  subStructure: {
    structureType: "interposed",
    rhythmDensity: 5,
    rhythmOrientation: 0,
    rhythmPhase: 0,
    subStructure: {
      structureType: "terminal",
      rhythmDensity: 3,
      rhythmOrientation: 0,
    },
  },
});
// phasedRhythmComponents ===
//   [
//     {
//       structureType: "initial",
//       rhythmResolution: 7,
//       rhythmPhase: 0,
//       subStructure: {
//         structureType: "terminal",
//         rhythmDensity: 5,
//         rhythmOrientation: 0,
//       },
//     },
//     {
//       structureType: "initial",
//       rhythmResolution: 7,
//       rhythmPhase: 0,
//       subStructure: {
//         structureType: "interposed",
//         rhythmDensity: 5,
//         rhythmOrientation: 0,
//         rhythmPhase: 0,
//         subStructure: {
//           structureType: "terminal",
//           rhythmDensity: 3,
//           rhythmOrientation: 0,
//         },
//       },
//     },
//   ];

^{rhythm component, phased recursive euclidean rhythm}

getAlignedRhythmComponents

computes Array<AlignedRhythmComponent> from AlignedRhythmStructure

const alignedRhythmComponents = getAlignedRhythmComponents({
  structureType: "initial",
  rhythmResolution: 7,
  subStructure: {
    structureType: "interposed",
    rhythmDensity: 5,
    rhythmOrientation: 0,
    subStructure: {
      structureType: "terminal",
      rhythmDensity: 3,
      rhythmOrientation: 0,
    },
  },
});
// alignedRhythmComponents ===
//   [
//     {
//       structureType: "initial",
//       rhythmResolution: 7,
//       subStructure: {
//         structureType: "terminal",
//         rhythmDensity: 5,
//         rhythmOrientation: 0,
//       },
//     },
//     {
//       structureType: "initial",
//       rhythmResolution: 7,
//       subStructure: {
//         structureType: "interposed",
//         rhythmDensity: 5,
//         rhythmOrientation: 0,
//         subStructure: {
//           structureType: "terminal",
//           rhythmDensity: 3,
//           rhythmOrientation: 0,
//         },
//       },
//     },
//   ];

^{rhythm component, aligned recursive euclidean rhythm}

getRhythmGroupId

transforms RhythmGroupStructure to RhythmGroupId

const rhythmGroupId = getRhythmGroupId({
  baseStructure: {
    structureType: "initial",
    rhythmResolution: 5,
  },
  memberStructure: {
    structureType: "terminal",
    rhythmDensity: 3,
  },
});
// rhythmGroupId === "group___5___3";

^{rhythm group}

getRhythmGroup

transforms RhythmGroupStructure to RhythmGroup

const rhythmGroup = getRhythmGroup({
  baseStructure: {
    structureType: "initial",
    rhythmResolution: 5,
  },
  memberStructure: {
    structureType: "terminal",
    rhythmDensity: 3,
  },
});
// rhythmGroup ===
//   [
//     {
//       structureType: "initial",
//       rhythmResolution: 5,
//       subStructure: {
//         structureType: "terminal",
//         rhythmDensity: 3,
//         rhythmOrientation: 0,
//       },
//     },
//     {
//       structureType: "initial",
//       rhythmResolution: 5,
//       subStructure: {
//         structureType: "terminal",
//         rhythmDensity: 3,
//         rhythmOrientation: 1,
//       },
//     },
//     {
//       structureType: "initial",
//       rhythmResolution: 5,
//       subStructure: {
//         structureType: "terminal",
//         rhythmDensity: 3,
//         rhythmOrientation: 2,
//       },
//     },
//   ];

^{rhythm group}

getAlignedRhythmId

transforms AlignedRhythmStructure to AlignedRecursiveEuclideanRhythmId

const alignedRhythmId = getAlignedRhythmId({
  structureType: "initial",
  rhythmResolution: 5,
  subStructure: {
    structureType: "terminal",
    rhythmDensity: 3,
    rhythmOrientation: 0,
  },
});
// alignedRhythmId === "aligned__5__3_0"

^{aligned recursive euclidean rhythm}

getPhasedRhythmId

transforms PhasedRhythmStructure to PhasedRecursiveEuclideanRhythmId

const phasedRhythmId = getPhasedRhythmId({
  structureType: "initial",
  rhythmResolution: 5,
  rhythmPhase: 0,
  subStructure: {
    structureType: "terminal",
    rhythmDensity: 3,
    rhythmOrientation: 0,
  },
});
// phasedRhythmId === "phased__5_0__3_0"

^{phased recursive euclidean rhythm}

getRhythmIntervals

computes Array<RhythmInterval> from RhythmMap

const rhythmIntervals = getRhythmIntervals(
  getRhythmMap({
    structureType: "initial",
    rhythmResolution: 5,
    subStructure: {
      structureType: "terminal",
      rhythmDensity: 3,
      rhythmOrientation: 0,
    },
  })
);
// rhythmIntervals = [1,2,2]

^{rhythm interval}

getRhythmLineage

computes RhythmLineage from AlignedRhythmStructure

const rhythmLineage = getRhythmLineage({
  structureType: "initial",
  rhythmResolution: 7,
  subStructure: {
    structureType: "interposed",
    rhythmDensity: 5,
    rhythmOrientation: 0,
    subStructure: {
      structureType: "terminal",
      rhythmDensity: 3,
      rhythmOrientation: 0,
    },
  },
});
// rhythmLineage ===
//   [
//     {
//       baseStructure: {
//         structureType: "initial",
//         rhythmResolution: 7,
//       },
//       memberStructure: {
//         structureType: "interposed",
//         rhythmDensity: 5,
//         subStructure: {
//           structureType: "terminal",
//           rhythmDensity: 3,
//         },
//       },
//     },
//     {
//       baseStructure: {
//         structureType: "initial",
//         rhythmResolution: 7,
//         subStructure: {
//           structureType: "interposed",
//           rhythmDensity: 5,
//           rhythmOrientation: 0,
//         },
//       },
//       memberStructure: {
//         structureType: "terminal",
//         rhythmDensity: 3,
//       },
//     },
//   ];

^{rhythm lineage, rhythm group}

getRhythmMap

transforms RecursiveRhythmStructure to RhythmMap

const rhythmMap = getRhythmMap({
  structureType: 'initial',
  rhythmResolution: 5,
  subStructure: {
    structureType: 'terminal'
    rhythmDensity: 3,
    rhythmOrientation: 0
  }
})
// rhythmMap === {
//   rhythmResolution: 5,
//   rhythmPoints: [0,1,3]
// }

^{rhythm resolution, rhythm point}

getRhythmPointWeights

computes Array<RhythmPointWeight> from RhythmMap and Array<RhythmSlotWeight>

const rhythmGroupRhythmMaps = getRhythmGroup({
  baseStructure: {
    structureType: "initial",
    rhythmResolution: 5,
  },
  memberStructure: {
    structureType: "terminal",
    rhythmDensity: 3,
  },
}).map(getRhythmMap);

const rhythmPointWeights = getRhythmPointWeights(
  rhythmGroupMemberRhythmMaps[0],
  getRhythmSlotWeights(rhythmGroupMemberRhythmMaps)
);
// rhythmPointWeights === [3, 1, 2];

^{rhythm point weight, rhythm slot weight}

getRhythmSlotWeights

transforms Array<RhythmMap> to Array<RhythmSlotWeight>

const rhythmSlotWeights = getRhythmSlotWeights(
  getRhythmGroup({
    baseStructure: {
      structureType: "initial",
      rhythmResolution: 5,
    },
    memberStructure: {
      structureType: "terminal",
      density: 3,
    },
  }).map(getRhythmMap)
);
// rhythmSlotWeights === [3, 1, 2, 2, 1];

^{rhythm slot weight}

getRhythmString

transforms RhythmMap to RhythmString

const rhythmString = getRhythmString(
  getRhythmMap({
    structureType: "initial",
    rhythmResolution: 5,
    subStructure: {
      structureType: "terminal",
      rhythmDensity: 3,
      rhythmOrientation: 0,
    },
  })
);
// rhythmString === "11010"

^rhythm

getRhythmWeight

computes RhythmWeight from RhythmMap and Array<RhythmSlotWeight>

const rhythmGrouphRythmMaps = getRhythmGroup({
  baseStructure: {
    structureType: "initial",
    rhythmResolution: 5,
  },
  memberStructure: {
    structureType: "terminal",
    rhythmDensity: 3,
  },
}).map(getRhythmMap);

const rhythmWeight = getRhythmWeight(
  rhythmGroupMemberRhythmMaps[0],
  getRhythmSlotWeights(rhythmGroupMemberRhythmMaps)
);
// rhythmWeight === 6

^{rhythm weight, rhythm slot weight}

^{getRhythmSlotWeights}

primes (functions)

getPrime

computes prime of given prime index

const prime = getPrime(3);
// prime === 7

getPrimes

computes primes up to given prime index

const primes = getPrimes(3);
// primes === [2, 3, 5, 7]

getPrimesLessThanInclusive

computes primes less than or equal to given number

const primesLessThan12 = getPrimesLessThanInclusive(12);
// primesLessThan12 = [2, 3, 5, 7, 11]

getNearestPrimes

computes the nearest prime below and above given number

const nearestPrimes = getNearestPrimes(10);
// nearestPrimes === [7, 11]

getPrimesRangeInclusive

computes primes contained within given minimum number and maximum number

const primesRange = getPrimesRangeInclusive(4, 11);
// primesRange === [5, 7, 11]

getPrimesSlice

computes primes from given minimum prime index to given maximum prime index

const primesSlice = getPrimesSlice(3, 5);
// primesSlice === [7, 11, 13]

getNumberGreaterThanPrime

computes a number greater than the prime of given prime index

const numberGreaterThan7 = getNumberGreaterThanPrime(3);
// numberGreaterThan7 === 8

isPrime

checks if given number is prime

const isFourPrime = isPrime(4);
// isFourPrime === false

getPrimeContainer

computes prime container of given prime container index

const primeContainer = getPrimeContainer(2);
// primeContainer === 12

getPrimeContainers

computes prime containers up to given prime container index

const primeContainers = getPrimeContainers(2);
// primeContainers = [4, 6, 12]

isPrimeContainer

checks if given number is prime container

const isFourPrimeContainer = isPrimeContainer(4);
// isFourPrimeContainer === true