tone 14.8.27

package/Tone/signal/Add.test.ts

@@ -0,0 +1,60 @@
+import { BasicTests } from "test/helper/Basic";
+import { connectFrom, connectTo } from "test/helper/Connect";
+import { ConstantOutput } from "test/helper/ConstantOutput";
+import { Add } from "./Add";
+import { Signal } from "./Signal";
+
+describe("Add", () => {
+
+	BasicTests(Add);
+
+	context("Addition", () => {
+
+		it("handles input and output connections", () => {
+			const add = new Add();
+			connectFrom().connect(add);
+			connectFrom().connect(add.addend);
+			add.connect(connectTo());
+			add.dispose();
+		});
+
+		it("correctly sums a signal and a number", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(0);
+				const adder = new Add(3);
+				signal.connect(adder);
+				adder.toDestination();
+			}, 3);
+		});
+
+		it("can handle negative values", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(10);
+				const adder = new Add(-1);
+				signal.connect(adder);
+				adder.toDestination();
+			}, 9);
+		});
+
+		it("can sum two signals", () => {
+			return ConstantOutput(() => {
+				const sigA = new Signal(1);
+				const sigB = new Signal(4);
+				const adder = new Add();
+				sigA.connect(adder);
+				sigB.connect(adder.addend);
+				adder.toDestination();
+			}, 5);
+		});
+
+		it("can set addend", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(10);
+				const adder = new Add(-1);
+				adder.addend.value = 2;
+				signal.connect(adder);
+				adder.toDestination();
+			}, 12);
+		});
+	});
+});

package/Tone/signal/Add.ts

@@ -0,0 +1,63 @@
+import { connectSeries } from "../core/context/ToneAudioNode";
+import { Gain } from "../core/context/Gain";
+import { Param } from "../core/context/Param";
+import { optionsFromArguments } from "../core/util/Defaults";
+import { Signal, SignalOptions } from "./Signal";
+
+/**
+ * Add a signal and a number or two signals. When no value is
+ * passed into the constructor, Tone.Add will sum input and `addend`
+ * If a value is passed into the constructor, the it will be added to the input.
+ *
+ * @example
+ * return Tone.Offline(() => {
+ * 	const add = new Tone.Add(2).toDestination();
+ * 	add.addend.setValueAtTime(1, 0.2);
+ * 	const signal = new Tone.Signal(2);
+ * 	// add a signal and a scalar
+ * 	signal.connect(add);
+ * 	signal.setValueAtTime(1, 0.1);
+ * }, 0.5, 1);
+ * @category Signal
+ */
+export class Add extends Signal {
+
+	override = false;
+
+	readonly name: string = "Add";
+
+	/**
+	 * the summing node
+	 */
+	private _sum: Gain = new Gain({ context: this.context });
+	readonly input = this._sum;
+	readonly output = this._sum;
+
+	/**
+	 * The value which is added to the input signal
+	 */
+	readonly addend: Param<"number"> = this._param;
+
+	/**
+	 * @param value If no value is provided, will sum the input and [[addend]].
+	 */
+	constructor(value?: number);
+	constructor(options?: Partial<SignalOptions<"number">>);
+	constructor() {
+		super(Object.assign(optionsFromArguments(Add.getDefaults(), arguments, ["value"])));
+
+		connectSeries(this._constantSource, this._sum);
+	}
+
+	static getDefaults(): SignalOptions<"number"> {
+		return Object.assign(Signal.getDefaults(), {
+			value: 0,
+		});
+	}
+
+	dispose(): this {
+		super.dispose();
+		this._sum.dispose();
+		return this;
+	}
+}

package/Tone/signal/AudioToGain.test.ts

@@ -0,0 +1,53 @@
+import { expect } from "chai";
+import { BasicTests } from "test/helper/Basic";
+import { connectFrom, connectTo } from "test/helper/Connect";
+import { ConstantOutput } from "test/helper/ConstantOutput";
+import { Offline } from "test/helper/Offline";
+import { Oscillator } from "../source/oscillator/Oscillator";
+import { AudioToGain } from "./AudioToGain";
+import { Signal } from "./Signal";
+import { Zero } from "./Zero";
+
+describe("AudioToGain", () => {
+
+	BasicTests(AudioToGain);
+
+	it("normalizes an oscillator to 0,1", () => {
+		return Offline(() => {
+			const osc = new Oscillator(1000).start();
+			const a2g = new AudioToGain();
+			osc.connect(a2g);
+			a2g.toDestination();
+		}).then(buffer => {
+			expect(buffer.min()).to.be.closeTo(0, 0.01);
+			expect(buffer.max()).to.be.closeTo(1, 0.01);
+		});
+	});
+
+	it("outputs 0.5 for an input value of 0", () => {
+		return ConstantOutput(() => {
+			const sig = new Zero();
+			const a2g = new AudioToGain();
+			sig.connect(a2g);
+			a2g.toDestination();
+		}, 0.5);
+	});
+
+	it("outputs 1 for an input value of 1", () => {
+		return ConstantOutput(() => {
+			const sig = new Signal(1);
+			const a2g = new AudioToGain();
+			sig.connect(a2g);
+			a2g.toDestination();
+		}, 1);
+	});
+
+	it("outputs 0 for an input value of -1", () => {
+		return ConstantOutput(() => {
+			const sig = new Signal(-1);
+			const a2g = new AudioToGain();
+			sig.connect(a2g);
+			a2g.toDestination();
+		}, 0);
+	});
+});

