tone 14.8.27

package/Tone/signal/Multiply.ts

@@ -0,0 +1,85 @@
+import { Gain } from "../core/context/Gain";
+import { Param } from "../core/context/Param";
+import { optionsFromArguments } from "../core/util/Defaults";
+import { Signal, SignalOptions } from "./Signal";
+import { InputNode, OutputNode } from "../core/context/ToneAudioNode";
+
+/**
+ * Multiply two incoming signals. Or, if a number is given in the constructor,
+ * multiplies the incoming signal by that value.
+ *
+ * @example
+ * // multiply two signals
+ * const mult = new Tone.Multiply();
+ * const sigA = new Tone.Signal(3);
+ * const sigB = new Tone.Signal(4);
+ * sigA.connect(mult);
+ * sigB.connect(mult.factor);
+ * // output of mult is 12.
+ * @example
+ * // multiply a signal and a number
+ * const mult = new Tone.Multiply(10);
+ * const sig = new Tone.Signal(2).connect(mult);
+ * // the output of mult is 20.
+ * @category Signal
+ */
+export class Multiply<TypeName extends "number" | "positive" = "number"> extends Signal<TypeName> {
+
+	readonly name: string = "Multiply";
+
+	/**
+	 * Indicates if the value should be overridden on connection
+	 */
+	readonly override = false;
+
+	/**
+	 * the input gain node
+	 */
+	private _mult: Gain;
+
+	/**
+	 * The multiplicand input.
+	 */
+	input: InputNode;
+
+	/**
+	 * The product of the input and [[factor]]
+	 */
+	output: OutputNode;
+
+	/**
+	 * The multiplication factor. Can be set directly or a signal can be connected to it.
+	 */
+	factor: Param<TypeName>;
+
+	/**
+	 * @param value Constant value to multiple
+	 */
+	constructor(value?: number);
+	constructor(options?: Partial<SignalOptions<TypeName>>);
+	constructor() {
+		super(Object.assign(optionsFromArguments(Multiply.getDefaults(), arguments, ["value"])));
+		const options = optionsFromArguments(Multiply.getDefaults(), arguments, ["value"]);
+
+		this._mult = this.input = this.output = new Gain({
+			context: this.context,
+			minValue: options.minValue,
+			maxValue: options.maxValue,
+		});
+
+		this.factor = this._param = this._mult.gain as unknown as Param<TypeName>;
+		this.factor.setValueAtTime(options.value, 0);
+	}
+
+	static getDefaults(): SignalOptions<any> {
+		return Object.assign(Signal.getDefaults(), {
+			value: 0,
+		});
+	}
+
+	dispose(): this {
+		super.dispose();
+		this._mult.dispose();
+		return this;
+	}
+}

package/Tone/signal/Negate.test.ts

@@ -0,0 +1,30 @@
+import { BasicTests } from "test/helper/Basic";
+import { ConstantOutput } from "test/helper/ConstantOutput";
+import { Negate } from "./Negate";
+import { Signal } from "./Signal";
+
+describe("Negate", () => {
+
+	BasicTests(Negate);
+
+	context("Negating", () => {
+
+		it("negateates a positive value", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(1);
+				const negate = new Negate();
+				signal.connect(negate);
+				negate.toDestination();
+			}, -1);
+		});
+
+		it("makes a negateative value positive", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(-10);
+				const negate = new Negate();
+				signal.connect(negate);
+				negate.toDestination();
+			}, 10);
+		});
+	});
+});

package/Tone/signal/Negate.ts

@@ -0,0 +1,41 @@
+import { ToneAudioNodeOptions } from "../core/context/ToneAudioNode";
+import { Multiply } from "./Multiply";
+import { SignalOperator } from "./SignalOperator";
+
+/**
+ * Negate the incoming signal. i.e. an input signal of 10 will output -10
+ *
+ * @example
+ * const neg = new Tone.Negate();
+ * const sig = new Tone.Signal(-2).connect(neg);
+ * // output of neg is positive 2.
+ * @category Signal
+ */
+export class Negate extends SignalOperator<ToneAudioNodeOptions> {
+
+	readonly name: string = "Negate";
+
+	/**
+	 * negation is done by multiplying by -1
+	 */
+	private _multiply: Multiply = new Multiply({
+		context: this.context,
+		value: -1,
+	});
+
+	/**
+	 * The input and output are equal to the multiply node
+	 */
+	input = this._multiply;
+	output = this._multiply;
+
+	/**
+	 * clean up
+	 * @returns {Negate} this
+	 */
+	dispose(): this {
+		super.dispose();
+		this._multiply.dispose();
+		return this;
+	}
+}

