bayes-server/lib/core.d.ts

Bayes Server JavaScript API

export declare class VariableId {
    static readonly Zero: VariableId;
    static readonly One: VariableId;
    private _Dhb_x_;
    private static readonly _Dhc_x_;
    private constructor();
    increment(): VariableId;
    private _rqsv_x_(p_autogen1, p_autogen2);
    compareTo(that: VariableId): number;
    private _rqtq_x_(p_autogen4, p_autogen5);
}
/**
*  Contains methods to reverse the direction of a {@link com.bayesserver.Link}, known as arc reversal.
*/
export declare class ArcReversal {
    /**
*  Reverse the direction of a {@link com.bayesserver.Link} (known as arc reversal).
*
* @param {Link} link The link whose direction should be changed.
*/
    static reverse(link: Link): void;
    private static _q_x_(p_autogen1);
    private static _r_x_(p_autogen2);
    private static _s_x_(p_autogen3, p_autogen4);
}
/**
*  Stores the position and size of an element.
*/
export declare class Bounds {
    private _A_x_;
    private _B_x_;
    private _C_x_;
    private _D_x_;
    /**
*  Initializes a new instance of the {@link com.bayesserver.Bounds} class.
*
* @param {number} x The x-axis value of the left side of the element.
*
* @param {number} y The y-axis value of the top side of the element.
*
* @param {number} width The width of the element.
*
* @param {number} height The height of the element.
*/
    constructor(x: number, y: number, width: number, height: number);
    /**
*  Gets the x-axis value of the left side of the element.
*/
    readonly x: number;
    /**
*  Gets the y-axis value of the top side of the element.
*/
    readonly y: number;
    /**
*  Gets the width of the element.
*/
    readonly width: number;
    /**
*  Gets the height of the element.
*/
    readonly height: number;
}
/**
*  Class for canceling long running operations.

* @see com.bayesserver.ICancellation
*/
export declare class Cancellation implements ICancellation {
    private cancel_AUTO_GENERATED;
    /**
* @inheritDoc
*/
    /**
* @inheritDoc
*/
    cancel: boolean;
}
/**
*  Represents a Conditional Linear Gaussian probability distribution.
*
*  The distribution contains a {@link com.bayesserver.Table} distribution which represents any discrete combinations, and for each combination there exists a multivariate Gaussian distribution and weight/regression coefficients. Note that head variables are those that appear to the left of the bar in the expression P(A|B) and tail variables are those to the right.
*/
export declare class CLGaussian implements IDistribution {
    /**
* @inheritDoc
*/
    _39d9d5f7317c4bb79bd3c1e43b2b4a43: string | null;
    private _E_x_;
    private static readonly _F_x_;
    private static readonly _G_x_;
    private static readonly _H_x_;
    private static readonly _Ba_x_;
    private static _Bb_x_;
    private static readonly _Bc_x_;
    private _Bd_x_;
    private _Be_x_;
    private _Bf_x_;
    private _Bg_x_;
    private _Bh_x_;
    private _Ca_x_;
    private _Cb_x_;
    private _Cc_x_;
    private _Cd_x_;
    private _Ce_x_;
    private _Cf_x_;
    private _Cg_x_;
    private static _Ch_x_;
    private static _Da_x_;
    private static readonly _Db_x_;
    private static readonly _Dc_x_;
    constructor(variableContexts: VariableContext[]);
    constructor(variableContexts: IList<VariableContext>);
    constructor(variableContexts: IList<VariableContext>, headTail: HeadTail);
    /**
*  Initializes a new instance of the {@link com.bayesserver.CLGaussian} class with [count] variables specified in [variableContexts].
*
*  Each variable, if it belongs to a temporal node can have an associated time.  A variable is also marked as either head or tail. Head variables are those on the left, and tail variables are those on the right in the expression P(A|B).
*
* @param {VariableContext[]} variableContexts The variable contexts containing the distribution variables.
*
* @param {number} count The number of items to include from [variableContexts].

* @exception ReferenceError Raised if [variableContexts] is null.
*/
    constructor(variableContexts: VariableContext[], count: number);
    /**
*  Initializes a new instance of the {@link com.bayesserver.CLGaussian} class with [count] variables specified in [variableContexts].
*
*  Each variable, if it belongs to a temporal node can have an associated time.  A variable is also marked as either head or tail. Head variables are those on the left, and tail variables are those on the right in the expression P(A|B).
*
* @param {VariableContext[]} variableContexts The variable contexts containing the distribution variables.
*
* @param {number} count The number of items to include from [variableContexts].
*
* @param {HeadTail} headTail Overrides the Head or Tail value found in each {@link com.bayesserver.VariableContext}.

* @exception ReferenceError Raised if [variableContexts] is null.
*/
    constructor(variableContexts: VariableContext[], count: number, headTail: HeadTail);
    /**
*  Initializes a new instance of the {@link com.bayesserver.CLGaussian} class with the variables of a single node at the specified time.  Variables are assumed to be head variables.
*
* @param {Node} node The node whose variables will belong to the new distribution.
*
* @param {?number} time The time for any temporal nodes/variables.

* @exception ReferenceError Raised if [node] is null.
*/
    constructor(node: Node, time: number | null);
    /**
*  Initializes a new instance of the {@link com.bayesserver.CLGaussian} class with the specified variables at a particular time.  Variables are assumed to be head variables.
*
* @param {IList<Variable>} variables The variables for the new distribution.
*
* @param {?number} time The time for any temporal nodes/variables.

* @exception ReferenceError Raised if [variables] is null.

* @exception Error Raised if an element of [variables] is null or a variable does not belong to a network.
*/
    constructor(variables: IList<Variable>, time: number | null);
    /**
*  Initializes a new instance of the {@link com.bayesserver.CLGaussian} class with the specified variables.
*
* @param {IList<Variable>} variables The variables for the new distribution.
*
* @param {HeadTail} headTail Specifies whether the variables should be marked as Head or Tail.

* @exception ReferenceError Raised if [variables] is null.

* @exception Error Raised if an element of [variables] is null or a variable does not belong to a network.
*/
    constructor(variables: IList<Variable>, headTail: HeadTail);
    /**
*  Initializes a new instance of the {@link com.bayesserver.CLGaussian} class with the specified variables.
*
* @param {IList<Variable>} variables The variables for the new distribution.
*
* @param {?number} time The time for any temporal nodes/variables.
*
* @param {HeadTail} headTail Specifies whether the variables should be marked as Head or Tail.

* @exception ReferenceError Raised if [variables] is null.

* @exception Error Raised if an element of [variables] is null or a variable does not belong to a network.
*/
    constructor(variables: IList<Variable>, time: number | null, headTail: HeadTail);
    /**
*  Initializes a new instance of the {@link com.bayesserver.CLGaussian} class with the specified variables.  Variables are assumed to be head variables.
*
* @param {IList<Variable>} variables The variables for the new distribution.
*/
    constructor(variables: IList<Variable>);
    /**
*  Initializes a new instance of the {@link com.bayesserver.CLGaussian} class with the specified variables.  Variables are assumed to be head variables.
*
* @param {Variable[]} variables The variables for the new distribution.
*/
    constructor(variables: Variable[]);
    /**
*  Initializes a new instance of the {@link com.bayesserver.CLGaussian} class with the variables of a single node.  Variables are assumed to be head variables.
*
* @param {Node} node The node whose variables will belong to the new distribution.
*/
    constructor(node: Node);
    /**
*  Initializes a new instance of the {@link com.bayesserver.CLGaussian} class with a single variable.  The variable is assumed to be a head variable.
*
* @param {Variable} variable The variable that will belong to the new distribution.
*/
    constructor(variable: Variable);
    /**
*  Initializes a new instance of the {@link com.bayesserver.CLGaussian} class from a single {@link com.bayesserver.VariableContext}.
*
* @param {VariableContext} variableContext The variable context.

* @exception ReferenceError Raised when [variableContext] is null.
*/
    constructor(variableContext: VariableContext);
    /**
*  Initializes a new instance of the {@link com.bayesserver.CLGaussian} class with a single variable at the specified time.  The variable is assumed to be a head variable.
*
* @param {Variable} variable The variable that will belong to the new distribution.
*
* @param {?number} time The time associated with the variable.

* @exception ReferenceError Raised if [variable] is null.
*/
    constructor(variable: Variable, time: number | null);
    /**
*  Initializes a new instance of the {@link com.bayesserver.CLGaussian} class, copying the source distribution.
*
* @param {CLGaussian} source The distribution to copy.
*/
    constructor(source: CLGaussian);
    /**
*  Initializes a new instance of the {@link com.bayesserver.CLGaussian} class, copying the source distribution but shifting any times by the specified number of units.
*
* @param {CLGaussian} source The distribution to copy.
*
* @param {?number} timeShift The number of units to adjust any times associated with variables.
*/
    constructor(source: CLGaussian, timeShift: number | null);
    private _cons_autogen0(variableContexts);
    private _cons_autogen1(variableContexts);
    private _cons_autogen2(variableContexts, headTail);
    private _cons_autogen3(variableContexts, count);
    private _cons_autogen4(variableContexts, count, headTail);
    private _cons_autogen5(node, time);
    private _cons_autogen6(variables, time);
    private _cons_autogen7(variables, headTail);
    private _cons_autogen8(variables, time, headTail);
    private _cons_autogen9(variables);
    private _cons_autogen10(variables);
    private _cons_autogen11(node);
    private _cons_autogen12(variable);
    private _cons_autogen13(variableContext);
    private _cons_autogen14(variable, time);
    private _cons_autogen15(source);
    private _cons_autogen16(source, timeShift);
    /**
* @inheritDoc
*/
    toString(): string;
    /**
*  Resets all mean, covariance and weight entries to zero.
*/
    reset(): void;
    private _t_x_(p_autogen9, p_autogen10, p_autogen11, p_autogen12);
    /**
*  Shifts any times associated with the distribution variables by the specified number of time units.
*
* @param {number} units The number of time units to shift.  Can be negative if required.
*/
    timeShift(units: number): void;
    private _u_x_(p_autogen25);
    /**
* @inheritDoc
*/
    /**
* @inheritDoc
*/
    locked: boolean;
    /**
* @inheritDoc
*/
    isReadOnly(): boolean;
    /**
*  Creates a copy of the distribution.  The new distribution will not have an owner.

* @return {IDistribution} A copy of this instance.
*/
    copy(): IDistribution;
    /**
*  Creates a copy of the distribution, and shifts any times associated with variables by the specified amount.  The new distribution will not have an owner.
*
* @param {?number} timeShift The amount to shift any times present in the distribution.  Can be negative.

* @return {IDistribution}  A copy of this instance, with shifted times.
*/
    copy(timeShift: number | null): IDistribution;
    private _Copy_autogen0();
    private _Copy_autogen1(timeShift);
    private _rr_x_();
    /**
*  Gets the mean of the Gaussian distribution at the specified [index] in the {@link com.bayesserver.Table} of discrete combinations.
*
* @param {number} index The index into the discrete table of combinations.  If no discrete variables are present in the distribution, index will always be 0.
*
* @param {number} sortedContinuousHead The position of the required continuous head variable.

* @return {number} The mean value.
*/
    getMean(index: number, sortedContinuousHead: number): number;
    /**
*  Gets the mean value of the Gaussian distribution for the specified [continuousHead] variable for the [discrete] combination.
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The mean value.
*/
    getMean(continuousHead: Variable, discrete: State[]): number;
    /**
*  Gets the mean value of a Gaussian distribution with no discrete variables for the specified [continuousHead] variable.
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).

* @return {number} The mean value.
*/
    getMean(continuousHead: Variable): number;
    /**
*  Gets the mean value of a Gaussian distribution with no discrete variables for the specified [continuousHead] variable and time.
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} time The time of the continuous head variable, or null if not a temporal variable.

* @return {number} The mean value.
*/
    getMean(continuousHead: Variable, time: number | null): number;
    /**
*  Gets the mean value of the Gaussian distribution for the specified [continuousHead] variable for the [discrete] combination.
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} time The time of the continuous head variable, or null if not a temporal variable.
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The mean value.
*/
    getMean(continuousHead: Variable, time: number | null, discrete: State[]): number;
    /**
*  Gets the mean value of the Gaussian distribution for the specified [continuousHead] variable for the [discrete] combination.
*
* @param {VariableContext} continuousHead A continuous head variable and time (if any) from H in the expression P(H) or P(H|T).
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The mean value.
*/
    getMean(continuousHead: VariableContext, discrete: State[]): number;
    /**
*  Gets the mean value of the Gaussian distribution for the specified [continuousHead] variable for the [discrete] combination.
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {StateContext[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The mean value.
*/
    getMean(continuousHead: Variable, discrete: StateContext[]): number;
    /**
*  Gets the mean value of the Gaussian distribution for the specified [continuousHead] variable for the [discrete] combination.
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} time The time of the continuous head variable, or null if not a temporal variable.
*
* @param {StateContext[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The mean value.
*/
    getMean(continuousHead: Variable, time: number | null, discrete: StateContext[]): number;
    /**
*  Gets the mean value of the Gaussian distribution for the specified [continuousHead] variable for the [discrete] combination.
*
* @param {VariableContext} continuousHead A continuous head variable and time (if any) from H in the expression P(H) or P(H|T).
*
* @param {StateContext[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The mean value.
*/
    getMean(continuousHead: VariableContext, discrete: StateContext[]): number;
    /**
*  Gets the mean value of the Gaussian distribution for the specified [continuousHead] variable for the discrete combination.
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {TableIterator} iterator The discrete combination (mixture) identified by the position of the iterator.

* @return {number} The mean value.
*/
    getMean(continuousHead: Variable, iterator: TableIterator): number;
    /**
*  Gets the mean value of the Gaussian distribution for the specified [continuousHead] variable for the discrete combination.
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} time The time of the continuous head variable, or null if not a temporal variable.
*
* @param {TableIterator} iterator The discrete combination (mixture) identified by the position of the iterator.

* @return {number} The mean value.
*/
    getMean(continuousHead: Variable, time: number | null, iterator: TableIterator): number;
    /**
*  Gets the mean value of the Gaussian distribution for the specified [continuousHead] variable for the discrete combination.
*
* @param {VariableContext} continuousHead A continuous head variable and time (if any) from H in the expression P(H) or P(H|T).
*
* @param {TableIterator} iterator The discrete combination (mixture) identified by the position of the iterator.

* @return {number} The mean value.
*/
    getMean(continuousHead: VariableContext, iterator: TableIterator): number;
    private _GetMean_autogen0(index, sortedContinuousHead);
    private _GetMean_autogen1(continuousHead, discrete);
    private _GetMean_autogen2(continuousHead);
    private _GetMean_autogen3(continuousHead, time);
    private _GetMean_autogen4(continuousHead, time, discrete);
    private _GetMean_autogen5(continuousHead, discrete);
    private _GetMean_autogen6(continuousHead, discrete);
    private _GetMean_autogen7(continuousHead, time, discrete);
    private _GetMean_autogen8(continuousHead, discrete);
    private _GetMean_autogen9(continuousHead, iterator);
    private _GetMean_autogen10(continuousHead, time, iterator);
    private _GetMean_autogen11(continuousHead, iterator);
    _rs_x_(p_autogen41: number, p_autogen42: number): number;
    /**
*  Gets the variance of the Gaussian distribution at the specified [index] in the {@link com.bayesserver.Table} of discrete combinations.
*
* @param {number} index The index into the discrete table of combinations.  If no discrete variables are present in the distribution, index will always be 0.
*
* @param {number} sortedContinuousHead The position of the required continuous head variable.

* @return {number} The variance.
*/
    getVariance(index: number, sortedContinuousHead: number): number;
    /**
*  Gets the variance of the Gaussian distribution for the specified [continuousHead] variable for a particular discrete combination (mixture).
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The variance value.
*/
    getVariance(continuousHead: Variable, discrete: State[]): number;
    /**
*  Gets the variance of a Gaussian distribution with no discrete variables for the specified [continuousHead] variable.
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).

* @return {number} The variance value.
*/
    getVariance(continuousHead: Variable): number;
    /**
*  Gets the variance of a Gaussian distribution with no discrete variables for the specified [continuousHead] variable.
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} time The time of the continuous head variable, or null if not a temporal variable.

* @return {number} The variance value.
*/
    getVariance(continuousHead: Variable, time: number | null): number;
    /**
*  Gets the variance of the Gaussian distribution for the specified [continuousHead] variable for a particular discrete combination (mixture).
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} time The time of the continuous head variable, or null if not a temporal variable.
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The variance value.
*/
    getVariance(continuousHead: Variable, time: number | null, discrete: State[]): number;
    /**
*  Gets the variance of the Gaussian distribution for the specified [continuousHead] variable for a particular discrete combination (mixture).
*
* @param {VariableContext} continuousHead A continuous head variable and time (if any) from H in the expression P(H) or P(H|T).
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The variance value.
*/
    getVariance(continuousHead: VariableContext, discrete: State[]): number;
    /**
*  Gets the variance of the Gaussian distribution for the specified [continuousHead] variable for a particular discrete combination (mixture).
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {StateContext[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The variance value.
*/
    getVariance(continuousHead: Variable, discrete: StateContext[]): number;
    /**
*  Gets the variance of the Gaussian distribution for the specified [continuousHead] variable for a particular discrete combination (mixture).
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} time The time of the continuous head variable, or null if not a temporal variable.
*
* @param {StateContext[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The variance value.
*/
    getVariance(continuousHead: Variable, time: number | null, discrete: StateContext[]): number;
    /**
*  Gets the variance of the Gaussian distribution for the specified [continuousHead] variable for a particular discrete combination (mixture).
*
* @param {VariableContext} continuousHead A continuous head variable and time (if any) from H in the expression P(H) or P(H|T).
*
* @param {StateContext[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The variance value.
*/
    getVariance(continuousHead: VariableContext, discrete: StateContext[]): number;
    /**
*  Gets the variance of the Gaussian distribution for the specified [continuousHead] variable for a particular discrete combination (mixture).
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {TableIterator} iterator The discrete combination (mixture) identified by the position of the iterator.

* @return {number} The variance value.
*/
    getVariance(continuousHead: Variable, iterator: TableIterator): number;
    /**
*  Gets the variance of the Gaussian distribution for the specified [continuousHead] variable for a particular discrete combination (mixture).
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} time The time of the continuous head variable, or null if not a temporal variable.
*
* @param {TableIterator} iterator The discrete combination (mixture) identified by the position of the iterator.

* @return {number} The variance value.
*/
    getVariance(continuousHead: Variable, time: number | null, iterator: TableIterator): number;
    /**
*  Gets the variance of the Gaussian distribution for the specified [continuousHead] variable for a particular discrete combination (mixture).
*
* @param {VariableContext} continuousHead A continuous head variable and time (if any) from H in the expression P(H) or P(H|T).
*
* @param {TableIterator} iterator The discrete combination (mixture) identified by the position of the iterator.

* @return {number} The variance value.
*/
    getVariance(continuousHead: VariableContext, iterator: TableIterator): number;
    private _GetVariance_autogen0(index, sortedContinuousHead);
    private _GetVariance_autogen1(continuousHead, discrete);
    private _GetVariance_autogen2(continuousHead);
    private _GetVariance_autogen3(continuousHead, time);
    private _GetVariance_autogen4(continuousHead, time, discrete);
    private _GetVariance_autogen5(continuousHead, discrete);
    private _GetVariance_autogen6(continuousHead, discrete);
    private _GetVariance_autogen7(continuousHead, time, discrete);
    private _GetVariance_autogen8(continuousHead, discrete);
    private _GetVariance_autogen9(continuousHead, iterator);
    private _GetVariance_autogen10(continuousHead, time, iterator);
    private _GetVariance_autogen11(continuousHead, iterator);
    _rt_x_(p_autogen69: number, p_autogen70: number): number;
    /**
*  Gets the covariance of the Gaussian distribution at the specified [index] in the {@link com.bayesserver.Table} of discrete combinations.
*
* @param {number} index The index into the discrete table of combinations.  If no discrete variables are present in the distribution, index will always be 0.
*
* @param {number} sortedContinuousHeadA The position of the first continuous head variable.
*
* @param {number} sortedContinuousHeadB The position of the second continuous head variable.

* @return {number} The covariance entry.
*/
    getCovariance(index: number, sortedContinuousHeadA: number, sortedContinuousHeadB: number): number;
    /**
*  Gets the covariance of the Gaussian distribution between [continuousHeadA] and [continuousHeadB] for a particular discrete combination (mixture).
*
* @param {Variable} continuousHeadA A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {Variable} continuousHeadB A second continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The covariance value.
*/
    getCovariance(continuousHeadA: Variable, continuousHeadB: Variable, discrete: State[]): number;
    /**
*  Gets the covariance of a Gaussian distribution with no discrete variables between [continuousHeadA] and [continuousHeadB].
*
* @param {Variable} continuousHeadA A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {Variable} continuousHeadB A second continuous head variable from H in the expression P(H) or P(H|T).

* @return {number} The covariance value.
*/
    getCovariance(continuousHeadA: Variable, continuousHeadB: Variable): number;
    /**
*  Gets the covariance of a Gaussian distribution with no discrete variables between [continuousHeadA] and [continuousHeadB].
*
* @param {Variable} continuousHeadA A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} timeA The time of the first continuous head variable, or null if not a temporal variable.
*
* @param {Variable} continuousHeadB A second continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} timeB The time of the second continuous head variable, or null if not a temporal variable.

* @return {number} The covariance value.
*/
    getCovariance(continuousHeadA: Variable, timeA: number | null, continuousHeadB: Variable, timeB: number | null): number;
    /**
*  Gets the covariance of the Gaussian distribution between [continuousHeadA] and [continuousHeadB] for a particular discrete combination (mixture).
*
* @param {Variable} continuousHeadA A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {Variable} continuousHeadB A second continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {StateContext[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The covariance value.
*/
    getCovariance(continuousHeadA: Variable, continuousHeadB: Variable, discrete: StateContext[]): number;
    /**
*  Gets the covariance of the Gaussian distribution between [continuousHeadA] and [continuousHeadB] for a particular discrete combination (mixture).
*
* @param {Variable} continuousHeadA A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} timeA The time of the first continuous head variable, or null if not a temporal variable.
*
* @param {Variable} continuousHeadB A second continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} timeB The time of the second continuous head variable, or null if not a temporal variable.
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The covariance value.
*/
    getCovariance(continuousHeadA: Variable, timeA: number | null, continuousHeadB: Variable, timeB: number | null, discrete: State[]): number;
    /**
*  Gets the covariance of the Gaussian distribution between [continuousHeadA] and [continuousHeadB] for a particular discrete combination (mixture).
*
* @param {Variable} continuousHeadA A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} timeA The time of the first continuous head variable, or null if not a temporal variable.
*
* @param {Variable} continuousHeadB A second continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} timeB The time of the second continuous head variable, or null if not a temporal variable.
*
* @param {StateContext[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The covariance value.
*/
    getCovariance(continuousHeadA: Variable, timeA: number | null, continuousHeadB: Variable, timeB: number | null, discrete: StateContext[]): number;
    /**
*  Gets the covariance of the Gaussian distribution between [continuousHeadA] and [continuousHeadB] for a particular discrete combination (mixture).
*
* @param {VariableContext} continuousHeadA A continuous head variable and time (if any) from H in the expression P(H) or P(H|T).
*
* @param {VariableContext} continuousHeadB A second continuous head variable and time (if any) from H in the expression P(H) or P(H|T).
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The covariance value.
*/
    getCovariance(continuousHeadA: VariableContext, continuousHeadB: VariableContext, discrete: State[]): number;
    /**
*  Gets the covariance of the Gaussian distribution between [continuousHeadA] and [continuousHeadB] for a particular discrete combination (mixture).
*
* @param {VariableContext} continuousHeadA A continuous head variable and time (if any) from H in the expression P(H) or P(H|T).
*
* @param {VariableContext} continuousHeadB A second continuous head variable and time (if any) from H in the expression P(H) or P(H|T).
*
* @param {StateContext[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The covariance value.
*/
    getCovariance(continuousHeadA: VariableContext, continuousHeadB: VariableContext, discrete: StateContext[]): number;
    /**
*  Gets the covariance of the Gaussian distribution between [continuousHeadA] and [continuousHeadB] for a particular discrete combination (mixture).
*
* @param {Variable} continuousHeadA A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {Variable} continuousHeadB A second continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {TableIterator} iterator The discrete combination (mixture) identified by the position of the iterator.

* @return {number} The covariance value.
*/
    getCovariance(continuousHeadA: Variable, continuousHeadB: Variable, iterator: TableIterator): number;
    /**
*  Gets the covariance of the Gaussian distribution between [continuousHeadA] and [continuousHeadB] for a particular discrete combination (mixture).
*
* @param {Variable} continuousHeadA A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} timeA The time of the first continuous head variable, or null if not a temporal variable.
*
* @param {Variable} continuousHeadB A second continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} timeB The time of the second continuous head variable, or null if not a temporal variable.
*
* @param {TableIterator} iterator The discrete combination (mixture) identified by the position of the iterator.

* @return {number} The covariance value.
*/
    getCovariance(continuousHeadA: Variable, timeA: number | null, continuousHeadB: Variable, timeB: number | null, iterator: TableIterator): number;
    /**
*  Gets the covariance of the Gaussian distribution between [continuousHeadA] and [continuousHeadB] for a particular discrete combination (mixture).
*
* @param {VariableContext} continuousHeadA A continuous head variable and time (if any) from H in the expression P(H) or P(H|T).
*
* @param {VariableContext} continuousHeadB A second continuous head variable and time (if any) from H in the expression P(H) or P(H|T).
*
* @param {TableIterator} iterator The discrete combination (mixture) identified by the position of the iterator.

* @return {number} The covariance value.
*/
    getCovariance(continuousHeadA: VariableContext, continuousHeadB: VariableContext, iterator: TableIterator): number;
    private _GetCovariance_autogen0(index, sortedContinuousHeadA, sortedContinuousHeadB);
    private _GetCovariance_autogen1(continuousHeadA, continuousHeadB, discrete);
    private _GetCovariance_autogen2(continuousHeadA, continuousHeadB);
    private _GetCovariance_autogen3(continuousHeadA, timeA, continuousHeadB, timeB);
    private _GetCovariance_autogen4(continuousHeadA, continuousHeadB, discrete);
    private _GetCovariance_autogen5(continuousHeadA, timeA, continuousHeadB, timeB, discrete);
    private _GetCovariance_autogen6(continuousHeadA, timeA, continuousHeadB, timeB, discrete);
    private _GetCovariance_autogen7(continuousHeadA, continuousHeadB, discrete);
    private _GetCovariance_autogen8(continuousHeadA, continuousHeadB, discrete);
    private _GetCovariance_autogen9(continuousHeadA, continuousHeadB, iterator);
    private _GetCovariance_autogen10(continuousHeadA, timeA, continuousHeadB, timeB, iterator);
    private _GetCovariance_autogen11(continuousHeadA, continuousHeadB, iterator);
    _ru_x_(p_autogen98: number, p_autogen99: number, p_autogen100: number): number;
    /**
*  Gets the weight (regression coefficient) of the Gaussian distribution at the specified [index] in the {@link com.bayesserver.Table} of discrete combinations.
*
* @param {number} index The index into the discrete table of combinations.  If no discrete variables are present in the distribution, index will always be 0.
*
* @param {number} sortedContinuousHead The position of the required continuous head variable.
*
* @param {number} sortedContinuousTail The position of the required continuous tail variable.

* @return {number} The weight / regression coefficient.
*/
    getWeight(index: number, sortedContinuousHead: number, sortedContinuousTail: number): number;
    /**
*  Gets the weight/regression coefficient of the Gaussian distribution between the [continuousTail] and [continuousHead] for a particular discrete combination (mixture).
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H|T).
*
* @param {Variable} continuousTail A continuous tail variable from T in the expression P(H|T).
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The weight/regression coefficient.
*/
    getWeight(continuousHead: Variable, continuousTail: Variable, discrete: State[]): number;
    /**
*  Gets the weight/regression coefficient of the Gaussian distribution between the [continuousTail] and [continuousHead] for a particular discrete combination (mixture).
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H|T).
*
* @param {?number} timeHead The time of the continuous head variable, or null if not a temporal variable.
*
* @param {Variable} continuousTail A continuous tail variable from T in the expression P(H|T).
*
* @param {?number} timeTail The time of the continuous tail variable, or null if not a temporal variable.
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The weight/regression coefficient.
*/
    getWeight(continuousHead: Variable, timeHead: number | null, continuousTail: Variable, timeTail: number | null, discrete: State[]): number;
    /**
*  Gets the weight/regression coefficient of the Gaussian distribution between the [continuousTail] and [continuousHead] for a particular discrete combination (mixture).
*
* @param {VariableContext} continuousHead A continuous head variable and time (if any) from H in the expression P(H|T).
*
* @param {VariableContext} continuousTail A continuous tail variable and time (if any) from T in the expression P(H|T).
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The weight/regression coefficient.
*/
    getWeight(continuousHead: VariableContext, continuousTail: VariableContext, discrete: State[]): number;
    /**
*  Gets the weight/regression coefficient of the Gaussian distribution between the [continuousTail] and [continuousHead] for a particular discrete combination (mixture).
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H|T).
*
* @param {Variable} continuousTail A continuous tail variable from T in the expression P(H|T).
*
* @param {StateContext[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The weight/regression coefficient.
*/
    getWeight(continuousHead: Variable, continuousTail: Variable, discrete: StateContext[]): number;
    /**
*  Gets the weight/regression coefficient of a Gaussian distribution with no discrete variables between the [continuousTail] and [continuousHead].
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H|T).
*
* @param {Variable} continuousTail A continuous tail variable from T in the expression P(H|T).

* @return {number} The weight/regression coefficient.
*/
    getWeight(continuousHead: Variable, continuousTail: Variable): number;
    /**
*  Gets the weight/regression coefficient of the Gaussian distribution between the [continuousTail] and [continuousHead] for a particular discrete combination (mixture).
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H|T).
*
* @param {?number} timeHead The time of the continuous head variable, or null if not a temporal variable.
*
* @param {Variable} continuousTail A continuous tail variable from T in the expression P(H|T).
*
* @param {?number} timeTail The time of the continuous tail variable, or null if not a temporal variable.
*
* @param {StateContext[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The weight/regression coefficient.
*/
    getWeight(continuousHead: Variable, timeHead: number | null, continuousTail: Variable, timeTail: number | null, discrete: StateContext[]): number;
    /**
*  Gets the weight/regression coefficient of a Gaussian distribution with no discrete variables between the [continuousTail] and [continuousHead].
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H|T).
*
* @param {?number} timeHead The time of the continuous head variable, or null if not a temporal variable.
*
* @param {Variable} continuousTail A continuous tail variable from T in the expression P(H|T).
*
* @param {?number} timeTail The time of the continuous tail variable, or null if not a temporal variable.

* @return {number} The weight/regression coefficient.
*/
    getWeight(continuousHead: Variable, timeHead: number | null, continuousTail: Variable, timeTail: number | null): number;
    /**
*  Gets the weight/regression coefficient of the Gaussian distribution between the [continuousTail] and [continuousHead] for a particular discrete combination (mixture).
*
* @param {VariableContext} continuousHead A continuous head variable and time (if any) from H in the expression P(H|T).
*
* @param {VariableContext} continuousTail A continuous tail variable and time (if any) from T in the expression P(H|T).
*
* @param {StateContext[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).

* @return {number} The weight/regression coefficient.
*/
    getWeight(continuousHead: VariableContext, continuousTail: VariableContext, discrete: StateContext[]): number;
    /**
*  Gets the weight/regression coefficient of the Gaussian distribution between the [continuousTail] and [continuousHead] for a particular discrete combination (mixture).
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H|T).
*
* @param {Variable} continuousTail A continuous tail variable from T in the expression P(H|T).
*
* @param {TableIterator} iterator The discrete combination (mixture) identified by the position of the iterator.

* @return {number} The weight/regression coefficient.
*/
    getWeight(continuousHead: Variable, continuousTail: Variable, iterator: TableIterator): number;
    /**
*  Gets the weight/regression coefficient of the Gaussian distribution between the [continuousTail] and [continuousHead] for a particular discrete combination (mixture).
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H|T).
*
* @param {?number} timeHead The time of the continuous head variable, or null if not a temporal variable.
*
* @param {Variable} continuousTail A continuous tail variable from T in the expression P(H|T).
*
* @param {?number} timeTail The time of the continuous tail variable, or null if not a temporal variable.
*
* @param {TableIterator} iterator The discrete combination (mixture) identified by the position of the iterator.

* @return {number} The weight/regression coefficient.
*/
    getWeight(continuousHead: Variable, timeHead: number | null, continuousTail: Variable, timeTail: number | null, iterator: TableIterator): number;
    /**
*  Gets the weight/regression coefficient of the Gaussian distribution between the [continuousTail] and [continuousHead] for a particular discrete combination (mixture).
*
* @param {VariableContext} continuousHead A continuous head variable and time (if any) from H in the expression P(H|T).
*
* @param {VariableContext} continuousTail A continuous tail variable from T in the expression P(H|T).
*
* @param {TableIterator} iterator The discrete combination (mixture) identified by the position of the iterator.

* @return {number} The weight/regression coefficient.
*/
    getWeight(continuousHead: VariableContext, continuousTail: VariableContext, iterator: TableIterator): number;
    private _GetWeight_autogen0(index, sortedContinuousHead, sortedContinuousTail);
    private _GetWeight_autogen1(continuousHead, continuousTail, discrete);
    private _GetWeight_autogen2(continuousHead, timeHead, continuousTail, timeTail, discrete);
    private _GetWeight_autogen3(continuousHead, continuousTail, discrete);
    private _GetWeight_autogen4(continuousHead, continuousTail, discrete);
    private _GetWeight_autogen5(continuousHead, continuousTail);
    private _GetWeight_autogen6(continuousHead, timeHead, continuousTail, timeTail, discrete);
    private _GetWeight_autogen7(continuousHead, timeHead, continuousTail, timeTail);
    private _GetWeight_autogen8(continuousHead, continuousTail, discrete);
    private _GetWeight_autogen9(continuousHead, continuousTail, iterator);
    private _GetWeight_autogen10(continuousHead, timeHead, continuousTail, timeTail, iterator);
    private _GetWeight_autogen11(continuousHead, continuousTail, iterator);
    _rv_x_(p_autogen143: number, p_autogen144: number, p_autogen145: number): number;
    /**
*  Sets the mean value of the Gaussian distribution at the specified [index] in the {@link com.bayesserver.Table} of discrete combinations.
*
* @param {number} index The index into the discrete table of combinations.  If no discrete variables are present in the distribution, index will always be 0.
*
* @param {number} sortedContinuousHead The position of the required continuous head variable.
*
* @param {number} value The mean value.
*/
    setMean(index: number, sortedContinuousHead: number, value: number): void;
    /**
*  Sets the mean value of the Gaussian distribution for the specified [continuousHead] variable for the [discrete] combination.
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {number} value The mean value.
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).
*/
    setMean(continuousHead: Variable, value: number, discrete: State[]): void;
    /**
*  Sets the mean value of the Gaussian distribution for the specified [continuousHead] variable for the [discrete] combination.
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {?number} time The time of the continuous head variable, or null if not a temporal variable.
*
* @param {number} value The mean value.
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).
*/
    setMean(continuousHead: Variable, time: number | null, value: number, discrete: State[]): void;
    /**
*  Sets the mean value of the Gaussian distribution for the specified [continuousHead] variable for the [discrete] combination.
*
* @param {VariableContext} continuousHead A continuous head variable and time (if any) from H in the expression P(H) or P(H|T).
*
* @param {number} value The mean value.
*
* @param {State[]} discrete The discrete combination (mixture).  Can be empty if this distribution has no discrete variables (i.e. the Gaussian is not a mixture of Gaussians).
*/
    setMean(continuousHead: VariableContext, value: number, discrete: State[]): void;
    /**
*  Sets the mean value of the Gaussian distribution for the specified [continuousHead] variable for the [discrete] combination.
*
* @param {Variable} continuousHead A continuous head variable from H in the expression P(H) or P(H|T).
*
* @param {number} value The mean value.
*
* @param {StateContext[]} discrete The discrete combination (mixture).  C