package/Tone/signal/AudioToGain.ts

@@ -0,0 +1,40 @@
+import { ToneAudioNodeOptions } from "../core/context/ToneAudioNode";
+import { SignalOperator } from "./SignalOperator";
+import { WaveShaper } from "./WaveShaper";
+
+/**
+ * AudioToGain converts an input in AudioRange [-1,1] to NormalRange [0,1].
+ * See [[GainToAudio]].
+ * @category Signal
+ */
+export class AudioToGain extends SignalOperator<ToneAudioNodeOptions> {
+
+	readonly name: string = "AudioToGain";
+
+	/**
+	 * The node which converts the audio ranges
+	 */
+	private _norm = new WaveShaper({
+		context: this.context,
+		mapping: x => (x + 1) / 2,
+	});
+
+	/**
+	 * The AudioRange input [-1, 1]
+	 */
+	input = this._norm;
+
+	/**
+	 * The GainRange output [0, 1]
+	 */
+	output = this._norm;
+
+	/**
+	 * clean up
+	 */
+	dispose(): this {
+		super.dispose();
+		this._norm.dispose();
+		return this;
+	}
+}

package/Tone/signal/GainToAudio.test.ts

@@ -0,0 +1,41 @@
+import { BasicTests } from "test/helper/Basic";
+import { connectFrom, connectTo } from "test/helper/Connect";
+import { ConstantOutput } from "test/helper/ConstantOutput";
+import { Zero } from "Tone/signal/Zero";
+import { GainToAudio } from "./GainToAudio";
+import { Signal } from "./Signal";
+
+describe("GainToAudio", () => {
+
+	BasicTests(GainToAudio);
+
+	context("Gain To Audio", () => {
+
+		it("outputs 0 for an input value of 0.5", () => {
+			return ConstantOutput(() => {
+				const sig = new Signal(0.5);
+				const g2a = new GainToAudio();
+				sig.connect(g2a);
+				g2a.toDestination();
+			}, 0);
+		});
+
+		it("outputs 1 for an input value of 1", () => {
+			return ConstantOutput(() => {
+				const sig = new Signal(1);
+				const g2a = new GainToAudio();
+				sig.connect(g2a);
+				g2a.toDestination();
+			}, 1);
+		});
+
+		it("outputs -1 for an input value of 0", () => {
+			return ConstantOutput(() => {
+				const sig = new Zero();
+				const g2a = new GainToAudio();
+				sig.connect(g2a);
+				g2a.toDestination();
+			}, -1);
+		});
+	});
+});

package/Tone/signal/GainToAudio.ts

@@ -0,0 +1,40 @@
+import { ToneAudioNodeOptions } from "../core/context/ToneAudioNode";
+import { SignalOperator } from "./SignalOperator";
+import { WaveShaper } from "./WaveShaper";
+
+/**
+ * GainToAudio converts an input in NormalRange [0,1] to AudioRange [-1,1].
+ * See [[AudioToGain]].
+ * @category Signal
+ */
+export class GainToAudio extends SignalOperator<ToneAudioNodeOptions> {
+
+	readonly name: string = "GainToAudio";
+
+	/**
+	 * The node which converts the audio ranges
+	 */
+	private _norm = new WaveShaper({
+		context: this.context,
+		mapping: x => Math.abs(x) * 2 - 1,
+	});
+
+	/**
+	 * The NormalRange input [0, 1]
+	 */
+	input = this._norm;
+
+	/**
+	 * The AudioRange output [-1, 1]
+	 */
+	output = this._norm;
+
+	/**
+	 * clean up
+	 */
+	dispose(): this {
+		super.dispose();
+		this._norm.dispose();
+		return this;
+	}
+}

package/Tone/signal/GreaterThan.test.ts

