[jdata4] fix complex array chunking (1D and ND)

- jdataencode: ND chunking of complex tiles now serialises
  [real(chunk(:))', imag(chunk(:))'] instead of typecast on the raw
  complex buffer (which was platform-dependent)
- jdatadecode: 1D chunked path restored _ArrayZipSize_ to [1,2N]
  instead of [2,N], breaking complex(row1,row2) reconstruction;
  now sets [2, N/2] when _ArrayIsComplex_ is present
- jdatadecode: ND chunked path allocates a complex intermediate array,
  fills real+imag halves per tile, then emits flat [re…,im…] buffer
  with correct _ArrayZipSize_ = [2, N]
- test: add 8 tests covering 1D and ND chunking of complex arrays,
  both direct decode and roundtrip via savejson/loadjson

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: fangq

jdatadecode.m

@@ -284,7 +284,12 @@
                         ndim = numel(arrsize);
                         nchunks_nd = ceil(arrsize ./ chunkshape);
                         ntiles = prod(nchunks_nd);
-                        ndata = cast(zeros(arrsize), arraytype);
+                        iscpx_arr = isfield(data, N_ArrayIsComplex) && data(j).(N_ArrayIsComplex);
+                        if (iscpx_arr)
+                            ndata = complex(cast(zeros(arrsize), arraytype));
+                        else
+                            ndata = cast(zeros(arrsize), arraytype);
+                        end
                         tidx = cell(1, ndim);
                         for ci = 1:ntiles
                             [tidx{:}] = ind2sub(nchunks_nd, ci);
@@ -301,12 +306,26 @@
                                 ranges{d} = r1:r2;
                                 tilesize(d) = r2 - r1 + 1;
                             end
-                            ndata(ranges{:}) = reshape(rawchunk, tilesize);
+                            if (iscpx_arr)
+                                half = numel(rawchunk) / 2;
+                                ndata(ranges{:}) = complex(reshape(rawchunk(1:half), tilesize), ...
+                                                           reshape(rawchunk(half + 1:end), tilesize));
+                            else
+                                ndata(ranges{:}) = reshape(rawchunk, tilesize);
+                            end
+                        end
+                        if (iscpx_arr)
+                            ndata = [real(ndata(:))', imag(ndata(:))'];
+                        else
+                            ndata = ndata(:).';
                         end
-                        ndata = ndata(:).';  % flatten to row, same layout as 1-D path
                     end
-                    % Set ZipSize to flat row so downstream _ArraySize_ reshape works
-                    data(j).(N_ArrayZipSize) = [1, numel(ndata)];
+                    % Restore ZipSize for downstream complex reconstruction
+                    if (isfield(data, N_ArrayIsComplex) && data(j).(N_ArrayIsComplex))
+                        data(j).(N_ArrayZipSize) = [2, numel(ndata) / 2];
+                    else
+                        data(j).(N_ArrayZipSize) = [1, numel(ndata)];
+                    end
                     dims = data(j).(N_ArrayZipSize);
                 elseif (needbase64 && strcmp(zipmethod, 'base64') == 0)
                     ndata = reshape(typecast(decompfun(base64decode(data(j).(N_ArrayZipData)), decodeparam{:}), arraytype), dims);

jdataencode.m

@@ -530,7 +530,12 @@
                     ranges{d} = r1:r2;
                 end
                 chunk = item(ranges{:});
