Data and files / Dados e arquivos

Cells are heterogeneous rectangular 2D values: {1,'a';true,[]} is 2-by-2; cell(n), cell(m,n) and cell([m,n]) initialize entries to explicit null(), not []. C{index} or C{row,col} extracts one value with scalar 1-based indices, including end; no comma-separated lists or brace slices. C(indices) and C(rows,cols) return a Cell subset using numeric vectors, logical masks, ranges, colon and end. Linear order is column-major. C(indices)=rhs requires a Cell with matching count; two-dimensional assignment requires matching shape. C{idx}=value and s.field=value require a simple variable base; nested lvalues are rejected by the parser, with no automatic growth or deletion by []. Numeric content reads such as record.numbers(2) and C{1}(2) work. null() is distinct from [] and has size 0-by-0.

struct(name,value,...) creates a scalar value-copy record with unique nonempty fields; fieldnames returns lexicographically sorted column cellstr. getfield/setfield/rmfield inspect or return values, not struct arrays or OOP objects. containers.Map(cellkeys,cellvalues) takes unique string keys; containers.Map() and @containers.Map work. map('key') reads/writes one key, map.Count reports size; keys/values return columns in lexicographic key order, isKey accepts a string or cellstr. Assignment and anonymous captures copy containers by value. remove returns a NEW map and errors on missing keys; it is not MATLAB handle mutation.

Studio exposes bounded read-only previews of six new kinds: Struct, Cell, Map, Table, DateTime and Null. Workspace opens a read-only preview dialog; debugger locals show summaries and previews in the inspection panel, not that dialog. Null has size 0-by-0 and summary null. These views are not numeric matrix editors and do not provide arbitrary-depth container editing or whole-session persistence.

C={1,'a';true,[]};
disp(C{1}==1 && C{2} && strcmp(C{1,2},'a'));
empty=cell(1,2);
disp(isnull(empty{1}) && !isnull([]));
part=C(:,2);
disp(iscell(part) && strcmp(part{1},'a'));
C([2,3])={7,8};
disp(C{2}==7 && C{1,2}==8);
s=struct('value',1);
copy=s;
s.value=2;
disp(copy.value==1 && s.value==2);
make=@containers.Map;
lookup=make({'key'},{3});
copy=lookup;
lookup('key')=4;
without=remove(lookup,'key');
disp(copy('key')==3 && lookup('key')==4 && !isKey(without,'key'));

Cells sao valores heterogeneos retangulares 2D: {1,'a';true,[]} tem 2 por 2; cell(n), cell(m,n) e cell([m,n]) iniciam entradas com null(), nao []. C{index} ou C{row,col} extrai um valor com indices escalares baseados em 1, inclusive end; sem listas de valores ou fatias entre chaves. C(indices) e C(rows,cols) retornam subconjunto Cell com vetores numericos, mascaras logicas, intervalos, dois-pontos e end. Ordem linear por colunas. C(indices)=rhs exige Cell com mesma quantidade; atribuicao bidimensional exige mesma forma. C{idx}=value e s.field=value exigem base variavel simples; o parser rejeita lvalues aninhados, sem crescimento automatico ou exclusao por []. Leituras numericas como registro.numeros(2) e C{1}(2) funcionam. null() difere de [] e tem forma 0 por 0.

struct(name,value,...) cria registro escalar por valor, campos unicos nao vazios; fieldnames retorna cellstr coluna em ordem lexicografica. getfield/setfield/rmfield operam sobre valores, nao arrays de structs nem OOP. containers.Map(cellkeys,cellvalues) exige chaves string unicas; containers.Map() e @containers.Map funcionam. map('key') le/escreve uma chave, map.Count le tamanho; keys/values retornam colunas em ordem lexicografica de chave, isKey aceita string ou cellstr. Atribuicao e captura anonima copiam conteineres por valor. remove retorna NOVO mapa e rejeita chave ausente; nao e mutacao de handle MATLAB.

