Варианты конвертации bool/byte/int в byte/int

@belalugoci · Регистрация: 01.06.2018

Студворк — интернет-сервис помощи студентам

В Си, если мне не изменяет память можно наоборот любые данные интерпретировать как true/false. А вот меня интересует преобразование числовых данных отличных от нуля в единицу, а нулевых значений в ноль.
Я воспользовался уже двумя реализациями (на самом деле есть еще две, но они сильно зависят от контекста и не являются универсальными), и по производительности остановился на первой:
1)

C#
1
2
3
byte x1;
byte x2;
x2 = (byte)((x1) == 0 ? 0 : 1);

2) у меня данные не могут быть более 32, поэтому такой вариант тоже возможен

C#
1
2
3
4
public static readonly byte[] BitsValue =    { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
byte x1;
byte x2;
x2 = BitsValue[x1];

Если написал сумбурно, то меня интересует код, который из любого положительного числа делает 1, а из нуля - 0. Так же как частный случай использовался такой код:

C#
1
2
3
byte x1;
byte x2;
x2 = (byte)((x1 & 8) >> 3);

Что можете подсказать ещё?

@belalugoci · 20.01.2019, 07:45 **[ТС]**

Сообщение от maximka777

второй ускоренный

вы могли бы прокомментировать ваш код, так как я не могу соотнести его со своим.

@maximka777 · 20.01.2019, 15:50

Сообщение от belalugoci

вы могли бы прокомментировать ваш код, так как я не могу соотнести его со своим.

А что конкретно не понятно ?

Добавлено через 1 час 23 минуты
Чтобы было понятнее внес как можно меньше исправлений в оригинал. Сейчас считает как в оригинале без "ошибок". countX считать не стал, просто лень уже писать код.

Кликните здесь для просмотра всего текста

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
 
namespace CalcBitsCL
{
    class Program
    {
        static object locker = new object();
 
        // это расчётные значения для работы с матрицей 5х5, но с фиксированным одним значение верхнего элемента, я тестировал со значением 0, но работает и с любым но одиночным значением
        // это большая оптимизация которая позволила резко сократить число операций, значения в массиве обозначают места для разных значений SumBits
        // идея в том, что сравнивать одни данные с другими имеет смысла только если суммы бит одинаковые, так мы сокращаем число итераций для For(Compare)
        public static readonly int[] DimIdx = { 0, 1, 21, 211, 1351, 6196, 21700, 60460, 137980, 263950, 431910, 616666, 784626, 910596, 988116, 1026876, 1042380, 1047225, 1048365, 1048555, 1048575, 1048576, 1048576, 1048576, 1048576, 1048576, 1048576 };
        public static int[] countNidx = { 0, 1, 21, 211, 1351, 6196, 21700, 60460, 137980, 263950, 431910, 616666, 784626, 910596, 988116, 1026876, 1042380, 1047225, 1048365, 1048555, 1048575, 1048576, 1048576, 1048576, 1048576, 1048576, 1048576 };
 
        public static DimBitsS[] DimBitsSN = new DimBitsS[1048576]; // число элементов матрицы 5х5, но для одного значения верхнего вектора, то есть формально 2 в двадцатой степени + 1
        public static byte SumBits = 0; // хранит сумму бит, является так же индексом для DimIdx и countNidx
 
        public static byte x1, x2, x3, x4, x5; // числа, используемые для отражения значений матрицы 5х5, x1 - верх, x5 - низ
 
        public static ulong countN = 0; public static ulong countIn = 0; public static ulong countX, old_countX; public static int num1, num2;
 
        public struct DimBitsS
        {
            public byte[] Bits; // массив сумм бит
            public int Sum; // значение SumBits сохранённое во время расчета каждого элемента
            public byte Hash; // XOR хэш
            public byte CRC8; // CRC8
 
            public int zip;
 
            public DimBitsS(int _Sum) // инициализация
            {
                this.Sum = _Sum;
                this.Hash = 0;
                this.CRC8 = 0;
                this.Bits = new byte[28];
 
                zip = 0;
            }
        }
 
        public static void Compare(int y)
        {
        }
 
        public static byte BitCount(ulong value) // считаем число бит в переменной
        {
            ulong result = value - ((value >> 1) & 0x5555555555555555UL);
            result = (result & 0x3333333333333333UL) + ((result >> 2) & 0x3333333333333333UL);
            return (byte)(unchecked(((result + (result >> 4)) & 0xF0F0F0F0F0F0F0FUL) * 0x101010101010101UL) >> 56);
        }
 
        static class CRC8 // расчет CRC8, нужно такое же, но на CRC32
        {
            static byte[] CRC8_TABLE = new byte[]{
                0, 94, 188, 226, 97, 63, 221, 131, 194, 156, 126, 32, 163, 253, 31, 65,
                157, 195, 33, 127, 252, 162, 64, 30, 95, 1, 227, 189, 62, 96, 130, 220,
                35, 125, 159, 193, 66, 28, 254, 160, 225, 191, 93, 3, 128, 222, 60, 98,
                190, 224, 2, 92, 223, 129, 99, 61, 124, 34, 192, 158, 29, 67, 161, 255,
                70, 24, 250, 164, 39, 121, 155, 197, 132, 218, 56, 102, 229, 187, 89, 7,
                219, 133, 103, 57, 186, 228, 6, 88, 25, 71, 165, 251, 120, 38, 196, 154,
                101, 59, 217, 135, 4, 90, 184, 230, 167, 249, 27, 69, 198, 152, 122, 36,
                248, 166, 68, 26, 153, 199, 37, 123, 58, 100, 134, 216, 91, 5, 231, 185,
                140, 210, 48, 110, 237, 179, 81, 15, 78, 16, 242, 172, 47, 113, 147, 205,
                17, 79, 173, 243, 112, 46, 204, 146, 211, 141, 111, 49, 178, 236, 14, 80,
                175, 241, 19, 77, 206, 144, 114, 44, 109, 51, 209, 143, 12, 82, 176, 238,
                50, 108, 142, 208, 83, 13, 239, 177, 240, 174, 76, 18, 145, 207, 45, 115,
                202, 148, 118, 40, 171, 245, 23, 73, 8, 86, 180, 234, 105, 55, 213, 139,
                87, 9, 235, 181, 54, 104, 138, 212, 149, 203, 41, 119, 244, 170, 72, 22,
                233, 183, 85, 11, 136, 214, 52, 106, 43, 117, 151, 201, 74, 20, 246, 168,
                116, 42, 200, 150, 21, 75, 169, 247, 182, 232, 10, 84, 215, 137, 107, 53 };
 
            public static byte Calculate(byte[] data, byte init = 0)
            {
                byte result = init;
                for (var i = 0; i < 20/*data.Length*/; i++) // по алгоритму конечно надо ставить data.Length, но для моего алгоритма это значение 28, а лучшую скорость даёт 20
                {
                    result = CRC8_TABLE[result ^ data[i]];
                }
                return result;
            }
        }
        class C
        {
            public int Begin, End, Zip;
            public C(int begin, int end, int zip)
            {
                Begin = begin;
                End = end;
                Zip = zip;
            }
 
            public override string ToString()
            {
                return $"{Begin} : {End} : {Zip}";
            }
        }
 
        static void Main(string[] args)
        {
 
            var ranges = new List<C>();
 
            var sw = Stopwatch.StartNew(); // запуск таймера
 
 
            int temp, old_percent = 0; // инициализация счетчиков и временных переменных
            num1 = 0; num2 = 0;
            if (num1 >= num2) num2 = num1 + 1; else num2++; // по большому счёту нужно только если первое и второе значения менять, если ничего не трогать, то можно не обращать внимание
            for (x1 = (byte)num1; x1 < (byte)num2; x1++) // первая переменная из матрицы 5х5 бит (условно верхняя)
            {
                countN = 0; countX = 0; old_countX = 0; // инициализация счетчиков
 
                for (x2 = 0; x2 < 32; x2++) // вторая переменная из матрицы
                {
                    // обновление элементов на форме, происходит только если данные изменились
                    temp = (int)((ulong)countN * (ulong)(x1 + 1) * 100 / (ulong)(Math.Pow(32, 4) * (num2 - num1))); // тут я набредил и больше не трогал, используется для вычисления шкалы ProgressBar, нормально работает для одного значения x1, по если x1 > 0 будет показывать криво
                                                                                                                    // обновление ProgressBar и Label с процентом
                                                                                                                    // порой достаточно посмотреть 50% от всей программы (это примерно 33% от всего объёма вычислений)
                    if (old_percent != temp)
                    {
                        Console.WriteLine(temp.ToString() + "%");
                        old_percent = temp;
                    }
                    for (x3 = 0; x3 < 32; x3++) // третья переменная из матрицы
                    {
                        for (x4 = 0; x4 < 32; x4++) // четвертая из матрицы
                        {
                            for (x5 = 0; x5 < 32; x5++) // пятая переменная
                            {
                                SumBits = (byte)(BitCount(x1) + BitCount(x2) + BitCount(x3) + BitCount(x4) + BitCount(x5)); // сумма сумм бит
                                DimBitsSN[countNidx[SumBits]] = new DimBitsS(SumBits); // инициализация данных в структуре
 
                                // заполнение массива в структуре
                                DimBitsSN[countNidx[SumBits]].Bits[0] = (byte)BitCount(x5); // (byte) тут нужно только если поменять логику вычисления суммы бит
                                DimBitsSN[countNidx[SumBits]].Bits[1] = (byte)BitCount(x4); // можно придумать свои варианты суммирования, например
                                DimBitsSN[countNidx[SumBits]].Bits[2] = (byte)BitCount(x3); // ((x1) == 0 ? 0 : 1)
                                DimBitsSN[countNidx[SumBits]].Bits[3] = (byte)BitCount(x2); // в таком случае оптимизации нужно подстраивать под контекст
                                DimBitsSN[countNidx[SumBits]].Bits[4] = (byte)BitCount(x1); // например для моих алгоритвом расчёта я выяснил какие именно данные чаще меняются
                                DimBitsSN[countNidx[SumBits]].Bits[5] = (byte)BitCount(x5); // и отсортировал их в этом массиве, где 0 - часто, 27 - редко
                                DimBitsSN[countNidx[SumBits]].Bits[6] = (byte)BitCount(x4);
                                DimBitsSN[countNidx[SumBits]].Bits[7] = (byte)BitCount(x3);
                                DimBitsSN[countNidx[SumBits]].Bits[8] = (byte)BitCount(x2);
                                DimBitsSN[countNidx[SumBits]].Bits[9] = (byte)BitCount(x1);
                                DimBitsSN[countNidx[SumBits]].Bits[10] = (byte)BitCount(x5);
                                DimBitsSN[countNidx[SumBits]].Bits[11] = (byte)BitCount(x4);
                                DimBitsSN[countNidx[SumBits]].Bits[12] = (byte)BitCount(x3);
                                DimBitsSN[countNidx[SumBits]].Bits[13] = (byte)BitCount(x2);
                                DimBitsSN[countNidx[SumBits]].Bits[14] = (byte)BitCount(x1);
                                DimBitsSN[countNidx[SumBits]].Bits[15] = (byte)BitCount(x5);
                                DimBitsSN[countNidx[SumBits]].Bits[16] = (byte)BitCount(x4);
                                DimBitsSN[countNidx[SumBits]].Bits[17] = (byte)BitCount(x3);
                                DimBitsSN[countNidx[SumBits]].Bits[18] = (byte)BitCount(x2);
                                DimBitsSN[countNidx[SumBits]].Bits[19] = (byte)BitCount(x1);
                                DimBitsSN[countNidx[SumBits]].Bits[20] = (byte)BitCount(x5);
                                DimBitsSN[countNidx[SumBits]].Bits[21] = (byte)BitCount(x4);
                                DimBitsSN[countNidx[SumBits]].Bits[22] = (byte)BitCount(x3);
                                DimBitsSN[countNidx[SumBits]].Bits[23] = (byte)BitCount(x2);
                                DimBitsSN[countNidx[SumBits]].Bits[24] = (byte)BitCount(x1);
                                DimBitsSN[countNidx[SumBits]].Bits[25] = (byte)BitCount(x5);
                                DimBitsSN[countNidx[SumBits]].Bits[26] = (byte)BitCount(x4);
                                DimBitsSN[countNidx[SumBits]].Bits[27] = (byte)BitCount(x3);
 
                                // заполняем CRC8
                                DimBitsSN[countNidx[SumBits]].CRC8 = CRC8.Calculate(DimBitsSN[countNidx[SumBits]].Bits);
 
                                // считаем и заполняем XOR хэш
                                for (var h = 0; h < 3; h++) DimBitsSN[countNidx[SumBits]].Hash ^= DimBitsSN[countNidx[SumBits]].Bits[h];
 
                                DimBitsSN[countNidx[SumBits]].zip = DimBitsSN[countNidx[SumBits]].Hash << 8 | DimBitsSN[countNidx[SumBits]].CRC8;
 
                                // запускаем основной цикл сравнения. Условие смотрит только за тем, чтобы проверка запускалась только если более одного значения посчитано
                                if (countN > 0 && DimIdx[SumBits] != countNidx[SumBits])
                                {
 
 
                                    ranges.Add(new C(
                                       DimIdx[SumBits],
                                       (DimIdx[SumBits] == countNidx[SumBits] ? countNidx[SumBits] + 1 : countNidx[SumBits]),
                                       DimBitsSN[countNidx[SumBits]].Hash << 8 | DimBitsSN[countNidx[SumBits]].CRC8)
                                       );
 
 
 
                                    //for (var i = DimIdx[SumBits]; i < (DimIdx[SumBits] == countNidx[SumBits] ? countNidx[SumBits] + 1 : countNidx[SumBits]); i++)
                                    //{
                                    //    if (DimBitsSN[countNidx[SumBits]].Hash == DimBitsSN[i].Hash)
                                    //    {   // этот хэш простой XOR, число переменных выбирается
                                    //        // в BackgroundThreadFunc() до вызова For(Compare),
                                    //        // текущее значение выбрано опытным путём
                                    //        if (DimBitsSN[countNidx[SumBits]].CRC8 == DimBitsSN[i].CRC8) // функция взята с одной из тем Cyberforum
                                    //                                                                     // тоже не иду по всем byte[], значение подобрано
                                    //        {
                                    //            countIn++; // так увидим число входов, оно определяет продолжительность вычислений
                                    //            for (var n = 0; n < 24; n++)
                                    //            {
                                    //                if (DimBitsSN[countNidx[SumBits]].Bits[n] == DimBitsSN[i].Bits[n])
                                    //                // если прошли через хэши, то проверяем от частого к редкому и отлавливаем совпавшие
                                    //                {
                                    //                    countX++; // число совпавших
                                    //                }
                                    //            }
                                    //        }
                                    //    }
                                    //}
 
 
 
 
 
                                }
 
                                countN++; // общее число итераций
                                countNidx[SumBits]++; // движение указателей на данные
                            }
                        }
                    }
                }
                //sw.Stop(); // таймер времени выполнения программы
                //Console.WriteLine(countIn.ToString() + " : " + countX.ToString() + " : " + sw.Elapsed.ToString());
 
            }
 
 
            foreach (var group in ranges.GroupBy(x => x.Begin))
            {
                int i = group.Key;
 
                ulong[] data = new ulong[1 << 16];
 
                foreach (var item in group.OrderBy(x => x.End))
                {
                    for (; i < item.End; i++)
                    {
                        data[DimBitsSN[i].zip]++;
                    }
                    countIn += data[item.Zip];
                }
            }
 
 
 
 
            sw.Stop(); // таймер времени выполнения программы
 
            Console.WriteLine(countIn.ToString() + " : " + countX.ToString() + " : " + sw.Elapsed.ToString());
 
 
            Console.WriteLine("Цимес!!! Прес эни кий ту континью...");
            Console.ReadKey();
        }
    }
}

@belalugoci · 20.01.2019, 16:18 **[ТС]**

Сообщение от maximka777

ranges.Add

Сообщение от maximka777

foreach (var group in ranges.GroupBy(x => x.Begin))

я не понимаю что именно вы делаете в этих двух блоках.

@maximka777 · 20.01.2019, 17:17

Сообщение от belalugoci

ranges.Add

собираю хэши массивов и диапазоны циклов в лист.

Сообщение от belalugoci

foreach (var group in ranges.GroupBy(x => x.Begin))

группирую их по начальному значению диапазона цикла.

@belalugoci · 20.01.2019, 17:33 **[ТС]**

Сообщение от maximka777

группирую их по начальному значению диапазона цикла.

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

Someone007 · 20.01.2019, 17:43

belalugoci, в чем суть вашего алгоритма? По факту вы тут просто считаете сколько одинаковых байтов в массивах между индексами, вычисленными по только вам понятному алгоритму... Обязательно байты по отдельности считать? Что если сравнивать массивы целиком, а не по байтно?

@maximka777 · 20.01.2019, 17:58

Сообщение от belalugoci

куда важнее произвести сравнение каждого с каждым чтобы найти совпадения и я этого не вижу в вашем коде

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

Сообщение от belalugoci

возможно объединение хэшей в одну переменную ласт прирост в скорости, но это будет локальное решение, до внедрения Crc32.

Там не важно какой хэш, на скорость это почти не повлияет.

@belalugoci · 20.01.2019, 18:31 **[ТС]**

Сообщение от maximka777

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

Ну а как иначе? Если вы не повторяете алгоритм, то у вас априори не будут те же результаты работы программы.

Сообщение от maximka777

Там не важно какой хэш, на скорость это почти не повлияет.

Основная идея хэша - давать одинаковый хэш при одинаковых данных и максимально снизить коллизии, это позволяет для большой выборки данных сократить число итераций. Сейчас хэш 8 бит, что дает 20 млн коллизий при 8448 конечных данных. Мне кажется тут есть что улучшать.

Добавлено через 6 минут

Сообщение от Someone007

в чем суть вашего алгоритма?

представление одних данных другими. происходит через определенные операции с битами.

Сообщение от Someone007

По факту вы тут просто считаете сколько одинаковых байтов в массивах между индексами

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

Сообщение от Someone007

Обязательно байты по отдельности считать? Что если сравнивать массивы целиком, а не по байтно?

Не обязательно если вы знаете другие способы.
Мне казалось любые последовательные данные при любых вариантах так или иначе будут сравниваться поэлементно. Максимум что можно сделать это укрупнить сами элементы, например вместо byte использовать ulong, в котором упакованы byte. В чем ваша идея?

Someone007 · 20.01.2019, 18:33

belalugoci, у меня при использовании 64 битного хэша получается другой результат, а именно 2015854720 итераций, что совпадает с результатом полученным maximka777, причем всего за секунду времени (с 64 битным хэшем у меня считает все те же 2.5 минуты...)
Из чего следует что ваш xor хэш и crc8 дает слишком много коллизий, из-за чего получается неверный результат.

@belalugoci · 20.01.2019, 18:36 **[ТС]**

Сообщение от Someone007

в чем суть вашего алгоритма?

условно есть две матрицы
0, 15, 3, 7, 12
и
0, 11, 22, 10, 4
видно что данные разные, но результат работы алгоритма может дать две одинаковые последовательности из 28 байт. именно такие коллизии я отлавливаю. сейчас на 20 бит это 8448 коллизий (1048576 элементов всего или 0,008%), что лучше моего самого первого алгоритма, там было 40%.

Someone007 · 20.01.2019, 18:42

Сообщение от belalugoci

0, 15, 3, 7, 12
и
0, 11, 22, 10, 4
видно что данные разные, но результат работы алгоритма может дать две одинаковые последовательности из 28 байт

Каким образом вы из этих данных получили 2 одинаковы последовательности из 28 байт? У меня не выходит...

@belalugoci · 20.01.2019, 18:46 **[ТС]**

Сообщение от Someone007

неверный результат.

что вы понимаете под этим?
неверный результат - это когда в результате работы программы я не получаю один и тот же массив коллизий моего алгоритма.
в коде maximka777 я не вижу результатов работы алгоритма, нет сравнений (или они есть но мне не хватает мозгов их понять).
Он считает countIn, который показывает сколько раз происходило сравнение данных, а я считаю countX, который показывает число коллизий моего алгоритма.
если ваш countIn и countIn maximka777 совпадают, то это лишь говорит о том, что вы используете такой алгоритм хэширования, который дает одинаковое число коллизий хэша, но работа программы не ставит целью считать хэши, это лишь инструмент для сокращения числа итераций.

Добавлено через 37 секунд

Сообщение от Someone007

Каким образом вы из этих данных получили 2 одинаковы последовательности из 28 байт? У меня не выходит...

у вас же нет алгоритма.

Добавлено через 1 минуту

Сообщение от Someone007

у меня при использовании 64 битного хэша получается другой результат

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

@maximka777 · 20.01.2019, 18:46

Сообщение от belalugoci

сейчас на 20 бит это 8448 коллизий (1048576 элементов всего или 0,008%), что лучше моего самого первого алгоритма, там было 40%.

Дак возьмите хэш на 128бит , и будет вообще здорово , коллизии просо исчезнут.

Someone007 · 20.01.2019, 18:47

Сообщение от belalugoci

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

maximka777 вообще никаких хэшей не использует, а я использовал, результат одинаковый...

@belalugoci · 20.01.2019, 18:49 **[ТС]**

Сообщение от maximka777

Дак возьмите хэш на 128бит , и будет вообще здорово , коллизии просо исчезнут.

как только найду то что смогу использовать - использую.

Сообщение от Someone007

maximka777 вообще никаких хэшей не использует, а я использовал, результат одинаковый...

результат чего?

Someone007 · 20.01.2019, 19:01

Сообщение от belalugoci

результат чего?

Работы программы, очевидно же.

Сообщение от belalugoci

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

Алгоритм хэша отсюда https://github.com/differentra... /XXHash.cs

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
using System;
using static System.Threading.Tasks.Parallel;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Runtime.InteropServices;
using YYProject.XXHash;
//using System.Runtime.CompilerServices;
 
namespace CalcBitsCL
{
    class Program
    {
        static object lockObj = new object();
 
        // это расчётные значения для работы с матрицей 5х5, но с фиксированным одним значение верхнего элемента, я тестировал со значением 0, но работает и с любым но одиночным значением
        // это большая оптимизация которая позволила резко сократить число операций, значения в массиве обозначают места для разных значений SumBits
        // идея в том, что сравнивать одни данные с другими имеет смысла только если суммы бит одинаковые, так мы сокращаем число итераций для For(Compare)
        public static readonly int[] DimIdx = { 0, 1, 21, 211, 1351, 6196, 21700, 60460, 137980, 263950, 431910, 616666, 784626, 910596, 988116, 1026876, 1042380, 1047225, 1048365, 1048555, 1048575, 1048576, 1048576, 1048576, 1048576, 1048576, 1048576 };
        public static int[] countNidx = { 0, 1, 21, 211, 1351, 6196, 21700, 60460, 137980, 263950, 431910, 616666, 784626, 910596, 988116, 1026876, 1042380, 1047225, 1048365, 1048555, 1048575, 1048576, 1048576, 1048576, 1048576, 1048576, 1048576 };
 
        public static DimBitsS[] DimBitsSN = new DimBitsS[1048576]; // число элементов матрицы 5х5, но для одного значения верхнего вектора, то есть формально 2 в двадцатой степени + 1
        //public static byte SumBits = 0; // хранит сумму бит, является так же индексом для DimIdx и countNidx
 
        //public static byte x1, x2, x3, x4, x5; // числа, используемые для отражения значений матрицы 5х5, x1 - верх, x5 - низ
 
        //public static ulong countN = 0;
        //public static ulong countIn = 0;
        //public static ulong countX, old_countX;
        //public static int num1, num2;
 
        public unsafe struct DimBitsS
        {
            public byte[] Bits; // массив сумм бит
            //public fixed byte Bits[28];
            public int Sum; // значение SumBits сохранённое во время расчета каждого элемента
            //public byte Hash; // XOR хэш
            //public byte CRC8; // CRC8
            public ulong Hash64;
 
            public DimBitsS(int _Sum, byte[] bits) // инициализация
            //public DimBitsS(int _Sum) // инициализация
            {
                this.Sum = _Sum;
                //this.Hash = 0;
                //this.CRC8 = 0;
                Bits = bits;
                Hash64 = 0;
            }
        }
 
        public static void Compare(int y)
        {
        }
 
        public static byte BitCount64(ulong value) // считаем число бит в переменной
        {
            ulong result = value - ((value >> 1) & 0x5555555555555555UL);
            result = (result & 0x3333333333333333UL) + ((result >> 2) & 0x3333333333333333UL);
            return (byte)(unchecked(((result + (result >> 4)) & 0xF0F0F0F0F0F0F0FUL) * 0x101010101010101UL) >> 56);
        }
 
        //static byte NumberOfSetBitsInt32(int i)
        //{
        //    i = i - ((i >> 1) & 0x55555555);
        //    i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
        //    return (byte)(unchecked(((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24);
        //}
 
        //static class CRC8 // расчет CRC8, нужно такое же, но на CRC32
        //{
        //    static byte[] CRC8_TABLE = new byte[]{
        //        0, 94, 188, 226, 97, 63, 221, 131, 194, 156, 126, 32, 163, 253, 31, 65,
        //        157, 195, 33, 127, 252, 162, 64, 30, 95, 1, 227, 189, 62, 96, 130, 220,
        //        35, 125, 159, 193, 66, 28, 254, 160, 225, 191, 93, 3, 128, 222, 60, 98,
        //        190, 224, 2, 92, 223, 129, 99, 61, 124, 34, 192, 158, 29, 67, 161, 255,
        //        70, 24, 250, 164, 39, 121, 155, 197, 132, 218, 56, 102, 229, 187, 89, 7,
        //        219, 133, 103, 57, 186, 228, 6, 88, 25, 71, 165, 251, 120, 38, 196, 154,
        //        101, 59, 217, 135, 4, 90, 184, 230, 167, 249, 27, 69, 198, 152, 122, 36,
        //        248, 166, 68, 26, 153, 199, 37, 123, 58, 100, 134, 216, 91, 5, 231, 185,
        //        140, 210, 48, 110, 237, 179, 81, 15, 78, 16, 242, 172, 47, 113, 147, 205,
        //        17, 79, 173, 243, 112, 46, 204, 146, 211, 141, 111, 49, 178, 236, 14, 80,
        //        175, 241, 19, 77, 206, 144, 114, 44, 109, 51, 209, 143, 12, 82, 176, 238,
        //        50, 108, 142, 208, 83, 13, 239, 177, 240, 174, 76, 18, 145, 207, 45, 115,
        //        202, 148, 118, 40, 171, 245, 23, 73, 8, 86, 180, 234, 105, 55, 213, 139,
        //        87, 9, 235, 181, 54, 104, 138, 212, 149, 203, 41, 119, 244, 170, 72, 22,
        //        233, 183, 85, 11, 136, 214, 52, 106, 43, 117, 151, 201, 74, 20, 246, 168,
        //        116, 42, 200, 150, 21, 75, 169, 247, 182, 232, 10, 84, 215, 137, 107, 53 };
 
        //    public static unsafe byte Calculate(byte* data, byte init = 0)
        //    {
        //        byte result = init;
        //        //for (var i = 0; i < 20/*data.Length*/; i++) // по алгоритму конечно надо ставить data.Length, но для моего алгоритма это значение 28, а лучшую скорость даёт 20
        //        //{
        //        //    result = CRC8_TABLE[result ^ data[i]];
        //        //}
        //        for (var i = 0; i < 5/*data.Length*/; i++) // по алгоритму конечно надо ставить data.Length, но для моего алгоритма это значение 28, а лучшую скорость даёт 20
        //        {
        //            result = CRC8_TABLE[result ^ data[i * 4 + 0]];
        //            result = CRC8_TABLE[result ^ data[i * 4 + 1]];
        //            result = CRC8_TABLE[result ^ data[i * 4 + 2]];
        //            result = CRC8_TABLE[result ^ data[i * 4 + 3]];
        //        }
        //        return result;
        //    }
        //}
 
        //static unsafe void SetBits(byte* dest, byte b5, byte b4, byte b3, byte b2, byte b1)
        //{
        //    int* pDest = (int*)dest;
 
        //    *pDest = b5 | b4 << 8 | b3 << 16 | b2 << 24;
        //    pDest++;
 
        //    *pDest = b1 | b5 << 8 | b4 << 16 | b3 << 24;
        //    pDest++;
 
        //    *pDest = b2 | b1 << 8 | b5 << 16 | b4 << 24;
        //    pDest++;
 
        //    *pDest = b3 | b2 << 8 | b1 << 16 | b5 << 24;
        //    pDest++;
 
        //    *pDest = b4 | b3 << 8 | b2 << 16 | b1 << 24;
        //    pDest++;
 
        //    *pDest = b5 | b4 << 8 | b3 << 16 | b2 << 24;
        //    pDest++;
 
        //    *pDest = b1 | b5 << 8 | b4 << 16 | b3 << 24;
        //}
 
        static unsafe void Main(string[] args)
        {
            int temp, old_percent = 0; // инициализация счетчиков и временных переменных
            int num1 = 0, num2 = 0;
 
            if (num1 >= num2)
                num2 = num1 + 1;
            else
                num2++; // по большому счёту нужно только если первое и второе значения менять, если ничего не трогать, то можно не обращать внимание
 
            ulong countN, countX, countIn = 0;
 
            //byte hash = 0, crc = 0;
 
            byte* bitCounts = stackalloc byte[256];
 
            for (byte i = 0; i < 255; i++)
                bitCounts[i] = BitCount64(i);
 
            XXHash64 xxHash = XXHash64.Create();
 
            for (byte x1 = (byte)num1; x1 < (byte)num2; x1++) // первая переменная из матрицы 5х5 бит (условно верхняя)
            {
                countN = 0; countX = 0; // инициализация счетчиков
                var sw = Stopwatch.StartNew(); // запуск таймера
                for (byte x2 = 0; x2 < 32; x2++) // вторая переменная из матрицы
                {
                    // обновление элементов на форме, происходит только если данные изменились
                    temp = (int)((ulong)countN * (ulong)(x1 + 1) * 100 / (ulong)(Math.Pow(32, 4) * (num2 - num1))); // тут я набредил и больше не трогал, используется для вычисления шкалы ProgressBar, нормально работает для одного значения x1, по если x1 > 0 будет показывать криво
                                                                                                                    // обновление ProgressBar и Label с процентом
                                                                                                                    // порой достаточно посмотреть 50% от всей программы (это примерно 33% от всего объёма вычислений)
                    if (old_percent != temp)
                    {
                        Console.WriteLine(temp.ToString() + "%");
                        old_percent = temp;
                    }
 
                    for (byte x3 = 0; x3 < 32; x3++) // третья переменная из матрицы
                    {
                        for (byte x4 = 0; x4 < 32; x4++) // четвертая из матрицы
                        {
                            for (byte x5 = 0; x5 < 32; x5++) // пятая переменная
                            {
                                byte x1c = bitCounts[x1];
                                byte x2c = bitCounts[x2];
                                byte x3c = bitCounts[x3];
                                byte x4c = bitCounts[x4];
                                byte x5c = bitCounts[x5];
 
                                byte sum1 = (byte)(bitCounts[0] + bitCounts[15] + bitCounts[3] + bitCounts[7] + bitCounts[12]);
                                byte sum2 = (byte)(bitCounts[0] + bitCounts[11] + bitCounts[22] + bitCounts[10] + bitCounts[4]);
 
                                byte SumBits = (byte)(x1c + x2c + x3c + x4c + x5c); // сумма сумм бит
                                ref int tempIndex = ref countNidx[SumBits];
 
                                // заполнение массива в структуре
                                byte[] bitsArray = new byte[] { x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c };
                                //byte* bitsArray = stackalloc byte[] { x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c };
 
                                //ref DimBitsS dimBits = ref DimBitsSN[tempIndex];
 
                                //dimBits = new DimBitsS(SumBits, bitsArray); // инициализация данных в структуре
 
                                DimBitsSN[tempIndex] = new DimBitsS(SumBits, bitsArray); // инициализация данных в структуре
                                //DimBitsSN[tempIndex] = new DimBitsS(SumBits); // инициализация данных в структуре
 
                                ref DimBitsS dimBits = ref DimBitsSN[tempIndex];
 
                                xxHash.ComputeHash(bitsArray);
                                ulong hash64 = dimBits.Hash64 = xxHash.HashUInt64;
 
                                //fixed (byte* bits = bitsArray)
                                ////fixed (byte* bits = dimBits.Bits)
                                //{
                                //    //SetBits(bits, x5c, x4c, x3c, x2c, x1c);
 
                                //    //Unsafe.CopyBlock(bits, bitsArray, 28);
 
                                //    // заполняем CRC8
                                //    crc = dimBits.CRC8 = CRC8.Calculate(bits);
 
                                //    // считаем и заполняем XOR хэш
                                //    hash = 0;
                                //    for (var h = 0; h < 3; h++)
                                //        hash ^= bits[h];
                                //    dimBits.Hash = hash;
                                //}
 
                                //fixed (byte* bits = bitsArray)
                                //{
                                //    // заполняем CRC8
                                //    dimBits.CRC8 = CRC8.Calculate(bits);
 
                                //    // считаем и заполняем XOR хэш
                                //    for (var h = 0; h < 3; h++)
                                //        dimBits.Hash ^= bits[h];
                                //}
 
                                // запускаем основной цикл сравнения. Условие смотрит только за тем, чтобы проверка запускалась только если более одного значения посчитано
                                int dimIdxStart = DimIdx[SumBits];
 
                                if (countN > 0 && dimIdxStart != tempIndex)
                                {
                                    int dimIdxEnd = (dimIdxStart == tempIndex ? tempIndex + 1 : tempIndex);
 
                                    for (int i = dimIdxStart; i < dimIdxEnd; i++)
                                    {
                                        ref DimBitsS dimBits2 = ref DimBitsSN[i];
                                        byte[] bitsArray2 = dimBits2.Bits;
 
                                        //if (hash == dimBits2.Hash)
                                        //{   // этот хэш простой XOR, число переменных выбирается
                                        //    // в BackgroundThreadFunc() до вызова For(Compare),
                                        //    // текущее значение выбрано опытным путём
                                        //    if (crc == dimBits2.CRC8) // функция взята с одной из тем Cyberforum
                                        //                              // тоже не иду по всем byte[], значение подобрано
                                        //    {
                                        //        countIn++; // так увидим число входов, оно определяет продолжительность вычислений
 
                                        //        fixed (byte* pBits1 = bitsArray)
                                        //        fixed (byte* pBits2 = bitsArray2)
                                        //        //fixed (byte* pBits1 = dimBits.Bits)
                                        //        //fixed (byte* pBits2 = dimBits2.Bits)
                                        //        {
                                        //            for (int n = 0; n < 24; n++)
                                        //            {
                                        //                // если прошли через хэши, то проверяем от частого к редкому и отлавливаем совпавшие
                                        //                if (pBits1[n] == pBits2[n])
                                        //                {
                                        //                    countX++; // число совпавших
                                        //                }
                                        //            }
                                        //        }
                                        //    }
                                        //}
 
                                        if (hash64 == dimBits2.Hash64)
                                        {
                                            countIn++; // так увидим число входов, оно определяет продолжительность вычислений
 
                                            fixed (byte* pBits1 = bitsArray)
                                            fixed (byte* pBits2 = bitsArray2)
                                            //fixed (byte* pBits1 = dimBits.Bits)
                                            //fixed (byte* pBits2 = dimBits2.Bits)
                                            {
                                                for (int n = 0; n < 24; n++)
                                                {
                                                    // если прошли через хэши, то проверяем от частого к редкому и отлавливаем совпавшие
                                                    if (pBits1[n] == pBits2[n])
                                                    {
                                                        countX++; // число совпавших
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
 
                                countN++; // общее число итераций
                                tempIndex++; // движение указателей на данные
                            }
                        }
                    }
                }
                sw.Stop(); // таймер времени выполнения программы
                Console.WriteLine(countN + " : " + countIn + " : " + countX + " : " + sw.Elapsed);
            }
            Console.WriteLine("Цимес!!! Прес эни кий ту континью...");
            Console.ReadKey();
        }
    }
}

@belalugoci · 20.01.2019, 19:23 **[ТС]**

Сообщение от Someone007

Работы программы, очевидно же.

Вы какую переменную считаете таким результатом?

Someone007 · 20.01.2019, 19:26

Сообщение от belalugoci

Вы какую переменную считаете таким результатом?

countX

@belalugoci · 20.01.2019, 19:30 **[ТС]**

Сообщение от Someone007

countX

но maximka777 её не считает совсем. с чем вы тогда сравниваете?

Someone007 · 20.01.2019, 19:47

Сообщение от belalugoci

но maximka777 её не считает совсем. с чем вы тогда сравниваете?

Значит я уже запутался с вашими переменными. Я сейчас поменял код и у меня теперь countIn и countX всегда равны.

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
using System;
using static System.Threading.Tasks.Parallel;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Runtime.InteropServices;
using YYProject.XXHash;
//using System.Runtime.CompilerServices;
 
namespace CalcBitsCL
{
    class Program
    {
        static object lockObj = new object();
 
        // это расчётные значения для работы с матрицей 5х5, но с фиксированным одним значение верхнего элемента, я тестировал со значением 0, но работает и с любым но одиночным значением
        // это большая оптимизация которая позволила резко сократить число операций, значения в массиве обозначают места для разных значений SumBits
        // идея в том, что сравнивать одни данные с другими имеет смысла только если суммы бит одинаковые, так мы сокращаем число итераций для For(Compare)
        public static readonly int[] DimIdx = { 0, 1, 21, 211, 1351, 6196, 21700, 60460, 137980, 263950, 431910, 616666, 784626, 910596, 988116, 1026876, 1042380, 1047225, 1048365, 1048555, 1048575, 1048576, 1048576, 1048576, 1048576, 1048576, 1048576 };
        public static int[] countNidx = { 0, 1, 21, 211, 1351, 6196, 21700, 60460, 137980, 263950, 431910, 616666, 784626, 910596, 988116, 1026876, 1042380, 1047225, 1048365, 1048555, 1048575, 1048576, 1048576, 1048576, 1048576, 1048576, 1048576 };
 
        public static DimBitsS[] DimBitsSN = new DimBitsS[1048576]; // число элементов матрицы 5х5, но для одного значения верхнего вектора, то есть формально 2 в двадцатой степени + 1
        //public static byte SumBits = 0; // хранит сумму бит, является так же индексом для DimIdx и countNidx
 
        //public static byte x1, x2, x3, x4, x5; // числа, используемые для отражения значений матрицы 5х5, x1 - верх, x5 - низ
 
        //public static ulong countN = 0;
        //public static ulong countIn = 0;
        //public static ulong countX, old_countX;
        //public static int num1, num2;
 
        public unsafe struct DimBitsS
        {
            public byte[] Bits; // массив сумм бит
            public int Sum; // значение SumBits сохранённое во время расчета каждого элемента
            public ulong Hash64;
 
            public DimBitsS(int _Sum, byte[] bits) // инициализация
            {
                this.Sum = _Sum;
                Bits = bits;
                Hash64 = 0;
            }
        }
 
        public static void Compare(int y)
        {
        }
 
        public static byte BitCount64(ulong value) // считаем число бит в переменной
        {
            ulong result = value - ((value >> 1) & 0x5555555555555555UL);
            result = (result & 0x3333333333333333UL) + ((result >> 2) & 0x3333333333333333UL);
            return (byte)(unchecked(((result + (result >> 4)) & 0xF0F0F0F0F0F0F0FUL) * 0x101010101010101UL) >> 56);
        }
 
        static unsafe void Main(string[] args)
        {
            int temp, old_percent = 0; // инициализация счетчиков и временных переменных
            int num1 = 0, num2 = 0;
 
            if (num1 >= num2)
                num2 = num1 + 1;
            else
                num2++; // по большому счёту нужно только если первое и второе значения менять, если ничего не трогать, то можно не обращать внимание
 
            ulong countN, countX, countIn = 0;
 
            byte* bitCounts = stackalloc byte[256];
 
            for (byte i = 0; i < 255; i++)
                bitCounts[i] = BitCount64(i);
 
            XXHash64 xxHash = XXHash64.Create();
 
            for (byte x1 = (byte)num1; x1 < (byte)num2; x1++) // первая переменная из матрицы 5х5 бит (условно верхняя)
            {
                countN = 0; countX = 0; // инициализация счетчиков
                var sw = Stopwatch.StartNew(); // запуск таймера
                for (byte x2 = 0; x2 < 32; x2++) // вторая переменная из матрицы
                {
                    // обновление элементов на форме, происходит только если данные изменились
                    temp = (int)((ulong)countN * (ulong)(x1 + 1) * 100 / (ulong)(Math.Pow(32, 4) * (num2 - num1))); // тут я набредил и больше не трогал, используется для вычисления шкалы ProgressBar, нормально работает для одного значения x1, по если x1 > 0 будет показывать криво
                                                                                                                    // обновление ProgressBar и Label с процентом
                                                                                                                    // порой достаточно посмотреть 50% от всей программы (это примерно 33% от всего объёма вычислений)
                    if (old_percent != temp)
                    {
                        Console.WriteLine(temp.ToString() + "%");
                        old_percent = temp;
                    }
 
                    for (byte x3 = 0; x3 < 32; x3++) // третья переменная из матрицы
                    {
                        for (byte x4 = 0; x4 < 32; x4++) // четвертая из матрицы
                        {
                            for (byte x5 = 0; x5 < 32; x5++) // пятая переменная
                            {
                                byte x1c = bitCounts[x1];
                                byte x2c = bitCounts[x2];
                                byte x3c = bitCounts[x3];
                                byte x4c = bitCounts[x4];
                                byte x5c = bitCounts[x5];
 
                                byte sum1 = (byte)(bitCounts[0] + bitCounts[15] + bitCounts[3] + bitCounts[7] + bitCounts[12]);
                                byte sum2 = (byte)(bitCounts[0] + bitCounts[11] + bitCounts[22] + bitCounts[10] + bitCounts[4]);
 
                                byte SumBits = (byte)(x1c + x2c + x3c + x4c + x5c); // сумма сумм бит
                                ref int tempIndex = ref countNidx[SumBits];
 
                                // заполнение массива в структуре
                                byte[] bitsArray = new byte[] { x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c, x2c, x1c, x5c, x4c, x3c, 0, 0, 0, 0 };
 
                                DimBitsSN[tempIndex] = new DimBitsS(SumBits, bitsArray); // инициализация данных в структуре
 
                                ref DimBitsS dimBits = ref DimBitsSN[tempIndex];
 
                                xxHash.ComputeHash(bitsArray);
                                ulong hash64 = dimBits.Hash64 = xxHash.HashUInt64;
 
                                // запускаем основной цикл сравнения. Условие смотрит только за тем, чтобы проверка запускалась только если более одного значения посчитано
                                int dimIdxStart = DimIdx[SumBits];
 
                                if (countN > 0 && dimIdxStart != tempIndex)
                                {
                                    int dimIdxEnd = (dimIdxStart == tempIndex ? tempIndex + 1 : tempIndex);
 
                                    for (int i = dimIdxStart; i < dimIdxEnd; i++)
                                    {
                                        ref DimBitsS dimBits2 = ref DimBitsSN[i];
                                        byte[] bitsArray2 = dimBits2.Bits;
 
                                        if (hash64 == dimBits2.Hash64)
                                        {
                                            countIn++; // так увидим число входов, оно определяет продолжительность вычислений
 
                                            fixed (byte* pBits1 = bitsArray)
                                            fixed (byte* pBits2 = bitsArray2)
                                            {
                                                ulong* uBits1 = (ulong*)pBits1;
                                                ulong* uBits2 = (ulong*)pBits2;
 
                                                if (uBits1[0] != uBits2[0] || uBits1[1] != uBits2[1] || uBits1[2] != uBits2[2] || uBits1[3] != uBits2[3])
                                                    continue;
 
                                                countX++;
                                            }
                                        }
                                    }
                                }
 
                                countN++; // общее число итераций
                                tempIndex++; // движение указателей на данные
                            }
                        }
                    }
                }
                sw.Stop(); // таймер времени выполнения программы
                Console.WriteLine(countN + " : " + countIn + " : " + countX + " : " + sw.Elapsed);
            }
            Console.WriteLine("Цимес!!! Прес эни кий ту континью...");
            Console.ReadKey();
        }
    }
}

Новые блоги и статьи Все статьи Все блоги /
сукцессия 33. открытые вопросы от клауде anaschu 19.07.2026 "Что накопилось за эту часть А — тринадцать правок, из которых шесть пришли из ваших вопросов и каждая оказалась реальной ошибкой, а не калибровкой: односторонний симбиоз, отсутствующий листопад,. . .	32 сукцессия anaschu 19.07.2026 сукцессия 28‑мерное ядро стабилизировано Коллеги, фиксирую разбор инженерных правок и их изоморфную проекцию на экономику, меметику и половой отбор. Модель теперь не «подкручивает» сходимость —. . .	сукцессия 31: модель микоризы - это модель ещё нескольких явлений, социальных и экономических anaschu 18.07.2026 Теория «Всего»: апдейт v1. 1. 2 — 28‑мерное ядро стабилизировано Коллеги, фиксирую разбор инженерных правок и их изоморфную проекцию на экономику, меметику и половой отбор. Модель теперь не. . .	сукцессия 30. Массив проверяющих друг друга моделей anaschu 18.07.2026 Архитектура сети взаимопроверяющих моделей микоризной сукцессии (v2. 0) Развитие тензорного ОДУ-ядра и создание кросс-платформенного калибровочного полигона Уважаемые коллеги! В продолжение. . .
Грибы - это женщины, деревья - это мужчины. Анти инь янь для союза мужчины и женщины. anaschu 18.07.2026 ГЛАВНЫЙ НАУЧНО-ФИЛОСОФСКИЙ ВЫВОД: Сексуально-Репродуктивный Капитализм против Государства Моногамии Коллеги, мы вышли на финишную прямую 20-мерного ОДУ-моделирования вековой сукцессии (ветка. . .	Текстовый слайдер с нумерацией страниц и кроссбраузерность. russiannick 18.07.2026 Один мой друг написал текстовый слайдер с нумерацией страниц. Сегодня я расскажу как он умудрился подружить его с кроссбраузерностью. Очевидно сложно угодить с шириной каждому браузеру. Один крадет. . .	Грибы - это мемы, дерево - это человек. Применение микоризной модели к теории меметики Докинза. anaschu 18.07.2026 Меметический изоморфизм теории «всего»: Грибная сукцессия как модель эволюции идей Докинза Базовый код системы ОДУ микоризной сукцессии описывает не просто биологию, а универсальную. . .	Грибы - это корпорации, деревья - это государства. Механизм массонского захвата власти anaschu 18.07.2026 Макроэкономический изоморфизм теории «всего»: Грибная сукцессия как модель транснационального капитализма Базовый код системы ОДУ микоризной сукцессии описывает не просто биологию, а. . .

Someone007 6691 / 4102 / 1607 Регистрация: 09.05.2015 Сообщений: 9,576
	20.01.2019, 17:43
	belalugoci, в чем суть вашего алгоритма? По факту вы тут просто считаете сколько одинаковых байтов в массивах между индексами, вычисленными по только вам понятному алгоритму... Обязательно байты по отдельности считать? Что если сравнивать массивы целиком, а не по байтно? 0

Someone007 6691 / 4102 / 1607 Регистрация: 09.05.2015 Сообщений: 9,576
	20.01.2019, 18:33
	belalugoci, у меня при использовании 64 битного хэша получается другой результат, а именно 2015854720 итераций, что совпадает с результатом полученным maximka777, причем всего за секунду времени (с 64 битным хэшем у меня считает все те же 2.5 минуты...) Из чего следует что ваш xor хэш и crc8 дает слишком много коллизий, из-за чего получается неверный результат. 0