private calcAlphaBeta()

in src/converter/data/dataSmooth.ts [128:180]

• 44 lines of code
• 5 McCabe index (conditional complexity)

    private calcAlphaBeta(
        robustnessWeights: number[],
        itrn: number,
        timePoint: number,
        ileft: number,
        iright: number,
        points: IDataRepresentationPoint[],
    ): IAlphaBeta {
        const edge: number = (points[itrn].x.getTime() - points[ileft].x.getTime())
            > (points[iright].x.getTime() - points[itrn].x.getTime())
            ? ileft
            : iright;
        let w: number;
        let sumWeights: number = 0;
        let sumX: number = 0;
        let sumXSquared: number = 0;
        let sumY: number = 0;
        let sumXY: number = 0;

        const denom: number = Math.abs(1 / (points[edge].x.getTime() - timePoint));

        for (let k: number = ileft; k <= iright; ++k) {
            const xk: number = points[k].x.getTime();
            const yk: number = points[k].y;
            const dist: number = k < itrn ? timePoint - xk : xk - timePoint;

            w = this.science_stats_loessTricube(dist * denom) * robustnessWeights[k];

            const xkw: number = xk * w;

            sumWeights += w;
            sumX += xkw;
            sumXSquared += xk * xkw;
            sumY += yk * w;
            sumXY += yk * xkw;
        }

        const meanX: number = sumX / sumWeights;
        const meanY: number = sumY / sumWeights;
        const meanXY: number = sumXY / sumWeights;
        const meanXSquared: number = sumXSquared / sumWeights;

        const beta: number = (Math.sqrt(Math.abs(meanXSquared - meanX * meanX)) < this.accuracy)
            ? 0 : ((meanXY - meanX * meanY) / (meanXSquared - meanX * meanX));

        const alpha: number = meanY - beta * meanX;

        return {
            alpha,
            beta,
            w
        }
    }