O Studio exibe previews limitados somente leitura de seis novos tipos: Struct, Cell, Map, Table, DateTime e Null. Workspace abre um dialogo de preview somente leitura; locais do debugger mostram resumos e previews no painel de inspecao, nao nesse dialogo. Null tem forma 0 por 0 e resumo null. Essas visualizacoes nao sao editores de matrizes numericas nem oferecem edicao arbitrariamente profunda de conteineres ou persistencia da sessao inteira.

dados={1,'a';true,[]};
dados{1}=7;
parte=dados(1:end,1);
disp(parte{1}==7 && parte{2});
registro=struct('numeros',[3,5]);
copia=registro;
registro.numeros=[7,9];
C={[10,20]};
disp(copia.numeros(2)==5 && registro.numeros(2)==9 && C{1}(2)==20);
mapa=containers.Map({'nome'},{'Sun'});
captura=@() mapa('nome');
mapa('nome')='Studio';
novo=remove(mapa,'nome');
disp(captura()=='Sun' && mapa('nome')=='Studio' && novo.Count==0);

Column names are case-sensitive: exactly Properties is reserved for table metadata in every construction and validation path, including readtable CSV/XLSX headers. The lowercase name properties remains valid, and struct('Properties',42) is valid because this restriction applies only to table columns. This name restriction is separate from the read-only metadata view T.Properties.VariableNames.

table(columns...[, 'VariableNames', cellnames]) accepts equal-length real/logical/complex vectors (including scalars) and heterogeneous Cell vectors containing only Number, Bool, Complex, String, DateTime or Null scalars. Columns normalize to N-by-1; rows*columns must be <=100000. Nested containers and matrices inside Cell columns are rejected, even 1-by-1 matrices. Names are nonempty and unique, default Var1, Var2, ... . height/width report rows/variables; table2cell returns a 2D Cell. t.column reads a copy; t.column=value and setfield validate the same scalar-column contract and row count. t.Properties.VariableNames is read-only row cellstr.

T(rows,cols) requires both selectors: numeric indices, logical masks, ranges, colon and end, or column names as a string/Cell of strings. Duplicate selected columns are rejected. A selection with zero columns has height zero in this subset. Imported nullable/mixed scalar columns can be passed to table or used as replacements. Complex columns work in memory, not JSON/table-file export. No curly table extraction, nested Properties writes, row names, joins, categorical/timetable support, struct arrays, OOP or N-D arrays.

T=table([2,4],[true,false],{'a','b'},'VariableNames',{'value','valid','name'});
column=T.value;
names=T.Properties.VariableNames;
disp(height(T)==2 && width(T)==3 && all(size(column)==[2,1]) && strcmp(names{1},'value'));
T.value=[6,8];
subset=T(2:end,{'value','valid'});
disp(height(subset)==1 && width(subset)==2 && subset.value(1)==8);
empty=T(:,[]);
disp(height(empty)==0 && width(empty)==0);
Z=table({1;true;1+i;'Sun';datetime('2024-01-02');null()});
column=Z.Var1;
disp(height(Z)==6 && all(size(column)==[6,1]) && imag(column{3})==1 && isdatetime(column{5}) && isnull(column{6}));

Nomes de coluna diferenciam maiusculas de minusculas: exatamente Properties e reservado para metadados de tabela em toda construcao e validacao, inclusive cabecalhos CSV/XLSX de readtable. O nome properties em minusculas continua valido, e struct('Properties',42) e valido porque a restricao se aplica somente a colunas de tabela. Essa restricao de nome e distinta da visualizacao de metadados T.Properties.VariableNames somente leitura.

