подскажите пожалуйста как выполнить цикл

for(i=0 i<ZNACHENIE; i++)
{
  ....
}

где значение это 42 битное число??

Здравствуйте, emergenter, Вы писали:

E>подскажите пожалуйста как выполнить цикл


E>

E>for(i=0 i<ZNACHENIE; i++)
E>{
E>  ....
E>}
E>

E>где значение это 42 битное число??

В этом случае и i должно быть не менее чем 42 бит, если компилятор поддерживает
64х битные переменные (__int64 или long long) то просто используйте их.

Если нет то можно реализовать с использованием двух 32-х битных

Здравствуйте, emergenter, Вы писали:

E>

E>for(i=0 i<ZNACHENIE; i++)
E>{
E>  ....
E>}
E>

От нуля до четырёх квадриллионов...
Ууу

Здравствуйте, maq, Вы писали:

maq>Здравствуйте, emergenter, Вы писали:

E>>подскажите пожалуйста как выполнить цикл


E>>

E>>for(i=0 i<ZNACHENIE; i++)
E>>{
E>>  ....
E>>}
E>>

E>>где значение это 42 битное число??

maq>В этом случае и i должно быть не менее чем 42 бит, если компилятор поддерживает
maq>64х битные переменные (__int64 или long long) то просто используйте их.

maq>Если нет то можно реализовать с использованием двух 32-х битных
А можно и адщфе использовать, если использовать в качестве индекса не нужно.

LVV>А можно и адщфе использовать, если использовать в качестве индекса не нужно.

float...

Здравствуйте, LaptevVV, Вы писали:

E>>>подскажите пожалуйста как выполнить цикл

E>>>

E>>>for(i=0 i<ZNACHENIE; i++)
E>>>{
E>>>  ....
E>>>}
E>>>

E>>>где значение это 42 битное число??

maq>>В этом случае и i должно быть не менее чем 42 бит, если компилятор поддерживает
maq>>64х битные переменные (__int64 или long long) то просто используйте их.

maq>>Если нет то можно реализовать с использованием двух 32-х битных
LVV>А можно и адщфе использовать, если использовать в качестве индекса не нужно.

адщфе = float?
Тогда ты не прав. Флоат всего 4 байта и цикл, перебирающий 2^42 значений, на нем никак не организуешь.
Вот на double можно организовать. У него одна мантисса 52 бита.

[msdn]
Type Exponent length Mantissa length
float 8 bits 23 bits
double 11 bits 52 bits
[/msdn]

А в качестве индекса все равно поиспользовать не получится... хоть double используй, хоть __int64.

Здравствуйте, emergenter, Вы писали:

E>подскажите пожалуйста как выполнить цикл


E>

E>for(i=0 i<ZNACHENIE; i++)
E>{
E>  ....
E>}
E>

E>где значение это 42 битное число??

for (int i=0; i < ZNACHENIE>>32; i++)
{
    for (int j=0; j < ZNACHENIE & 0xffffffff; j++)
    {
    .........
    }
}

Здравствуйте, emergenter, Вы писали:

E>подскажите пожалуйста как выполнить цикл


E>

E>for(i=0 i<ZNACHENIE; i++)
E>{
E>  ....
E>}
E>

E>где значение это 42 битное число??

Может быть быть имеет смысл переделать сам алгоритм? Даже просто перебор 42-битного счетчика весьма ресурсоемок. А если в цикле будут хоть какие-то вычисления, то это будет долгий цикл.

Здравствуйте, Tan4ik, Вы писали:

maq>>>Если нет то можно реализовать с использованием двух 32-х битных
LVV>>А можно и адщфе использовать, если использовать в качестве индекса не нужно.

T>адщфе = float?
T>Тогда ты не прав. Флоат всего 4 байта и цикл, перебирающий 2^42 значений, на нем никак не организуешь.
T>Вот на double можно организовать. У него одна мантисса 52 бита.
C doublom-то понятно!
T>[msdn]
T>Type Exponent length Mantissa length
T>float 8 bits 23 bits
T>double 11 bits 52 bits
T>[/msdn]

T>А в качестве индекса все равно поиспользовать не получится... хоть double используй, хоть __int64.

Предел float 10^38 = 2^38*5^38
2^42 = 2^4*2^38 = 16*2^38
Очень даже организуешь!
Или я где-то грабли не вижу?

