Reference

Identifier catalog

A searchable map of keywords, literals, built-ins, constants, operators, and symbols.

Catalog structure

The sections below separate syntactic roles that are easy to conflate. The built-in catalog is generated from the same typed data used by search and the function reference.

Reserved keywords 16

functionreturnifelseifelseforparforwhilebreakcontinueswitchcaseotherwisetrycatchend

Special literals 2

truefalse

Built-in functions 222

222 functions

Name	Signature	Availability
`fmincon`	`[x,fval] = fmincon(fun,x0,A,b[,Aeq,beq[,lb,ub[,nonlcon[,options]]]])`	Interpreter
`sparse`	`sparse(A) \| sparse(m,n) \| sparse(i,j,v,m,n)`	Interpreter
`full`	`full(A)`	Interpreter
`issparse`	`issparse(value)`	Interpreter
`nnz`	`nnz(A)`	Interpreter
`pcg`	`[x,flag,relres,iter] = pcg(A,b[,tol[,maxiter]])`	Interpreter
`gmres`	`[x,flag,relres,iter] = gmres(A,b[,restart[,tol[,maxiter]]])`	Interpreter
`eigs`	`values = eigs(A[,k[,which]]) \| [V,D] = eigs(A[,k[,which]])`	Interpreter
`fsolve`	`[x,residual] = fsolve(fun,x0[,tol[,maxiter]])`	Interpreter
`lsqnonneg`	`[x,resnorm] = lsqnonneg(C,d[,tol])`	Interpreter
`ode15s`	`[T,Y] = ode15s(fun,tspan,y0[,reltol[,abstol]])`	Interpreter
`linprog`	`[x,fval] = linprog(f,A,b[,Aeq,beq[,lb,ub]])`	Interpreter
`jsonencode`	`jsonencode(value)`	Interpreter
`jsondecode`	`jsondecode(value)`	Interpreter
`fileread`	`fileread(filename)`	InterpreterHost
`filewrite`	`filewrite(filename, text)`	InterpreterHost
`readlines`	`readlines(filename)`	InterpreterHost
`writelines`	`writelines(textOrCellstr, filename)`	InterpreterHost
`readbytes`	`readbytes(filename)`	InterpreterHost
`writebytes`	`writebytes(filename, bytes)`	InterpreterHost
`readtable`	`readtable(filename[, sheet])`	InterpreterHost
`writetable`	`writetable(table, filename[, sheet])`	InterpreterHost
`imread`	`imread(filename)`	InterpreterHost
`imwrite`	`imwrite(image, filename)`	InterpreterHost
`struct`	`struct() \| struct(name, value, ...)`	Interpreter
`cell`	`cell(n) \| cell(m, n) \| cell([m,n])`	Interpreter
`isstruct`	`isstruct(value)`	Interpreter
`iscell`	`iscell(value)`	Interpreter
`istable`	`istable(value)`	Interpreter
`isnull`	`isnull(value)`	Interpreter
`null`	`null()`	Interpreter
`fieldnames`	`fieldnames(s)`	Interpreter
`isfield`	`isfield(s, name)`	Interpreter
`getfield`	`getfield(value, name)`	Interpreter
`setfield`	`setfield(value, name, replacement)`	Interpreter
`rmfield`	`rmfield(s, nameOrCellstr)`	Interpreter
`containers.Map`	`containers.Map() \| containers.Map(cellkeys, cellvalues)`	Interpreter
`keys`	`keys(map)`	Interpreter
`values`	`values(map)`	Interpreter
`isKey`	`isKey(map, keyOrCellstr)`	Interpreter
`remove`	`remove(map, keyOrCellstr)`	Interpreter
`table`	`table(columns...[, 'VariableNames', cellnames])`	Interpreter
`height`	`height(table)`	Interpreter
`width`	`width(table)`	Interpreter
`table2cell`	`table2cell(table)`	Interpreter
`string`	`string(value)`	Interpreter
`char`	`char(value)`	Interpreter
`strlength`	`strlength(text)`	Interpreter
`strcat`	`strcat(text...)`	Interpreter
`strcmp`	`strcmp(a, b)`	Interpreter
`strcmpi`	`strcmpi(a, b)`	Interpreter
`contains`	`contains(text, part)`	Interpreter
`startsWith`	`startsWith(text, prefix)`	Interpreter
`endsWith`	`endsWith(text, suffix)`	Interpreter
`strtrim`	`strtrim(text)`	Interpreter
`lower`	`lower(text)`	Interpreter
`upper`	`upper(text)`	Interpreter
`strrep`	`strrep(text, old, replacement)`	Interpreter
`split`	`split(text[, delimiter])`	Interpreter
`strjoin`	`strjoin(cellstr[, delimiter])`	Interpreter
`isstring`	`isstring(value)`	Interpreter
`regexp`	`regexp(text, pattern[, 'start'\|'end'\|'match'])`	Interpreter
`regexprep`	`regexprep(text, pattern, replacement)`	Interpreter
`datetime`	`datetime() \| datetime(text) \| datetime(y,m,d) \| datetime(y,m,d,h,m,s)`	Interpreter
`year`	`year(datetime)`	Interpreter
`month`	`month(datetime)`	Interpreter
`day`	`day(datetime)`	Interpreter
`hour`	`hour(datetime)`	Interpreter
`minute`	`minute(datetime)`	Interpreter
`second`	`second(datetime)`	Interpreter
`posixtime`	`posixtime(datetime)`	Interpreter
`isdatetime`	`isdatetime(value)`	Interpreter
`fft`	`fft(X[, n[, dim]])`	Interpreter
`ifft`	`ifft(X[, n[, dim]])`	Interpreter
`fft2`	`fft2(X) \| fft2(X, m, n)`	Interpreter
`ifft2`	`ifft2(X) \| ifft2(X, m, n)`	Interpreter
`conv2`	`conv2(A, B[, 'full'\|'same'\|'valid'])`	Interpreter
`filter`	`[y, zf] = filter(b, a, x[, zi[, dim]])`	Interpreter
`eig`	`values = eig(A) \| [V, D] = eig(A)`	Interpreter
`roots`	`roots(coefficients)`	Interpreter
`normpdf`	`normpdf(X[, mu[, sigma]])`	Interpreter
`normcdf`	`normcdf(X[, mu[, sigma]])`	Interpreter
`norminv`	`norminv(p[, mu[, sigma]])`	Interpreter
`tpdf`	`tpdf(X, nu)`	Interpreter
`tcdf`	`tcdf(X, nu)`	Interpreter
`tinv`	`tinv(p, nu)`	Interpreter
`chi2pdf`	`chi2pdf(X, nu)`	Interpreter
`chi2cdf`	`chi2cdf(X, nu)`	Interpreter
`chi2inv`	`chi2inv(p, nu)`	Interpreter
`fpdf`	`fpdf(X, d1, d2)`	Interpreter
`fcdf`	`fcdf(X, d1, d2)`	Interpreter
`finv`	`finv(p, d1, d2)`	Interpreter
`ttest`	`[h, p] = ttest(x[, mu[, alpha]])`	Interpreter
`ttest2`	`[h, p] = ttest2(x, y[, alpha])`	Interpreter
`sqrt`	`sqrt(x)`	InterpreterLLVM
`sin`	`sin(x)`	InterpreterLLVM
`cos`	`cos(x)`	InterpreterLLVM
`tan`	`tan(x)`	Interpreter
`abs`	`abs(x)`	Interpreter
`accumarray`	`accumarray(subs, values)`	Interpreter
`acos`	`acos(x)`	Interpreter
`acosd`	`acosd(x)`	Interpreter
`acosh`	`acosh(x)`	Interpreter
`acot`	`acot(x)`	Interpreter
`acotd`	`acotd(x)`	Interpreter
`acoth`	`acoth(x)`	Interpreter
`acsc`	`acsc(x)`	Interpreter
`acscd`	`acscd(x)`	Interpreter
`acsch`	`acsch(x)`	Interpreter
`all`	`all(x)`	Interpreter
`allbetween`	`allbetween(x, lower, upper)`	Interpreter
`allfinite`	`allfinite(x)`	Interpreter
`class`	`class(value)`	Interpreter
`isa`	`isa(value, className)`	Interpreter
`double`	`double(value)`	Interpreter
`exp`	`exp(x)`	InterpreterLLVM
`log`	`log(x)`	InterpreterLLVM
`floor`	`floor(x)`	Interpreter
`ceil`	`ceil(x)`	Interpreter
`round`	`round(x)`	Interpreter
`fix`	`fix(x)`	Interpreter
`mod`	`mod(a, b)`	Interpreter
`rem`	`rem(a, b)`	Interpreter
`linspace`	`linspace(start, stop) \| linspace(start, stop, count)`	Interpreter
`sum`	`sum(A) \| sum(A, dim) \| sum(A, "all")`	Interpreter
`mean`	`mean(A) \| mean(A, dim) \| mean(A, "all")`	Interpreter
`median`	`median(A) \| median(A, dim) \| median(A, "all")`	Interpreter
`prod`	`prod(A) \| prod(A, dim) \| prod(A, "all")`	Interpreter
`var`	`var(A) \| var(A, normalization) \| var(A, normalization, dimOrAll)`	Interpreter
`std`	`std(A) \| std(A, normalization) \| std(A, normalization, dimOrAll)`	Interpreter
`cumsum`	`cumsum(x) \| cumsum(A, dim)`	Interpreter
`diff`	`diff(x) \| diff(x, order)`	Interpreter
`sort`	`sort(x) \| sort(A, dim)`	Interpreter
`unique`	`unique(x)`	Interpreter
`polyval`	`polyval(coefficients, x)`	Interpreter
`conv`	`conv(a, b)`	Interpreter
`cov`	`cov(A[, 0\|1]) \| cov(x, y[, 0\|1])`	Interpreter
`corrcoef`	`corrcoef(A) \| corrcoef(x, y)`	Interpreter
`gradient`	`[dx, dy] = gradient(F[, h]) \| gradient(F, hx, hy)`	Interpreter
`polyfit`	`p = polyfit(x, y, n)`	Interpreter
`histcounts`	`[N, E, B] = histcounts(X[, nbins\|edges])`	Interpreter
`trapz`	`trapz(Y[, dim]) \| trapz(X, Y[, dim])`	Interpreter
`interp1`	`interp1(Y, Xq[, method[, fill\|'extrap']]) \| interp1(X, Y, Xq[, method[, fill\|'extrap']])`	Interpreter
`fzero`	`[root, residual] = fzero(fun, x0[, tol[, maxiter]])`	Interpreter
`fminbnd`	`[xmin, fval] = fminbnd(fun, a, b[, tol[, maxiter]])`	Interpreter
`fminsearch`	`[xmin, fval] = fminsearch(fun, x0[, tol[, maxiter]])`	Interpreter
`integral`	`[q, error] = integral(fun, a, b[, abstol[, reltol]])`	Interpreter
`ode45`	`[T, Y] = ode45(fun, tspan, y0[, reltol[, abstol]])`	Interpreter
`ode23`	`[T, Y] = ode23(fun, tspan, y0[, reltol[, abstol]])`	Interpreter
`rng`	`rng(seed)`	Interpreter
`rand`	`rand() \| rand(n) \| rand(rows, cols)`	Interpreter
`randn`	`randn() \| randn(n) \| randn(rows, cols)`	Interpreter
`randi`	`randi(maximum) \| randi(maximum, rows, cols)`	Interpreter
`randperm`	`randperm(n) \| randperm(n, count)`	Interpreter
`min`	`min(A) \| [values, indices] = min(A, [], dimOrAll) \| min(A, B)`	Interpreter
`max`	`max(A) \| [values, indices] = max(A, [], dimOrAll) \| max(A, B)`	Interpreter
`zeros`	`zeros() \| zeros(n) \| zeros(r, c) \| zeros([r, c])`	Interpreter
`ones`	`ones() \| ones(n) \| ones(r, c) \| ones([r, c])`	Interpreter
`eye`	`eye() \| eye(n) \| eye(r, c) \| eye([r, c])`	Interpreter
`transpose`	`transpose(A)`	Interpreter
`mldivide`	`mldivide(A, B)`	Interpreter
`det`	`det(A)`	Interpreter
`inv`	`inv(A)`	Interpreter
`solve`	`solve(A, B)`	Interpreter
`lu`	`packed = lu(A) \| [L,U] = lu(A) \| [L,U,P] = lu(A)`	Interpreter
`chol`	`factor = chol(A[, 'upper' \| 'lower']) \| [factor,p] = chol(A[, 'upper' \| 'lower'])`	Interpreter
`qr`	`R = qr(A[, 0]) \| [Q, R] = qr(A[, 0]) \| [Q, R, P] = qr(A) \| [Q, R, p] = qr(A, 0)`	Interpreter
`lsqminnorm`	`lsqminnorm(A, B[, tol])`	Interpreter
`rank`	`rank(A[, tol])`	Interpreter
`cond`	`cond(A) \| cond(A, 2)`	Interpreter
`svd`	`s = svd(A[, 0 \| 'econ']) \| [U, S] = svd(A[, 0 \| 'econ']) \| [U, S, V] = svd(A[, 0 \| 'econ'])`	Interpreter
`pinv`	`pinv(A[, tol])`	Interpreter
`size`	`size(A) \| size(A, dim) \| [rows, cols] = size(A)`	Interpreter
`reshape`	`reshape(A, rows, cols) \| reshape(A, [rows, cols])`	Interpreter
`length`	`length(A)`	Interpreter
`any`	`any(A) \| any(A, dim) \| any(A, "all")`	Interpreter
`find`	`find(A[, count[, "first" \| "last"]]) \| [row, col, value] = find(A)`	Interpreter
`sec`	`sec(x)`	Interpreter
`numel`	`numel(x)`	Interpreter
`isempty`	`isempty(x)`	Interpreter
`complex`	`complex(realPart, imaginaryPart)`	Interpreter
`real`	`real(x)`	Interpreter
`imag`	`imag(x)`	Interpreter
`conj`	`conj(x)`	Interpreter
`keywords`	`keywords()`	Interpreter
`constants`	`constants()`	Interpreter
`builtins`	`builtins()`	Interpreter
`nargout`	`nargout()`	Interpreter
`isargout`	`isargout(k)`	Interpreter
`disp`	`disp(value)`	InterpreterLLVM
`pause`	`pause() \| pause(seconds) \| pause(state)`	InterpreterHost
`error`	`error(message) \| error(identifier, message)`	Interpreter
`rethrow`	`rethrow(exception)`	Interpreter
`readmatrix`	`readmatrix(filename)`	InterpreterHost
`writematrix`	`writematrix(value, filename)`	InterpreterHost
`plot`	`plot(x, y)`	InterpreterHost
`plot3`	`plot3(x, y, z)`	InterpreterHost
`surf`	`surf(Z) \| surf(x, y, Z) \| surf(X, Y, Z)`	InterpreterHost
`area`	`area(x, y)`	InterpreterHost
`bar`	`bar(x, y)`	InterpreterHost
`barh`	`barh(x, y)`	InterpreterHost
`semilogx`	`semilogx(x, y)`	InterpreterHost
`semilogy`	`semilogy(x, y)`	InterpreterHost
`loglog`	`loglog(x, y)`	InterpreterHost
`stem`	`stem(x, y)`	InterpreterHost
`polarplot`	`polarplot(theta, rho)`	InterpreterHost
`histogram`	`histogram(values)`	InterpreterHost
`contour`	`contour(Z)`	InterpreterHost
`view`	`view(2) \| view(3) \| view(azimuth, elevation)`	InterpreterHost
`colormap`	`colormap("sun" \| "parula" \| "turbo" \| "gray" \| "hot" \| "cool")`	InterpreterHost
`shading`	`shading("smooth" \| "flat" \| "faceted")`	InterpreterHost
`title`	`title(text) \| title(layout, text)`	InterpreterHost
`tiledlayout`	`layout = tiledlayout(rows, cols)`	InterpreterHost
`nexttile`	`nexttile \| nexttile() \| nexttile(index)`	InterpreterHost
`sgtitle`	`sgtitle(text)`	InterpreterHost
`xlabel`	`xlabel(text)`	InterpreterHost
`ylabel`	`ylabel(text)`	InterpreterHost
`zlabel`	`zlabel(text)`	InterpreterHost
`legend`	`legend(labels...) \| legend("on" \| "off")`	InterpreterHost
`grid`	`grid() \| grid(flag)`	InterpreterHost
`axis`	`axis("auto") \| axis(limits)`	InterpreterHost
`clf`	`clf()`	InterpreterHost

Numeric constants 11

Name	Meaning
`pi`	Circle constant
`Inf`	Positive infinity
`NaN`	Not a number
`eps`	Double-precision spacing at 1
`realmin`	Smallest positive normal double
`realmax`	Largest finite double
`flintmax`	Largest consecutively representable integer
`intmin`	Signed integer lower bound represented as a double
`intmax`	Signed integer upper bound represented as a double
`i`	Imaginary unit
`j`	Imaginary unit

Operators and symbols

Arithmetic	`+ - * / ^`
Element-wise	`.* ./ .^`
Transpose	`.' '`
Comparison	`== ~= < <= > >=`
Logical	`! && \|\|`
Assignment and range	`= :`
Output discard	`~`
Syntax	`. ( ) [ ] { } , ; % %%`

Recommended architecture

The upstream project currently keeps dispatch knowledge in several runtime modules. A future central source catalog could expose name, category, signature, description, effect classification, and backend support, then validate generated docs against it.

Source note

This is a documentation architecture recommendation, not a claim that the upstream catalog already exists.