AutoMovie API
    Preparing search index...

    Function RecoveryChartFitSolve

    • Solve the normalized box problem and reconstruct the original coefficient registry.

      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.

      • system: {
            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.

      Returns {
          controls: (readonly [number, number, number])[];
          dependentEnclosureViolationMm: number;
          hi: [number, number, number];
          iterations: number;
          lo: [number, number, number];
          projectedGradient: number;
          solved: {
              initialObjective: number;
              iterations: number;
              maximumDiagonal: number;
              minimumPositiveDiagonal: number | null;
              objective: number;
              originalLipschitz: number;
              projectedGradient: number;
              restarts: number;
              scaledLipschitz: number;
              values: Float64Array;
          };
          x: Float64Array;
      }

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

        Shared coefficient registry or its declared population, addressed by patch control IDs.

      • dependentEnclosureViolationMm: number

        Largest excursion of an affine dependent control outside the original millimetre box; zero means none observed.

      • hi: [number, number, number]

        Upper componentwise control bound in the normalized solver chart.

      • iterations: number

        Actual numerical iterations attempted, including iterations without an accepted update.

      • lo: [number, number, number]

        Lower componentwise control bound in the normalized solver chart.

      • projectedGradient: number

        Infinity norm of the normalized projected-gradient mapping used for termination.

      • solved: {
            initialObjective: number;
            iterations: number;
            maximumDiagonal: number;
            minimumPositiveDiagonal: number | null;
            objective: number;
            originalLipschitz: number;
            projectedGradient: number;
            restarts: number;
            scaledLipschitz: number;
            values: Float64Array;
        }

        Numerical box-solver output retained with its actual termination and objective diagnostics.

        • initialObjective: number

          The same normalized quadratic objective before iterative updates.

        • iterations: number

          Actual numerical iterations attempted, including iterations without an accepted update.

        • maximumDiagonal: number

          Largest Hessian diagonal used in scaling and diagnostics.

        • minimumPositiveDiagonal: number | null

          Smallest positive Hessian diagonal; null means no positive entry was observed.

        • objective: number

          Current normalized quadratic objective value under the declared row weights.

        • originalLipschitz: number

          Row-sum spectral upper estimate for the original Hessian, not a condition number.

        • projectedGradient: number

          Infinity norm of the normalized projected-gradient mapping used for termination.

        • restarts: number

          Actual acceleration-momentum resets after objective increase.

        • scaledLipschitz: number

          Row-sum spectral upper estimate after diagonal congruence, not a condition number.

        • values: Float64Array

          Owned scalar solution values in the operation's declared coefficient ordering and units.

      • x: Float64Array

        Owned normalized solution storage ordered by independent-control slot and Cartesian coordinate.