Предыстория: По электронике необходимо оптимизировать большие логические выражения. В-общем, оптимизировать-то я оптимизировал, а вот проверять лень, поскольку выражений четыре (два раза: оригинал и оптимизированное), входов X - 8. Т.е. для каждого выражения надо высчитать 256 комбинаций битов X. Итого: 2048 умственных расчётов.
Решил всё сделать синтетический тест на Ruby.

Проблема: Чтобы делать много проверок для всех комбинаций решил сделать массив этих самых комбинаций (т.е. матрицу). Примерно так:

Написал алгоритм, который должен заполнить пустую матрицу 256x8 нужными значениями. (Заполняется первый столбец наполовину нулями, наполовину - единицами. 0011. Следующий по четверти, но уже два раза. 0101)
*** размеры матрицы и значений поменял на меньшие для удобства. С нужными размерами тоже самое.


Работает цикл столько, сколько надо. Отладка выводит то, что и ожидалось:


Обратите внимание на 
Я вывожу tests[y][x], всё ок. Больше этот элемент я нигде не трогаю.
Т.е. 6:2 = 0, а 7:2 = 1.   

Ставлю теперь строчку


Что бы вы думали? 
11

Чтобы описать моё состояние, дам ссылку на картинку: http://shattl.org/i/ffuuu.jpg

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


Что бы вы думали? Компьютер с полной уверенностью пишет, что
0 is 1

Вопрос: Неужели я так сильно хочу спать, что прямо возле носа не вижу своей ошибки?

P.S. tests.each {... утверждает, что все элементы матрицы - единички.

Добавлено через 3 минуты и 26 секунд
Понимаю, что можно в тесте просто чесать от 0 до 255, разделяя i на восемь бит и отдавая их Y-выражениям. Я просто хочу уже разобраться, наконец, с этой аномалией.

Какой-то мегагемморойный способ заполнить матрицу нулями и единичками... без пол литра(и отладчика) не разберёшься.
Пожалей людей, которые твой код читать будут!!!

Лично мне первое что пришло в голову для заполнения матрицы всеми возможными комбинациями нулей и единиц по 8 штук - перебрать все числа от 0 до 255:




И никаких тебе аномалий...

Нормальное заполнение-то я сделал. Меня конкретно смущает то, что запись в элемент массива переписывает все элементы.

А алгоритм простой:
Внешний цикл - это обход столбцов.
density - это плотность заполнения, изначально равная половине количества вариантов.
Самый внутренний цикл заполняет density ячеек нулями, а потом (цикл values.each) единичками.
Для следующего ряда density уменьшается вдвое.
Примерно так:

Но поскольку каждый ряд заполнен только на density значений, я повторяю заполнение. При чём количество повторов удваивается каждый ряд


А насчёт сопровождения: я специально вынес размерность и принимаемые аргументы. Чтобы в будущем просто использовать это код без изменений. Например, чтобы получить массив всех возможных IP-адресов, достаточно задать x_from=0, x_to=3, values=(0..255).to_a

Что ж в нём нормального, если даже ты как автор не можешь понять почему он не работает корректно, а на выходе получается массив из одних единиц. Код не просто попахивает, он воняет: взять хотя бы 4 вложенных цикла для заполнения двумерного массива, за такое можно смело премии лишать.    А если серьёзно, то рефакторинг просто необходим, чтобы код стал нормальным и читаемым. 



Чего ж тебя смущает, ты ведь сам под все вложенные массивы выделил одну общую область памяти:

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


Но лучше выкинуть все 24 строки и переписать нормально весь алгоритм, чтобы код стал читабельным, а не write-only. Всё-таки Ruby - очень выразительный язык, и весьма неприятно видеть подобные примеры его использования.

Спасибо!