)
}
}
)
(
}
{
)
)
(
)
(
(
{
}
)
(
)
}
)
)
{
(
(
)
)
}
)
(
}

Inverse of a Function

1. `const expoIn = t => `
2. `  (t==0) ? 0 : Math.pow(2, 10 * (t - 1))`
3. ` `
4. `const expoInInverse= t => `
5. `  (t==0) ? 0 : ((Math.log(t) + 10 * Math.log(2)) / Math.log(2)) / 10`
6. ` `
7. ` `
8. `console.log(expoIn(.35) + ' ' +  expoInInverse(expoIn(.35)))`

Very nice inverse function calculator by user fawad over at Wolfram Alpha. Was attempting to invert a standard “exponential in” easing function – after some futzing I resorted to the calculator ðŸ˜€

Normalize Value Between 0 and 1

1. `const d = document.body.appendChild(`
2. `  document.createElement`div`)`
3. `d.innerHTML = ``
4. `<input `
5. `  id="input"`
6. `  type="range" `
7. `  min="-2" max="5" `
8. `  value="0">`
9. ```
10. ` `
11. `let val = 0;`
12. ` `
13. `console.log('drag slider...')`
14. ` `
15. `const range = (input.max - input.min);`
16. ` `
17. `input.oninput = () => {`
18. `  val = (input.value - input.min) / range`
19. `  console.log(input.value + ' - normalized = ' + val)`
20. `}`
// html // javascript // math // ui

Decompose Matrix

1. `const deltaTransformPoint = (matrix, point) => {`
2. `  return {`
3. `    x: point.x * matrix.a + point.y * matrix.c,`
4. `    y: point.x * matrix.b + point.y * matrix.d`
5. `  }`
6. `}`
7. ` `
8. `const decomposeMatrix = matrix => {`
9. `  let px = deltaTransformPoint(matrix, { x: 0, y: 1 })`
10. `  let py = deltaTransformPoint(matrix, { x: 1, y: 0 })`
11. `  let skewX = FROM_RADS * Math.atan2(px.y, px.x) - 90`
12. `  let skewY = FROM_RADS * Math.atan2(py.y, py.x)`
13. ` `
14. `  return {`
15. `    tx: matrix.e,`
16. `    ty: matrix.f,`
17. `    scaleX: Math.sqrt(matrix.a * matrix.a + matrix.b * matrix.b),`
18. `    scaleY: Math.sqrt(matrix.c * matrix.c + matrix.d * matrix.d),`
19. `    skewX: skewX,`
20. `    skewY: skewY,`
21. `    rotation: skewX`
22. `  }`
23. `}`

Get the scale, translation, rotationa and skew values from a matrix.

Great stackoverflow answer from user dave

// graphics // math // matrix

Iterative Square Root

1. `//------------------------------------------------------------------`
2. `float function_IterativeSquareRoot (float x) {`
3. `  // http://en.wikipedia.org/wiki/Methods_of_computing_square_roots`
4. `  // Ancient Babylonian technology`
5. `  functionName = "Iterative (Heron's) Square Root";`
6. `  float y = 0.5; `
7. `  int n = 6;`
8. `  for (int i=0; i<n; i++) {`
9. `    y = (y + x/y)/2.0;`
10. `  }`
11. `  return y;`
12. `}`

Was browsing some code by Golan Levin and stumbled on this…

There are some real gems in the repo – might port some stuff from there in the future…

Fibonacci Triangle Golfed

1. `// by Arnauld - https://codegolf.stackexchange.com/users/58563/arnauld`
2. `f=(n,a=b=1,p)=>n?''.padEnd(p)+a+`+\${b}=\${b+=a}`
3. ``+f(n-1,b-a,(a+"").length-~p):''`
4. ` `
5. `console.log(f(20))`

Great golfed solution to this question at codegolf stackexchange by user Arnauld

snippet.zone ~ 2021-24 /// {s/z}