package/Tone/signal/Pow.test.ts

@@ -0,0 +1,40 @@
+import { BasicTests } from "test/helper/Basic";
+import { Pow } from "./Pow";
+import { ConstantOutput } from "test/helper/ConstantOutput";
+import { Signal } from "./Signal";
+
+describe("Pow", () => {
+
+	BasicTests(Pow);
+
+	context("Exponential Scaling", () => {
+
+		it("can do powers of 2", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(0.3);
+				const pow = new Pow(2);
+				signal.connect(pow);
+				pow.toDestination();
+			}, 0.09); 
+		});
+
+		it("can compute negative values and powers less than 1", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(-0.49);
+				const pow = new Pow(0.5);
+				signal.connect(pow);
+				pow.toDestination();
+			}, 0.7); 
+		});
+
+		it("can set a new exponent", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(0.5);
+				const pow = new Pow(1);
+				pow.value = 3;
+				signal.connect(pow);
+				pow.toDestination();
+			}, 0.125); 
+		});
+	});
+});

package/Tone/signal/Pow.ts

@@ -0,0 +1,84 @@
+import { WaveShaper, WaveShaperMappingFn } from "./WaveShaper";
+import { optionsFromArguments } from "../core/util/Defaults";
+import { SignalOperator } from "./SignalOperator";
+import { ToneAudioNodeOptions } from "../core/context/ToneAudioNode";
+
+export interface PowOptions extends ToneAudioNodeOptions {
+	value: number;
+}
+
+/**
+ * Pow applies an exponent to the incoming signal. The incoming signal must be AudioRange [-1, 1]
+ *
+ * @example
+ * const pow = new Tone.Pow(2);
+ * const sig = new Tone.Signal(0.5).connect(pow);
+ * // output of pow is 0.25. 
+ * @category Signal
+ */
+export class Pow extends SignalOperator<PowOptions> {
+
+	readonly name: string = "Pow";
+
+	private _exponent: number;
+
+	private _exponentScaler: WaveShaper;
+
+	input: WaveShaper;
+
+	output: WaveShaper;
+
+	/**
+	 * @param value Constant exponent value to use
+	 */
+	constructor(value?: number);
+	constructor(options?: Partial<PowOptions>);
+	constructor() {
+		super(Object.assign(optionsFromArguments(Pow.getDefaults(), arguments, ["value"])));
+		const options = optionsFromArguments(Pow.getDefaults(), arguments, ["value"]);
+
+		this._exponentScaler = this.input = this.output = new WaveShaper({
+			context: this.context,
+			mapping: this._expFunc(options.value),
+			length: 8192,
+		});
+
+		this._exponent = options.value;
+	}
+
+	static getDefaults(): PowOptions {
+		return Object.assign(SignalOperator.getDefaults(), {
+			value: 1,
+		});
+	}
+
+	/**
+	 * the function which maps the waveshaper
+	 * @param exponent exponent value
+	 */
+	private _expFunc(exponent: number): WaveShaperMappingFn {
+		return (val: number) => {
+			return Math.pow(Math.abs(val), exponent);
+		};
+	}
+
+	/**
+	 * The value of the exponent.
+	 */
+	get value(): number {
+		return this._exponent;
+	}
+	set value(exponent: number) {
+		this._exponent = exponent;
+		this._exponentScaler.setMap(this._expFunc(this._exponent));
+	}
+
+	/**
+	 * Clean up.
+	 */
+	dispose(): this {
+		super.dispose();
+		this._exponentScaler.dispose();
+		return this;
+	}
+}

package/Tone/signal/Scale.test.ts