@@ -0,0 +1,81 @@
+import { ConstantOutput } from "test/helper/ConstantOutput";
+import { BasicTests } from "test/helper/Basic";
+import { GreaterThan } from "./GreaterThan";
+import { Signal } from "./Signal";
+
+describe("GreaterThan", () => {
+
+	BasicTests(GreaterThan);
+
+	context("Comparison", () => {
+
+		it("outputs 0 when signal is less than value", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(1);
+				const gt = new GreaterThan(20);
+				signal.connect(gt);
+				gt.toDestination();
+			}, 0);
+		});
+
+		it("outputs 0 when signal is equal to the value", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(10);
+				const gt = new GreaterThan(10);
+				signal.connect(gt);
+				gt.toDestination();
+			}, 0);
+		});
+
+		it("outputs 1 value is greater than", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(0.8);
+				const gt = new GreaterThan(0.4);
+				signal.connect(gt);
+				gt.toDestination();
+			}, 1);
+		});
+
+		it("can handle negative values", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(-2);
+				const gt = new GreaterThan(-4);
+				signal.connect(gt);
+				gt.toDestination();
+			}, 1);
+		});
+
+		it("can set a new value", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(2);
+				const gt = new GreaterThan(-100);
+				gt.value = 1;
+				signal.connect(gt);
+				gt.toDestination();
+			}, 1);
+		});
+
+		it("outputs 0 when first signal is less than second", () => {
+			return ConstantOutput(() => {
+				const sigA = new Signal(1);
+				const sigB = new Signal(4);
+				const gt = new GreaterThan();
+				sigA.connect(gt);
+				sigB.connect(gt.comparator);
+				gt.toDestination();
+			}, 0);
+		});
+
+		it("outputs 1 when first signal is greater than second", () => {
+			return ConstantOutput(() => {
+				const sigA = new Signal(2.01);
+				const sigB = new Signal(2);
+				const gt = new GreaterThan();
+				sigA.connect(gt);
+				sigB.connect(gt.comparator);
+				gt.toDestination();
+			}, 1);
+		});
+	});
+});
+

package/Tone/signal/GreaterThan.ts

@@ -0,0 +1,88 @@
+import { ToneAudioNode } from "../core/context/ToneAudioNode";
+import { optionsFromArguments } from "../core/util/Defaults";
+import { Subtract } from "./Subtract";
+import { Signal, SignalOptions } from "./Signal";
+import { GreaterThanZero } from "./GreaterThanZero";
+import { readOnly } from "../core/util/Interface";
+import { Param } from "../core/context/Param";
+
+export type GreaterThanOptions = SignalOptions<"number">;
+
+/**
+ * Output 1 if the signal is greater than the value, otherwise outputs 0.
+ * can compare two signals or a signal and a number.
+ * 
+ * @example
+ * return Tone.Offline(() => {
+ * 	const gt = new Tone.GreaterThan(2).toDestination();
+ * 	const sig = new Tone.Signal(4).connect(gt);
+ * }, 0.1, 1);
+ * @category Signal
+ */
+export class GreaterThan extends Signal<"number"> {
+
+	readonly name: string = "GreaterThan"
+
+	readonly override: boolean = false;
+
+	readonly input: ToneAudioNode;
+	readonly output: ToneAudioNode;
+
+	/**
+	 * compare that amount to zero after subtracting
+	 */
+	private _gtz: GreaterThanZero;
+
+	/**
+	 * Subtract the value from the input node
+	 */
+	private _subtract: Subtract;
+
+	/**
+	 * The signal to compare to the incoming signal against.
+	 * @example
+	 * return Tone.Offline(() => {
+	 * 	// change the comparison value
+	 * 	const gt = new Tone.GreaterThan(1.5).toDestination();
+	 * 	const signal = new Tone.Signal(1).connect(gt);
+	 * 	gt.comparator.setValueAtTime(0.5, 0.1);
+	 * }, 0.5, 1);
+	 */
+	readonly comparator: Param<"number">
+
+	/**
+	 * @param value The value to compare to
+	 */
+	constructor(value?: number);
+	constructor(options?: Partial<GreaterThanOptions>);
+	constructor() {
+		super(Object.assign(optionsFromArguments(GreaterThan.getDefaults(), arguments, ["value"])));
+		const options = optionsFromArguments(GreaterThan.getDefaults(), arguments, ["value"]);
+
+		this._subtract = this.input = new Subtract({
+			context: this.context,
+			value: options.value
+		});
+		this._gtz = this.output = new GreaterThanZero({ context: this.context });
+
+		this.comparator = this._param = this._subtract.subtrahend;
+		readOnly(this, "comparator");
+
+		// connect
+		this._subtract.connect(this._gtz);
+	}
+
+	static getDefaults(): GreaterThanOptions {
+		return Object.assign(Signal.getDefaults(), {
+			value: 0,
+		});
+	}
+
+	dispose(): this {
+		super.dispose();
+		this._gtz.dispose();
+		this._subtract.dispose();
+		this.comparator.dispose();
+		return this;
+	}
+}

package/Tone/signal/GreaterThanZero.test.ts