table(columns...[, 'VariableNames', cellnames]) aceita vetores reais/logicos/complexos de igual comprimento (inclusive escalares) e vetores Cell heterogeneos apenas de escalares Number, Bool, Complex, String, DateTime ou Null. Colunas normalizadas para N por 1; linhas*colunas <=100000. Rejeita conteineres aninhados e matrizes dentro de coluna Cell, inclusive matrizes 1 por 1. Nomes nao vazios e unicos, padrao Var1, Var2, ... . height/width contam linhas/variaveis; table2cell retorna Cell 2D. t.column le copia; t.column=value e setfield validam o mesmo contrato escalar e numero de linhas. t.Properties.VariableNames e cellstr linha somente leitura.

T(rows,cols) exige dois seletores: indices numericos, mascaras logicas, intervalos, dois-pontos e end, ou nomes de coluna como string/Cell de strings. Colunas selecionadas duplicadas sao rejeitadas. Selecao sem colunas tem altura zero neste subconjunto. Colunas escalares mistas/anulaveis importadas podem ser reconstruidas com table ou usadas como substituicao. Complexos funcionam em memoria, nao na exportacao JSON/arquivos de tabela. Sem extracao por chaves, escrita profunda em Properties, nomes de linha, joins, categorical/timetable, arrays de structs, OOP ou N-D.

tabela=table([1,2],{'um','dois'});
nomes=tabela.Properties.VariableNames;
disp(strcmp(nomes{1},'Var1') && strcmp(nomes{2},'Var2'));
tabela.extra=[true,false];
celulas=table2cell(tabela);
disp(height(tabela)==2 && width(tabela)==3 && celulas{2,1}==2 && !celulas{2,3});
tabela.Var1={1;null()};
copia=setfield(tabela,'Var1',{false;'Sun'});
disp(isnull(tabela.Var1{2}) && copia.Var1{2}=='Sun');

Single/double quotes, char and string all produce scalar Unicode text, not MATLAB character arrays or string arrays. Conversion accepts scalar text, finite Number, logical, datetime or null; null converts to empty text. String shape is always 1-by-1, length/numel are 1 and isempty is false, even for ''. Null itself has shape 0-by-0. strlength and regexp positions independently count Unicode scalar values, not bytes or grapheme clusters. strcat concatenates without trimming; strcmp is exact and strcmpi compares Unicode lowercase mappings, not locale collation/full case folding. contains/startsWith/endsWith, strtrim, lower/upper and strrep operate on scalar strings. split(text) splits whitespace into column cellstr, split(text,delimiter) uses a literal delimiter; strjoin defaults to a space.

regexp(text,pattern[,mode]) has ONE output: default 'start' or 'end' gives a row of 1-based inclusive positions; 'match' gives row cellstr. Empty-match end can be less than start (including 0). regexprep supports capture replacement $1/${name} and $$ for literal dollar. The Rust regex engine has no look-around or backreferences in patterns. Text/input/output is bounded at 8 MiB, result counts at 100000, patterns at 64 KiB and regex/DFA compiled budgets at 1 MiB each.

parts=split('one two');
disp(strcmp(strjoin(parts,'-'),'one-two') && strcmpi('SUN','sun'));
disp(isstring(char(12)) && strlength(string(null()))==0);
disp(all(size('')==[1,1]) && length('')==1 && numel('')==1 && !isempty(''));
positions=regexp('ab12cd34','[0-9]+','end');
matches=regexp('ab12','[0-9]+','match');
disp(all(positions==[4,8]) && strcmp(matches{1},'12'));
disp(strcmp(regexprep('ab12','[0-9]+','X'),'abX'));

Aspas simples/duplas, char e string produzem texto Unicode escalar, nao arrays de caracteres/strings MATLAB. Conversao aceita texto, Number finito, logico, datetime ou null; null vira texto vazio. String sempre tem forma 1 por 1, length/numel iguais a 1 e isempty falso, mesmo para ''. Null tem forma 0 por 0. strlength e posicoes de regexp contam independentemente escalares Unicode, nao bytes ou grafemas. strcat nao remove espacos; strcmp e exato, strcmpi compara mapeamento Unicode para minusculas, nao colacao local/case folding completo. contains/startsWith/endsWith, strtrim, lower/upper e strrep operam em escalares. split(text) separa espacos em cellstr coluna, delimitador explicito e literal; strjoin usa espaco por padrao.