@@ -0,0 +1,58 @@
+import { expect } from "chai";
+import { BasicTests } from "test/helper/Basic";
+import { connectFrom, connectTo } from "test/helper/Connect";
+import { ConstantOutput } from "test/helper/ConstantOutput";
+import { Scale } from "./Scale";
+import { Signal } from "./Signal";
+
+describe("Scale", () => {
+
+	BasicTests(Scale);
+
+	context("Scaling", () => {
+
+		it("handles input and output connections", () => {
+			const scale = new Scale({ min: 0, max: 100 });
+			connectFrom().connect(scale);
+			scale.connect(connectTo());
+			scale.dispose();
+		});
+
+		it("can set the min and max values", () => {
+			const scale = new Scale({ min: 0, max: 100 });
+			scale.min = -0.01;
+			expect(scale.min).to.be.closeTo(-0.01, 0.001);
+			scale.max = 1000;
+			expect(scale.max).to.be.closeTo(1000, 0.001);
+			scale.dispose();
+		});
+
+		it("scales to the min when the input is 0", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(0);
+				const scale = new Scale({ min: -10, max: 8 });
+				signal.connect(scale);
+				scale.toDestination();
+			}, -10);
+		});
+
+		it("scales to the max when the input is 1", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(1);
+				const scale = new Scale(-10, 0);
+				scale.max = 8;
+				signal.connect(scale);
+				scale.toDestination();
+			}, 8);
+		});
+
+		it("scales an input of 0.5 to 15 (10, 20)", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(0.5);
+				const scale = new Scale({ min: 10, max: 20 });
+				signal.connect(scale);
+				scale.toDestination();
+			}, 15);
+		});
+	});
+});

package/Tone/signal/Scale.ts

@@ -0,0 +1,119 @@
+import { InputNode, OutputNode, ToneAudioNodeOptions } from "../core/context/ToneAudioNode";
+import { optionsFromArguments } from "../core/util/Defaults";
+import { Add } from "./Add";
+import { Multiply } from "./Multiply";
+import { SignalOperator } from "./SignalOperator";
+
+export interface ScaleOptions extends ToneAudioNodeOptions {
+	min: number;
+	max: number;
+}
+
+/**
+ * Performs a linear scaling on an input signal.
+ * Scales a NormalRange input to between
+ * outputMin and outputMax.
+ *
+ * @example
+ * const scale = new Tone.Scale(50, 100);
+ * const signal = new Tone.Signal(0.5).connect(scale);
+ * // the output of scale equals 75
+ * @category Signal
+ */
+export class Scale<Options extends ScaleOptions = ScaleOptions> extends SignalOperator<Options> {
+
+	readonly name: string = "Scale";
+
+	input: InputNode;
+	output: OutputNode;
+
+	/**
+	 * Hold the multiple
+	 */
+	protected _mult: Multiply;
+
+	/**
+	 * Hold the adder
+	 */
+	protected _add: Add;
+
+	/**
+	 * Private reference to the min value
+	 */
+	private _min: number;
+
+	/**
+	 * Private reference to the max value
+	 */
+	private _max: number;
+
+	/**
+	 * @param min The output value when the input is 0.
+	 * @param max The output value when the input is 1.
+	 */
+	constructor(min?: number, max?: number);
+	constructor(options?: Partial<ScaleOptions>);
+	constructor() {
+		super(Object.assign(optionsFromArguments(Scale.getDefaults(), arguments, ["min", "max"])));
+		const options = optionsFromArguments(Scale.getDefaults(), arguments, ["min", "max"]);
+
+		this._mult = this.input = new Multiply({
+			context: this.context,
+			value: options.max - options.min,
+		});
+
+		this._add = this.output = new Add({
+			context: this.context,
+			value: options.min,
+		});
+
+		this._min = options.min;
+		this._max = options.max;
+
+		this.input.connect(this.output);
+	}
+
+	static getDefaults(): ScaleOptions {
+		return Object.assign(SignalOperator.getDefaults(), {
+			max: 1,
+			min: 0,
+		});
+	}
+
+	/**
+	 * The minimum output value. This number is output when the value input value is 0.
+	 */
+	get min(): number {
+		return this._min;
+	}
+	set min(min) {
+		this._min = min;
+		this._setRange();
+	}
+
+	/**
+	 * The maximum output value. This number is output when the value input value is 1.
+	 */
+	get max(): number {
+		return this._max;
+	}
+	set max(max) {
+		this._max = max;
+		this._setRange();
+	}
+
+	/**
+	 * set the values
+	 */
+	private _setRange(): void {
+		this._add.value = this._min;
+		this._mult.value = this._max - this._min;
+	}
+
+	dispose(): this {
+		super.dispose();
+		this._add.dispose();
+		this._mult.dispose();
+		return this;
+	}
+}

