Implement fixedscaleoffset codec

packages/zarrita/src/codecs.ts

@@ -2,6 +2,7 @@ import type { Codec as _Codec } from "numcodecs";
 import { BitroundCodec } from "./codecs/bitround.js";
 import { BytesCodec } from "./codecs/bytes.js";
 import { Crc32cCodec } from "./codecs/crc32c.js";
+import { FixedScaleOffsetCodec } from "./codecs/fixedscaleoffset.js";
 import { GzipCodec } from "./codecs/gzip.js";
 import { JsonCodec } from "./codecs/json2.js";
 import { TransposeCodec } from "./codecs/transpose.js";
@@ -35,7 +36,8 @@ function create_default_registry(): Map<string, () => Promise<CodecEntry>> {
 		.set("crc32c", () => Crc32cCodec)
 		.set("vlen-utf8", () => VLenUTF8)
 		.set("json2", () => JsonCodec)
-		.set("bitround", () => BitroundCodec);
+		.set("bitround", () => BitroundCodec)
+		.set("fixedscaleoffset", () => FixedScaleOffsetCodec);
 }
 
 export const registry: Map<string, () => Promise<CodecEntry>> =

packages/zarrita/src/codecs/fixedscaleoffset.ts

@@ -0,0 +1,56 @@
+import type { Chunk, NumberDataType, TypedArrayConstructor } from "../metadata.js"
+import { coerce_dtype, get_ctr } from "../util.js"
+
+type FixedScaleOffsetConfig = {
+    offset: number;
+    scale: number;
+    dtype: string;
+    astype?: string;
+}
+
+export class FixedScaleOffsetCodec<D extends NumberDataType, A extends NumberDataType> {
+    readonly kind = "array_to_array";
+
+    #offset: number;
+    #scale: number;
+    #TypedArrayIn: TypedArrayConstructor<D>
+    #TypedArrayOut: TypedArrayConstructor<A>
+
+    constructor(configuration: FixedScaleOffsetConfig) {
+        const { data_type } = coerce_dtype(configuration.dtype);
+	this.#TypedArrayIn = get_ctr(data_type as NumberDataType);
+        const { data_type: as_data_type } = coerce_dtype(configuration.astype ?? configuration.dtype);
+	this.#TypedArrayOut = get_ctr(as_data_type as NumberDataType);
+
+	this.#offset = configuration.offset;
+	this.#scale = configuration.scale;
+    }
+
+    static fromConfig(configuration: FixedScaleOffsetConfig) {
+	return new FixedScaleOffsetCodec(configuration);
+    }
+
+    encode(arr: Chunk<D>): Chunk<A> {
+        const data = new this.#TypedArrayOut(arr.data.length);
+	arr.data.forEach((value: number, i: number) => {
+	    data[i] = (value - this.#offset) * this.#scale;
+	});
+        return {
+            data,
+            shape: arr.shape,
+            stride: arr.stride
+        }
+    }
+
+    decode(arr: Chunk<A>): Chunk<D> {
+	const out_data = new this.#TypedArrayIn(arr.data.length);
+	arr.data.forEach((value: number, i: number) => {
+	    out_data[i] = (value / this.#scale) + this.#offset;
+	});
+	return {
+	    data: out_data,
+	    shape: arr.shape,
+	    stride: arr.stride,
+	};
+    }
+}

packages/zarrita/src/util.ts

@@ -119,7 +119,7 @@ export function create_chunk_key_encoder({
 	throw new Error(`Unknown chunk key encoding: ${name}`);
 }
 
-function coerce_dtype(
+export function coerce_dtype(
 	dtype: string,
 ): { data_type: DataType } | { data_type: DataType; endian: "little" | "big" } {
 	if (dtype === "|O") {