Matlab：帮助实现用于实现映射函数的编码 一个例子：考虑单峰：x[n+1]＝4×x[n] 1-x[n]。该映射可用于使用该技术生成+1/-1符号

我想使用map fx将上述概念扩展到3个级别，每个级别对应一个符号，但我不确定如何做到这一点。

要将获得的连续范围（例如作为伪随机数生成器的输出）或逻辑映射到一组小的离散值，您需要将连续范围拆分为多个区域，并为每个区域指定一个输出值。这些区域的限制将决定要使用的相应阈值

例如，在二进制情况下，从[0,1]中的连续值范围开始，将其分为两个区域：[0,0.5]和0.5,1]。每个区域开始分配一个输出符号，即-1和+1。正如您所注意到的，设置为[0,1]输入范围中点的区域边界的阈值为0.5。这可以通过以下方式实施：

if (x > 0.5)
  symbol = +1;
else
  symbol = -1;
end

function x = inverse_mapping(x,SymbIndex,p)
  if (SymbIndex==0)
    x = ((1-p)*x-14)/2;
  elseif (SymbIndex==1)
    x = ((1-p)*x-10)/2;
  elseif (SymbIndex==2)
    x = ((1-p)*x-6)/2;
  elseif (SymbIndex==3)
    x = ((1-p)*x-2)/2;
  elseif (SymbIndex==4)
    x = ((1-p)*x+2)/2;
  elseif (SymbIndex==5)
    x = ((1-p)*x+6)/2;
  elseif (SymbIndex==6)
    x = ((1-p)*x+10)/2;
  elseif (SymbIndex==7)
    x = ((1-p)*x+14)/2;
  end
end

作为一个更紧凑的实现，公式2*x>0.5-1利用了以下事实：在Matlab中，x>0.5表达式的真实条件的值为1，而false的值为0

对于3个离散输出值，您可以将[0,1]输入范围类似地划分为3个区域：[0,1/3]、1/3,2/3]和2/3,1]。因此，相应的阈值为1/3和2/3

最后，对于8个离散输出值，您可以将[0,1]输入范围类似地划分为8个区域：[0,1/8]、1/8,2/8]、2/8,3/8]、3/8,4/8]、4/8,5/8]、5/8,6/8]、6/8,7/8]和7/8,1]。因此，相应的阈值为1/8、2/8、3/8、4/8、5/8、6/8和7/8，如下图所示：

thresholding function input: |-----|-----|-----|-----|-----|-----|-----|-----|
                             0     |     |     |     |     |     |     |     1
thresholds:                       1/8   2/8   3/8   4/8   5/8   6/8   7/8
                                |     |     |     |     |     |     |     |
                                v     v     v     v     v     v     v     v
generated symbol:              -7    -5    -3    -1    +1    +3    +5    +7

然后给出以下符号映射实现：

if (x < 1/8)
  symbol = -7;
elseif (x < 2/8)
  symbol = -5;
elseif (x < 3/8)
  symbol = -3;
elseif (x < 4/8)
  symbol = -1;
elseif (x < 5/8)
  symbol = +1;
elseif (x < 6/8)
  symbol = +3;
elseif (x < 7/8)
  symbol = +5;
else
  symbol = +7;
end

现在，如果你想生成实数部分有8个级别，虚数部分有8个级别的复杂符号，你可以简单地将它们组合起来，就像在二进制情况下一样。主要是生成第一个值，给出实部，然后生成第二个值，给出虚部：

x_real = rand(); % random input 0 <= x_real <= 1
x_imag = rand(); % another one
s = threshold(x_real) + sqrt(-1)*threshold(x_imag);

为了获得最终的64-QAM符号，你将在正交中组合两个8 PAM符号，即X64 QAM= XQ+SqRT-1*席席，其中XQ和XI都是用上述过程生成的。 也就是说，如果目标是使用64-QAM符号和额外的混沌调制来实现数字通信系统，那么最终需要考虑要传输的输入数据源，而不是一次性随机生成混沌调制和源数据。也就是说，即使对于性能评估，您最终随机生成源数据，也最好独立于混沌调制生成源数据

为了解决这些问题，本文根据您提供的反向映射提出了一种不同的方法，该方法可以实现为：

if (x > 0.5)
  symbol = +1;
else
  symbol = -1;
end

function x = inverse_mapping(x,SymbIndex,p)
  if (SymbIndex==0)
    x = ((1-p)*x-14)/2;
  elseif (SymbIndex==1)
    x = ((1-p)*x-10)/2;
  elseif (SymbIndex==2)
    x = ((1-p)*x-6)/2;
  elseif (SymbIndex==3)
    x = ((1-p)*x-2)/2;
  elseif (SymbIndex==4)
    x = ((1-p)*x+2)/2;
  elseif (SymbIndex==5)
    x = ((1-p)*x+6)/2;
  elseif (SymbIndex==6)
    x = ((1-p)*x+10)/2;
  elseif (SymbIndex==7)
    x = ((1-p)*x+14)/2;
  end
end

正如您可能注意到的，该函数采用符号索引3位，这是您从输入源数据和调制输出的当前状态中获得的，您可以使用逆映射收敛范围内的任何值作为两个独立的输入流进行播种。请注意，您可以通过使用输入符号索引s=0和s=7（例如，使用x=0的种子）查找映射重复应用的限制来计算逆_映射的收敛范围的边界。这应该收敛到[-14/1+p，14/1+p]

然后，可以通过设置控制参数p=0.8来实现中所述的混沌调制，例如：

% Simulation parameters
Nsymb = 10000;
p     = 0.8;
M     = 64;

% Source data generation
SymbolIndexQ = randi([0 sqrt(M)-1],Nsymb,1);
SymbolIndexI = randi([0 sqrt(M)-1],Nsymb,1);

% Modulation
xmax = 14/(1+p); % found by iterative application of inverse_mapping 
xQ = xmax*(2*rand(1)-1); % seed initial state
xI = xmax*(2*rand(1)-1); % seed initial state
x  = zeros(Nsymb,1);
for i=1:Nsymb
  xQ = inverse_mapping(xQ, SymbolIndexQ(i), p);
  xI = inverse_mapping(xI, SymbolIndexI(i), p);
  x(i) = xQ + sqrt(-1)*xI;
end

% x holds the modulated symbols
plot(real(x), imag(x), '.');

% if you also need the unmodulated symbols you can get them from
% SymbolIndexQ and SymbolIndexI
s = (2*SymbolIndexQ-7) + sqrt(-1)*(2*SymbolIndexI-7);

应生成相应的星座图：

或p=1，基本上未调节：

---

我不太清楚你想做什么，也不完全清楚s和j是什么。此外，由于没有足够的上下文，术语级别也不清楚。您可能希望将问题回滚到早期编辑。目前还不清楚你在问什么，例如什么是外汇？你没有给它下任何定义，我已经把它回滚到以前的编辑——这是OP中的第五个这样的问题，几个月后进行了一次大的编辑，这似乎是不合理的。你似乎摆脱了我在回答中试图解决的你的原始问题的许多方面。如果它们仍然有效，我建议您回滚其中的一些编辑。是的，您可以使用帐篷或逻辑映射作为一个不太好的伪随机数生成器，提供[0,1]范围内的值，以便后续用作所提供阈值函数的输入。您可以将其视为两个单独的块。第一种方法是每次迭代生成一个x值，每次迭代使用逻辑图，根据前一个生成下一个x值。然后，第二个块将获得这些X中的每一个，并应用分段线性变换，我在文章中称之为阈值，以获得最终输出。最终输出不会反馈给第一个 块