逻辑类型 #

% 创建逻辑值
a = true;    % 1
b = false;   % 0

% 查看类型
class(a)     % 'logical'

% 使用true/false
a = true;    % 逻辑1
b = false;   % 逻辑0

% 使用logical函数
c = logical(1);   % true
d = logical(0);   % false
e = logical(5);   % true（非零为真）

% 比较运算
x = 5;
y = 3;

result1 = x > y;    % true
result2 = x == y;   % false
result3 = x ~= y;   % true

% 数组比较
A = [1 2 3 4 5];
result = A > 3;     % [0 0 0 1 1]

% 创建逻辑数组
log_arr = [true, false, true];
log_arr = logical([1 0 1 0 1]);

% 使用函数创建
log_arr = true(3);      % 3x3全true矩阵
log_arr = false(2, 3);  % 2x3全false矩阵

% 条件筛选产生
data = [1 2 3 4 5];
mask = data > 3;        % [0 0 0 1 1]

% 与运算
true & true    % true
true & false   % false
false & false  % false

% 或运算
true | true    % true
true | false   % true
false | false  % false

% 非运算
~true          % false
~false         % true

% 异或运算
xor(true, true)    % false
xor(true, false)   % true
xor(false, false)  % false

% 数组运算
A = [true false true];
B = [true true false];

A & B          % [true false false]
A | B          % [true true true]
~A             % [false true false]

% 短路与
x = 5;
if x > 0 && x < 10
    disp('x在0到10之间');
end

% 短路或
x = -5;
if x < 0 || x > 100
    disp('x不在0到100之间');
end

% 避免错误
x = 0;
if x ~= 0 && 1/x > 0.5    % 使用&&避免除零错误
    disp('条件满足');
end

% 注意：&& 和 || 只能用于标量
% A = [true false];
% A && B    % 错误！

% 优先级从高到低：
% 1. ~ (非)
% 2. & (与)
% 3. | (或)

% 示例
~true & false     % false（先~后&）
~(true & false)   % true

true | false & false  % true（先&后|）
(true | false) & false  % false

% all：所有元素为真
A = [true true true];
all(A)    % true

A = [true false true];
all(A)    % false

% 按维度
A = [true false; true true];
all(A, 1)   % [true false]（按列）
all(A, 2)   % [false; true]（按行）

% any：任一元素为真
A = [false false true];
any(A)    % true

A = [false false false];
any(A)    % false

% find：查找非零元素索引
A = [1 0 3 0 5];
idx = find(A);       % [1, 3, 5]
idx = find(A > 2);   % [3, 5]

% 查找满足条件的元素
data = [10 20 30 40 50];
idx = find(data > 25);    % [3, 4, 5]
values = data(idx);       % [30 40 50]

% 返回行列索引
A = [1 0 3; 0 5 0];
[row, col] = find(A);
% row = [1; 2; 1]
% col = [1; 2; 3]

% islogical：判断是否为逻辑类型
islogical(true)      % true
islogical(1)         % false
islogical(logical(1)) % true

% 其他判断函数返回逻辑值
isnumeric(5)         % true
ischar('hello')      % true
isstring("hello")    % true
isempty([])          % true
isnan(NaN)           % true
isinf(Inf)           % true
isfinite(5)          % true

% 使用逻辑数组索引
data = [10 20 30 40 50];
mask = [true false true false true];
selected = data(mask);    % [10 30 50]

% 使用条件表达式
selected = data(data > 25);  % [30 40 50]

% 修改满足条件的元素
data(data > 25) = 0;
% data = [10 20 0 0 0]

data = [10 20 30 40 50 60];

% 与条件
selected = data(data > 20 & data < 50);  % [30 40]

% 或条件
selected = data(data < 20 | data > 50);  % [10 60]

% 排除条件
selected = data(~(data > 30));  % [10 20 30]

% 二维矩阵
A = [1 2 3; 4 5 6; 7 8 9];

