замена умножения

[Zenon]

У вас множитель целый - вот его и надо сдвигать, последовательно проверяя биты. А float - складывать: (x+=x как умножение на 2)

Например, 1000000 десятичное - это 11110100001001000000 двоичное. Значит как-то так смотрим за младшим битом:

tmp= delt;
delt= 0;
1111010000100100000(0)
tmp+=tmp; //tmp = 2*delt
111101000010010000(0)
tmp+=tmp; //tmp = 4*delt
11110100001001000(0)
tmp+=tmp; //tmp = 8*delt
1111010000100100(0)
tmp+=tmp; //tmp = 16*delt
111101000010010(0)
tmp+=tmp; //tmp = 32*delt
11110100001001(0)
tmp+=tmp; //tmp = 64*delt
1111010000100(1)
delt+= tmp; //delt = 64*delt
tmp+=tmp; //tmp = 128*delt
111101000010(0)
tmp+=tmp; //tmp = 256*delt
11110100001(0)
tmp+=tmp; //tmp = 512*delt
1111010000(1)
delt+= tmp; //delt = 64*delt + 512*delt
tmp+=tmp; //tmp = 1024*delt

ну и т.д. пока сдвигаемое целое не ноль

[AlexVI]

люди помогите примером

[Zenon]

cм. выше на 4 минуты

[p51x]

люди помогите примером

Чем вас мой пример не устроил?

[Smitt&Wesson]

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

люди помогите примером

Вот ещё ссылочка.
Ну, вот пример:

[AlexVI]

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

У вас множитель целый - вот его и надо сдвигать, последовательно проверяя биты. А float - складывать: (x+=x как умножение на 2)

Например, 1000000 десятичное - это 11110100001001000000 двоичное. Значит как-то так смотрим за младшим битом:

tmp= delt;
delt= 0;
1111010000100100000(0)
tmp+=tmp; //tmp = 2*delt
111101000010010000(0)
tmp+=tmp; //tmp = 4*delt
11110100001001000(0)
tmp+=tmp; //tmp = 8*delt
1111010000100100(0)
tmp+=tmp; //tmp = 16*delt
111101000010010(0)
tmp+=tmp; //tmp = 32*delt
11110100001001(0)
tmp+=tmp; //tmp = 64*delt
1111010000100(1)
delt+= tmp; //delt = 64*delt
tmp+=tmp; //tmp = 128*delt
111101000010(0)
tmp+=tmp; //tmp = 256*delt
11110100001(0)
tmp+=tmp; //tmp = 512*delt
1111010000(1)
delt+= tmp; //delt = 64*delt + 512*delt
tmp+=tmp; //tmp = 1024*delt

ну и т.д. пока сдвигаемое целое не ноль

повторил все НО !!!

//Например, 10 000 000 десятичное - это 00000000100110001001011010000000 двоичное. Значит как-то так смотрим за младшим битом:

int iG; iG=10000000;
float delt,tmp;
delt=0.010384548; //103845,48

tmp= delt;
delt= 0;

//00000000100110001001011010000000(0)
tmp+=tmp; //tmp = 2*delt
//0000000010011000100101101000000(0)
tmp+=tmp; //tmp = 4*delt
//000000001001100010010110100000(0)
tmp+=tmp; //tmp = 8*delt
//00000000100110001001011010000(0)
tmp+=tmp; //tmp = 16*delt
//0000000010011000100101101000(0)
tmp+=tmp; //tmp = 32*delt
//000000001001100010010110100(0)
tmp+=tmp; //tmp = 64*delt
//00000000100110001001011010(0)
//delt+= tmp; //delt = 64*delt
tmp+=tmp; //tmp = 128*delt
//0000000010011000100101101(0)
tmp+=tmp; //tmp = 256*delt
//000000001001100010010110(1)
delt+=tmp; // delt =  256*delt
tmp+=tmp; //tmp = 512*delt
//00000000100110001001011(0)
tmp+=tmp; //tmp = 1024*delt
//0000000010011000100101(1)
delt+=tmp; //delt =  256*delt + 1024*delt
tmp+=tmp; //tmp = 2048*delt
//000000001001100010010(1)
delt+=tmp; //delt =  256*delt + 1024*delt + 2048*delt
tmp+=tmp; //tmp = 4096*delt
//00000000100110001001(0)
tmp+=tmp; //tmp = 8192*delt
//0000000010011000100(1)
delt+=tmp; //delt =  256*delt + 1024*delt + 2048*delt + 8192*delt
tmp+=tmp; //tmp = 16384*delt
//000000001001100010(0)
tmp+=tmp; //tmp = 32768*delt
//00000000100110001(0)
tmp+=tmp; //tmp = 65536*delt
//0000000010011000(1)
delt+=tmp; //delt =  256*delt + 1024*delt + 2048*delt + 8192*delt + 65536*delt
tmp+=tmp; //tmp = 131072*delt
//000000001001100(0)
tmp+=tmp; //tmp = 262144*delt
//00000000100110(0)
tmp+=tmp; //tmp = 524288*delt
//0000000010011(0)
tmp+=tmp; //tmp = 1048576*delt
//000000001001(1)
delt+=tmp; //delt =  256*delt + 1024*delt + 2048*delt + 8192*delt + 65536*delt +  1048576*delt
tmp+=tmp; //tmp = 2097152*delt
//00000000100(1)
delt+=tmp; //delt =  256*delt + 1024*delt + 2048*delt + 8192*delt + 65536*delt +  1048576*delt + 2097152*delt
tmp+=tmp; //tmp = 4194304*delt
//0000000010(0)
tmp+=tmp; //tmp = 4194304*2*delt
//000000001(0)
tmp+=tmp; //tmp = 4194304*4*delt
//00000000(1)
delt+=tmp; //delt =  256*delt + 1024*delt + 2048*delt + 8192*delt + 65536*delt +  1048576*delt + 2097152*delt + 4194304*4*delt

в последней строке получился результат = 207690.96 но это в 2-ое больше чем мне надо !!! = 103845.48
В чем может быть проблема !!!!

[AlexVI]

Вот что получилось:

PHP код:

//Например, 10 000 000 десятичное - это 00000000100110001001011010000000 двоичное. Значит как-то так смотрим за младшим битом:

int iG;
float delt,tmp;
delt=0.010384548; //0.010384548*10000000=103845,48

tmp= delt;
delt= 0;

for(int i=1; i<32; i++)
{
    if(i==8 ||i==10 ||i==11 || i==13 ||i==16 ||i==20 ||i==21 ||i==24) delt+=tmp;
    tmp+=tmp;
}
iG=(int)delt; 


1. Скорее то что у меня получилось медленнее считает чем просто перемножить два флоата (или я так реализовал коряво) - было основной задачей;
2. Умножения нет;
3. Разобрался хоть так, но смещение так и нет;
4. Если у кого все таки есть пожелание чем умножение заменить (более быстрым алгоритмом) буду рад;

[Zenon]

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

Конечно 2 float-а перемножить быстрее. Это в очень старых процессорах умножение было во много раз медленнее, чем сложение, и на этом иногда экономили. Если я не ошибаюсь, то сейчас из простых арифметических операций остался смысл экономить только на делении (и то не факт). Но даже деление нет смысла конвертировать в сдвиги и прочее, т.к. обойдется дороже. Исключение - деление целых на степени двойки, что быстрее делать через сдвиги.

Экономить стоит в первую очередь на сложных операциях вроде sin/cos и на вызовах функций (особенно системных).