LVV>Предел float 10^38 = 2^38*5^38
LVV>2^42 = 2^4*2^38 = 16*2^38
LVV>Очень даже организуешь!
LVV>Или я где-то грабли не вижу?

Грабли могут быть в точности вычисления i++.
Можно получить бесконечный цикл.

Здравствуйте, emergenter, Вы писали:

E>подскажите пожалуйста как выполнить цикл


E>

E>for(i=0 i<ZNACHENIE; i++)
E>{
E>  ....
E>}
E>

E>где значение это 42 битное число??

Два int-a..

T>>А в качестве индекса все равно поиспользовать не получится... хоть double используй, хоть __int64.

LVV>Предел float 10^38 = 2^38*5^38
LVV>2^42 = 2^4*2^38 = 16*2^38
LVV>Очень даже организуешь!
LVV>Или я где-то грабли не вижу?

Конечно не видите, что, вообще говоря, странно...
Распределение вещественных чисел, представляемых флоат (да и любым числом с плавающей точкой) на множестве вещественных чисел, неравномерно. Наиболее плотно числа представлены (отбросив знак) в районе единицы, далее, ближе к границам диапазона — значительно более разрежено. Т.е. далеко не все целые числа из диапазона флоата можно с точностью до +-0.5 им представить. Более того. Общее количество (вещественных) чисел, представляемых float, составляет примерно (точно я не помню) 2^25 + 1. Общее количество (вещественных) чисел, представляемых double, состоявляет 2^53 + 1, т.е. им представить 42 битное число с некоторой осторожностью можно (при этом, очевидно, от операции инкремента в виде прибавления единички к значению придется отказаться, придумав нечто другое, что не изменяло бы значения порядка, а только мантиссы). В общем — правильнее и быстрее использовать вложеный цикл на long, если компилер не поддерживает 64-х битные целые.

Здравствуйте, LaptevVV, Вы писали:

maq>>>>Если нет то можно реализовать с использованием двух 32-х битных
LVV>>>А можно и адщфе использовать, если использовать в качестве индекса не нужно.

T>>адщфе = float?
T>>Тогда ты не прав. Флоат всего 4 байта и цикл, перебирающий 2^42 значений, на нем никак не организуешь.

LVV>Предел float 10^38 = 2^38*5^38
LVV>2^42 = 2^4*2^38 = 16*2^38
LVV>Очень даже организуешь!
LVV>Или я где-то грабли не вижу?

int main()
{
    float a=1;
    for (int i=0; i<10; ++i)
        a *= 10.f;

    float b=a+10;

    cout << "Is 10^10 + 10 == 10000000000?" << endl;
    if (a==b)
        cout << "Yes, of course!" << endl;
    else
        cout << "No!" << endl;

    return 0;
}

Объяснение — см. ответ Andrew S

Здравствуйте, Andrew S, Вы писали:

T>>>А в качестве индекса все равно поиспользовать не получится... хоть double используй, хоть __int64.

LVV>>Предел float 10^38 = 2^38*5^38
LVV>>2^42 = 2^4*2^38 = 16*2^38
LVV>>Очень даже организуешь!
LVV>>Или я где-то грабли не вижу?

AS>Конечно не видите, что, вообще говоря, странно...
AS>Распределение вещественных чисел, представляемых флоат (да и любым числом с плавающей точкой) на множестве вещественных чисел, неравномерно. Наиболее плотно числа представлены (отбросив знак) в районе единицы, далее, ближе к границам диапазона — значительно более разрежено. Т.е. далеко не все целые числа из диапазона флоата можно с точностью до +-0.5 им представить.
Наиболее плотно — в районе нуля

AS>Более того. Общее количество (вещественных) чисел, представляемых float, составляет примерно (точно я не помню) 2^25 + 1.
Больше. Намного больше. Чуть меньше 2^32 (меньше из-за того, что некоторые числа имеют неоднозначное представление, но таких чисел очень мало).

AS>Общее количество (вещественных) чисел, представляемых double, состоявляет 2^53 + 1,
Тоже ошибаешься. Порядка 2^64. Как и следовало ожидать.

AS>т.е. им представить 42 битное число с некоторой осторожностью можно (при этом, очевидно, от операции инкремента в виде прибавления единички к значению придется отказаться, придумав нечто другое, что не изменяло бы значения порядка, а только мантиссы).
Осторожность никогда не повредит, но в данном случае можно смело пользоваться double. При условии, что используются только +-*= и значение не вылазиет за 2^52.