regexp tem UMA saida: 'start' padrao e 'end' retornam linha de posicoes inclusivas baseadas em 1; 'match' retorna cellstr linha. Match vazio pode terminar antes do inicio, inclusive 0. regexprep aceita $1/${name} e $$ literal. Rust regex nao aceita look-around/backreferences no padrao. Limites: texto 8 MiB, 100000 resultados, padrao 64 KiB, compilado/DFA 1 MiB cada.

texto=strcat(' Sun',' ');
disp(strcmp(strtrim(lower(texto)),'sun') && startsWith(texto,' ') && endsWith(texto,' '));
disp(contains(strrep('a-b','-','/'),'/'));
partes=split('a,b',',');
disp(strcmp(upper(strjoin(partes,' ')),'A B'));
disp(all(size(null())==[0,0]) && isempty(null()) && !isempty(''));

datetime() / datetime('now') reads the UTC clock; datetime(text) parses RFC3339 (offsets normalize to UTC) or exact YYYY-MM-DD. datetime(y,m,d) / datetime(y,m,d,h,m,s) takes finite numeric components: all integral except seconds in [0,60), rounded to nanoseconds. Canonical RFC3339 UTC text uses years 0..9999 and automatic subsecond precision. isdatetime and year/month/day/hour/minute/second/posixtime inspect one scalar. No date arrays, durations, datetime arithmetic, timezone options or leap seconds. All datetime forms are blocked in parfor, including deterministic parsing.

date=datetime('2024-01-02T03:04:05+01:00');
disp(isdatetime(date) && year(date)==2024 && month(date)==1 && day(date)==2 && hour(date)==2 && minute(date)==4 && second(date)==5);
disp(posixtime(datetime(1970,1,1))==0 && strcmp(string(datetime(2024,1,2)),'2024-01-02T00:00:00Z'));

datetime() / datetime('now') consulta relogio UTC; datetime(text) aceita RFC3339 com offsets normalizados para UTC ou YYYY-MM-DD exato. datetime(y,m,d) / datetime(y,m,d,h,m,s) exige componentes numericos finitos inteiros, exceto segundos em [0,60) arredondados a nanossegundos. Texto canonico RFC3339 UTC, anos 0..9999 e precisao fracionaria automatica. isdatetime e year/month/day/hour/minute/second/posixtime inspecionam escalar. Sem arrays, duracoes, aritmetica datetime, opcoes de fuso ou segundos intercalares. Toda forma de datetime e bloqueada em parfor.

data=datetime(2024,2,29,12,30,0.5);
disp(isdatetime(data) && day(data)==29 && abs(second(data)-0.5)<1e-12);
disp(strcmp(char(datetime('1970-01-01')),'1970-01-01T00:00:00Z'));

jsondecode maps objects to scalar structs and null to explicit null(), not []. [] decodes as real 0-by-0. Flat homogeneous numeric/logical arrays become N-by-1 matrices; rectangular nonempty numeric rows become a real matrix, and rectangular boolean rows become a logical matrix with matching shape. Other arrays (mixed, nullable, strings or ragged) become N-by-1 cells with recursive decoding. Duplicate object keys keep the last value. jsonencode accepts finite numbers, booleans, strings, null, real/logical matrices, cells, structs, string-key maps and supported tables; datetimes become strings. Complex values and handles error.

