数值类型 #

% 有符号整数
a = int8(100);
b = int16(10000);
c = int32(100000);
d = int64(10000000000);

% 无符号整数
e = uint8(200);
f = uint16(50000);
g = uint32(3000000000);
h = uint64(10000000000000000000);

% 类型转换
x = 3.7;
int8(x)    % 结果: 3（截断）
int16(x)   % 结果: 3

% 查看整数范围
intmax('int8')    % 127
intmin('int8')    % -128

intmax('uint8')   % 255
intmin('uint8')   % 0

% 饱和运算（不会溢出）
x = int8(120);
y = int8(20);
z = x + y         % 结果: 127（饱和到最大值）

x = int8(-120);
y = int8(-20);
z = x + y         % 结果: -128（饱和到最小值）

% 整数运算
a = int16(100);
b = int16(50);

a + b     % 150
a - b     % 50
a * b     % 5000
a / b     % 2
mod(a, b) % 0

% 混合运算（结果为整数）
a = int16(100);
b = 3.5;
a * b     % 350（int16）

% 不同整数类型运算
a = int16(100);
b = int32(200);
% c = a + b;  % 错误：不能直接运算

% 需要先统一类型
c = int32(a) + b;

% 默认类型
x = 3.14;
class(x)    % 'double'

% 科学计数法
a = 1.5e-10;     % 1.5 × 10^-10
b = 2.5E8;       % 2.5 × 10^8

% 十六进制表示
c = 0x1.Fp+10;   % 十六进制浮点数

% 特殊值
inf_val = 1/0;        % Inf
neg_inf = -1/0;       % -Inf
nan_val = 0/0;        % NaN

% 创建单精度
x = single(3.14);
class(x)    % 'single'

% 内存占用更小
a = zeros(1000, 1000, 'double');    % 8 MB
b = zeros(1000, 1000, 'single');    % 4 MB

% 精度较低
format long
pi_double = pi               % 3.141592653589793
pi_single = single(pi)       % 3.1415927

% 单精度运算
a = single(1.5);
b = single(2.5);
c = a + b;                   % single类型

% 机器精度
eps      % 2.2204e-16（double）
eps('single')  % 1.1921e-07

% 精度问题
0.1 + 0.2 == 0.3    % false!

% 原因
format long
0.1 + 0.2           % 0.300000000000000
0.3                 % 0.299999999999999

% 正确的比较方法
abs(0.1 + 0.2 - 0.3) < eps    % true

% 使用容差比较
function result = approxEqual(a, b, tol)
    if nargin < 3
        tol = 1e-10;
    end
    result = abs(a - b) < tol;
end

% 双精度范围
realmax        % 1.7977e+308
realmin        % 2.2251e-308

% 单精度范围
realmax('single')   % 3.4028e+38
realmin('single')   % 1.1755e-38

% 超出范围
realmax * 2    % Inf
-realmax * 2   % -Inf

% 直接创建
z1 = 3 + 4i;
z2 = 3 + 4j;        % i和j等价
z3 = 3 + 4*1i;      % 更安全的方式

% 使用complex函数
z4 = complex(3, 4); % 实部3，虚部4

% 从极坐标创建
r = 5;
theta = pi/4;
z5 = r * exp(1i * theta);

z = 3 + 4i;

% 实部和虚部
real(z)      % 3
imag(z)      % 4

% 模和辐角
abs(z)       % 5
angle(z)     % 0.9273（弧度）

% 共轭复数
conj(z)      % 3 - 4i

% 复数信息
isreal(z)    % false
iscomplex(z) % true

z1 = 3 + 4i;
z2 = 1 + 2i;

% 四则运算
z1 + z2      % 4 + 6i
z1 - z2      % 2 + 2i
z1 * z2      % -5 + 10i
z1 / z2      % 2.2 - 0.4i

% 幂运算
z1^2         % -7 + 24i
sqrt(z1)     % 2 + 1i

% 指数和对数
exp(z1)      % e^(3+4i)
log(z1)      % ln(3+4i)

% 三角函数
sin(z1)
cos(z1)

% 创建复数数组
A = [1+2i, 3+4i; 5+6i, 7+8i];

% 提取实部和虚部
real(A)
imag(A)

% 共轭转置
A'           % 共轭转置
A.'          % 非共轭转置

% 产生无穷大
1/0          % Inf
1e308 * 2    % Inf
exp(1000)    % Inf

% 无穷大运算
Inf + Inf    % Inf
Inf - Inf    % NaN
Inf * 0      % NaN
Inf / Inf    % NaN

% 检查无穷大
isinf(1/0)   % true
isinf([1, Inf, -Inf])  % [false, true, true]

