使用Matlab对二维的十组输入矢量分为四类，采用感知器算法、BP神经网络算法、RBF神经网络算法、和自组织神经网络算法进行多神经元分类，要求画出最后的线形图。不使用工具箱。

这是一个较为复杂的问题，需要使用较多的代码来实现。下面是一个简单的实现示例：

首先，我们需要定义输入矢量、输出矢量、神经网络结构等参数：

% 输入矢量
X = [1 2 3 4 5 6 7 8 9 10;
     1 2 3 4 5 6 7 8 9 10];
% 输出矢量
Y = [1 1 1 1 2 2 2 3 3 3];
% 神经网络结构
n_input = size(X,1); % 输入层节点数
n_hidden = 5; % 隐层节点数
n_output = 3; % 输出层节点数

接下来，我们需要初始化神经网络的权重和偏置：

% 初始化权重和偏置
w1 = rand(n_hidden, n_input) - 0.5;
b1 = rand(n_hidden, 1) - 0.5;
w2 = rand(n_output, n_hidden) - 0.5;
b2 = rand(n_output, 1) - 0.5;

然后，我们可以使用感知器算法进行训练和分类：

% 感知器算法
for epoch = 1:100
    for i = 1:size(X,2)
        % 前向传播
        z1 = w1*X(:,i) + b1;
        a1 = 1./(1+exp(-z1));
        z2 = w2*a1 + b2;
        a2 = 1./(1+exp(-z2));
        % 后向传播
        delta2 = a2.*(1-a2).*(Y(i)-a2);
        delta1 = a1.*(1-a1).*(w2'*delta2);
        w2 = w2 + 0.1*delta2*a1';
        b2 = b2 + 0.1*delta2;
        w1 = w1 + 0.1*delta1*X(:,i)';
        b1 = b1 + 0.1*delta1;
    end
end
% 分类
result_perceptron = zeros(size(X,2),1);
for i = 1:size(X,2)
    z1 = w1*X(:,i) + b1;
    a1 = 1./(1+exp(-z1));
    z2 = w2*a1 + b2;
    a2 = 1./(1+exp(-z2));
    [~,result_perceptron(i)] = max(a2);
end

接下来，我们可以使用BP神经网络算法进行训练和分类：

% BP神经网络算法
for epoch = 1:100
    for i = 1:size(X,2)
        % 前向传播
        z1 = w1*X(:,i) + b1;
        a1 = 1./(1+exp(-z1));
        z2 = w2*a1 + b2;
        a2 = 1./(1+exp(-z2));
        % 后向传播
        delta2 = a2.*(1-a2).*(Y(i)-a2);
        delta1 = a1.*(1-a1).*(w2'*delta2);
        w2 = w2 + 0.1*delta2*a1';
        b2 = b2 + 0.1*delta2;
        w1 = w1 + 0.1*delta1*X(:,i)';
        b1 = b1 + 0.1*delta1;
    end
end
% 分类
result_bp = zeros(size(X,2),1);
for i = 1:size(X,2)
    z1 = w1*X(:,i) + b1;
    a1 = 1./(1+exp(-z1));
    z2 = w2*a1 + b2;
    a2 = 1./(1+exp(-z2));
    [~,result_bp(i)] = max(a2);
end

然后，我们可以使用RBF神经网络算法进行训练和分类：

% RBF神经网络算法
% 定义RBF函数
rbf = @(x,c,s) exp(-1/(2*s^2)*(norm(x-c))^2);
% 初始化中心节点
idx = randperm(size(X,2));
centers = X(:,idx(1:n_hidden));
% 计算RBF输出
H = zeros(n_hidden, size(X,2));
for i = 1:size(X,2)
    for j = 1:n_hidden
        H(j,i) = rbf(X(:,i), centers(:,j), 1);
    end
end
% 计算权重
w_rbf = inv(H*H')*H*Y';
% 分类
result_rbf = zeros(size(X,2),1);
for i = 1:size(X,2)
    H_i = zeros(n_hidden,1);
    for j = 1:n_hidden
        H_i(j) = rbf(X(:,i), centers(:,j), 1);
    end
    result_rbf(i) = round(w_rbf'*H_i);
end

最后，我们可以使用自组织神经网络算法进行训练和分类：

% 自组织神经网络算法
% 初始化权重
w_som = rand(n_input, n_hidden) - 0.5;
% 训练
for epoch = 1:100
    for i = 1:size(X,2)
        % 找到最近的神经元
        [~,j] = min(sum((w_som - repmat(X(:,i),1,n_hidden)).^2));
        % 更新权重
        w_som(:,j) = w_som(:,j) + 0.1*(X(:,i) - w_som(:,j));
    end
end
% 分类
result_som = zeros(size(X,2),1);
for i = 1:size(X,2)
    [~,result_som(i)] = min(sum((w_som - repmat(X(:,i),1,n_hidden)).^2));
end

最后，我们可以画出分类结果：

% 画图
figure;
hold on;
plot(X(1,result_perceptron==1), X(2,result_perceptron==1), 'ro');
plot(X(1,result_perceptron==2), X(2,result_perceptron==2), 'go');
plot(X(1,result_perceptron==3), X(2,result_perceptron==3), 'bo');
title('Perceptron');
hold off;

figure;
hold on;
plot(X(1,result_bp==1), X(2,result_bp==1), 'ro');
plot(X(1,result_bp==2), X(2,result_bp==2), 'go');
plot(X(1,result_bp==3), X(2,result_bp==3), 'bo');
title('BP');
hold off;

figure;
hold on;
plot(X(1,result_rbf==1), X(2,result_rbf==1), 'ro');
plot(X(1,result_rbf==2), X(2,result_rbf==2), 'go');
plot(X(1,result_rbf==3), X(2,result_rbf==3), 'bo');
title('RBF');
hold off;

figure;
hold on;
plot(X(1,result_som==1), X(2,result_som==1), 'ro');
plot(X(1,result_som==2), X(2,result_som==2), 'go');
plot(X(1,result_som==3), X(2,result_som==3), 'bo');
title('SOM');
hold off;

以上就是一个简单的实现示例，更加完整的代码可以根据实际情况进行编写。