Update index.html

Author: Gmac4247

index.html

@@ -624,6 +624,253 @@ <h4 style="font-size:160%;margin:7px">Trigonometry</h4>
 <br>
 <br>
 <br>
+<div>
+<script>
+
+// ---- Trigonometry ----
+// A lightweight approximation-based lookup function
+
+
+// The lookup table 
+
+const trig = {
+"rad(1.6)": {
+  "sin": "1"
+  "cos": "0"
+  "tan":  "undefined"
+  "deg": "90.0"
+},
+
+ 
+"rad(1.467)": {
+  "sin":  "0.991"
+  "cos":  "0.131"
+  "tan": "7.596"
+  "deg":  "82.5"
+  
+}
+
+}
+
+	// Helper: Finds closest rad(x) match for given function (sin or cos)
+ function findClosestRad(value, funcType) {
+  let closestKey = null;
+  let minDiff = Infinity;
+
+  for (const key in trig) {
+    if (!trig[key][funcType]) continue;
+    const keyMatch = key.match(/rad\(([\d.]+)\)/);
+    if (!keyMatch) continue;
+
+    const radVal = parseFloat(keyMatch[1]);
+    const diff = Math.abs(radVal - value);
+
+    if (diff < minDiff) {
+      minDiff = diff;
+      closestKey = key;
+    }
+  
+
+  if (closestKey) {
+    const approxVal = trig[closestKey][funcType].value?.approx ?? trig[closestKey][funcType].value;
+    return `${funcType}(${closestKey}) ≈ ${approxVal}`;
+  }
+ }
+
+function querySin(input) {
+  // Normalize input: remove spaces, handle cases like "sin 0533" or "sin(0.533)"
+  const match = input.match(/sin\s*\(?([0-9.]+)\)?/i);
+  if (!match) return "Invalid input. Format: sin 0.533 or sin(0.533)";
+  
+  const x = parseFloat(match[1]);
+  const radKey = `rad(${x.toFixed(3)})`;
+
+  // Case 1: Exact match
+  if ([radKey] && [radKey].sin) {
+    return `sin(${x}) ≈ ${trig[radKey].sin.value?.approx ?? trig[radKey].sin.value}`;
+  }
+
+  // Case 2A: 1.6 > x > 0.8 OR 0.1 > x > 0
+  if ((x > 0.8 && x < 1.6) || (x > 0 && x < 0.1)) {
+    // Find closest match in trig table
+    const closest = findClosestRad(x, 'sin');
+    return `sin(${x}) ≈ ${closest}`;
+  }
+
+  // Case 2B: 0.8 > x > 0.1 → Reflect to cosine
+  if (x > 0.1 && x < 0.8) {
+    const reflected = (1.6 - x).toFixed(3);
+    const reflectedKey = `rad(${reflected})`;
+    if (trig[reflectedKey] && trig[reflectedKey].cos) {
+      return `sin(${x}) ≈ cos(${reflected}) ≈ ${trig[reflectedKey].cos.value?.approx ?? trig[reflectedKey].cos.value}`;
+    }
+    const closest = findClosestRad(reflected, 'cos');
+    return `sin(${x}) ≈ cos(${reflected}) ≈ ${closest}`;
+  }
+
+}
+
+ function queryCos(input) {
+  // Normalize and extract the value from input like "cos 0.533" or "cos(0.533)"
+  const match = input.match(/cos\s*\(?([0-9.]+)\)?/i);
+  if (!match) return; // Invalid input format
+
+  const x = parseFloat(match[1]);
+  const radKey = `rad(${x.toFixed(3)})`;
+
+// Case 1: Exact match
+  if (trig[radKey] && trig[radKey].cos) {
+    return `cos(${x}) ≈ ${trig[radKey].cos.value?.approx ?? trig[radKey].cos.value}`;
+  }
+
+  // Case 2A: 1.6 > x > 0.8 OR 0.1 > x > 0
+  if ((x > 0.8 && x < 1.6) || (x > 0 && x < 0.1)) {
+    const closest = findClosestRad(x, 'cos');
+    return `cos(${x}) ≈ ${closest}`;
+  }
+
+  // Case 2B: 0.8 > x > 0.1 → Reflect to sin(1.6 - x)
+  if (x > 0.1 && x < 0.8) {
+    const reflected = (1.6 - x).toFixed(3);
+    const reflectedKey = `rad(${reflected})`;
+
+    if (trig[reflectedKey] && trig[reflectedKey].sin) {
+      return `cos(${x}) ≈ sin(${reflected}) ≈ ${trig[reflectedKey].sin.value?.approx ?? trig[reflectedKey].sin.value}`;
+    }
+
+    const closest = findClosestRad(reflected, 'sin');
+    return `cos(${x}) ≈ sin(${reflected}) ≈ ${closest}`;
+  }
+}
+
+ function queryTan(input) {
+  // Normalize and extract the value from input like "tan 0.533" or "tan(0.533)"
+  const match = input.match(/tan\s*\(?([0-9.]+)\)?/i);
+  if (!match) return; // Invalid input format
+
+  const x = parseFloat(match[1]);
+  const radKey = `rad(${x.toFixed(3)})`;
+
+  // Case 1: Exact match
+  if (trig[radKey] && trig[radKey].tan) {
+    return `tan(${x}) ≈ ${trig[radKey].tan.value?.approx ?? trig[radKey].tan.value}`;
+  }
+
+  // Case 2A: 1.6 > x > 0.8 OR 0.1 > x > 0
+  if ((x > 0.8 && x < 1.6) || (x > 0 && x < 0.1)) {
+    const closest = findClosestRad(x, 'tan');
+    return `tan(${x}) ≈ ${closest}`;
+  }
+
+  // Case 2B: 0.8 > x > 0.1 → Reflect
+  if (x > 0.1 && x < 0.8) {
+  const reflected = (1.6 - x).toFixed(3);
+  const reflectedKey = `rad(${reflected})`;
+
+  if (trig[reflectedKey] && trig[reflectedKey].tan) {
+    const reflectedTan = parseFloat(trig[reflectedKey].tan.value?.approx ?? trig[reflectedKey].tan.value);
+    return `tan(${x}) ≈ 1 / tan(${reflected})`;
+  }
+
+  const fallback = findClosestRad(reflected, 'tan');
+  return `tan(${x}) ≈ 1 / tan(${reflected}) ≈ 1 / (${fallback})`;
+  }
+}
+
+function findClosestValueMatch(value, funcType) {
+  let bestMatch = null;
+  let minDiff = Infinity;
+
+  for (const key in trig) {
+    const approx = trig[key][funcType]?.value?.approx ?? trig[key][funcType]?.value;
+    if (!approx) continue;
+
+    const diff = Math.abs(parseFloat(approx) - value);
+    if (diff < minDiff) {
+      minDiff = diff;
+      bestMatch = { angle: key, approx };
+    }
+  }
+
+  return bestMatch;
+}
+
+
+ function queryAsin(input) {
+  // Normalize and extract the value: "asin 0.5" or "asin(0.5)"
+  const match = input.match(/asin\s*\(?([0-9./\s√-]+)\)?/i);
+  if (!match) return; // Invalid format
+
+  const inputStr = match[1].trim();
+  const x = parseFloat(eval(inputStr.replace(/√(\d+)/g, 'Math.sqrt($1)'))); // handles √2 etc.
+
+  if (isNaN(x) || x <= 0 || x >= 1) return; // asin(x) only defined for 0 < x < 1
+
+  // Case A: x > 0.707 or x < 0.1 → search sin column directly
+  if (x > 0.707 || x < 0.1) {
+    const bestMatch = findClosestValueMatch(x, 'sin');
+    if (bestMatch) return `asin(${inputStr}) ≈ ${bestMatch.angle}`;
+  }
+
+  // Case B: 0.1 < x < 0.707 → search cos column and reflect
+  const bestCosMatch = findClosestValueMatch(x, 'cos');
+  if (bestCosMatch) {
+    const angleMatch = bestCosMatch.angle;
+    const angleNum = parseFloat(angleMatch.match(/[\d.]+/)[0]);
+    const reflected = (1.6 - angleNum).toFixed(3);
+    return `asin(${inputStr}) ≈ 1.6 - ${angleMatch} ≈ rad(${reflected})`;
+  }
+}
+
+ function queryAcos(input) {
+  // Normalize and extract the value: "acos 0.5" or "acos(0.5)"
+  const match = input.match(/acos\s*\(?([0-9./\s√-]+)\)?/i);
+  if (!match) return; // Invalid format
+
+  const inputStr = match[1].trim();
+  const x = parseFloat(eval(inputStr.replace(/√(\d+)/g, 'Math.sqrt($1)')));
+
+  if (isNaN(x) || x <= 0 || x >= 1) return; // acos(x) only defined for 0 < x < 1
+
+  // Case A: x < 0.707 or x > 0.996 → match cos directly
+  if (x < 0.707 || x > 0.996) {
+    const bestMatch = findClosestValueMatch(x, 'cos');
+    if (bestMatch) return `acos(${inputStr}) ≈ ${bestMatch.angle}`;
+  }
+
+  // Case B: 0.707 < x < 0.996 → reflect from sin column
+  const bestSinMatch = findClosestValueMatch(x, 'sin');
+  if (bestSinMatch) {
+    const angleNum = parseFloat(bestSinMatch.angle.match(/[\d.]+/)[0]);
+    const reflected = (1.6 - angleNum).toFixed(3);
+    return `acos(${inputStr}) ≈ 1.6 - ${bestSinMatch.angle} ≈ rad(${reflected})`;
+  }
+}
+
+ function queryAtan(input) {
+  // Normalize and extract the value: "atan 0.5" or "atan(0.5)"
+  const match = input.match(/atan\s*\(?([0-9./\s√-]+)\)?/i);
+  if (!match) return; // Invalid format
+
+  const inputStr = match[1].trim();
+  const x = parseFloat(eval(inputStr.replace(/√(\d+)/g, 'Math.sqrt($1)')));
+
+  if (isNaN(x) || x <= 0 || x >= 7.6) return; // Domain cutoffs from your spec
+
+  // Case A: x > 1 or x < 0.089 → direct match
+  if (x > 1 || x < 0.089) {
+    const bestMatch = findClosestValueMatch(x, 'tan');
+    if (bestMatch) return `atan(${inputStr}) ≈ ${bestMatch.angle}`;
+  }
+
+  // Case B: 0.089 < x < 1 → invert to 1/x and search tan table
+  const reciprocal = 1 / x;
+  const bestMatch = findClosestValueMatch(reciprocal, 'tan');
+  if (bestMatch) return `atan(${inputStr}) ≈ ${bestMatch.angle}`;
+}
+
+</script>
+</div>
 <div>
  <p style="margin:12px;">Area of a triangle:
 <br>
@@ -1978,6 +2225,36 @@ <h6 style="font-size:160%;margin:7px">Area of a circle</h6>
 <br>
 <br>
 <br>
+<label style="margin:12px;" for="test1">test1:</label>
+<input id="test1" type="number" value="1" step="any" />
+<br>
+<label style="margin:12px;" for="test2">test2:</label>
+<input id="test2" type="number" value="1" step="any" />
+	
+<script>
+  function test(test1, test2) {
+    return  test1 + test2 * test3 ;
+  }
+
+  function updateTestVolume() {
+    const test1 = parseFloat(document.getElementById('test1').value);
+    const test2 = parseFloat(document.getElementById('test2').value);
+const test3 = queryTan(1.2);
+	  
+    if (isNaN(test1) || isNaN(test2)) {
+      document.getElementById('test-volume').innerText = '';
+      return;
+    }
+
+    document.getElementById('test-volume').innerText =
+      `Volume: ${testVolume(test1, test2).toFixed(5)} cubic units`;
+  }
+
+  document.getElementById('test1').addEventListener('input', updateTestVolume);
+  document.getElementById('test2').addEventListener('input', updateTestVolume);
+</script>
+<p style="margin:12px;" id="test-volume"></p>
+</div>
 <div>
 <h17 style="font-size:160%;margin:7px">Geometry Calculator Android App</h17>
 <br>