AutoMovie API
    Preparing search index...

    Function RecoveryChartFitSystem

    • Assemble the same sparse weighted system and its bounded rank diagnostics.

      Parameters

      • input: IAutoMovieRecoveryChartFit.Input
      • prepared: {
            basis: (t: number) => number[];
            finite: (p: readonly [number, number, number]) => boolean;
            lower: readonly [number, number, number];
            maximumRowBudget: number;
            normalizedConstants: (readonly [number, number, number])[];
            origin: number[];
            reduced: {
                expressions: {
                    constant: [number, number, number];
                    terms: { id: number; weight: number }[];
                }[];
                independent: number[];
                maximumDepth: number;
                maximumTerms: number;
                maximumWeightSumError: number;
                minimumWeight: number;
            };
            scale: number;
            slots: Int32Array;
            totalWeight: number;
            unknowns: number;
            upper: readonly [number, number, number];
        }
        • basis: (t: number) => number[]

          Evaluates the normalized cubic Bernstein basis at the supplied local parameter.

        • finite: (p: readonly [number, number, number]) => boolean

          Checks finite Cartesian coordinates without repairing or clamping values.

        • lower: readonly [number, number, number]

          Lower componentwise physical control bound in registered millimetres.

        • maximumRowBudget: number

          Admitted ceiling on sparse stencil entries after affine substitution.

        • normalizedConstants: (readonly [number, number, number])[]

          Fixed affine contributions after subtracting the admitted origin and dividing by the common scale.

        • origin: number[]

          Physical millimetre origin subtracted from coefficient positions before normalization.

        • reduced: {
              expressions: {
                  constant: [number, number, number];
                  terms: { id: number; weight: number }[];
              }[];
              independent: number[];
              maximumDepth: number;
              maximumTerms: number;
              maximumWeightSumError: number;
              minimumWeight: number;
          }

          Admitted acyclic affine substitution, preserving fixed values and independent control identities.

          • expressions: { constant: [number, number, number]; terms: { id: number; weight: number }[] }[]

            One sparse millimetre expression per original control, in input ID order.

          • independent: number[]

            Unowned original IDs, in ascending order; these are the free variables.

          • maximumDepth: number

            Largest declared relation-edge depth, including zero-weight dependencies.

          • maximumTerms: number

            Largest final independent term count, excluding folded fixed sources.

          • maximumWeightSumError: number

            Largest absolute deviation of pre-folding source weight sum from one.

          • minimumWeight: number

            Least retained flattened source weight; zero for an empty expression.

        • scale: number

          Positive common millimetre scale used to normalize the physical coefficient box.

        • slots: Int32Array

          Original control index to independent solver slot; fixed or dependent entries retain the owner's sentinel.

        • totalWeight: number

          Sum of positive observation weights used to normalize the assembled objective.

        • unknowns: number

          Number of independent vector controls after fixed and affine dependent controls are eliminated.

        • upper: readonly [number, number, number]

          Upper componentwise physical control bound in registered millimetres.

      Returns {
          dataQrDiagonalRatio: number | null;
          dataRowRank: number | null;
          diagnostics: string[];
          diagonal: Float64Array;
          gramPivotRatio: number | null;
          hessian: Map<number, number>[];
          leastSquaresConstant: number;
          maximumRowTerms: number;
          observationRank: number | null;
          physicalJetRows: number;
          rankTolerance: number;
          rhs: Float64Array;
          unseen: number;
      }

      • dataQrDiagonalRatio: number | null

        Smallest accepted over largest data-QR diagonal, or null when unavailable; not a singular-value certificate.

      • dataRowRank: number | null

        Rank of column-scaled twice-reorthogonalized data rows, or null when its work budget is exceeded.

      • diagnostics: string[]

        Observed admission failures and qualification limits in production order; an empty array adds no extra certificate.

      • diagonal: Float64Array

        Hessian diagonal in independent-control slot order, used for congruence scaling.

      • gramPivotRatio: number | null

        Smallest accepted over largest Cholesky pivot, or null when unavailable; not a condition number.

      • hessian: Map<number, number>[]

        Sparse symmetric Hessian rows; each entry stores a column index and its numeric coefficient.

      • leastSquaresConstant: number

        Constant term of the assembled normalized least-squares objective.

      • maximumRowTerms: number

        Largest assembled sparse observation stencil, including exact-zero retained terms.

      • observationRank: number | null

        Numerically observed Gram rank, or null when the explicit dense diagnostic budget is exceeded.

      • physicalJetRows: number

        Actual number of signed physical-derivative rows included in the objective.

      • rankTolerance: number

        Relative binary64 rank-admission threshold; this is not an exact rank predicate.

      • rhs: Float64Array

        Assembled normalized right-hand-side values in the same unknown-slot order as the Hessian.

      • unseen: number

        Number of unknown controls with no positive observation-basis support.