% 产生NaN
0/0          % NaN
Inf - Inf    % NaN
0 * Inf      % NaN

% NaN特性
NaN == NaN   % false
NaN ~= NaN   % true

% 检查NaN
isnan(0/0)   % true
isnan([1, NaN, 3])  % [false, true, false]

% NaN在运算中传播
sum([1, NaN, 3])    % NaN
mean([1, NaN, 3])   % NaN

% 忽略NaN的函数
nansum([1, NaN, 3])    % 4
nanmean([1, NaN, 3])   % 2
nanmax([1, NaN, 3])    % 3

% 整数转换
x = 3.7;
int8(x)      % 3（截断）
int16(x)     % 3
int32(x)     % 3
int64(x)     % 3

% 四舍五入后转换
int32(round(x))    % 4

% 浮点数转换
y = 100;
single(y)    % 单精度
double(y)    % 双精度

% 复数转换
z = 3 + 4i;
double(z)    % 保持复数类型

x = 3.7;
y = -3.7;

% 向零取整
fix(x)       % 3
fix(y)       % -3

% 向下取整
floor(x)     % 3
floor(y)     % -4

% 向上取整
ceil(x)      % 4
ceil(y)      % -3

% 四舍五入
round(x)     % 4
round(y)     % -4

% 指定小数位数
round(pi, 2)       % 3.14
round(pi, 4)       % 3.1416

x = 42;
y = 3.14;
z = 3 + 4i;

% 判断函数
isinteger(x)       % false（double类型）
isinteger(int32(x)) % true
isfloat(y)         % true
isreal(z)          % false
isnumeric(x)       % true

% 获取类型
class(x)           % 'double'
class(int32(x))    % 'int32'

% 默认格式
format          % 短格式

% 常用格式
format short    % 4位小数：3.1416
format long     % 15位小数：3.141592653589793
format shortE   % 科学计数法：3.1416e+00
format longE    % 科学计数法（长）：3.141592653589793e+00
format bank     % 2位小数：3.14
format hex      % 十六进制：400921fb54442d18
format rat      % 有理数：355/113

% 示例
pi
% short:  3.1416
% long:   3.141592653589793
% shortE: 3.1416e+00
% rat:    355/113

% 紧凑显示
format compact

% 宽松显示
format loose

% 显示分隔线
format loose
x = [1 2 3]

% 输出：
x =
     1     2     3

format compact
x = [1 2 3]

% 输出：
x = 1 2 3

% 算术运算
a = 10;
b = 3;

a + b      % 加法：13
a - b      % 减法：7
a * b      % 乘法：30
a / b      % 除法：3.3333
a \ b      % 左除：0.3
a ^ b      % 幂：1000
mod(a, b)  % 取余：1
rem(a, b)  % 取余：1

% mod vs rem
mod(-7, 3)   % 2（结果与除数同号）
rem(-7, 3)   % -1（结果与被除数同号）

% 三角函数（弧度）
sin(pi/2)      % 1
cos(0)         % 1
tan(pi/4)      % 1
asin(1)        % 1.5708
acos(0)        % 1.5708
atan(1)        % 0.7854

% 角度转换
deg2rad(180)   % 3.1416
rad2deg(pi)    % 180

% 指数和对数
exp(1)         % 2.7183
log(10)        % 2.3026（自然对数）
log10(100)     % 2（常用对数）
log2(8)        % 3
sqrt(16)       % 4
power(2, 10)   % 1024

% 绝对值和符号
abs(-5)        % 5
sign(-5)       % -1
sign(0)        % 0
sign(5)        % 1

% 默认使用double
x = 3.14;

% 大数组且精度要求不高时使用single
largeArray = zeros(10000, 10000, 'single');

% 整数数据使用整数类型
imageData = imread('image.jpg');  % uint8
indices = int32(1:1000000);       % 节省内存

% 避免不必要的类型转换
% 不推荐
for i = 1:1000000
    x(i) = double(i);
end

% 推荐
x = double(1:1000000);

% 使用容差比较浮点数
function result = isEqual(a, b, tol)
    if nargin < 3
        tol = 1e-10;
    end
    result = abs(a - b) < tol;
end

% 使用相对误差
function result = isApproxEqual(a, b, relTol)
    if nargin < 3
        relTol = 1e-8;
    end
    result = abs(a - b) < relTol * max(abs(a), abs(b));
end

% 检查并处理NaN
data = [1, NaN, 3, NaN, 5];

% 移除NaN
cleanData = data(~isnan(data));

% 替换NaN
data(isnan(data)) = 0;

% 使用忽略NaN的函数
mean(data, 'omitnan');
std(data, 'omitnan');