Math.log not working correctly?

[codemonkeynorth]

Bug description

Mathf.log functions don't return the correct value

Steps to reproduce

export function test_log(x: f32): f32 {
  return Mathf.log(x) // x = 10 => -0.004908394999802113 // (incorrect)
}
export function test_log10(x: f32): f32 {
  return Mathf.log10(x) // x = 10 => 1.0 // (correct)
}
export function test_log2(x: f32): f32 {
  return Mathf.log2(x) // x = 10 => -0.005684611387550831 // (incorrect)
}

EXAMPLE FIX:

export function test_log_fixed(x: f32): f32 {
  // x= 10 => 2.3025851249694824 (correct)
  return Mathf.log10(x) * <f32>Math.LN10; 
}

export function test_log2_fixed(x: f32): f32 {
  // x = 10 => 3.321928024291992 (correct)
  return (Mathf.log10(x) * <f32>Math.LN10) / <f32>Math.LN2 
}

AssemblyScript version

0.28.2

[MaxGraey]

I can't reproduce this playground

Output:

AS Mathf.log(10) = 2.3025851249694824
AS Math.log(10) = 2.302585092994046
JS Math.log(10) = 2.302585092994046

Either way, we would have failed unit tests.

Makes sure you're not corrupt wasm's linear memory due to log/pow functions use static lookup tables

[codemonkeynorth]

@MaxGraey here's my specific code

export const UINT16ARRAY_ID = idof<Uint16Array>()
export const FLOAT32ARRAY_ID = idof<Float32Array>()

export function log_transform(
  inputPtr: usize,
  outputPtr: usize,
  length: i32,
  min: i32,
  max: i32,
  value: f32
): void {
  const invRange: f32 = 1.0 / <f32>(max - min)
  // -----------------------------------------------------------------------
  // works: 
  // const logBase: f32 = value > 0.0 ? Mathf.log10(1.0 + value) * <f32>Math.LN10 : 1.0
  // breaks:
  const logBase: f32 = value > 0.0 ? Mathf.log(1.0 + value) : 1.0
  // -----------------------------------------------------------------------

  for (let i = 0; i < length; i++) {
    // Read 16-bit value directly
    const value: u16 = load<u16>(inputPtr + (i << 1))

    const diff: f32 = <f32>(value - min)
    const prod: f32 = diff * invRange
    const intensity: f32 = Mathf.max(prod, <f32>0.0001)
    let adjusted: f32
    if (value > 0.0) {
      const valueIntensity: f32 = <f32>value * intensity
      const onePlusValueIntensity: f32 = 1.0 + valueIntensity
      // works:
      //const logValue: f32 = Mathf.log10(onePlusValueIntensity) * <f32>Math.LN10
      // breaks:
      const logValue: f32 = Mathf.log(onePlusValueIntensity) 
      // -----------------------------------------------------------------------
      adjusted = logValue / logBase 
    } else {
      adjusted = intensity
    }
    store<f32>(outputPtr + (i << 2), adjusted)
  }
}

[MaxGraey]

Yeah. You make direct unsafe access to linear memory via:

load<u16>(inputPtr + (i << 1))
...
store<f32>(outputPtr + (i << 2), adjusted)

And probably override static lookup table which uses for log method. outputPtr should have some offset and should not equal to zero or close to it. The most safe way is utilize memory.__data_end which will be a base offses for inputPtr and outputPtr
https://www.assemblyscript.org/runtime.html#memory-layout

[CountBleck]

Depending on the code, that's probably not safe either, because judging from the example snippet, the heap is also being used (the reference to Uint16Array and such). You'd probably want your memory addresses to be from:

• a statically allocated buffer, using memory.data(1234), where 1234 is the length of the buffer in bytes
• an ArrayBuffer or StaticArray, using changetype<usize>(bufferOrStaticArray)
• a TypedArray, using changetype<usize>(typedArray.buffer) + typedArray.byteOffset, or
• a manually heap-allocated (not garbage collected) buffer of memory, using heap.alloc(1234) to allocate the buffer and get the pointer/address, and heap.free(ptr) to free it