rf-touchstone 0.0.0 → 0.0.2

package/dist/frequency.d.ts

@@ -0,0 +1,394 @@
+/**
+ * Frequency units: 'Hz', 'kHz', 'MHz', 'GHz'
+ * Touchstone standard doesn't support THz as the frequency unit in Touchstone file
+ */
+export declare const FrequencyUnits: readonly ["Hz", "kHz", "MHz", "GHz"];
+/**
+ * Type definition for frequency units
+ * - Hz: Hertz (cycles per second)
+ * - kHz: Kilohertz (10³ Hz)
+ * - MHz: Megahertz (10⁶ Hz)
+ * - GHz: Gigahertz (10⁹ Hz)
+ * Touchstone standard doesn't support THz as the frequency unit in Touchstone file
+ */
+export type FrequencyUnit = (typeof FrequencyUnits)[number];
+/**
+ * Speed of light in m/s
+ */
+export declare const SPEED_OF_LIGHT = 299792458;
+/**
+ * Multipliers for converting from any FrequencyUnit or THz to Hz
+ */
+export declare const FREQUENCY_MULTIPLIERS: Record<FrequencyUnit | 'THz', number>;
+/**
+ * Multipliers for converting from other wavelength units to meters
+ */
+export declare const WAVELENGTH_MULTIPLIERS_TO_M: Record<string, number>;
+/**
+ * Class representing frequency data in RF and microwave engineering
+ *
+ * @remarks
+ * The Frequency class manages frequency-related data, including:
+ * - Frequency unit management
+ * - Storage of frequency points
+ * - Unit conversion capabilities
+ *
+ * @example
+ * ```typescript
+ * const freq = new Frequency();
+ * freq.unit = 'GHz';
+ * freq.f_scale = [1.0, 2.0, 3.0];
+ * ```
+ */
+export declare class Frequency {
+    /**
+     * Internal storage for frequency unit
+     * Defaults to 'Hz' as the base SI unit for frequency
+     */
+    private _unit;
+    /**
+     * Sets the frequency unit for the instance
+     *
+     * @param newUnit - The frequency unit to set
+     * @throws {Error} If the provided unit is not one of the supported frequency units
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'MHz'; // Sets unit to Megahertz
+     * ```
+     */
+    set unit(newUnit: FrequencyUnit);
+    /**
+     * Gets the current frequency unit
+     *
+     * @returns The current frequency unit
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * console.log(freq.unit); // Outputs: 'Hz'
+     * ```
+     */
+    get unit(): FrequencyUnit;
+    /**
+     * Internal storage for frequency points array
+     * Each element represents a frequency point in the specified unit
+     * @private
+     */
+    private _f_scaled;
+    /**
+     * Array of frequency points in the current frequency unit
+     * Each element represents a discrete frequency point for measurement or analysis
+     *
+     * @param value - Array of frequency points
+     * @throws {Error} If the input is not an array
+     * @throws {Error} If any element in the array is not a number
+     * @throws {Error} If the array contains negative frequencies
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'GHz';
+     * freq.f_scaled = [1.0, 1.5, 2.0]; // Sets frequency points in GHz
+     * ```
+     */
+    set f_scaled(value: number[]);
+    /**
+     * Gets the array of frequency points
+     * @returns Array of frequency points in the current unit
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'MHz';
+     * freq.f_scaled = [100, 200, 300];
+     * console.log(freq.f_scaled); // Outputs: [100, 200, 300]
+     * ```
+     */
+    get f_scaled(): number[];
+    /**
+     * Private helper method to get frequency values in a target unit.
+     * @param targetUnit - The key of the target frequency unit in FREQUENCY_MULTIPLIERS.
+     * @returns Array of frequency points in the target unit.
+     */
+    private _getFrequencyInTargetUnit;
+    /**
+     * Private helper method to set frequency values from a source unit.
+     * @param values - Array of frequency points in the source unit.
+     * @param sourceUnit - The key of the source frequency unit in FREQUENCY_MULTIPLIERS.
+     */
+    private _setFrequencyFromTargetUnit;
+    /**
+     * Gets frequency points in Hz
+     * @returns Array of frequency points in Hz
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'GHz';
+     * freq.f_scaled = [1, 2, 3]; // 1 GHz, 2 GHz, 3 GHz
+     * console.log(freq.f_Hz); // Outputs: [1e9, 2e9, 3e9]
+     * ```
+     */
+    get f_Hz(): number[];
+    /**
+     * Sets frequency points assuming input is in Hz
+     * @param values - Array of frequency points in Hz
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'MHz';
+     * freq.f_Hz = [1e9, 2e9, 3e9]; // Sets frequencies as 1 GHz, 2 GHz, 3 GHz
+     * console.log(freq.f_scaled); // Outputs: [1000, 2000, 3000] (in MHz)
+     * ```
+     */
+    set f_Hz(values: number[]);
+    /**
+     * Gets frequency points in kHz
+     * @returns Array of frequency points in kHz
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'Hz';
+     * freq.f_scaled = [1000, 2000, 3000]; // 1 kHz, 2 kHz, 3 kHz
+     * console.log(freq.f_kHz); // Outputs: [1, 2, 3]
+     * ```
+     */
+    get f_kHz(): number[];
+    /**
+     * Sets frequency points assuming input is in kHz
+     * @param values - Array of frequency points in kHz
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'Hz';
+     * freq.f_kHz = [1, 2, 3]; // Sets frequencies as 1 kHz, 2 kHz, 3 kHz
+     * console.log(freq.f_scaled); // Outputs: [1000, 2000, 3000] (in Hz)
+     * ```
+     */
+    set f_kHz(values: number[]);
+    /**
+     * Gets frequency points in MHz
+     * @returns Array of frequency points in MHz
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'GHz';
+     * freq.f_scaled = [0.1, 0.2, 0.3]; // 0.1 GHz, 0.2 GHz, 0.3 GHz
+     * console.log(freq.f_MHz); // Outputs: [100, 200, 300]
+     * ```
+     */
+    get f_MHz(): number[];
+    /**
+     * Sets frequency points assuming input is in MHz
+     * @param values - Array of frequency points in MHz
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'GHz';
+     * freq.f_MHz = [100, 200, 300]; // Sets frequencies as 100 MHz, 200 MHz, 300 MHz
+     * console.log(freq.f_scaled); // Outputs: [0.1, 0.2, 0.3] (in GHz)
+     * ```
+     */
+    set f_MHz(values: number[]);
+    /**
+     * Gets frequency points in GHz
+     * @returns Array of frequency points in GHz
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'MHz';
+     * freq.f_scaled = [1000, 2000, 3000]; // 1000 MHz, 2000 MHz, 3000 MHz
+     * console.log(freq.f_GHz); // Outputs: [1, 2, 3]
+     * ```
+     */
+    get f_GHz(): number[];
+    /**
+     * Sets frequency points assuming input is in GHz
+     * @param values - Array of frequency points in GHz
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'MHz';
+     * freq.f_GHz = [1, 2, 3]; // Sets frequencies as 1 GHz, 2 GHz, 3 GHz
+     * console.log(freq.f_scaled); // Outputs: [1000, 2000, 3000] (in MHz)
+     * ```
+     */
+    set f_GHz(values: number[]);
+    /**
+     * Gets frequency points in THz
+     * @returns Array of frequency points in THz
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'GHz';
+     * freq.f_scaled = [1000, 2000, 3000]; // 1000 GHz, 2000 GHz, 3000 GHz
+     * console.log(freq.f_THz); // Outputs: [1, 2, 3]
+     * ```
+     */
+    get f_THz(): number[];
+    /**
+     * Sets frequency points assuming input is in THz
+     * @param values - Array of frequency points in THz
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'GHz';
+     * freq.f_THz = [1, 2, 3]; // Sets frequencies as 1 THz, 2 THz, 3 THz
+     * console.log(freq.f_scaled); // Outputs: [1000, 2000, 3000] (in GHz)
+     * ```
+     */
+    set f_THz(values: number[]);
+    /**
+     * Private helper method to get wavelength values in a target unit.
+     * @param targetWavelengthUnit - The key of the target wavelength unit in WAVELENGTH_MULTIPLIERS_TO_M.
+     * @returns Array of wavelength points in the target unit.
+     */
+    private _getWavelengthInTargetUnit;
+    /**
+     * Private helper method to set frequency values from wavelength values in a source unit.
+     * @param values - Array of wavelength points in the source unit.
+     * @param sourceWavelengthUnit - The key of the source wavelength unit in WAVELENGTH_MULTIPLIERS_TO_M.
+     */
+    private _setWavelengthFromTargetUnit;
+    /**
+     * Gets wavelength in meters
+     * @returns Array of wavelength values in meters
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'GHz';
+     * freq.f_scaled = [1, 2, 3]; // Frequencies in GHz
+     * console.log(freq.wavelength_m); // Outputs: Wavelengths in meters
+     * ```
+     */
+    get wavelength_m(): number[];
+    /**
+     * Sets wavelength in meters. Converts to frequency and stores.
+     * @param values - Array of wavelength values in meters
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'GHz';
+     * freq.wavelength_m = [0.3, 0.15, 0.1]; // Wavelengths in meters
+     * console.log(freq.f_scaled); // Outputs: Frequencies in GHz
+     * ```
+     */
+    set wavelength_m(values: number[]);
+    /**
+     * Gets wavelength in centimeters
+     * @returns Array of wavelength values in centimeters
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'GHz';
+     * freq.f_scaled = [10, 20, 30]; // Frequencies in GHz
+     * console.log(freq.wavelength_cm); // Outputs: Wavelengths in centimeters
+     * ```
+     */
+    get wavelength_cm(): number[];
+    /**
+     * Sets wavelength in centimeters. Converts to frequency and stores.
+     * @param values - Array of wavelength values in centimeters
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'GHz';
+     * freq.wavelength_cm = [30, 15, 10]; // Wavelengths in centimeters
+     * console.log(freq.f_scaled); // Outputs: Frequencies in GHz
+     * ```
+     */
+    set wavelength_cm(values: number[]);
+    /**
+     * Gets wavelength in millimeters
+     * @returns Array of wavelength values in millimeters
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'GHz';
+     * freq.f_scaled = [100, 200, 300]; // Frequencies in GHz
+     * console.log(freq.wavelength_mm); // Outputs: Wavelengths in millimeters
+     * ```
+     */
+    get wavelength_mm(): number[];
+    /**
+     * Sets wavelength in millimeters. Converts to frequency and stores.
+     * @param values - Array of wavelength values in millimeters
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'GHz';
+     * freq.wavelength_mm = [300, 150, 100]; // Wavelengths in millimeters
+     * console.log(freq.f_scaled); // Outputs: Frequencies in GHz
+     * ```
+     */
+    set wavelength_mm(values: number[]);
+    /**
+     * Gets wavelength in micrometers
+     * @returns Array of wavelength values in micrometers
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'GHz';
+     * freq.f_scaled = [1000, 2000, 3000]; // Frequencies in GHz
+     * console.log(freq.wavelength_um); // Outputs: Wavelengths in micrometers
+     * ```
+     */
+    get wavelength_um(): number[];
+    /**
+     * Sets wavelength in micrometers. Converts to frequency and stores.
+     * @param values - Array of wavelength values in micrometers
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'GHz';
+     * freq.wavelength_um = [300000, 150000, 100000]; // Wavelengths in micrometers
+     * console.log(freq.f_scaled); // Outputs: Frequencies in GHz
+     * ```
+     */
+    set wavelength_um(values: number[]);
+    /**
+     * Gets wavelength in nanometers
+     * @returns Array of wavelength values in nanometers
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'THz';
+     * freq.f_scaled = [100, 200, 300]; // Frequencies in THz
+     * console.log(freq.wavelength_nm); // Outputs: Wavelengths in nanometers
+     * ```
+     */
+    get wavelength_nm(): number[];
+    /**
+     * Sets wavelength in nanometers. Converts to frequency and stores.
+     * @param values - Array of wavelength values in nanometers
+     *
+     * @example
+     * ```typescript
+     * const freq = new Frequency();
+     * freq.unit = 'THz';
+     * freq.wavelength_nm = [300, 150, 100]; // Wavelengths in nanometers
+     * console.log(freq.f_scaled); // Outputs: Frequencies in THz
+     * ```
+     */
+    set wavelength_nm(values: number[]);
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import { abs, add, arg, log10, index, multiply, pi, pow, round, subset } from 'mathjs';
+/**
+ * Creates a complex value or converts a value to a complex value.
+ *
+ * @see {@link https://mathjs.org/docs/reference/functions/complex.html | Math.js documentation for complex}
+ */
+export declare const complex: {
+    (arg?: import('mathjs').MathNumericType | string | import('mathjs').PolarCoordinates): import('mathjs').Complex;
+    (arg?: import('mathjs').MathCollection): import('mathjs').MathCollection;
+    (re: number, im: number): import('mathjs').Complex;
+};
+/**
+ * Create an array or matrix with a range of numbers.
+ *
+ * @see {@link https://mathjs.org/docs/reference/functions/range.html | Math.js documentation for range}
+ */
+export declare const range: {
+    (str: string, includeEnd?: boolean): import('mathjs').Matrix;
+    (start: number | import('mathjs').BigNumber, end: number | import('mathjs').BigNumber, includeEnd?: boolean): import('mathjs').Matrix;
+    (start: number | import('mathjs').BigNumber | import('mathjs').Unit, end: number | import('mathjs').BigNumber | import('mathjs').Unit, step: number | import('mathjs').BigNumber | import('mathjs').Unit, includeEnd?: boolean): import('mathjs').Matrix;
+};
+export { abs, add, arg, log10, index, multiply, pi, pow, round, subset };
+export * from './frequency';
+export * from './touchstone';