Assemblyscript: स्मृति पर u16/u32/f64... ect कैसे साझा करें?

मैं AS और JS से मेमोरी एक्सेस करने के लिए MDN उदाहरण जैसे कोड का उपयोग करता हूं।
लेकिन u8/i8 को छोड़कर, सभी परीक्षण पैटर्न विफल हो गए और मैंने देखा कि JS द्वारा दिखाया गया डेटा AS द्वारा दिखाए गए डेटा से भिन्न है।

मैं फ्लोट में डेटा कैसे स्टोर कर सकता हूं?

मेरे कोड जैसे:

```index.ts
// असेंबली/index.ts

निर्यात समारोह readMemoryU8 (ऑफ़सेट: उपयोग करें): u8 {
वापसी भार(ऑफसेट)
}

निर्यात समारोह लिखें मेमोरीयू 8 (ऑफ़सेट: उपयोग करें, मान: यू 8): शून्य {
दुकान(ऑफसेट, मूल्य)
}

निर्यात समारोह readMemoryU16 (ऑफ़सेट: उपयोग करें): u16 {
वापसी भार(ऑफसेट)
}

एक्सपोर्ट फंक्शन राइटमेमोरीयू16 (ऑफ़सेट: यूज़, वैल्यू: यू16): शून्य {
दुकान(ऑफसेट, मूल्य)
}

निर्यात समारोह readMemoryF64 (ऑफ़सेट: उपयोग करें): f64 {
वापसी भार(ऑफसेट)
}

एक्सपोर्ट फंक्शन राइटमेमरीएफ 64 (ऑफसेट: यूज, वैल्यू: एफ 64): शून्य {
दुकान(ऑफसेट, मूल्य)
}

//...

```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 = आवश्यकता ('../index');
कॉन्स्ट मेमोरी = wasm.memory;

वर्णन करें ('टेस्ट WASM', () => {
पहले सभी (() => {
कॉन्स्ट मेम = नया Uint8Array (मेमोरी.बफर);
अगर (मेम। लंबाई <1) {
मेमोरी.ग्रो (1);
}
wasm.memory.grow(1);
});

परीक्षण ('uint8 पढ़ें / लिखें', () => {
कॉन्स्ट मेम = नया Uint8Array (मेमोरी.बफर);

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);

});

परीक्षण ('uint16 पढ़ें / लिखें', () => {
कॉन्स्ट मेम = नया Uint16Array (मेमोरी.बफर);

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);

});

परीक्षण ('फ्लोट 64 पढ़ें / लिखें', () => {
कॉन्स्ट मेम = नया फ्लोट64एरे (मेमोरी.बफर);

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);

});
});

```