Matlab конвертирует вектор в двоичную матрицу

Очень простой вызов bsxfun сделает свое дело:

>> n = 3;
>> v = [1,1,3,2].';
>> M = bsxfun(@eq, v, 1:n)

M =

     1     0     0
     1     0     0
     0     0     1
     0     1     0

Принцип работы кода на самом деле довольно прост. bsxfun – это так называемая функция расширения Binary Singleton EX. Это означает, что вы предоставляете два массива/матрицы любого размера, если они широковещательные. Это означает, что они должны иметь возможность расширяться в размерах, чтобы они оба были равны по размеру. В этом случае v представляет собой интересующий вас вектор и является первым параметром — обратите внимание, что он транспонирован. Второй параметр — это вектор от 1 до n. Что произойдет сейчас, так это то, что вектор-столбец v будет реплицирован / расширен для стольких значений, сколько имеется n, а второй вектор будет реплицирован для стольких строк, сколько есть в v. . Затем мы делаем оператор eq/равно между этими двумя массивами. Фактически эта расширенная матрица имеет все единицы в первом столбце, все двойки во втором столбце, вплоть до n. Выполняя eq между этими двумя матрицами, вы фактически определяете, какие значения в v равны соответствующему индексу столбца.

Вот подробный тест времени и разбивка каждой функции. Я поместил каждую реализацию в отдельную функцию, а также разрешил n=max(v), чтобы работал первый код Луиса. Я использовал timeit для определения времени каждой функции:

function timing_binary

n = 10000;
v = randi(1000,n,1);
m = numel(v);

    function luis_func()
    M1 = full(sparse(1:m,v,1));       
    end

    function luis_func2()
    %m = numel(v);
    %n = 3; %// or compute n automatically as n = max(v);
    M2 = zeros(m, n);
    M2((1:m).' + (v-1)*m) = 1;      
    end

    function ray_func()
    M3 = bsxfun(@eq, v, 1:n);
    end

    function op_func()
    M4= ones(1,m)'*[1:n] == v * ones(1,n);
    end

t1 = timeit(@luis_func);
t2 = timeit(@luis_func2);
t3 = timeit(@ray_func);
t4 = timeit(@op_func);

fprintf('Luis Mendo - Sparse: %f\n', t1);
fprintf('Luis Mendo - Indexing: %f\n', t2);
fprintf('rayryeng - bsxfun: %f\n', t3);
fprintf('OP: %f\n', t4);


end

Этот тест предполагает n = 10000, а вектор v представляет собой вектор 10000 x 1 случайно распределенных целых чисел от 1 до 1000. Кстати, мне пришлось изменить вторую функцию Луиса, чтобы индексирование работало, поскольку для сложения требуются векторы совместимых размеров.

Запустив этот код, мы получим:

>> timing_binary
Luis Mendo - Sparse: 0.015086
Luis Mendo - Indexing: 0.327993
rayryeng - bsxfun: 0.040672
OP: 0.841827

Выигрывает код Луиса Мендо sparse (как я и ожидал), за ним следует bsxfun, за которым следует индексирование, а затем предлагаемый вами подход с использованием матричных операций. Тайминги указаны в секундах.

Предполагая, что n равно max(v), вы можете использовать sparse:

v = [1,1,3,2];
M = full(sparse(1:numel(v),v,1));

Что делает sparse, так это строит разреженную матрицу, используя первый аргумент в качестве индексов строк. , второй как индексы столбцов, а третий как значения матрицы. Затем он преобразуется в полную матрицу с full.

Другой подход состоит в том, чтобы определить матрицу, изначально содержащую нули, а затем использовать линейную индексацию для заполнения:

v = [1,1,3,2];
m = numel(v);
n = 3; %// or compute n automatically as n = max(v);
M = zeros(m, n);
M((1:m) + (v-1)*m) = 1;

Я думаю, что я также нашел способ сделать это, и было бы неплохо, если бы кто-нибудь мог сказать мне, какой из показанных методов быстрее для очень больших векторов и матриц. Дополнительный метод, о котором я подумал, заключается в следующем

M= ones(1,m)'*[1:n] == v * ones(1,n)