Vectors encode flat, genuine 2D real/logical matrices as nested rows; cells encode flat in stored row-major order, losing 2D cell shape. Tables encode objects of column arrays, not typed table records; nullable cells encode JSON null. Decoding an encoded table/map/datetime gives a struct/string, not the original type. Row-vector orientation, empty matrix axes and empty array types are not guaranteed round trips. JSON text/input/output <=8 MiB, depth <=32, cumulative entries <=100000 (matrix outer rows count too). NaN/Inf and integer tokens that lose f64 precision beyond flintmax are rejected; no arbitrary precision.

record=jsondecode('{"value":null,"numbers":[1,2],"mixed":[1,null]}');
column=record.numbers;
mixed=record.mixed;
disp(isnull(record.value) && record.numbers(2)==2 && all(size(column)==[2,1]) && iscell(mixed) && isnull(mixed{2}));
matrix=jsondecode(jsonencode([1,2;3,4]));
disp(all(size(matrix)==[2,2]) && all(matrix==[1,2;3,4]));
logical=jsondecode('[[true,false],[false,true]]');
disp(isa(logical,'logical') && all(size(logical)==[2,2]) && all(logical==[true,false;false,true]));
encoded=jsondecode(jsonencode(table([1,2])));
column=encoded.Var1;
disp(isstruct(encoded) && all(size(column)==[2,1]));

jsondecode transforma objetos em structs escalares e null em null(), nao []. [] vira matriz real 0 por 0. Arrays planos numericos/logicos homogeneos viram matrizes N por 1; linhas numericas retangulares nao vazias viram matriz real, linhas booleanas retangulares viram matriz logica de mesma forma. Outros arrays (mistos/anulaveis, strings ou irregulares) viram cells N por 1 recursivas. Chaves repetidas conservam ultimo valor. jsonencode aceita numeros finitos, logicos, strings, null, matrizes reais/logicas, cells, structs, mapas e tabelas suportadas; datetime vira string. Complexos e handles geram erro.

Vetores codificam planos, matrizes 2D reais/logicas como linhas aninhadas; cells codificam planas na ordem interna por linhas e perdem forma 2D. Tabelas viram objetos de arrays-coluna, cells anulaveis preservam null JSON. Decodificar table/map/datetime nao restaura tipo original. Orientacao de vetor linha, eixos vazios e tipos de arrays vazios nao garantem round trip. Limites: 8 MiB de texto, profundidade 32, 100000 entradas cumulativas, inclusive linhas externas matriciais. NaN/Inf e tokens inteiros com perda f64 alem de flintmax sao rejeitados; sem precisao arbitraria.

valor=jsondecode('[true,false]');
disp(all(size(valor)==[2,1]) && isa(valor,'logical'));
matriz=jsondecode('[[true,false],[false,true]]');
disp(isa(matriz,'logical') && all(size(matriz)==[2,2]) && all(matriz==[true,false;false,true]));
lista=jsondecode('["a",null]');
disp(iscell(lista) && strcmp(lista{1},'a') && isnull(lista{2}));
disp(strcmp(jsonencode(null()),'null') && isempty(jsondecode('[]')));

fileread/filewrite(filename,text) use strict UTF-8 and an 8 MiB budget. readlines returns a column cellstr, drops LF/CRLF terminators and does not create an extra trailing line; <=100000 lines. writelines(textOrCellstr,filename) adds LF when absent for each item. readbytes returns a real row vector (not uint8); writebytes(filename,bytes) accepts a finite integer real scalar/vector in 0..255, <=16 MiB. Note the different writer argument orders.

readtable(filename[,sheet]) / writetable(table,filename[,sheet]) support ONLY .csv and .xlsx, not .xls/.xlsb/.ods despite broader calamine reader formats. CSV uses UTF-8, commas, unique nonempty headers and rectangular records; a whole column is numeric only if all entries parse finite, logical only if all are true/false, otherwise cellstr. Null writes a blank CSV field and reads back as an empty String, NOT Null. XLSX uses calamine for reading, rust_xlsxwriter for new single-sheet writing; sheet is an existing name/1-based index on read, a name or index 1 on write. String headers start at A1; explicit blank Null cells are preserved, mixed/nullable columns become Cells. Scalar mixed columns can be reconstructed with table and replaced through fields/setfield. No formulas, macros, Excel serial dates, styles/ranges/options or existing-workbook preservation; datetime writes as canonical text, not an Excel date.

