Более быстрый способ инициализации массивов с помощью умножения пустой матрицы? (Матлаб)

результаты могут быть немного обманчивы. Когда вы умножаете две пустые матрицы, результирующая матрица не сразу "выделяется" и "инициализируется", а это откладывается до тех пор, пока вы ее не используете (вроде как ленивая оценка).

то же самое относится, когда индексации запрещен растут переменная, которая в случае числовых массивов заполняет любые отсутствующие записи нулями (я обсуждаю впоследствии нечисловой случай). Конечно рост матрицы таким образом не перезаписывает существующие элементы.

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

пример, чтобы показать это поведение, по сравнению с несколько другие альтернативы:

N = 1000;

clear z
tic, z = zeros(N,N); toc
tic, z = z + 1; toc
assert(isequal(z,ones(N)))

clear z
tic, z = zeros(N,0)*zeros(0,N); toc
tic, z = z + 1; toc
assert(isequal(z,ones(N)))

clear z
tic, z(N,N) = 0; toc
tic, z = z + 1; toc
assert(isequal(z,ones(N)))

clear z
tic, z = full(spalloc(N,N,0)); toc
tic, z = z + 1; toc
assert(isequal(z,ones(N)))

clear z
tic, z(1:N,1:N) = 0; toc
tic, z = z + 1; toc
assert(isequal(z,ones(N)))

clear z
val = 0;
tic, z = val(ones(N)); toc
tic, z = z + 1; toc
assert(isequal(z,ones(N)))

clear z
tic, z = repmat(0, [N N]); toc
tic, z = z + 1; toc
assert(isequal(z,ones(N)))

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

// zeros(N,N)
Elapsed time is 0.004525 seconds.
Elapsed time is 0.000792 seconds.

// zeros(N,0)*zeros(0,N)
Elapsed time is 0.000052 seconds.
Elapsed time is 0.004365 seconds.

// z(N,N) = 0
Elapsed time is 0.000053 seconds.
Elapsed time is 0.004119 seconds.

другие тайминги были:

// full(spalloc(N,N,0))
Elapsed time is 0.001463 seconds.
Elapsed time is 0.003751 seconds.

// z(1:N,1:N) = 0
Elapsed time is 0.006820 seconds.
Elapsed time is 0.000647 seconds.

// val(ones(N))
Elapsed time is 0.034880 seconds.
Elapsed time is 0.000911 seconds.

// repmat(0, [N N])
Elapsed time is 0.001320 seconds.
Elapsed time is 0.003749 seconds.

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

в любом случае распределение обычно делается один раз, так что кто заботится, если это займет дополнительные 30 мс :)

---

аналогичное поведение можно наблюдать с массивами ячеек или массивами структур. Рассмотрим следующий пример:

N = 1000;

tic, a = cell(N,N); toc
tic, b = repmat({[]}, [N,N]); toc
tic, c{N,N} = []; toc

что дает:

Elapsed time is 0.001245 seconds.
Elapsed time is 0.040698 seconds.
Elapsed time is 0.004846 seconds.

обратите внимание, что даже если они все равны, они занимают разные объемы памяти:

>> assert(isequal(a,b,c))
>> whos a b c
  Name         Size                  Bytes  Class    Attributes

  a         1000x1000              8000000  cell               
  b         1000x1000            112000000  cell               
  c         1000x1000              8000104  cell               

на самом деле ситуация здесь немного сложнее, так как MATLAB, вероятно,обмен тот же пустой матрица для всех ячеек, а не создание нескольких копий.

массив ячеек a фактически является массивом неинициализированных ячеек (массив нулевых указателей), в то время как b - это массив ячеек, где каждая ячейка является пустой массив [] (внутренне и из-за обмена данными, только первая ячейка b{1} указывает на [] в то время как все остальные имеют ссылку на первую ячейку). Последний массив c похож на a (неинициализированные ячейки), но с последним содержит пустую числовую матрицу [].

---

я просмотрел список экспортированных функций C из libmx.dll (через Dependency Walker), и я нашел несколько интересных вещей.

• существуют недокументированные функции для создания неинициализированных массивов:mxCreateUninitDoubleMatrix,mxCreateUninitNumericArray и mxCreateUninitNumericMatrix. На самом деле есть представление о Обмен использует эти функции для обеспечения более быстрого альтернатива

после проведения некоторых исследований, я нашел в этой статье на "Недокументированный Matlab", в котором Г-Н Яир Альтман уже пришел к выводу, что MathWork способ предварительного распределения матриц используя zeros(M, N) действительно не самый эффективный способ.

он приурочен x = zeros(M,N) и clear x, x(M,N) = 0 и обнаружил, что последний ~в 500 раз быстрее. Согласно его объяснению, второй метод просто создает M-by-N матрица, элементы которой автоматически инициализируются до 0. Однако первый метод создает x (С x с автоматическими нулевыми элементами), а затем присваивает ноль каждому элементу в x опять же, и это избыточная операция, которая занимает больше времени.

в случае умножения пустой матрицы, например, что вы показали в своем вопросе, MATLAB ожидает, что продукт будет матрицей m×N, и поэтому он выделяет матрицу M×N. Следовательно, выходная матрица автоматически инициализируется до нуля. Поскольку исходные матрицы пусты, дальнейшие вычисления не выполняются, и, следовательно, элементы в выходной матрице остаются неизменными и равными нулю.

интересный вопрос, по-видимому, есть несколько способов, чтобы "бить" встроенный

этот ответ фальсифицирован. Хранится только для записи. Кажется, matlab решает использовать разреженных матриц, когда он получил команду z(n,n)=0; когда n достаточно большой. Внутренняя реализация может быть в виде условия, например: (если newsize>THRESHOLD+oldsize, то используйте sparse...) где порог - это ваш "пороговый размер".

однако, это несмотря на Mathworks утверждая: "Matlab никогда создает разреженные матрицы автоматически" (ссылке)

У меня нет Matlab, чтобы проверить это. Тем не менее, использование разреженных матриц (внутренне) является более коротким объяснением (бритва Оккама), следовательно, лучше до фальсификации.