@@ -0,0 +1,49 @@
+import { ConstantOutput } from "test/helper/ConstantOutput";
+import { BasicTests } from "test/helper/Basic";
+import { GreaterThanZero } from "./GreaterThanZero";
+import { Signal } from "Tone/signal/Signal";
+
+describe("GreaterThanZero", () => {
+
+	BasicTests(GreaterThanZero);
+
+	describe("Comparison", () => {
+
+		it("Outputs 0 when the value is less than 0", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(-1);
+				const gtz = new GreaterThanZero();
+				signal.connect(gtz);
+				gtz.toDestination();
+			}, 0);
+		});
+
+		it("Outputs 1 when the value is greater than 0", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(1);
+				const gtz = new GreaterThanZero();
+				signal.connect(gtz);
+				gtz.toDestination();
+			}, 1);
+		});
+
+		it("Outputs 0 when the value is equal to 0", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(0);
+				const gtz = new GreaterThanZero();
+				signal.connect(gtz);
+				gtz.toDestination();
+			}, 0);
+		});
+
+		it("Outputs 1 when the value is slightly above 0", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(0.001);
+				const gtz = new GreaterThanZero();
+				signal.connect(gtz);
+				gtz.toDestination();
+			}, 1);
+		});
+	});
+});
+

package/Tone/signal/GreaterThanZero.ts

@@ -0,0 +1,67 @@
+import { SignalOperator, SignalOperatorOptions } from "./SignalOperator";
+import { Multiply } from "./Multiply";
+import { ToneAudioNode } from "../core/context/ToneAudioNode";
+import { WaveShaper } from "./WaveShaper";
+import { optionsFromArguments } from "../core/util/Defaults";
+
+export type GreaterThanZeroOptions = SignalOperatorOptions
+
+/**
+ * GreaterThanZero outputs 1 when the input is strictly greater than zero
+ * @example
+ * return Tone.Offline(() => {
+ * 	const gt0 = new Tone.GreaterThanZero().toDestination();
+ * 	const sig = new Tone.Signal(0.5).connect(gt0);
+ * 	sig.setValueAtTime(-1, 0.05);
+ * }, 0.1, 1);
+ * @category Signal
+ */
+export class GreaterThanZero extends SignalOperator<GreaterThanZeroOptions> {
+
+	readonly name: string = "GreaterThanZero";
+
+	/**
+	 * The waveshaper
+	 */
+	private _thresh: WaveShaper;
+
+	/**
+	 * Scale the first thresholded signal by a large value.
+	 * this will help with values which are very close to 0
+	 */
+	private _scale: Multiply;
+
+	readonly output: ToneAudioNode;
+	readonly input: ToneAudioNode;
+
+	constructor(options?: Partial<GreaterThanZeroOptions>);
+	constructor() {
+		super(Object.assign(optionsFromArguments(GreaterThanZero.getDefaults(), arguments)));
+
+		this._thresh = this.output = new WaveShaper({
+			context: this.context,
+			length: 127,
+			mapping: (val) => {
+				if (val <= 0) {
+					return 0;
+				} else {
+					return 1;
+				}
+			},
+		});
+		this._scale = this.input = new Multiply({
+			context: this.context,
+			value: 10000
+		});
+
+		// connections
+		this._scale.connect(this._thresh);
+	}
+
+	dispose(): this {
+		super.dispose();
+		this._scale.dispose();
+		this._thresh.dispose();
+		return this;
+	}
+}

package/Tone/signal/Multiply.test.ts

@@ -0,0 +1,46 @@
+import { expect } from "chai";
+import { BasicTests } from "test/helper/Basic";
+import { connectFrom, connectTo } from "test/helper/Connect";
+// import Test from "test/helper/Test";
+import { ConstantOutput } from "test/helper/ConstantOutput";
+import { Multiply } from "./Multiply";
+// import Multiply from "Tone/signal/Multiply";
+import { Signal } from "./Signal";
+// import Oscillator from "Tone/source/Oscillator";
+
+describe("Multiply", () => {
+
+	BasicTests(Multiply);
+
+	describe("Multiplication", () => {
+
+		it("handles input and output connections", () => {
+			const mult = new Multiply();
+			connectFrom().connect(mult, 0);
+			connectFrom().connect(mult.factor);
+			mult.connect(connectTo());
+			mult.dispose();
+		});
+
+		it("correctly multiplys a signal and a scalar", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(2);
+				const mult = new Multiply(10);
+				expect(mult.value).to.equal(10);
+				signal.connect(mult);
+				mult.toDestination();
+			}, 20);
+		});
+
+		it("can multiply two signals", () => {
+			return ConstantOutput(() => {
+				const sigA = new Signal(3);
+				const sigB = new Signal(5);
+				const mult = new Multiply();
+				sigA.connect(mult);
+				sigB.connect(mult.factor);
+				mult.toDestination();
+			}, 15);
+		});
+	});
+});