estimator.ts

import { sumIgnoreNonNumbers } from "./utils";

export interface WorkPackage {
  /** Lower bound of effort needed to complete workPackage */
  a: number;
  /** Upper bound of effort needed to complete workPackage */
  b: number;
  /** Average expected effort needed to complete workPackage */
  c?: number;
}

/**
 * Calculate the expected effort for a given workpackage
 */
export function calculateE(workPackage: WorkPackage, r: number): number {
  const { a, b, c } = workPackage;
  if (
    typeof a !== "number" ||
    a === null ||
    typeof b !== "number" ||
    b === null
  ) {
    throw new TypeError("@calculateE(): At least a and b must be numbers");
  }
  return typeof c !== "number" || c === null
    ? (a + b) / 2
    : (a + r * c + b) / 6;
}

/**
 * Calculate the variance of the expected effort for a given workpackage
 */
export function calculateV(workPackage: WorkPackage, u: number): number {
  const { a, b } = workPackage;
  if (typeof a !== "number" || typeof b !== "number") {
    throw new TypeError("@calculateV(): a and b must be numbers");
  }
  return ((b - a) * (b - a)) / u ** 2;
}

/**
 * Calculate the standard deviation of the expected effort for a given workpackage
 */
export function calculateS(workPackage: WorkPackage, u: number): number {
  const { a, b } = workPackage;
  if (typeof a !== "number" || typeof b !== "number") {
    throw new TypeError("@calculateS(): a and b must be numbers");
  }
  return (b - a) / u;
}

export function calculateSSum(workPackages: WorkPackage[], u: number): number {
  return Math.sqrt(
    sumIgnoreNonNumbers(
      workPackages
        .filter(({ a, b }) => typeof a === "number" && typeof b === "number")
        .map((workPackage) => calculateS(workPackage, u) ** 2)
    )
  );
}

export function calculateESum(workPackages: WorkPackage[], r: number): number {
  return sumIgnoreNonNumbers(
    workPackages
      .filter(({ a, b }) => typeof a === "number" && typeof b === "number")
      .map((workPackage) => calculateE(workPackage, r))
  );
}

export function calculateVSum(workPackages: WorkPackage[], u: number): number {
  return sumIgnoreNonNumbers(
    workPackages
      .filter(({ a, b }) => typeof a === "number" && typeof b === "number")
      .map((workPackage) => calculateV(workPackage, u))
  );
}