<?xml version='1.0' encoding="utf-8"?>
      <rss version='2.0'>
      <channel>
      <title>Форум на Исходниках.RU</title>
      <link>https://forum.sources.ru</link>
      <description>Форум на Исходниках.RU</description>
      <generator>Форум на Исходниках.RU</generator>
  	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1757276</guid>
        <pubDate>Thu, 08 Nov 2007 18:30:45 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1757276</link>
        <description><![CDATA[shadeofgray: Блин. Ну почему постоянно у всех есть желание изобретать велосипед? :) Блочно-матричные алгоритмы - самое простое и естественное решение проблемы обращений к жесткому диску. Не надо никаких списков (для линейной алгебры вообще смерть - замедление в десятки раз), не надо ничего вообще. Матрица обрабатывается не по строкам, а по блокам. Соотношение между размером задачи и количеством доступной оперативной памяти естественным образом преобразуется в размер обрабатываемого блока. Число считываний элемента матрицы с жесткого диска не N (как в обычном алгоритме), а N/K, где K - размер блока.<br><br>Мне кажется, это идеальное решение. Только сложное, и мало кто о нем знает, т.к. в университетском курсе численных методов линейную алгебру читают на уровне чуть ли не 50-ых годов (по крайней мере, мне так читали).]]></description>
        <author>shadeofgray</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1756872</guid>
        <pubDate>Thu, 08 Nov 2007 13:16:19 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1756872</link>
        <description><![CDATA[VolkMan: Нет я конечно могу понять желание решить в лоб 50000 уравнений, но даже если удастья представить в памяти такой объём данных, то врядли стоит завидовать человеку, которому предстоит дождаться решения данной системы, к тому же хранить только те данные которые могут быть вычеслены это ещё более нагрузка на ЦП, да и где гарант, что система окажется совместна или не будет имет бесконечное множество решении. В жизни не видел ситуации где бы могло понадобится такое количество корней для чего либо. С другой стороны использовать жесткий диск конечно можно, но тогда необходимо минимизировать количество обращений к нему. Например если для решения системы используется всеми горячо любимый метод Гаусса, то можно хранить отдеьные строки (в количестве 2 штук) на прямом и обратном ходе алгоритма, после этого, в случае если система является невырожденной(по сути каждой переменной соотвестует едиснтвенное решение), то необходимо, считать только диагональные элементы, в противном случае лучше сразу бить в барабаны, потомучто даже если можно будет наити аналитическую форму записи для свободных переменных, то анализ такой системы в большинстве случаем сведётся к поиску оптимума, а вот эта задача скорее всего уже приведёт к ожиданию конца вычислении, ну как минимум до пенсии уважаемого Telc. Другого способа просто нет.]]></description>
        <author>VolkMan</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1756835</guid>
        <pubDate>Thu, 08 Nov 2007 12:53:59 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1756835</link>
        <description><![CDATA[deil: Не влезая в дебри теории, личн я бы подошёл к проблеме чисто технически :)<br><br>Преобразовал бы массив в список - т.е. паре (i, j) сопоставляется значение. И есть небольшой классик, который в себе умеет держать набор этих значений. Да, матрицы не разреженные, экономии это не даст :)<br>Зато есть возможность контролировать размер занимаемой памяти - (sizeof(i)*2 + sizeof(value))*current_loaded_items<br>Ну а далее уже можно тупо считывать с диска все записи, пока забьём отведенный размер. А после - считывать по надобности, высвобождая самые &quot;старые&quot; значения. Дешёво и сердито. И время на реализацию - 1-2 часа :yes:]]></description>
        <author>deil</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1756833</guid>
        <pubDate>Thu, 08 Nov 2007 12:51:06 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1756833</link>
        <description><![CDATA[experimenter: <div class='tag-quote'><a class='tag-quote-link' href='https://forum.sources.ru/index.php?showtopic=209002&view=findpost&p=1756825'><span class='tag-quote-prefix'>Цитата</span></a> <span class='tag-quote__quote-info'>Telc &#064; <time class="tag-quote__quoted-time" datetime="2007-11-08T12:45:35+00:00">08.11.07, 12:45</time></span><div class='quote '>В любом случае, прежде необходимо отаработать сам алгоритм на простом ПК.</div></div><br>
А до этого лучше на бумажке&#33; :)]]></description>
        <author>experimenter</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1756825</guid>
        <pubDate>Thu, 08 Nov 2007 12:45:35 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1756825</link>
        <description><![CDATA[Telc: В любом случае, прежде необходимо отаработать сам алгоритм на простом ПК.]]></description>
        <author>Telc</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1756312</guid>
        <pubDate>Thu, 08 Nov 2007 07:48:46 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1756312</link>
        <description><![CDATA[experimenter: <div class='tag-quote'><a class='tag-quote-link' href='https://forum.sources.ru/index.php?showtopic=209002&view=findpost&p=1756137'><span class='tag-quote-prefix'>Цитата</span></a> <span class='tag-quote__quote-info'>Alexus &#064; <time class="tag-quote__quoted-time" datetime="2007-11-08T05:08:57+00:00">08.11.07, 05:08</time></span><div class='quote '>Гм... Ну зачем же покупать? можно арендовать.<br>
Мне стало интересно - порылся по теме в инете и нашол некоторые цифры:</div></div><br>
Хорошая идея, кстати. Мне в голову не пришла даже. Только думаю, что нормальный мейнфрейм в России найти не так уж и просто. Тем более, чтоб тебя на него пустили попастись. :)]]></description>
        <author>experimenter</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1756137</guid>
        <pubDate>Thu, 08 Nov 2007 05:08:57 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1756137</link>
        <description><![CDATA[Alexus: <div class='tag-quote'><a class='tag-quote-link' href='https://forum.sources.ru/index.php?showtopic=209002&view=findpost&p=1753589'><span class='tag-quote-prefix'>Цитата</span></a> <span class='tag-quote__quote-info'>experimenter &#064; <time class="tag-quote__quoted-time" datetime="2007-11-06T08:25:56+00:00">06.11.07, 08:25</time></span><div class='quote '>Да, теперь понимаю. Ну, тогда давайте предложим человеку купить майнфрейм. </div></div><br>
<br>
Гм... Ну зачем же покупать? можно арендовать.<br>
Мне стало интересно -  порылся по теме в инете и нашол некоторые цифры:<br>
<div class='tag-quote'><span class='tag-quote-prefix'>Цитата</span> <span class='tag-quote__quote-info'>с какого то форума</span><div class='quote '>... на западе, там стоимость одного гигагерца маширнного времени за час: 1 доллар, у нас (в России) 0,15 - 0,20, то есть в 5-7 раз меньше...</div></div>]]></description>
        <author>Alexus</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1756039</guid>
        <pubDate>Wed, 07 Nov 2007 21:07:36 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1756039</link>
        <description><![CDATA[amk: Да, это модификация метода исключения Гаусса, точнее метода Жордана-Гаусса, но требования к памяти несколько ниже, чем у классических алгоритмов (есть еще так называемый метод оптимального исключения, у которого требования к памяти, вроде, еще меньше). Кроме того, по-моему, и среди блочно-матричных алгоритмов многие позволяют подобную оптимизацию использования памяти. Увеличивается размер блока, уменьшается число обращений к диску.<br><br>И еще, небольшая модификация этого метода позволяет решать системы, даже четверть матрицы которых не помещаетмся в память, проходя файл с матрицей несколько раз.<br><br>Еще про память.<br>Пусть мы имеем m систем n-го порядка с одинаковой матрицей, то есть расширенная матрица имеет размер n*(n+m)<br>При решении системы получается последовательность матриц размеров:<br>1*(n+m-1), 2*(n+m-2), 3*(n+m-3), ..., (n-1)*(m+1), n*(m), которые могут быть размещены по одному и тому же адресу (при построчном порядке, как в C). Последняя матрица будет содержать решения.<br><br>Хотя надо сказать, что этот метод хорош только для матриц с диагональным преобладанием (нет возможности выбирать гдавный элемент)]]></description>
        <author>amk</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1755957</guid>
        <pubDate>Wed, 07 Nov 2007 19:23:49 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1755957</link>
        <description><![CDATA[shadeofgray: Не уверен, что это подойдет - ведь предыдущие строки наверняка надо хранить в памяти, на каждой новой строке проходить по ним.<br><br>По сути, мне кажется, что все алгоритмы решения задачи в данном случае можно разделить на два класса: обычные и блочно-матричные. Детали подхода могут меняться, сам подход в целом остается. Ваш алгоритм похоже относится к первой категории.]]></description>
        <author>shadeofgray</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1755943</guid>
        <pubDate>Wed, 07 Nov 2007 19:09:13 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1755943</link>
        <description><![CDATA[amk: Есть еще вариация метода Гаусса - метод Жордана. Приводит матрицу сразу к диагональной единичной матрице. Можно обрабатывать матрицу построчно. Ввел строку, обработал вместе с предыдущими, чтобы левая часть была единичной матрицей (ее и хранить не нужно). Требования по памяти порядка четверти размера всей матрицы, максимум - на середине матрицы.]]></description>
        <author>amk</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1754597</guid>
        <pubDate>Tue, 06 Nov 2007 20:46:27 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1754597</link>
        <description><![CDATA[shadeofgray: <strong class='tag-b'>AndreyK</strong>, во-первых, сказали же, что такой большой кусок памяти в систему виртуальной памяти просто не влезет. Система адресации процессора не вытянет. Во-вторых, даже если бы и влез, основная проблема не в том, как отобразить, а как организовать работу, чтобы поменьше трещать винчестером.]]></description>
        <author>shadeofgray</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1754546</guid>
        <pubDate>Tue, 06 Nov 2007 19:19:54 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1754546</link>
        <description><![CDATA[AndreyK: <div class='tag-quote'><a class='tag-quote-link' href='https://forum.sources.ru/index.php?showtopic=209002&view=findpost&p=1753241'><span class='tag-quote-prefix'>Цитата</span></a> <span class='tag-quote__quote-info'>Pavia &#064; <time class="tag-quote__quoted-time" datetime="2007-11-05T20:43:10+00:00">05.11.07, 20:43</time></span><div class='quote '><strong class='tag-b'>AndreyK</strong><br>
И где это вы такую глупость вычитали?</div></div><br>
Здесь:<br>
The VirtualAlloc function reserves or commits a region of pages in the virtual address space of the calling process. Memory allocated by this function is automatically initialized to zero, unless MEM_RESET is specified. <br>
<br>
To allocate memory in the address space of another process, use the VirtualAllocEx function. <br>
<br>
LPVOID VirtualAlloc(<br>
  LPVOID lpAddress,        // region to reserve or commit<br>
  SIZE_T dwSize,           // size of region<br>
  DWORD flAllocationType,  // type of allocation<br>
  DWORD flProtect          // type of access protection<br>
);<br>
Parameters<br>
lpAddress <br>
[in] Starting address of the region to allocate. If the memory is being reserved, the specified address is rounded down to the next 64-kilobyte boundary. If the memory is already reserved and is being committed, the address is rounded down to the next page boundary. To determine the size of a page on the host computer, use the GetSystemInfo function. If this parameter is NULL, the system determines where to allocate the region. <br>
dwSize <br>
[in] Size of the region, in bytes. If the lpAddress parameter is NULL, this value is rounded up to the next page boundary. Otherwise, the allocated pages include all pages containing one or more bytes in the range from lpAddress to (lpAddress+dwSize). This means that a 2-byte range straddling a page boundary causes both pages to be included in the allocated region. <br>
flAllocationType <br>
[in] Type of memory allocation. This parameter must contain one of the following values.]]></description>
        <author>AndreyK</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1754327</guid>
        <pubDate>Tue, 06 Nov 2007 16:00:33 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1754327</link>
        <description><![CDATA[shadeofgray: Попробуйте покопать в сторону блочно-матричных алгоритмов (на таких алгоритмах основан LAPACK 3). Это алгоритмы линейной алгебры, которые оперируют не со строками/столбцами, а с подматрицами матрицы, помещающимися в кэш. За счет этого достигается 2-3 кратное ускорение работы на больших матрицах, которые помещаются в оперативке, но не влезают в кэш процессора. В вашем случае ускорение будет ещё выше.<br>
<br>
Я не могу сейчас в деталях описать эти алгоритмы, попробуйте поискать в lapack working notes, там есть pdf-Файлы для скачивания. Если кратко, то смысл в том, что большая матрица разбивается на две части - небольшая угловая подматрица, и огромный остаток. Сначала мы проводим операции над угловой подматрицей (например, строим её LU-разложение), затем обновляем остаток. После чего берем угловую подматрицу у остатка и обновляем уже её, и так далее. Смысл в том, что угловая подматрица влезает в кэш (в вашем случае - в оперативку) и считается очень быстро, а обновление остатка - по сути умножение огромной матрицы на матрицу небольшого размера, что можно очень эффективно проделать за один проход по остатку. Скажем, если у вас матрица NxN, а размер блока 10, то вам потребуется N/10 проходов по ней, чтобы всё рассчитать - N/10 считываний в оперативку с жесткого диска вместо N. Операции те же, просто переупорядочены так, чтобы работать более эффективно.<br>
<br>
В вашем случае можно попробовать сесть на два стула одновременно - сэкономить как за счет снижения количества проходов по диску, так и за счет осуществления операций только с субматрицами, помещающимися в кэш процессора.<br>
<br>
Я не уверен, что реализация, приведенная в LAPACK, подойдет вам без изменений (во-первых, она предполагает, что вся матрица помещается в оперативку; во-вторых, возможно, вы захотите оптимизировать структуру хранения матрицы на диске с учетом того, в каком порядке будут обходиться её элементы - чтобы по возможности считывать элементы в последовательных секторах). Кроме того, надо очень хорошо подумать над вопросом обусловленности вашей задачи - блочно-матричные алгоритмы менее стабильны, чем обычные, т.к. там имеют место определенные сложности с выбором ведущего элемента.<br>
<br>
В общем, мне кажется, надо копать в этом направлении. Попробуйте разобраться, если будут вопросы - спрашивайте. Я с этой темой неплохо знаком, просто нет времени расписать всё в деталях :( Но на конкретные вопросы отвечу. <br>
<br>
<span class="tag-color tag-color-named" data-value="gray" style="color: gray"><span class='tag-size' data-value='7' style='font-size:7pt;'>Добавлено <time class="tag-mergetime" datetime="2007-11-06T16:02:05+00:00">06.11.07, 16:02</time></span></span><br>
<div class='tag-quote'><a class='tag-quote-link' href='https://forum.sources.ru/index.php?showtopic=209002&view=findpost&p=1753838'><span class='tag-quote-prefix'>Цитата</span></a> <span class='tag-quote__quote-info'>Telc &#064; <time class="tag-quote__quoted-time" datetime="2007-11-06T10:32:42+00:00">06.11.07, 10:32</time></span><div class='quote '>Весь массив хронят в файле на винте и загружают столько строк, сколько помещается в оперативку, затем преобразовывают матрицу (приводят к трапецивидной форме) и записывают в файл. Так они в итоге получают треугольную матрицу.</div></div><br>
Да, это почти оно. По духу то же самое, немного другая реализация. <br>
<br>
<span class="tag-color tag-color-named" data-value="gray" style="color: gray"><span class='tag-size' data-value='7' style='font-size:7pt;'>Добавлено <time class="tag-mergetime" datetime="2007-11-06T16:06:51+00:00">06.11.07, 16:06</time></span></span><br>
По поводу двух стульев. Когда я говорил про операции с матрицами, помещающимися в кэш, то имел в виду, что обновление остатка также можно оптимизировать и реализовать в блочно-матричном стиле. Но, подумав, понял, что на самом деле здесь не тот случай, и определяющим фактором будет скорость работы с диском. Так что стул только один.]]></description>
        <author>shadeofgray</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753852</guid>
        <pubDate>Tue, 06 Nov 2007 10:42:03 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753852</link>
        <description><![CDATA[Pacific: <strong class='tag-b'>Telc</strong><br>
Это как раз то, что я описывал, только вместо кластера один компьютер, обрабатывающий матрицу кусками. Значит, кластер справится еще быстрее. Кстати, действительно, все строки матрицы, которые есть в оперативке, можно привести к такому виду, что останутся элементы только на главной диагонали, при небольшом числе обращений к диску (за один проход по файлу можно привести к такому виду весь кусок, находящийся в памяти).]]></description>
        <author>Pacific</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753838</guid>
        <pubDate>Tue, 06 Nov 2007 10:32:42 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753838</link>
        <description><![CDATA[Telc: Все написанное меня удивило.<br>Дело в том, что я на одной научно-практической конференции, к сожалению не в моем вузе и не в моем городе она проходила, слушал доклад, посвященный прикладной задаче из электромагнетизма. Людям приходится работать с системами нелинейных алгебраических уравнений. Решают они их методом Ньютона. На каждом шаге этого метода приходтся решать систему линейных уравнений. Вот они утверждают, что на обычном компе (с двухъядерным процессором) решают системы порядка 40000 уравнений и более за двое суток.<br>Используют модификацию метода Гаусса. Весь массив хронят в файле на винте и загружают столько строк, сколько помещается в оперативку, затем преобразовывают матрицу (приводят к трапецивидной форме) и записывают в файл. Так они в итоге получают треугольную матрицу.<br>(тезисы конференции к сожалению еще не вышли; да и ничего конкретного там расписано не будет, поскольку основные результаты их работы сводятся к физике).]]></description>
        <author>Telc</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753760</guid>
        <pubDate>Tue, 06 Nov 2007 09:47:23 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753760</link>
        <description><![CDATA[experimenter: <div class='tag-quote'><a class='tag-quote-link' href='https://forum.sources.ru/index.php?showtopic=209002&view=findpost&p=1753721'><span class='tag-quote-prefix'>Цитата</span></a> <span class='tag-quote__quote-info'>Pacific &#064; <time class="tag-quote__quoted-time" datetime="2007-11-06T09:25:50+00:00">06.11.07, 09:25</time></span><div class='quote '><strong class='tag-b'>experimenter</strong><br>
Прямой ссылки я не знаю, но представляю себе распределенный метод Гаусса так:<br>
<br>
1) Основная операция в методе Гаусса - сложение двух векторов C=A*t+B, где t - некоторый коэффициент.<br>
2) Главный компьютер рассылает (UDP-броадкастом) вектор A всем остальным компьютерам, плюс он сообщает им, какой элемент сейчас ведущий. Остальные компьютеры определяют коэффициенты t для всех строк B своей части матрицы и выполняют операцию (1)<br>
3) Когда шаг 2 закончен (остальные компы прислали сообщения главному), главный компьютер рассылает броадкаст с требованием предоставить ему (i+1)-ую строчку матрицы. Соответствующий компьютер отсылает данные.<br>
4) Теперь можно повторить шаги 2-3 со следующей строчкой.<br>
<br>
Объем передаваемой информации по сети - 2 строки матрицы на каждой итерации, что совсем немного, и обычная локалка это легко потянет.</div></div><br>
Да, похоже, что примерно так надо делать. Только я не советую, это самому писать, тем более на С++ каком-нибудь. С синхронизацией надо быть очень осторожным - довольно непростая тема. :) В общем, я бы советовал автору найти какой-то уже готовый алгоритм, а самому писать - это будет очень сложно.]]></description>
        <author>experimenter</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753721</guid>
        <pubDate>Tue, 06 Nov 2007 09:25:50 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753721</link>
        <description><![CDATA[Pacific: <strong class='tag-b'>experimenter</strong><br>
Прямой ссылки я не знаю, но представляю себе распределенный метод Гаусса так:<br>
<br>
1) Основная операция в методе Гаусса - сложение двух векторов C=A*t+B, где t - некоторый коэффициент.<br>
2) Главный компьютер рассылает (UDP-броадкастом) вектор A всем остальным компьютерам, плюс он сообщает им, какой элемент сейчас ведущий. Остальные компьютеры определяют коэффициенты t для всех строк B своей части матрицы и выполняют операцию (1)<br>
3) Когда шаг 2 закончен (остальные компы прислали сообщения главному), главный компьютер рассылает броадкаст с требованием предоставить ему (i+1)-ую строчку матрицы. Соответствующий компьютер отсылает данные.<br>
4) Теперь можно повторить шаги 2-3 со следующей строчкой.<br>
<br>
Объем передаваемой информации по сети - 2 строки матрицы на каждой итерации, что совсем немного, и обычная локалка это легко потянет.]]></description>
        <author>Pacific</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753691</guid>
        <pubDate>Tue, 06 Nov 2007 09:14:38 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753691</link>
        <description><![CDATA[experimenter: <div class='tag-quote'><a class='tag-quote-link' href='https://forum.sources.ru/index.php?showtopic=209002&view=findpost&p=1753681'><span class='tag-quote-prefix'>Цитата</span></a> <span class='tag-quote__quote-info'>Pacific &#064; <time class="tag-quote__quoted-time" datetime="2007-11-06T09:11:09+00:00">06.11.07, 09:11</time></span><div class='quote '><strong class='tag-b'>experimenter</strong><br>
А что здесь такого, обычная локальная сеть. Алгоритмы распределенных вычислений можно найти на том же parallel.ru или в гугле.</div></div><br>
Да, я понимаю, как делаются локальные сетки. Быть может, вы как раз знаете прямую ссылку на такой алгоритм.]]></description>
        <author>experimenter</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753681</guid>
        <pubDate>Tue, 06 Nov 2007 09:11:09 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753681</link>
        <description><![CDATA[Pacific: <strong class='tag-b'>experimenter</strong><br>
А что здесь такого, обычная локальная сеть. Алгоритмы распределенных вычислений можно найти на том же parallel.ru или в гугле.]]></description>
        <author>Pacific</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753673</guid>
        <pubDate>Tue, 06 Nov 2007 09:05:35 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753673</link>
        <description><![CDATA[experimenter: <div class='tag-quote'><a class='tag-quote-link' href='https://forum.sources.ru/index.php?showtopic=209002&view=findpost&p=1753647'><span class='tag-quote-prefix'>Цитата</span></a> <span class='tag-quote__quote-info'>Pacific &#064; <time class="tag-quote__quoted-time" datetime="2007-11-06T08:52:17+00:00">06.11.07, 08:52</time></span><div class='quote '>Здесь главное суммарный объем памяти. Но все равно, компов понадобится много, не во всяком универе столько будет </div></div><br>
Да, согласен. В общем, <strong class='tag-b'>Telc</strong>, надо руководителю объяснять, что нужно для решения такой офигенной системы уравнений, а он уж пусть разруливает ситуацию дальше. :)<br>
<strong class='tag-b'>Pacific</strong>, а вы не могли бы прямую ссылку дать, где объясняется, как создать такую сетку?]]></description>
        <author>experimenter</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753647</guid>
        <pubDate>Tue, 06 Nov 2007 08:52:17 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753647</link>
        <description><![CDATA[Pacific: Здесь главное суммарный объем памяти. Но все равно, компов понадобится много, не во всяком универе столько будет :yes-sad:]]></description>
        <author>Pacific</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753642</guid>
        <pubDate>Tue, 06 Nov 2007 08:48:32 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753642</link>
        <description><![CDATA[experimenter: Мне самому стало интересно и я вбил в гугл следущие слова<br>
<br>
huge system of linear equations<br>
<br>
куча всего выдается. в основном именно про распараллеливание вычислений. Так что вам надо смотреть в эту строну. и если задача у вас из универа например, то идти и объяснять руководителю, что он несколько замахнулся не туда. не по одёжке, так сказать, протянул ножки. :) <br>
<br>
<span class="tag-color tag-color-named" data-value="gray" style="color: gray"><span class='tag-size' data-value='7' style='font-size:7pt;'>Добавлено <time class="tag-mergetime" datetime="2007-11-06T08:49:43+00:00">06.11.07, 08:49</time></span></span><br>
<div class='tag-quote'><a class='tag-quote-link' href='https://forum.sources.ru/index.php?showtopic=209002&view=findpost&p=1753638'><span class='tag-quote-prefix'>Цитата</span></a> <span class='tag-quote__quote-info'>Pacific &#064; <time class="tag-quote__quoted-time" datetime="2007-11-06T08:46:49+00:00">06.11.07, 08:46</time></span><div class='quote '>Если у автора есть доступ к компам в университете, то, думаю, он найдет достаточное количество компов с нужным суммарным объемом памяти  Останется только согласовать с начальством.</div></div><br>
Да, пожалуй, это самый пока перспективный вариант. другое дело, что в универах компы обычно не очень-то мощные... по 2 ГБ оперативки там точно не стоит. :)]]></description>
        <author>experimenter</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753638</guid>
        <pubDate>Tue, 06 Nov 2007 08:46:49 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753638</link>
        <description><![CDATA[Pacific: Если у автора есть доступ к компам в университете, то, думаю, он найдет достаточное количество компов с нужным суммарным объемом памяти :) Останется только согласовать с начальством.]]></description>
        <author>Pacific</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753627</guid>
        <pubDate>Tue, 06 Nov 2007 08:40:20 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753627</link>
        <description><![CDATA[experimenter: <div class='tag-quote'><a class='tag-quote-link' href='https://forum.sources.ru/index.php?showtopic=209002&view=findpost&p=1753601'><span class='tag-quote-prefix'>Цитата</span></a> <span class='tag-quote__quote-info'>Pacific &#064; <time class="tag-quote__quoted-time" datetime="2007-11-06T08:30:25+00:00">06.11.07, 08:30</time></span><div class='quote '><strong class='tag-b'>experimenter</strong><br>
Ну еще можно сделать кластер из 16 компов, на каждом из которых будет по 2 Гб оперативки, объединить их в локальную сеть, и этот кластер тоже довольно быстро решит систему. Объем передаваемой между компами информации будет довольно небольшим. Так что автору прямая дорога на www.parallel.ru :)</div></div><br>
Да, интересные вы решения предлагаете&#33;<br>
Правда, что-то мне подсказывает, что автор не владеет какой-то фирмой солидной и в лотерею не выигрывал (как большинство нормальных людей), поэтому довольно трудно будет реализовать хотя бы какое-то из предложенных решений. :)]]></description>
        <author>experimenter</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753601</guid>
        <pubDate>Tue, 06 Nov 2007 08:30:25 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753601</link>
        <description><![CDATA[Pacific: <strong class='tag-b'>experimenter</strong><br>
Ну еще можно сделать кластер из 16 компов, на каждом из которых будет по 2 Гб оперативки, объединить их в локальную сеть, и этот кластер тоже довольно быстро решит систему. Объем передаваемой между компами информации будет довольно небольшим. Так что автору прямая дорога на www.parallel.ru :)]]></description>
        <author>Pacific</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753589</guid>
        <pubDate>Tue, 06 Nov 2007 08:25:56 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753589</link>
        <description><![CDATA[experimenter: <div class='tag-quote'><a class='tag-quote-link' href='https://forum.sources.ru/index.php?showtopic=209002&view=findpost&p=1753574'><span class='tag-quote-prefix'>Цитата</span></a> <span class='tag-quote__quote-info'>Pacific &#064; <time class="tag-quote__quoted-time" datetime="2007-11-06T08:18:48+00:00">06.11.07, 08:18</time></span><div class='quote '>Если матрица не влезет в память, то все упрется в скорость считывания с диска =&gt; полгода на решение одной системы. Если в память влезет, то все упрется в ПСП памяти, а это уже гораздо более разумное время счета (одна-две недели). Так что ему нужен такой комп (а они продаются, вот только стоят соответственно).</div></div><br>
Да, теперь понимаю. Ну, тогда давайте предложим человеку купить майнфрейм. :)]]></description>
        <author>experimenter</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753574</guid>
        <pubDate>Tue, 06 Nov 2007 08:18:48 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753574</link>
        <description><![CDATA[Pacific: <strong class='tag-b'>experimenter</strong><br>
Если матрица не влезет в память, то все упрется в скорость считывания с диска =&gt; полгода на решение одной системы. Если в память влезет, то все упрется в ПСП памяти, а это уже гораздо более разумное время счета (одна-две недели). Так что ему нужен такой комп (а они продаются, вот только стоят соответственно).]]></description>
        <author>Pacific</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753571</guid>
        <pubDate>Tue, 06 Nov 2007 08:15:27 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753571</link>
        <description><![CDATA[experimenter: <div class='tag-quote'><a class='tag-quote-link' href='https://forum.sources.ru/index.php?showtopic=209002&view=findpost&p=1753548'><span class='tag-quote-prefix'>Цитата</span></a> <span class='tag-quote__quote-info'>Pacific &#064; <time class="tag-quote__quoted-time" datetime="2007-11-06T07:53:35+00:00">06.11.07, 07:53</time></span><div class='quote '><strong class='tag-b'>Telc</strong><br>
50000x50000x8=18,62 Гб. Тебе нужен хороший многопроцессорный сервер с как минимум 32 Гб оперативки и 64-х разрядная операционка. Если памяти не хватит, то время решения (и так немаленькое) увеличится еще на порядок даже при условии оптимального чтения с диска (то есть все строки уравнения хранятся на диске последовательно и обрабатываются тоже последовательно). Я вообще не понимаю, как ты собираешься решать такую систему, понадобятся очень эффективные алгоритмы (метод Гаусса слишком медленный).<br>
<br>
В принципе, если использовать метод Гаусса, то при прямом и обратном обходе вполне можно обрабатывать матрицу кусками, влезающими в оперативку, ведь внутренний цикл работает только с двумя строками одновременно. К тому же это легко распарраллеливается. <br>
<br>
<span class="tag-color tag-color-named" data-value="gray" style="color: gray"><span class='tag-size' data-value='7' style='font-size:7pt;'>Добавлено <time class="tag-mergetime" datetime="2007-11-06T08:11:48+00:00">06.11.07, 08:11</time></span></span><br>
Предположим, что система решается методом Гаусса =&gt; это 2x50000 проходов по матрице, пусть скорость чтения с диска - 120 Мб/сек (рэйд там какой-нибудь). 18.62*1024*2*50000/120/86400=184 дня непрерывной работы. Так что нужно или долго ждать или использовать более эффективный метод...</div></div><br>
Я вот не понимаю, зачем человеку 32 ГБ оперативки. Таких компов днём с огнём не сыскать. Вот, например, взять 32-битную винду. Там можно захапать теоретически 4 ГБ оперативки, но никто же не говорит, что нужно, чтоб все 4 ГБ были вставлены в комп. Этим и занимается виртуальная память, раздувая оперативку до максимально возможного значения за счёт файла подкачки.]]></description>
        <author>experimenter</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753548</guid>
        <pubDate>Tue, 06 Nov 2007 07:53:35 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753548</link>
        <description><![CDATA[Pacific: <strong class='tag-b'>Telc</strong><br>
50000x50000x8=18,62 Гб. Тебе нужен хороший многопроцессорный сервер с как минимум 32 Гб оперативки и 64-х разрядная операционка. Если памяти не хватит, то время решения (и так немаленькое) увеличится еще на порядок даже при условии оптимального чтения с диска (то есть все строки уравнения хранятся на диске последовательно и обрабатываются тоже последовательно). Я вообще не понимаю, как ты собираешься решать такую систему, понадобятся очень эффективные алгоритмы (метод Гаусса слишком медленный).<br>
<br>
В принципе, если использовать метод Гаусса, то при прямом и обратном обходе вполне можно обрабатывать матрицу кусками, влезающими в оперативку, ведь внутренний цикл работает только с двумя строками одновременно. К тому же это легко распарраллеливается. <br>
<br>
<span class="tag-color tag-color-named" data-value="gray" style="color: gray"><span class='tag-size' data-value='7' style='font-size:7pt;'>Добавлено <time class="tag-mergetime" datetime="2007-11-06T08:11:48+00:00">06.11.07, 08:11</time></span></span><br>
Предположим, что система решается методом Гаусса =&gt; это 2x50000 проходов по матрице, пусть скорость чтения с диска - 120 Мб/сек (рэйд там какой-нибудь). 18.62*1024*2*50000/120/86400=184 дня непрерывной работы. Так что нужно или долго ждать или использовать более эффективный метод...]]></description>
        <author>Pacific</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753304</guid>
        <pubDate>Mon, 05 Nov 2007 21:50:42 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753304</link>
        <description><![CDATA[Pavia: <strong class='tag-b'>Telc</strong><br>
Если ты будешь считывать из файла один элемент, то это медленно. Лучше так прочитал строчку умножил ее на элимент сохронил. Или считал две строчки произвел между ними операции сохронил результаты.<br>
<br>
Насчет вычислений. Все зависит от скорости может посчитать быстрее будет. А может и нет.]]></description>
        <author>Pavia</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753288</guid>
        <pubDate>Mon, 05 Nov 2007 21:35:35 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753288</link>
        <description><![CDATA[Telc: Нет, обойти такую проблему принципиально не получится.<br>
Вопрос по сообщению <strong class='tag-b'>nvm</strong>: как использовать?<br>
Вопрос по сообщению <strong class='tag-b'>Pavia</strong>: что будет работать быстрее: записать на диск массив и затем, по мере необходимости считывать тот или иной элемент, или вообще не запоминать массив (ни на диске ни в оперативке), а считать конкретный элемент непосредственно перед его использованием (например, надо умножить a_{i,j} на b_{j} я вызываю процедуру, которая мне посчитает этот элемент a_{i,j} и тогда я перемножу его на b_{j})?]]></description>
        <author>Telc</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753255</guid>
        <pubDate>Mon, 05 Nov 2007 21:03:36 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753255</link>
        <description><![CDATA[nvm: <div class='tag-quote'><a class='tag-quote-link' href='https://forum.sources.ru/index.php?showtopic=209002&view=findpost&p=1752936'><span class='tag-quote-prefix'>Цитата</span></a> <span class='tag-quote__quote-info'>Telc &#064; <time class="tag-quote__quoted-time" datetime="2007-11-05T14:37:20+00:00">05.11.07, 14:37</time></span><div class='quote '>Порядка 50000 уравнений (матрица квадратная, плотно заполненная).</div></div><br>
Лучше всего найти способ обойти необходимость решать такие системы - может, сам метод решения задачи изменить.<br>
Или уж кластер использовать.]]></description>
        <author>nvm</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753241</guid>
        <pubDate>Mon, 05 Nov 2007 20:43:10 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753241</link>
        <description><![CDATA[Pavia: <strong class='tag-b'>AndreyK</strong><br>
И где это вы такую глупость вычитали?<br>
<br>
<br>
<strong class='tag-b'>Telc</strong><br>
Массив на диск. Доступ по средство чатения. В память должно считываться только необходимые данные. Алгоритм обработки должен снизить число обращений к диску.<br>
<br>
Решил полной ответ написать. <br>
Для доступа к файлу есть несколько механизмов. Просто читать файл по частям в память или целеком. <br>
<br>
Можно отоброзить файл в память. Тогда можно будет работать с файлом как с памятью. Если у вас физической памяти меньше чем файл. То виндос будет выгружать часть данных из памяти а нужную подгружать. <br>
Память разбита на страницы, все страницы имеют фиксированнный размер. Так что выгрузка загрузка осуществляется страницами. Если попробовать что-то дописать. То виндоус сам расширит требуемую память. <br>
<br>
Теперь о том почему так не сделать. <br>
Во-первых в 32-битных системах есть ограничения на размер отоброжаемого файла.<br>
Ограничение это то что пользовательскому процессу дается 2ГБ виртуальной памяти, в некоторых случаях 3ГБ. Но она разбита на куски. Так что максимальный размер ограничивается размера наибольшего куска.<br>
Так что тут выход 64-битная ОС.<br>
<br>
Во-вторых Если физическая память исчерпона, то программа будет просто ужастно тормазить. Загружая/выгружая страницы памяти.<br>
<br>
Но практика показывает, что если читать файл вручную, а не отображать в память, то можно получить прирост.]]></description>
        <author>Pavia</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753231</guid>
        <pubDate>Mon, 05 Nov 2007 20:37:29 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753231</link>
        <description><![CDATA[Telc: <div class='tag-quote'><a class='tag-quote-link' href='https://forum.sources.ru/index.php?showtopic=209002&view=findpost&p=1753197'><span class='tag-quote-prefix'>Цитата</span></a> <span class='tag-quote__quote-info'>AndreyK &#064; <time class="tag-quote__quoted-time" datetime="2007-11-05T19:56:59+00:00">05.11.07, 19:56</time></span><div class='quote '>В windows создаётся страница памяти нужного размера и в ней храните свой мегамассив. ОС самостоятельно будет принимать решение о выгрузке/загрузке страницы</div></div><br>
А как это сделать? Этот вариант является наиболее оптимальным?]]></description>
        <author>Telc</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753197</guid>
        <pubDate>Mon, 05 Nov 2007 19:56:59 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1753197</link>
        <description><![CDATA[AndreyK: В windows создаётся страница памяти нужного размера и в ней храните свой мегамассив. ОС самостоятельно будет принимать решение о выгрузке/загрузке страницы]]></description>
        <author>AndreyK</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1752962</guid>
        <pubDate>Mon, 05 Nov 2007 15:05:37 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1752962</link>
        <description><![CDATA[experimenter: Круто. С наскока могу лишь предолжить опять 64-битную систему для решения сей проблемы, хотя наверняка есть более оптимальные способы. :)]]></description>
        <author>experimenter</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1752936</guid>
        <pubDate>Mon, 05 Nov 2007 14:37:20 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1752936</link>
        <description><![CDATA[Telc: Порядка 50000 уравнений (матрица квадратная, плотно заполненная).]]></description>
        <author>Telc</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1752900</guid>
        <pubDate>Mon, 05 Nov 2007 14:07:37 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1752900</link>
        <description><![CDATA[experimenter: Так, если даже 10000 уравнений, то 10^10 размерность... Вроде так-то немного, а вот &quot;проклятие размерности&quot;.<br>В файл сохранять - это не выход, по-моему. Благо виртуальная память на то и придумано, чтоб файл подкачки раздувать. Ставьте 64-битную операционку, жёсткий диск побольше и должно влазить в нёё-то.]]></description>
        <author>experimenter</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1752876</guid>
        <pubDate>Mon, 05 Nov 2007 13:36:57 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1752876</link>
        <description><![CDATA[Алкаш: <strong class='tag-b'>Telc</strong>, а какая это размерность, что в оперативку не влазит?]]></description>
        <author>Алкаш</author>
        <category>Алгоритмы</category>
      </item>
	
      <item>
        <guid isPermaLink='true'>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1752843</guid>
        <pubDate>Mon, 05 Nov 2007 13:11:00 +0000</pubDate>
        <title>Как программисты работают с большими массивами?</title>
        <link>https://forum.sources.ru/index.php?showtopic=209002&amp;view=findpost&amp;p=1752843</link>
        <description><![CDATA[Telc: До сих пор я работал со СЛАУ сравнительно небольших размерностей. Матрицы таких СЛАУ можно было размещать в оперативной памяти.<br>
<strong class='tag-b'>Матрицы плотно заполнены.</strong><br>
Вообще говоря я пока еще не знакомился с теорией, относящейся к данному вопросу, поскольку, как я уже писал, не было такой необходимости, а в университете я этого не проходил.<br>
Пока у меня есть только два решения. <br>
Первое - записывать получаемые массивы в файл, то есть размещать их на жестком диске, и запаршивать каждый элемент когда это необходимо. Тогда это может очень увеличить время счета.<br>
Второе - вообще не считать коэффициенты матрицы до тех пор, пока соответствующий элемент не  затребуется на определнном шаге алгоритма, решающего СЛАУ, и считать его только в этот момент. Тогда придется один и тот же элемент определять несколько раз, да и время счета, по-моему, не сильно будет отличаться от первого варианта (или я ошибаюсь?).<br>
В общем, вопрос задан в названии темы. Прошу поделиться опытом.]]></description>
        <author>Telc</author>
        <category>Алгоритмы</category>
      </item>
	
      </channel>
      </rss>
	