-                zipchunks{ci} = compfun(typecast(chunk(:)', 'uint8'), encodeparam{:});
+                if (~isreal(item))
+                    chunk_flat = [real(chunk(:))', imag(chunk(:))'];
+                    zipchunks{ci} = compfun(typecast(chunk_flat, 'uint8'), encodeparam{:});
+                else
+                    zipchunks{ci} = compfun(typecast(chunk(:)', 'uint8'), encodeparam{:});
+                end
                 if (opt.base64)
                     zipchunks{ci} = char(base64encode(zipchunks{ci}));
                 end

test/run_jsonlab_test.m

@@ -4659,6 +4659,39 @@ function run_jsonlab_test(tests)
     dec_nd_json = jdatadecode(loadjson(savejson('', enc_nd_json, 'compact', 1)));
     test_jsonlab('nd chunks roundtrip via savejson/loadjson', @savejson, isequaln(dec_nd_json, big3d), '[true]', 'compact', 1);
 
+    %% --- _ArrayChunks_ with complex arrays ---
+    % 1-D chunking of a complex matrix (compressarraysize=1 forces compression on small arrays)
+    cpx2d = complex(reshape(1:12, 3, 4), reshape(101:112, 3, 4));
+    enc_cpx1d = jdataencode(cpx2d, 'formatversion', 4, 'compression', 'zlib', ...
+                            'arraychunks', 8, 'base64', 1, 'prefix', 'x', 'compressarraysize', 1);
+    test_jsonlab('complex 1d chunks field exists', @savejson, isfield(enc_cpx1d, 'x_ArrayIsComplex_'), '[true]', 'compact', 1);
+    test_jsonlab('complex 1d chunks chunklen', @savejson, enc_cpx1d.x_ArrayChunks_, '[8]', 'compact', 1);
+    dec_cpx1d = jdatadecode(enc_cpx1d, 'base64', 1, 'prefix', 'x');
+    test_jsonlab('complex 1d chunks roundtrip', @savejson, isequaln(dec_cpx1d, cpx2d), '[true]', 'compact', 1);
+
+    % roundtrip via savejson/loadjson
+    enc_cpx1d_json = jdataencode(cpx2d, 'formatversion', 4, 'compression', 'zlib', ...
+                                 'arraychunks', 8, 'base64', 1, 'compressarraysize', 1);
+    dec_cpx1d_json = jdatadecode(loadjson(savejson('', enc_cpx1d_json, 'compact', 1)));
+    test_jsonlab('complex 1d chunks roundtrip via savejson/loadjson', @savejson, isequaln(dec_cpx1d_json, cpx2d), '[true]', 'compact', 1);
+
+    % N-D chunking of a complex 3-D array
+    cpx3d = complex(single(reshape(1:60, 3, 4, 5)), single(reshape(101:160, 3, 4, 5)));
+    enc_cpxnd = jdataencode(cpx3d, 'formatversion', 4, 'compression', 'zlib', ...
+                            'arraychunks', [3, 3, 3], 'base64', 1, 'prefix', 'x', 'compressarraysize', 1);
+    test_jsonlab('complex nd chunks field exists', @savejson, isfield(enc_cpxnd, 'x_ArrayIsComplex_'), '[true]', 'compact', 1);
+    test_jsonlab('complex nd chunks chunkshape', @savejson, isequal(enc_cpxnd.x_ArrayChunks_, [3, 3, 3]), '[true]', 'compact', 1);
+    dec_cpxnd = jdatadecode(enc_cpxnd, 'base64', 1, 'prefix', 'x');
+    test_jsonlab('complex nd chunks roundtrip', @savejson, isequaln(dec_cpxnd, cpx3d), '[true]', 'compact', 1);
+
+    enc_cpxnd_json = jdataencode(cpx3d, 'formatversion', 4, 'compression', 'zlib', ...
+                                 'arraychunks', [3, 3, 3], 'base64', 1, 'compressarraysize', 1);
+    dec_cpxnd_json = jdatadecode(loadjson(savejson('', enc_cpxnd_json, 'compact', 1)));
+    test_jsonlab('complex nd chunks roundtrip via savejson/loadjson', @savejson, isequaln(dec_cpxnd_json, cpx3d), '[true]', 'compact', 1);
+
+    clear cpx2d enc_cpx1d dec_cpx1d enc_cpx1d_json dec_cpx1d_json;
+    clear cpx3d enc_cpxnd dec_cpxnd enc_cpxnd_json dec_cpxnd_json;
+
     clear big3d enc_ch enc_ch2 enc_ch3 enc_v2_ch enc_ch_json dec_ch dec_ch2 dec_ch3 dec_ch_json;
     clear enc_nd dec_nd enc_nd_json dec_nd_json;
     clear circ_enc circ_enc2 circ_ref circ_ref2 hank_enc hank_enc2 hank_ref hank_ref2;