@rwk/physics-math/lib/cjs/arith.d.ts

Math for physics homework problems

/**
 * @packageDocumentation
 * @module Functionals
 */
import { IndefiniteIntegral, IPCompiled, IPCompileResult, IPFunction, IPFunctionCalculus } from "./base";
import { PCalculus } from "./pfunction";
import { Units } from './unit-defs';
import { Unit, Divide, Multiply } from "./units";
import { Orientation, Point, Rotation, Vector, BaseValue, BaseValueRelative, RelativeOf, TYPE, BaseValueInFrame } from "./math-types";
/**
 * Add two BaseValue quantities or BaseValue-valued functions together.
 */
export declare function add<R extends BaseValueRelative>(a: R, ...rest: R[]): R;
export declare function add<R extends BaseValueInFrame>(a: R, ...rest: RelativeOf<R>[]): R;
export declare function add<U extends Unit, R extends Vector<U> | Rotation<U>>(a: IPCompiled<R>, ...rest: IPCompiled<R>[]): IPCompiled<R>;
export declare function add<R extends BaseValueInFrame>(a: IPCompiled<R>, ...rest: IPCompiled<RelativeOf<R>>[]): IPCompiled<R>;
export declare function add<R extends Point | Vector>(a: IPCompiled<R>, ...rest: IPCompiled<Vector>[]): IPCompiled<R>;
export declare function add<U extends Unit, R extends Rotation<U>>(a: R, ...rest: R[]): R;
export declare function add<R extends Orientation>(a: R, ...rest: Rotation<Units.angle>[]): R;
export declare function add<U extends Unit, R extends Rotation<U>>(a: IPCompiled<R>, ...rest: IPCompiled<R>[]): IPCompiled<R>;
export declare function add<R extends Orientation>(a: IPCompiled<R>, ...rest: IPCompiled<Rotation>[]): IPCompiled<R>;
export declare function add<R extends number>(a: IPFunction<R>, ...rest: IPFunction<BaseValueRelative>[]): IPFunction<R>;
export declare function add<R extends Point | Vector>(a: IPFunction<R>, ...rest: IPFunction<Vector>[]): IPFunction<R>;
export declare function add<U extends Unit, R extends Rotation<U>>(a: IPFunction<R>, ...rest: IPFunction<R>[]): IPFunction<R>;
export declare function add<R extends Orientation>(a: IPFunction<R>, ...rest: IPFunction<Rotation>[]): IPFunction<R>;
export declare function gadd(a: BaseValue | IPFunction | IPCompiled, ...rest: (BaseValueRelative | IPFunction | IPCompiled)[]): BaseValue | IPFunction | IPCompiled;
declare abstract class BinaryOp<R extends BaseValueRelative, X extends BaseValueRelative, C extends Unit, D extends Unit, I extends Unit> extends PCalculus<R, C, D, I> {
    l: IPFunctionCalculus<R, C, 1, D, I>;
    r: IPFunctionCalculus<X, C, 1, D, I>;
    protected constructor(l: IPFunctionCalculus<R, C, 1, D, I>, r: IPFunctionCalculus<X, C, 1, D, I>);
    get returnType(): TYPE;
    equiv<T>(f: T): null | this | T;
}
export declare class PAdd<R extends BaseValueRelative, C extends Unit, D extends Unit = Divide<C, Units.time>, I extends Unit = Multiply<C, Units.time>> extends BinaryOp<R, R, C, D, I> implements IPFunctionCalculus<R, C, 1, D, I> {
    constructor(a: IPFunctionCalculus<R, C, 1, D, I>, b: IPFunctionCalculus<R, C, 1, D, I>);
    differentiate(): IPFunctionCalculus<R, D, 1, Divide<D, Units.time>, C>;
    integrate(): IndefiniteIntegral<R, I, C>;
    protected compileFn(): IPCompileResult<R>;
}
export declare class PSub<R extends BaseValueRelative, U extends Unit, D extends Unit = Divide<U, Units.time>, I extends Unit = Multiply<U, Units.time>> extends BinaryOp<R, R, U, D, I> implements IPFunctionCalculus<R, U, 1, D, I> {
    constructor(a: IPFunctionCalculus<R, U, 1, D, I>, b: IPFunctionCalculus<R, U, 1, D, I>);
    differentiate(): IPFunctionCalculus<R, D, 1, Divide<D, Units.time>, U>;
    integrate(): IndefiniteIntegral<R, I, U>;
    protected compileFn(): IPCompileResult<R>;
}
/**
 * Multiply a number, Vector, or Rotation by 0 or more scalar values.
 * Works on individual values, or PFFunction or IPFunction's. (You cannot
 * mix levels, however).
 *
 * Returns the same type as the first argument.
 */
export declare function sub<R extends BaseValueInFrame>(a: R, ...rest: RelativeOf<R>[]): R;
export declare function sub<R extends BaseValueInFrame>(a: R, b: R): RelativeOf<R>;
export declare function sub<R extends BaseValueRelative>(a: R, ...b: R[]): R;
export declare function sub<R extends BaseValueInFrame>(a: IPCompiled<R>, ...rest: IPCompiled<RelativeOf<R>>[]): IPCompiled<R>;
export declare function sub<R extends BaseValueInFrame>(a: IPCompiled<R>, b: IPCompiled<R>): IPCompiled<RelativeOf<R>>;
export declare function sub<R extends BaseValueRelative>(a: IPCompiled<R>, ...b: IPCompiled<R>[]): IPCompiled<R>;
export declare function sub<R extends BaseValueInFrame>(a: IPFunction<R>, ...rest: IPFunction<RelativeOf<R>>[]): IPFunction<R>;
export declare function sub<R extends BaseValueInFrame>(a: IPFunction<R>, b: IPFunction<R>): IPFunction<RelativeOf<R>>;
export declare function sub<R extends BaseValueRelative>(a: IPFunction<R>, ...b: IPFunction<R>[]): IPFunction<R>;
export declare function gsub(a: BaseValue | IPFunction | IPCompiled, ...rest: (BaseValue | IPFunction | IPCompiled)[]): BaseValue | IPFunction | IPCompiled;
export declare class PMul<R extends BaseValueRelative, U extends Unit, D extends Unit, I extends Unit> extends BinaryOp<R, number, U, D, I> {
    constructor(a: IPFunctionCalculus<R, U, 1, D, I>, b: IPFunctionCalculus<number, U, 1, D, I>);
    differentiate(): IPFunctionCalculus<R, D, 1, Divide<D, Units.time>, U>;
    integrate(): IndefiniteIntegral<R, I, U>;
    protected compileFn(): IPCompileResult<R>;
}
export declare function mul<R extends BaseValueRelative>(a: R, ...rest: number[]): R;
export declare function mul<R extends BaseValueRelative>(a: IPCompiled<R>, ...rest: (IPCompiled<number> | number)[]): IPCompiled<R>;
export declare function mul<R extends BaseValueRelative>(a: IPFunction<R>, ...rest: (IPFunction<number> | number)[]): IPFunction<R>;
export declare function gmul(a: BaseValueRelative | IPFunction<BaseValueRelative> | IPCompiled<BaseValueRelative>, ...rest: (number | IPFunction<number> | IPCompiled<number>)[]): BaseValueRelative | IPFunction<BaseValueRelative> | IPCompiled<BaseValueRelative> | IPFunctionCalculus<BaseValueRelative>;
export declare function equal<T extends BaseValue>(a: T, b: T): boolean;
export declare function near<T extends BaseValue>(a: T, b: T, epsilon?: number): boolean;
export {};
//# sourceMappingURL=arith.d.ts.map