AS>В общем — правильнее и быстрее использовать вложеный цикл на long, если компилер не поддерживает 64-х битные целые.
Правильнее? Наверное да. Быстрее? Сомниваюсь. Все зависит от задачи и "внутренностей" цикла.

Здравствуйте, Astaroth, Вы писали:

A>От нуля до четырёх квадриллионов...
A>Ууу

2^42 = 4 * 2^40 = 4 * (2^10)^4 = 4 * (10^3)^4 = 4 * 10^12
Это всего лишь 4 миллиарда.

Здравствуйте, Аноним, Вы писали:

A>>От нуля до четырёх квадриллионов...
A>>Ууу

А>2^42 = 4 * 2^40 = 4 * (2^10)^4 = 4 * (10^3)^4 = 4 * 10^12
А>Это всего лишь 4 миллиарда.

Ну... а я всегда думал, что миллиард = 10^9. Видно ошибался

А>2^42 = 4 * 2^40 = 4 * (2^10)^4 = 4 * (10^3)^4 = 4 * 10^12

Или 4 триллиона. Блин, совсем запутался.

А>Может быть быть имеет смысл переделать сам алгоритм? Даже просто перебор 42-битного счетчика весьма ресурсоемок. А если в цикле будут хоть какие-то вычисления, то это будет долгий цикл.

М-да. Если хотя бы по микросекунде, то это 4 миллиона секунд — почти два месяца.

AS>>Распределение вещественных чисел, представляемых флоат (да и любым числом с плавающей точкой) на множестве вещественных чисел, неравномерно. Наиболее плотно числа представлены (отбросив знак) в районе единицы, далее, ближе к границам диапазона — значительно более разрежено. Т.е. далеко не все целые числа из диапазона флоата можно с точностью до +-0.5 им представить.
T>Наиболее плотно — в районе нуля

С чего это? Флоат хранится в нормализованом виде с неявной единицой.

AS>>Более того. Общее количество (вещественных) чисел, представляемых float, составляет примерно (точно я не помню) 2^25 + 1.
T>Больше. Намного больше. Чуть меньше 2^32 (меньше из-за того, что некоторые числа имеют неоднозначное представление, но таких чисел очень мало).

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

AS>>Общее количество (вещественных) чисел, представляемых double, состоявляет 2^53 + 1,
T>Тоже ошибаешься. Порядка 2^64. Как и следовало ожидать.

Аналогично предыдущему.

AS>>т.е. им представить 42 битное число с некоторой осторожностью можно (при этом, очевидно, от операции инкремента в виде прибавления единички к значению придется отказаться, придумав нечто другое, что не изменяло бы значения порядка, а только мантиссы).
T>Осторожность никогда не повредит, но в данном случае можно смело пользоваться double. При условии, что используются только +-*= и значение не вылазиет за 2^52.


AS>>В общем — правильнее и быстрее использовать вложеный цикл на long, если компилер не поддерживает 64-х битные целые.
T>Правильнее? Наверное да. Быстрее? Сомниваюсь. Все зависит от задачи и "внутренностей" цикла.

Быстрее — однозначно. По производительности будет не сильно ниже, чем с int64.

Здравствуйте, Andrew S, Вы писали:

AS>>>Распределение вещественных чисел, представляемых флоат (да и любым числом с плавающей точкой) на множестве вещественных чисел, неравномерно. Наиболее плотно числа представлены (отбросив знак) в районе единицы, далее, ближе к границам диапазона — значительно более разрежено. Т.е. далеко не все целые числа из диапазона флоата можно с точностью до +-0.5 им представить.
T>>Наиболее плотно — в районе нуля

AS>С чего это? Флоат хранится в нормализованом виде с неявной единицой.
Спорить не буду. Но мне всегда казалось, что от -0.1 до 0.1 флоатов больше, чем от 0.9 до 1.1. Но если окажется, что это не так, то я не очень расстроюсь.

AS>>>В общем — правильнее и быстрее использовать вложеный цикл на long, если компилер не поддерживает 64-х битные целые.
T>>Правильнее? Наверное да. Быстрее? Сомниваюсь. Все зависит от задачи и "внутренностей" цикла.

AS>Быстрее — однозначно.
Если с индексом ничего не делается, то да. Если делается — не факт.

AS>По производительности будет не сильно ниже, чем с int64.
Может и быстрее быть. Я же сказал "Все зависит от задачи и "внутренностей" цикла".