Table files are bounded at 64 MiB compressed/file bytes and XLSX decompressed total, <=10000 ZIP entries, <=100000 cells including headers; XLSX writing <=16384 columns, bounded XML estimate. EOCD/ZIP64 declared counts and actual central-directory entry counts are checked against 10000 BEFORE ZipArchive::new. Structured XML preflight validates ranges and shared-string references and rejects formulas before calamine. Macros are rejected, not executed. Finite numbers/logicals/text/datetime/null are exportable, not complex values. Writers atomically replace rather than append, validate before host write and reject output assignment before writing. Host read_file/write_file_atomic follows existing CSV paths: relative to process/Studio project context, not an OS filesystem sandbox; the standard host rejects symlink destinations. Function-project grants do not sandbox these I/O calls.

filewrite('data.txt','Sun');
disp(strcmp(fileread('data.txt'),'Sun'));
writelines({'one','two'},'lines.txt');
lines=readlines('lines.txt');
disp(strcmp(lines{1},'one') && strcmp(lines{2},'two'));
writebytes('bytes.bin',[0,128,255]);
disp(all(readbytes('bytes.bin')==[0,128,255]));
T=table({1;null();3},{'a';'b';'c'},'VariableNames',{'value','name'});
writetable(T,'data.csv');
loaded=readtable('data.csv');
disp(height(loaded)==3 && loaded.value{2}=='' && !isnull(loaded.value{2}));
writetable(T,'data.xlsx','Data');
loaded=readtable('data.xlsx','Data');
disp(height(loaded)==3 && width(loaded)==2 && loaded.value{1}==1 && isnull(loaded.value{2}) && loaded.value{3}==3);

fileread/filewrite(filename,text) usam UTF-8 estrito e limite 8 MiB. readlines retorna cellstr coluna sem terminadores LF/CRLF e sem linha extra final; ate 100000 linhas. writelines(textOrCellstr,filename) adiciona LF ausente por item. readbytes retorna vetor real linha, nao uint8; writebytes(filename,bytes) aceita escalar/vetor real inteiro finito em 0..255, ate 16 MiB. Observe as ordens diferentes de argumentos dos escritores.

readtable(filename[,sheet]) / writetable(table,filename[,sheet]) aceitam SOMENTE .csv e .xlsx, nao .xls/.xlsb/.ods apesar dos formatos adicionais do leitor calamine. CSV UTF-8 separado por virgulas, cabecalhos unicos nao vazios, registros retangulares. Coluna toda numerica finita vira matriz, toda true/false vira logica, demais cellstr. Null escreve campo CSV vazio e retorna como String vazia, NAO Null. XLSX usa calamine na leitura e rust_xlsxwriter na escrita de nova pasta com uma planilha; sheet aceita nome/indice existente na leitura, nome ou indice 1 na escrita. Cabecalhos string desde A1; celulas brancas Null explicitas sao preservadas, colunas mistas/anulaveis viram Cells. Colunas escalares mistas podem ser reconstruidas com table e substituidas por campos/setfield. Sem formulas, macros, datas seriais Excel, estilos/intervalos/opcoes ou preservacao de pasta existente; datetime escreve texto canonico, nao data Excel.