% 提取大于5的元素
values = A(A > 5);  % [6 7 8 9]

% 将偶数置零
A(mod(A, 2) == 0) = 0;
% A = [1 0 3; 0 5 0; 7 0 9]

% 提取对角线元素
n = size(A, 1);
diag_mask = logical(eye(n));
diag_vals = A(diag_mask);

% 自动转换
log_val = true;
num = log_val + 0;    % 1
num = double(log_val); % 1

% 在计算中自动转换
true + true    % 2
true * 5       % 5

% 统计真值个数
mask = [true false true true];
count = sum(mask);    % 3

% logical函数
logical(1)     % true
logical(0)     % false
logical(5)     % true（非零为真）
logical(-1)    % true

% 数组转换
nums = [1 0 3 0 5];
log_arr = logical(nums);  % [true false true false true]

% 注意：NaN转逻辑会报错
% logical(NaN)  % 错误

% 筛选有效数据
data = [1.2, NaN, 3.4, NaN, 5.6];
valid_data = data(~isnan(data));  % [1.2 3.4 5.6]

% 筛选满足多个条件的数据
scores = [85 92 78 95 60 88];
mask = scores >= 80 & scores <= 90;
good_scores = scores(mask);  % [85 88]

% 统计满足条件的元素个数
data = [1 2 3 4 5 6 7 8 9 10];

% 大于5的个数
count = sum(data > 5);  % 5

% 偶数个数
count = sum(mod(data, 2) == 0);  % 5

% 在范围内的个数
count = sum(data >= 3 & data <= 7);  % 5

% 替换异常值
data = [1 2 100 4 5 200 7];
data(data > 50) = NaN;  % [1 2 NaN 4 5 NaN 7]

% 替换特定值
data = [1 0 3 0 5];
data(data == 0) = -1;   % [1 -1 3 -1 5]

% 条件替换
data = [1 2 3 4 5];
data(data < 3) = 0;     % [0 0 3 4 5]

% 找到最大值位置
data = [3 7 2 9 5];
[max_val, max_idx] = max(data);
% max_val = 9, max_idx = 4

% 找到所有局部最大值
data = [1 3 2 4 1 5 2];
peaks = (data(2:end-1) > data(1:end-2)) & ...
        (data(2:end-1) > data(3:end));
peak_indices = find(peaks) + 1;  % [2, 4, 6]

% 错误：使用位运算符
% if a & b    % 对于标量可以，但效率低

% 正确：使用短路运算符
if a && b    % 推荐用于标量条件

% 错误：对数组使用短路运算符
A = [true false];
% if A && B   % 错误！

% 正确：使用元素运算符
if all(A)    % 检查所有元素

% 注意：logical(1) 不等于 1
a = true;
b = 1;

a == b        % true（值相等）
islogical(a)  % true
islogical(b)  % false

% 在某些函数中行为不同
find([1 0 1])        % [1, 3]
find(logical([1 0 1])) % [1, 3]（相同）

% 空逻辑数组
empty = logical([]);

% all和any对空数组的处理
all([])   % true（空数组所有元素满足条件）
any([])   % false（空数组没有元素满足条件）

% 不推荐：使用循环
data = rand(1000, 1);
result = [];
for i = 1:length(data)
    if data(i) > 0.5
        result = [result; data(i)];
    end
end

% 推荐：使用逻辑索引
result = data(data > 0.5);

% 推荐：使用短路运算符避免不必要的计算
if ~isempty(x) && x(1) > 0
    % 安全访问x(1)
end

% 不推荐
if ~isempty(x) & x(1) > 0  % 可能出错
end

% 推荐：使用有意义的变量名
is_valid = x > 0 & x < 100;
is_complete = status == 'done';

if is_valid & is_complete
    process_data();
end

% 不推荐：复杂的内联条件
if x > 0 & x < 100 & status == 'done'
    process_data();
end