@hasna/skills 0.1.26 → 0.1.29

package/skills/advanced-math/src/finance.ts

@@ -0,0 +1,75 @@
+import type { FinanceType, MathOptions } from "./types";
+
+// ============================================================================
+// Finance Mode
+// ============================================================================
+export function calculateFinance(type: FinanceType, options: MathOptions): number {
+  const { principal = 0, rate = 0, years = 0, periods, payment = 0, cashflows } = options;
+  const r = rate / 100; // Convert percentage to decimal
+
+  switch (type) {
+    case "compound":
+      // FV = PV * (1 + r)^n
+      const n = periods || years;
+      return principal * Math.pow(1 + r, n);
+
+    case "simple":
+      // FV = PV * (1 + r*n)
+      return principal * (1 + r * years);
+
+    case "npv":
+      // NPV = sum(CF_t / (1+r)^t)
+      if (!cashflows) throw new Error("Cash flows required for NPV");
+      const flows = cashflows.split(",").map(Number);
+      return flows.reduce((npv, cf, t) => npv + cf / Math.pow(1 + r, t), 0);
+
+    case "irr":
+      // IRR calculation using Newton-Raphson method
+      if (!cashflows) throw new Error("Cash flows required for IRR");
+      return calculateIRR(cashflows.split(",").map(Number));
+
+    case "pmt":
+      // PMT = PV * (r * (1+r)^n) / ((1+r)^n - 1)
+      const monthlyRate = r / 12;
+      const numPayments = years * 12;
+      return principal * (monthlyRate * Math.pow(1 + monthlyRate, numPayments)) /
+             (Math.pow(1 + monthlyRate, numPayments) - 1);
+
+    case "fv":
+      // Future Value = PV * (1 + r)^n
+      return principal * Math.pow(1 + r, years);
+
+    case "pv":
+      // Present Value = FV / (1 + r)^n
+      return payment / Math.pow(1 + r, years);
+
+    default:
+      throw new Error(`Unknown finance type: ${type}`);
+  }
+}
+
+function calculateIRR(cashflows: number[], guess: number = 0.1): number {
+  const maxIterations = 100;
+  const tolerance = 0.0001;
+  let rate = guess;
+
+  for (let i = 0; i < maxIterations; i++) {
+    let npv = 0;
+    let dnpv = 0;
+
+    for (let t = 0; t < cashflows.length; t++) {
+      npv += cashflows[t] / Math.pow(1 + rate, t);
+      dnpv -= t * cashflows[t] / Math.pow(1 + rate, t + 1);
+    }
+
+    const newRate = rate - npv / dnpv;
+
+    if (Math.abs(newRate - rate) < tolerance) {
+      return newRate * 100; // Return as percentage
+    }
+
+    rate = newRate;
+  }
+
+  throw new Error("IRR did not converge");
+}

package/skills/advanced-math/src/formatting.ts

@@ -0,0 +1,95 @@
+import { mathConfig } from "./runtime";
+import type { MathOptions, NumberFormat, Result } from "./types";
+
+// ============================================================================
+// Formatting Functions
+// ============================================================================
+export function formatNumber(value: any, format: NumberFormat, precision: number): string {
+  // Convert mathjs BigNumber to regular number
+  let num: number;
+  if (value && typeof value === "object" && "toNumber" in value) {
+    num = value.toNumber();
+  } else if (typeof value === "number") {
+    num = value;
+  } else {
+    num = Number(value);
+  }
+
+  switch (format) {
+    case "scientific":
+      return num.toExponential(precision);
+
+    case "fraction":
+      return mathConfig.format(mathConfig.fraction(num), { precision });
+
+    case "percentage":
+      return (num * 100).toFixed(precision) + "%";
+
+    case "number":
+    default:
+      return num.toFixed(precision);
+  }
+}
+
+export function formatResult(result: Result, options: MathOptions): string {
+  // Helper to convert BigNumber to string
+  const toString = (val: any): string => {
+    if (val && typeof val === "object" && "toString" in val) {
+      return val.toString();
+    }
+    return String(val);
+  };
+
+  if (options.output === "json") {
+    // Convert BigNumbers to strings for JSON
+    const jsonResult = JSON.parse(JSON.stringify(result, (key, value) => {
+      if (value && typeof value === "object" && "toString" in value) {
+        return value.toString();
+      }
+      return value;
+    }));
+    return JSON.stringify(jsonResult, null, 2);
+  }
+
+  if (options.output === "latex" && result.latex) {
+    return result.latex;
+  }
+
+  // Text format
+  let output = `\n${"=".repeat(80)}\n`;
+  output += `  Advanced Math - ${result.mode.toUpperCase()} Mode\n`;
+  output += `${"=".repeat(80)}\n\n`;
+
+  output += `Input: ${Array.isArray(result.input) ? result.input.join(", ") : result.input}\n\n`;
+
+  if (typeof result.output === "object" && !Array.isArray(result.output) && result.output !== null && !("toNumber" in result.output)) {
+    output += "Results:\n";
+    for (const [key, value] of Object.entries(result.output)) {
+      if (typeof value === "object" && value !== null && !("toNumber" in value)) {
+        output += `  ${key}:\n`;
+        for (const [k, v] of Object.entries(value as any)) {
+          output += `    ${k}: ${toString(v)}\n`;
+        }
+      } else {
+        output += `  ${key}: ${toString(value)}\n`;
+      }
+    }
+  } else {
+    output += `Result: ${result.formatted || toString(result.output)}\n`;
+  }
+
+  if (result.steps && result.steps.length > 0) {
+    output += "\nSteps:\n";
+    result.steps.forEach((step, i) => {
+      output += `  ${i + 1}. ${step}\n`;
+    });
+  }
+
+  if (result.latex) {
+    output += `\nLaTeX: ${result.latex}\n`;
+  }
+
+  output += `\n${"=".repeat(80)}\n`;
+
+  return output;
+}