Arquivos de tabela ate 64 MiB e total descomprimido XLSX ate 64 MiB; 10000 entradas ZIP, 100000 celulas incluindo cabecalhos, 16384 colunas XLSX na escrita e estimativa XML limitada. Contagens declaradas EOCD/ZIP64 e quantidade real de entradas do diretorio central sao verificadas contra 10000 ANTES de ZipArchive::new. Preflight XML estruturado valida intervalos e referencias shared-string e rejeita formulas antes de calamine. Macros sao rejeitadas, nao executadas. Exporta numeros finitos/logicos/texto/datetime/null, nao complexos. Escritores substituem atomicamente, nao append, validam antes da escrita e rejeitam atribuicao de saida antes de escrever. RuntimeHost usa caminhos do CSV existente, relativos ao processo/projeto Studio; nao e sandbox de arquivos. Host padrao rejeita destinos symlink; permissoes de projetos de funcoes nao isolam I/O.

filewrite('texto.txt','dados');
disp(strcmp(fileread('texto.txt'),'dados'));
writebytes('dados.bin',[10;20]);
disp(all(readbytes('dados.bin')==[10,20]));
tabela=table([3;4],[true;false]);
writetable(tabela,'tabela.xlsx');
lida=readtable('tabela.xlsx',1);
coluna=lida.Var2;
disp(height(lida)==2 && isa(coluna,'logical') && all(coluna==[true;false]));
anulavel=table({true;null();false},'VariableNames',{'ativo'});
writetable(anulavel,'anulavel.xlsx');
restaurada=readtable('anulavel.xlsx');
disp(restaurada.ativo{1} && isnull(restaurada.ativo{2}) && !restaurada.ativo{3});

imread(filename) recognizes PNG/JPEG from contents and accepts only decoded 8-bit grayscale, RGB or RGBA. Grayscale returns a real height-by-width matrix; RGB(A) returns a scalar struct with exactly red, green, blue and optional alpha, each a real 2D matrix of integer samples 0..255. No N-D image arrays, indexed/colormap output, grayscale-alpha, 16-bit/HDR or extra outputs. Palette files are accepted only if the decoder exposes a supported color type.

imwrite(image,filename) accepts a real grayscale MATRIX or exact RGB(A) channel struct with identical nonempty shapes. PNG preserves integer samples; JPEG (.jpg/.jpeg) is lossy, fixed quality 90, rejects alpha rather than dropping it. Do not test JPEG pixel equality. Each axis 1..4096, combined channel samples <=16777216, input/encoded output <=64 MiB. Header dimensions/color/sample count are checked before pixel allocation; decoder allocation is bounded. Writers validate and encode before atomic host replacement. Codecs may not be interrupted internally; cancellation checks surround codec work.

gray=[0,64;128,255];
imwrite(gray,'gray.png');
restored=imread('gray.png');
disp(all(size(restored)==[2,2]) && all(restored==gray));
image=struct('red',gray,'green',zeros(2),'blue',ones(2)*255,'alpha',ones(2)*255);
imwrite(image,'rgba.png');
restored=imread('rgba.png');
disp(isstruct(restored) && all(restored.red==gray) && all(restored.alpha==255));
imwrite(gray,'gray.jpg');
restored=imread('gray.jpg');
disp(all(size(restored)==[2,2]) && allfinite(restored));

imread identifica PNG/JPEG pelo conteudo, apenas cinza/RGB/RGBA decodificados de 8 bits. Cinza retorna matriz real altura por largura; RGB(A) retorna struct escalar exatamente red, green, blue e alpha opcional, canais reais 2D inteiros em 0..255. Sem imagem N-D, saida indexada/colormap, cinza-alpha, 16 bits/HDR ou saidas extras. Paleta so se o decoder expuser tipo de cor suportado.

imwrite aceita MATRIZ real cinza ou struct RGB(A) exata de canais nao vazios e mesma forma. PNG preserva amostras; JPEG .jpg/.jpeg tem perdas, qualidade fixa 90 e rejeita alpha. Nao compare pixels JPEG exatamente. Eixos 1..4096, ate 16777216 amostras combinadas, entrada/saida codificada ate 64 MiB. Guarda de cabecalho/cor/amostras antes da alocacao, decoder limitado. Validacao e codificacao antes da substituicao atomica. Cancelamento ao redor do codec, sem interrupcao interna garantida.