package/Tone/signal/ScaleExp.test.ts

@@ -0,0 +1,49 @@
+import { ConstantOutput } from "test/helper/ConstantOutput";
+import { ScaleExp } from "./ScaleExp";
+import { BasicTests } from "test/helper/Basic";
+import { Signal } from "Tone/signal/Signal";
+import { expect } from "chai";
+
+describe("ScaleExp", () => {
+
+	BasicTests(ScaleExp);
+
+	context("Scaling", () => {
+
+		it("can set the min and max values", () => {
+			const scale = new ScaleExp(-20, 10, 2);
+			scale.min = -0.01;
+			expect(scale.min).to.be.closeTo(-0.01, 0.001);
+			scale.max = 1000;
+			expect(scale.max).to.be.closeTo(1000, 0.001);
+			scale.dispose();
+		});
+
+		it("can set the exponent value", () => {
+			const scale = new ScaleExp(0, 100, 2);
+			expect(scale.exponent).to.be.closeTo(2, 0.001);
+			scale.exponent = 3;
+			expect(scale.exponent).to.be.closeTo(3, 0.001);
+			scale.dispose();
+		});
+
+		it("scales a signal between two values exponentially", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(0.5);
+				const scale = new ScaleExp(0, 1, 3);
+				signal.connect(scale);
+				scale.toDestination();
+			}, 0.125); 
+		});
+
+		it("scale a signal between 1 and 3 exponentially", () => {
+			return ConstantOutput(() => {
+				const signal = new Signal(0.5);
+				const scale = new ScaleExp(1, 3, 2);
+				signal.connect(scale);
+				scale.toDestination();
+			}, 1.5); 
+		});
+	});
+});
+

package/Tone/signal/ScaleExp.ts

@@ -0,0 +1,69 @@
+import { Scale, ScaleOptions } from "./Scale";
+import { Positive } from "../core/type/Units";
+import { optionsFromArguments } from "../core/util/Defaults";
+import { Pow } from "./Pow";
+
+export interface ScaleExpOptions extends ScaleOptions {
+	exponent: Positive;
+}
+
+/**
+ * Performs an exponential scaling on an input signal.
+ * Scales a NormalRange value [0,1] exponentially
+ * to the output range of outputMin to outputMax.
+ * @example
+ * const scaleExp = new Tone.ScaleExp(0, 100, 2);
+ * const signal = new Tone.Signal(0.5).connect(scaleExp);
+ * @category Signal
+ */
+export class ScaleExp extends Scale<ScaleExpOptions> {
+
+	readonly name: string = "ScaleExp";
+
+	/**
+	 * The exponent scaler
+	 */
+	private _exp: Pow;
+
+	/**
+	 * @param min The output value when the input is 0.
+	 * @param max The output value when the input is 1.
+	 * @param exponent The exponent which scales the incoming signal.
+	 */
+	constructor(min?: number, max?: number, exponent?: number);
+	constructor(options?: Partial<ScaleExpOptions>);
+	constructor() {
+		super(Object.assign(optionsFromArguments(ScaleExp.getDefaults(), arguments, ["min", "max", "exponent"])));
+		const options = optionsFromArguments(ScaleExp.getDefaults(), arguments, ["min", "max", "exponent"]);
+
+		this.input = this._exp = new Pow({
+			context: this.context,
+			value: options.exponent,
+		});
+		this._exp.connect(this._mult);
+	}
+
+	static getDefaults(): ScaleExpOptions {
+		return Object.assign(Scale.getDefaults(), {
+			exponent: 1,
+		});
+	}
+
+	/**
+	 * Instead of interpolating linearly between the [[min]] and
+	 * [[max]] values, setting the exponent will interpolate between
+	 * the two values with an exponential curve.
+	 */
+	get exponent(): Positive {
+		return this._exp.value;
+	}
+	set exponent(exp) {
+		this._exp.value = exp;
+	}
+
+	dispose(): this {
+		super.dispose();
+		this._exp.dispose();
+		return this;
+	}
+}