Assemblyscript: Wie teilt man u16/u32/f64 ... ect im Speicher?

Ich verwende nur Codes wie MDN Example , um auf Speicher von AS und JS zuzugreifen.
Aber außer u8/i8 sind alle Testmuster fehlgeschlagen und ich habe gesehen, dass die von JS angezeigten Daten sich von denen unterscheiden, die von AS angezeigt werden.

Wie kann ich Daten in Float speichern?

Meine Codes wie:

```index.ts
// Assembly/index.ts

Exportfunktion readMemoryU8(offset: usesize): u8 {
Rückladung(Versatz)
}

export function writeMemoryU8(offset: usize, value: u8): void {
Geschäft(Offset, Wert)
}

Exportfunktion readMemoryU16(offset: usesize): u16 {
Rückladung(Versatz)
}

export function writeMemoryU16(offset: usize, value: u16): void {
Geschäft(Offset, Wert)
}

Exportfunktion readMemoryF64(offset: usesize): f64 {
Rückladung(Versatz)
}

export function writeMemoryF64(offset: usize, value: f64): void {
Geschäft(Offset, Wert)
}

// ...

```index.js
// index.js

const fs = require("fs");
const compiled = new WebAssembly.Module(fs.readFileSync(__dirname + "/build/optimized.wasm"));
const imports = {};
Object.defineProperty(module, "exports", {
  get: () => new WebAssembly.Instance(compiled, imports).exports
});

```index.test.js
// __tests__/index.test.js

const wasm = require('../index');
const memory = wasm.memory;

description('WASM testen', () => {
vorAll(() => {
const mem = new Uint8Array (memory.buffer);
if (Speicherlänge < 1) {
memory.grow(1);
}
wasm.memory.grow(1);
});

test('lesen / schreiben uint8', () => {
const mem = new Uint8Array (memory.buffer);

mem.set([1, 3, 5]);
console.log([0, 1, 2, 3, 4, 5].map(wasm.readMemoryU8));
// [ 1, 3, 5, 0, 0, 0 ]
console.log(mem.subarray(0, 6));
//Uint8Array [ 1, 3, 5, 0, 0, 0 ]
expect(wasm.readMemoryU8(1)).toBe(3);
wasm.writeMemoryU8(1, 6);
expect(wasm.readMemoryU8(1)).toBe(6);
expect(mem[1]).toBe(6);
expect(wasm.readMemoryU8(0)).toBe(1);
expect(wasm.readMemoryU8(2)).toBe(5);

});

test('lesen/schreiben uint16', () => {
const mem = new Uint16Array (memory.buffer);

mem.set([1, 3, 257]);
console.log([0, 1, 2, 3, 4, 5].map(wasm.readMemoryU16)); 
// [ 1, 768, 3, 256, 257 ]
console.log(mem.subarray(0, 6)); 
// Uint16Array [ 1, 3, 257, 0, 0, 0 ]
expect(wasm.readMemoryU16(0)).toBe(1);
expect(wasm.readMemoryU16(1)).toBe(3); // failed
wasm.writeMemoryU16(1, 6);
expect(wasm.readMemoryU16(1)).toBe(6);
expect(mem[1]).toBe(6);
expect(wasm.readMemoryU16(2)).toBe(5);

});

test('float64 lesen/schreiben', () => {
const mem = new Float64Array (memory.buffer);

mem.set([1, -3.2, 25.8]);

console.log([0, 1, 2, 3, 4, 5].map(wasm.readMemoryF64));
// [ 1,
//  -3.0065162379579438e-182,
//  -2.413170169815393e-185,
//  -2.3536706995205933e-185,
//  -2.3534382797147542e-185,
//  -2.3534373718248877e-185 ]
console.log(mem.subarray(0, 6));
// Float64Array [ 1, -3.2, 25.8, 0, 0, 0 ]
expect(wasm.readMemoryF64(0)).toBe(1);
expect(wasm.readMemoryF64(1)).toBe(-3.2); // failed
wasm.writeMemoryI16(1, -6.5);
expect(wasm.readMemoryF64(1)).toBe(-6.5);
expect(mem[1]).toBe(-6.5);
expect(wasm.readMemoryI16(2)).toBe(25.8);

});
});

```