canal=[0,255;128,64];
imagem=struct('red',canal,'green',canal,'blue',canal);
imwrite(imagem,'rgb.png');
lida=imread('rgb.png');
disp(isstruct(lida) && all(lida.red==canal) && all(lida.green==canal) && all(lida.blue==canal));

Development snapshot: parser/runtime/CLI integration and a rebuilt executable are required; sun check validates syntax/parallel restrictions, not builtin availability, file contents or runtime domains. ALL new data builtins and new cell/field/map syntax are blocked in parfor, even pure-looking string predicates. LLVM rejects them with guidance to use sun run; no automatic fallback or native ABI support. Normal data builtins/readers return one output; filewrite/writelines/writebytes/writetable/imwrite return ZERO. Output arity (including discarded positions) is checked before any write. Failed validation leaves destinations intact; this does not roll back already completed I/O from other calls or argument side effects.

Container nesting <=32, cumulative container entries <=100000 and each text <=8 MiB; these are not a global memory quota. Index 0, fractional/out-of-range indices, invalid types/shapes, duplicate names, invalid regex/JSON and resource overflow raise errors, not silent growth or coercion. Parser diagnostics identify source positions; CLI runtime errors may print only the error message. catch exposes identifier/message, not a stack trace. Standard cancellation is not catchable. Studio exposes read-only container previews; no unsupported container editing, deep-view browsing, image editor or automatic full-state restoration is promised. Separate numeric/logical/complex matrix editing remains available. External web bridges, OOP, struct arrays and N-D remain absent. Stage 5 adds bounded real sparse storage and solvers: /language/sparse-advanced-solvers; Studio sparse read-only metadata is upcoming. Earlier guides: /language/scientific-computing, /language/numerical-solvers, /language/spectral-statistics.

caught=false;
try
    C=cell(1,1);
    missing=C{2};
catch problem
    caught=strlength(problem.identifier)>0 && strlength(problem.message)>0;
end
disp(caught);

Snapshot de desenvolvimento: exige integracao parser/runtime/CLI e executavel recompilado; sun check valida sintaxe/restricoes paralelas, nao disponibilidade de builtin, arquivos ou dominios. TODOS os novos builtins e sintaxe cell/campo/mapa sao bloqueados em parfor, inclusive predicados de texto puros. LLVM rejeita e orienta sun run, sem fallback automatico/ABI nativa. Builtins/leitores retornam uma saida; filewrite/writelines/writebytes/writetable/imwrite retornam ZERO. Aridade, inclusive descartes, e validada antes da escrita. Falha de validacao preserva destinos; nao desfaz I/O ja concluido de outras chamadas ou efeitos dos argumentos.

Conteineres: profundidade 32, 100000 entradas cumulativas, texto 8 MiB; nao sao cota global de memoria. Indice zero/fracionario/fora dos limites, tipo/forma invalida, nomes duplicados, regex/JSON invalidos e excesso de recursos geram erros. Parser identifica posicoes na fonte; erros de runtime no CLI podem imprimir apenas mensagem. catch expoe identifier/message, nao stack trace. Cancelamento nao capturavel. Studio oferece previews de conteineres somente leitura, sem prometer edicao, navegacao profunda, editor de imagem ou restauracao completa de estado. Edicao de matrizes reais/logicas/complexas permanece disponivel. Pontes web externas, OOP, arrays de structs e N-D continuam ausentes. Etapa 5 adiciona esparsos reais limitados e solvers: /language/sparse-advanced-solvers; metadados esparsos somente leitura no Studio estao previstos. Guias anteriores: /language/scientific-computing, /language/numerical-solvers, /language/spectral-statistics.

capturado=false;
try
    valor=jsondecode('{');
catch problema
    capturado=strlength(problema.identifier)>0;
end
disp(capturado);