ReSQL.ru
     
powered by simpleCommunicator - 2.0.59     © 2025 Programmizd 02
Мобильная версия    Контакт    Правила    FAQ    Помощь
Целевая тема:
Создать новую тему:
Автор:
Закрыть
Цитировать
Доб. в избранное | Игнор. тему | Прикреп. тему | Пометить прочит. / непрочит. | Фильтр
Форумы / C++ [игнор отключен] [закрыт для гостей] / inline extern из библиотеки, как правильно декларировать-имплементировать?
25 сообщений из 276, страница 8 из 12
  8  все
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39283539
Фотография Изопропил
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
Изопропил
Участник
Dima TЭто просто частный случай, демонстрирующий что нет идеального решения проблем работы с числами с фиксированной разрядностью.
BINARY FIXED(n,m)
DECIMAL FIXED(n,m)
...
Рейтинг: 0 / 0
31.07.2016, 21:54
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39283540
Dima T
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
Dima T
Участник
ИзопропилBINARY FIXED(n,m)
DECIMAL FIXED(n,m)
Краткость - сестра таланта, но тут непонятно из какой оперы эти понятия. Ссылку бы дал, или еще как-то намекнул о чем речь.
...
Рейтинг: 0 / 0
31.07.2016, 22:01
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39283542
Фотография Изопропил
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
Изопропил
Участник
Dima T,

это PL/1
...
Рейтинг: 0 / 0
31.07.2016, 22:08
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39283556
Фотография mayton
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
mayton
Участник
Челы. Толи от воскресенья... толи от количества выпитого пива туплю.

Глянте плиз пред ваши ясны очи.

На каждой нечетной итерации мантисса удваивает свое значение. На четной - добавляет единицу.

DoubleFormat после некой итерации перестает изменять свое raw-значение.
Код: plaintext
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.
#include <math.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>     
#include <time.h>       

#include <bitset>

using namespace std;

string formatFloatRaw(float arg1){
	union {
		float    v;
		uint32_t iv;
	} fu2;
	fu2.v = arg1;
	bitset<32>   fs(fu2.iv);
	string dss = fs.to_string();
	return dss.substr(0,1)    +"-"+
               dss.substr(0+1,8) +"-"+
               dss.substr(0+1+8,23);
}


string formatDoubleRaw(double arg1){
	union {
		double   v;
		uint64_t iv;
	} du2;
	du2.v = arg1;
	bitset<32>   dshi ((uint32_t)(du2.iv>>32));
	bitset<32>   dslow((uint32_t)(du2.iv&&0xFFFFFFFF));
	bitset<64>   ds(dshi.to_string() + dslow.to_string());
	string dss = ds.to_string();
	return dss.substr(0,1)    +"-"+
               dss.substr(0+1,11) +"-"+
               dss.substr(0+1+11,53);
}


#define MAX_MANT_DOUBLE 999999999999999.0

int main(int argc,char **argv,char **env){

	srand(0);
        
	// Float running bit
	float v=1.0f;
	for(int i=0;i<26;i++){
		printf("float = %f \t raw = %s \n",v,formatFloatRaw(v).c_str());
		printf("float = %f \t raw = %s \n",v+1.0f,formatFloatRaw(v+1.0f).c_str());
		v*=2.0f;
	}

	// Double running bit
	double vd=1.0;
	for(int i=0;i<60;i++){
		printf("double = %f \t raw = %s \n",vd,formatDoubleRaw(vd).c_str());
		printf("double = %f \t raw = %s \n",vd+1.0,formatDoubleRaw(vd+1.0).c_str());
		vd*=2.0;
	}

	return 0;
}



Отчотик

 
Код: plaintext
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.
float = 1.000000 	 raw = 0-01111111-00000000000000000000000 
float = 2.000000 	 raw = 0-10000000-00000000000000000000000 
float = 2.000000 	 raw = 0-10000000-00000000000000000000000 
float = 3.000000 	 raw = 0-10000000-10000000000000000000000 
float = 4.000000 	 raw = 0-10000001-00000000000000000000000 
float = 5.000000 	 raw = 0-10000001-01000000000000000000000 
float = 8.000000 	 raw = 0-10000010-00000000000000000000000 
float = 9.000000 	 raw = 0-10000010-00100000000000000000000 
float = 16.000000 	 raw = 0-10000011-00000000000000000000000 
float = 17.000000 	 raw = 0-10000011-00010000000000000000000 
float = 32.000000 	 raw = 0-10000100-00000000000000000000000 
float = 33.000000 	 raw = 0-10000100-00001000000000000000000 
float = 64.000000 	 raw = 0-10000101-00000000000000000000000 
float = 65.000000 	 raw = 0-10000101-00000100000000000000000 
float = 128.000000 	 raw = 0-10000110-00000000000000000000000 
float = 129.000000 	 raw = 0-10000110-00000010000000000000000 
float = 256.000000 	 raw = 0-10000111-00000000000000000000000 
float = 257.000000 	 raw = 0-10000111-00000001000000000000000 
float = 512.000000 	 raw = 0-10001000-00000000000000000000000 
float = 513.000000 	 raw = 0-10001000-00000000100000000000000 
float = 1024.000000 	 raw = 0-10001001-00000000000000000000000 
float = 1025.000000 	 raw = 0-10001001-00000000010000000000000 
float = 2048.000000 	 raw = 0-10001010-00000000000000000000000 
float = 2049.000000 	 raw = 0-10001010-00000000001000000000000 
float = 4096.000000 	 raw = 0-10001011-00000000000000000000000 
float = 4097.000000 	 raw = 0-10001011-00000000000100000000000 
float = 8192.000000 	 raw = 0-10001100-00000000000000000000000 
float = 8193.000000 	 raw = 0-10001100-00000000000010000000000 
float = 16384.000000 	 raw = 0-10001101-00000000000000000000000 
float = 16385.000000 	 raw = 0-10001101-00000000000001000000000 
float = 32768.000000 	 raw = 0-10001110-00000000000000000000000 
float = 32769.000000 	 raw = 0-10001110-00000000000000100000000 
float = 65536.000000 	 raw = 0-10001111-00000000000000000000000 
float = 65537.000000 	 raw = 0-10001111-00000000000000010000000 
float = 131072.000000 	 raw = 0-10010000-00000000000000000000000 
float = 131073.000000 	 raw = 0-10010000-00000000000000001000000 
float = 262144.000000 	 raw = 0-10010001-00000000000000000000000 
float = 262145.000000 	 raw = 0-10010001-00000000000000000100000 
float = 524288.000000 	 raw = 0-10010010-00000000000000000000000 
float = 524289.000000 	 raw = 0-10010010-00000000000000000010000 
float = 1048576.000000 	 raw = 0-10010011-00000000000000000000000 
float = 1048577.000000 	 raw = 0-10010011-00000000000000000001000 
float = 2097152.000000 	 raw = 0-10010100-00000000000000000000000 
float = 2097153.000000 	 raw = 0-10010100-00000000000000000000100 
float = 4194304.000000 	 raw = 0-10010101-00000000000000000000000 
float = 4194305.000000 	 raw = 0-10010101-00000000000000000000010 
float = 8388608.000000 	 raw = 0-10010110-00000000000000000000000 
float = 8388609.000000 	 raw = 0-10010110-00000000000000000000001 
float = 16777216.000000 	 raw = 0-10010111-00000000000000000000000 
float = 16777216.000000 	 raw = 0-10010111-00000000000000000000000 
float = 33554432.000000 	 raw = 0-10011000-00000000000000000000000 
float = 33554432.000000 	 raw = 0-10011000-00000000000000000000000 
double = 1.000000 	 raw = 0-01111111111-0000000000000000000000000000000000000000000000000001 
double = 2.000000 	 raw = 0-10000000000-0000000000000000000000000000000000000000000000000001 
double = 2.000000 	 raw = 0-10000000000-0000000000000000000000000000000000000000000000000001 
double = 3.000000 	 raw = 0-10000000000-1000000000000000000000000000000000000000000000000001 
double = 4.000000 	 raw = 0-10000000001-0000000000000000000000000000000000000000000000000001 
double = 5.000000 	 raw = 0-10000000001-0100000000000000000000000000000000000000000000000001 
double = 8.000000 	 raw = 0-10000000010-0000000000000000000000000000000000000000000000000001 
double = 9.000000 	 raw = 0-10000000010-0010000000000000000000000000000000000000000000000001 
double = 16.000000 	 raw = 0-10000000011-0000000000000000000000000000000000000000000000000001 
double = 17.000000 	 raw = 0-10000000011-0001000000000000000000000000000000000000000000000001 
double = 32.000000 	 raw = 0-10000000100-0000000000000000000000000000000000000000000000000001 
double = 33.000000 	 raw = 0-10000000100-0000100000000000000000000000000000000000000000000001 
double = 64.000000 	 raw = 0-10000000101-0000000000000000000000000000000000000000000000000001 
double = 65.000000 	 raw = 0-10000000101-0000010000000000000000000000000000000000000000000001 
double = 128.000000 	 raw = 0-10000000110-0000000000000000000000000000000000000000000000000001 
double = 129.000000 	 raw = 0-10000000110-0000001000000000000000000000000000000000000000000001 
double = 256.000000 	 raw = 0-10000000111-0000000000000000000000000000000000000000000000000001 
double = 257.000000 	 raw = 0-10000000111-0000000100000000000000000000000000000000000000000001 
double = 512.000000 	 raw = 0-10000001000-0000000000000000000000000000000000000000000000000001 
double = 513.000000 	 raw = 0-10000001000-0000000010000000000000000000000000000000000000000001 
double = 1024.000000 	 raw = 0-10000001001-0000000000000000000000000000000000000000000000000001 
double = 1025.000000 	 raw = 0-10000001001-0000000001000000000000000000000000000000000000000001 
double = 2048.000000 	 raw = 0-10000001010-0000000000000000000000000000000000000000000000000001 
double = 2049.000000 	 raw = 0-10000001010-0000000000100000000000000000000000000000000000000001 
double = 4096.000000 	 raw = 0-10000001011-0000000000000000000000000000000000000000000000000001 
double = 4097.000000 	 raw = 0-10000001011-0000000000010000000000000000000000000000000000000001 
double = 8192.000000 	 raw = 0-10000001100-0000000000000000000000000000000000000000000000000001 
double = 8193.000000 	 raw = 0-10000001100-0000000000001000000000000000000000000000000000000001 
double = 16384.000000 	 raw = 0-10000001101-0000000000000000000000000000000000000000000000000001 
double = 16385.000000 	 raw = 0-10000001101-0000000000000100000000000000000000000000000000000001 
double = 32768.000000 	 raw = 0-10000001110-0000000000000000000000000000000000000000000000000001 
double = 32769.000000 	 raw = 0-10000001110-0000000000000010000000000000000000000000000000000001 
double = 65536.000000 	 raw = 0-10000001111-0000000000000000000000000000000000000000000000000001 
double = 65537.000000 	 raw = 0-10000001111-0000000000000001000000000000000000000000000000000001 
double = 131072.000000 	 raw = 0-10000010000-0000000000000000000000000000000000000000000000000001 
double = 131073.000000 	 raw = 0-10000010000-0000000000000000100000000000000000000000000000000001 
double = 262144.000000 	 raw = 0-10000010001-0000000000000000000000000000000000000000000000000001 
double = 262145.000000 	 raw = 0-10000010001-0000000000000000010000000000000000000000000000000001 
double = 524288.000000 	 raw = 0-10000010010-0000000000000000000000000000000000000000000000000001 
double = 524289.000000 	 raw = 0-10000010010-0000000000000000001000000000000000000000000000000001 
double = 1048576.000000 	 raw = 0-10000010011-0000000000000000000000000000000000000000000000000001 
double = 1048577.000000 	 raw = 0-10000010011-0000000000000000000100000000000000000000000000000001 
double = 2097152.000000 	 raw = 0-10000010100-0000000000000000000000000000000000000000000000000001 
double = 2097153.000000 	 raw = 0-10000010100-0000000000000000000000000000000000000000000000000001 
double = 4194304.000000 	 raw = 0-10000010101-0000000000000000000000000000000000000000000000000001 
double = 4194305.000000 	 raw = 0-10000010101-0000000000000000000000000000000000000000000000000001 
double = 8388608.000000 	 raw = 0-10000010110-0000000000000000000000000000000000000000000000000001 
double = 8388609.000000 	 raw = 0-10000010110-0000000000000000000000000000000000000000000000000001 
double = 16777216.000000 	 raw = 0-10000010111-0000000000000000000000000000000000000000000000000001 
double = 16777217.000000 	 raw = 0-10000010111-0000000000000000000000000000000000000000000000000001 
double = 33554432.000000 	 raw = 0-10000011000-0000000000000000000000000000000000000000000000000001 
double = 33554433.000000 	 raw = 0-10000011000-0000000000000000000000000000000000000000000000000001 
double = 67108864.000000 	 raw = 0-10000011001-0000000000000000000000000000000000000000000000000001 
double = 67108865.000000 	 raw = 0-10000011001-0000000000000000000000000000000000000000000000000001 
double = 134217728.000000 	 raw = 0-10000011010-0000000000000000000000000000000000000000000000000001 
double = 134217729.000000 	 raw = 0-10000011010-0000000000000000000000000000000000000000000000000001 
double = 268435456.000000 	 raw = 0-10000011011-0000000000000000000000000000000000000000000000000001 
double = 268435457.000000 	 raw = 0-10000011011-0000000000000000000000000000000000000000000000000001 
double = 536870912.000000 	 raw = 0-10000011100-0000000000000000000000000000000000000000000000000001 
double = 536870913.000000 	 raw = 0-10000011100-0000000000000000000000000000000000000000000000000001 
double = 1073741824.000000 	 raw = 0-10000011101-0000000000000000000000000000000000000000000000000001 
double = 1073741825.000000 	 raw = 0-10000011101-0000000000000000000000000000000000000000000000000001 
double = 2147483648.000000 	 raw = 0-10000011110-0000000000000000000000000000000000000000000000000001 
double = 2147483649.000000 	 raw = 0-10000011110-0000000000000000000000000000000000000000000000000001 
double = 4294967296.000000 	 raw = 0-10000011111-0000000000000000000000000000000000000000000000000001 
double = 4294967297.000000 	 raw = 0-10000011111-0000000000000000000000000000000000000000000000000001 
double = 8589934592.000000 	 raw = 0-10000100000-0000000000000000000000000000000000000000000000000001 
double = 8589934593.000000 	 raw = 0-10000100000-0000000000000000000000000000000000000000000000000001 
double = 17179869184.000000 	 raw = 0-10000100001-0000000000000000000000000000000000000000000000000001 
double = 17179869185.000000 	 raw = 0-10000100001-0000000000000000000000000000000000000000000000000001 
double = 34359738368.000000 	 raw = 0-10000100010-0000000000000000000000000000000000000000000000000001 
double = 34359738369.000000 	 raw = 0-10000100010-0000000000000000000000000000000000000000000000000001 
double = 68719476736.000000 	 raw = 0-10000100011-0000000000000000000000000000000000000000000000000001 
double = 68719476737.000000 	 raw = 0-10000100011-0000000000000000000000000000000000000000000000000001 
double = 137438953472.000000 	 raw = 0-10000100100-0000000000000000000000000000000000000000000000000001 
double = 137438953473.000000 	 raw = 0-10000100100-0000000000000000000000000000000000000000000000000001 
double = 274877906944.000000 	 raw = 0-10000100101-0000000000000000000000000000000000000000000000000001 
double = 274877906945.000000 	 raw = 0-10000100101-0000000000000000000000000000000000000000000000000001 
double = 549755813888.000000 	 raw = 0-10000100110-0000000000000000000000000000000000000000000000000001 
double = 549755813889.000000 	 raw = 0-10000100110-0000000000000000000000000000000000000000000000000001 
double = 1099511627776.000000 	 raw = 0-10000100111-0000000000000000000000000000000000000000000000000001 
double = 1099511627777.000000 	 raw = 0-10000100111-0000000000000000000000000000000000000000000000000001 
double = 2199023255552.000000 	 raw = 0-10000101000-0000000000000000000000000000000000000000000000000001 
double = 2199023255553.000000 	 raw = 0-10000101000-0000000000000000000000000000000000000000000000000001 
double = 4398046511104.000000 	 raw = 0-10000101001-0000000000000000000000000000000000000000000000000001 
double = 4398046511105.000000 	 raw = 0-10000101001-0000000000000000000000000000000000000000000000000001 
double = 8796093022208.000000 	 raw = 0-10000101010-0000000000000000000000000000000000000000000000000001 
double = 8796093022209.000000 	 raw = 0-10000101010-0000000000000000000000000000000000000000000000000001 
double = 17592186044416.000000 	 raw = 0-10000101011-0000000000000000000000000000000000000000000000000001 
double = 17592186044417.000000 	 raw = 0-10000101011-0000000000000000000000000000000000000000000000000001 
double = 35184372088832.000000 	 raw = 0-10000101100-0000000000000000000000000000000000000000000000000001 
double = 35184372088833.000000 	 raw = 0-10000101100-0000000000000000000000000000000000000000000000000001 
double = 70368744177664.000000 	 raw = 0-10000101101-0000000000000000000000000000000000000000000000000001 
double = 70368744177665.000000 	 raw = 0-10000101101-0000000000000000000000000000000000000000000000000001 
double = 140737488355328.000000 	 raw = 0-10000101110-0000000000000000000000000000000000000000000000000001 
double = 140737488355329.000000 	 raw = 0-10000101110-0000000000000000000000000000000000000000000000000001 
double = 281474976710656.000000 	 raw = 0-10000101111-0000000000000000000000000000000000000000000000000001 
double = 281474976710657.000000 	 raw = 0-10000101111-0000000000000000000000000000000000000000000000000001 
double = 562949953421312.000000 	 raw = 0-10000110000-0000000000000000000000000000000000000000000000000001 
double = 562949953421313.000000 	 raw = 0-10000110000-0000000000000000000000000000000000000000000000000001 
double = 1125899906842624.000000 	 raw = 0-10000110001-0000000000000000000000000000000000000000000000000001 
double = 1125899906842625.000000 	 raw = 0-10000110001-0000000000000000000000000000000000000000000000000001 
double = 2251799813685248.000000 	 raw = 0-10000110010-0000000000000000000000000000000000000000000000000001 
double = 2251799813685249.000000 	 raw = 0-10000110010-0000000000000000000000000000000000000000000000000001 
double = 4503599627370496.000000 	 raw = 0-10000110011-0000000000000000000000000000000000000000000000000001 
double = 4503599627370497.000000 	 raw = 0-10000110011-0000000000000000000000000000000000000000000000000001 
double = 9007199254740992.000000 	 raw = 0-10000110100-0000000000000000000000000000000000000000000000000001 
double = 9007199254740992.000000 	 raw = 0-10000110100-0000000000000000000000000000000000000000000000000001 
double = 18014398509481984.000000 	 raw = 0-10000110101-0000000000000000000000000000000000000000000000000001 
double = 18014398509481984.000000 	 raw = 0-10000110101-0000000000000000000000000000000000000000000000000001 
double = 36028797018963968.000000 	 raw = 0-10000110110-0000000000000000000000000000000000000000000000000001 
double = 36028797018963968.000000 	 raw = 0-10000110110-0000000000000000000000000000000000000000000000000001 
double = 72057594037927936.000000 	 raw = 0-10000110111-0000000000000000000000000000000000000000000000000001 
double = 72057594037927936.000000 	 raw = 0-10000110111-0000000000000000000000000000000000000000000000000001 
double = 144115188075855870.000000 	 raw = 0-10000111000-0000000000000000000000000000000000000000000000000001 
double = 144115188075855870.000000 	 raw = 0-10000111000-0000000000000000000000000000000000000000000000000001 
double = 288230376151711740.000000 	 raw = 0-10000111001-0000000000000000000000000000000000000000000000000001 
double = 288230376151711740.000000 	 raw = 0-10000111001-0000000000000000000000000000000000000000000000000001 
double = 576460752303423490.000000 	 raw = 0-10000111010-0000000000000000000000000000000000000000000000000001 
double = 576460752303423490.000000 	 raw = 0-10000111010-0000000000000000000000000000000000000000000000000001

...
Рейтинг: 0 / 0
31.07.2016, 23:06
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39283597
m_Sla
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
m_Sla
Участник
mayton, это так и задумано?

dslow((uint32_t)(du2.iv && 0xFFFFFFFF));
...
Рейтинг: 0 / 0
01.08.2016, 05:13
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39283624
Фотография mayton
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
mayton
Участник
Блин...
...
Рейтинг: 0 / 0
01.08.2016, 08:52
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39283635
Dima T
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
Dima T
Участник
 
Выводи в hex, в нем смотреть удобнее
Код: plaintext
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.
char* double2hex(double x, char* buf) {
	sprintf(buf + 1, "%016llX", *((uint64_t*)&x));
	buf[0] = buf[1];
	buf[1] = buf[2];
	buf[2] = buf[3];
	buf[3] = '-';
	return buf;
}

char* float2hex(float x, char* buf) {
	uint32_t v = *((uint32_t*)&x);

	sprintf(buf, "%03X-%06X", (v & 0xFF800000) >> 23, v & 0x7FFFFF);
	return buf;
}



void main(int argc, char**argv) {
	char buf[256];

	double x = 1.;
	for (int i = 0; i < 16; i++) {
		printf("%3.0f => %s\n", x, double2hex(x, buf));
		x += 1.;
	}

	float y = 1.;
	for (int i = 0; i < 16; i++) {
		printf("%3.0f => %s\n", y, float2hex(y, buf));
		y += 1.;
	}
	printf("%s\n", double2hex(1. / 3., buf));
	printf("%s\n", float2hex(1. / 3., buf));
}


Результат
Код: plaintext
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.
  1 => 3FF-0000000000000
  2 => 400-0000000000000
  3 => 400-8000000000000
  4 => 401-0000000000000
  5 => 401-4000000000000
  6 => 401-8000000000000
  7 => 401-C000000000000
  8 => 402-0000000000000
  9 => 402-2000000000000
 10 => 402-4000000000000
 11 => 402-6000000000000
 12 => 402-8000000000000
 13 => 402-A000000000000
 14 => 402-C000000000000
 15 => 402-E000000000000
 16 => 403-0000000000000
  1 => 07F-000000
  2 => 080-000000
  3 => 080-400000
  4 => 081-000000
  5 => 081-200000
  6 => 081-400000
  7 => 081-600000
  8 => 082-000000
  9 => 082-100000
 10 => 082-200000
 11 => 082-300000
 12 => 082-400000
 13 => 082-500000
 14 => 082-600000
 15 => 082-700000
 16 => 083-000000
3FD-5555555555555
07D-2AAAAB
...
Рейтинг: 0 / 0
01.08.2016, 09:37
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39283674
Фотография mayton
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
mayton
Участник
Не совсем удобно. Группы битов sign-exponent-mantissa не кратны 4. Граница пересекает 1-hex символ.
...
Рейтинг: 0 / 0
01.08.2016, 10:20
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39283679
Dima T
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
Dima T
Участник
Сдвигами лечится.

PS у тебя еще в double с мантиссой косяк, не 53, а 52
...
Рейтинг: 0 / 0
01.08.2016, 10:28
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39283687
Siemargl
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
Siemargl
Участник
Dima T
 
Выводи в hex, в нем смотреть удобнее
Код: plaintext
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.
char* double2hex(double x, char* buf) {
	sprintf(buf + 1, "%016llX", *((uint64_t*)&x));
	buf[0] = buf[1];
	buf[1] = buf[2];
	buf[2] = buf[3];
	buf[3] = '-';
	return buf;
}

char* float2hex(float x, char* buf) {
	uint32_t v = *((uint32_t*)&x);

	sprintf(buf, "%03X-%06X", (v & 0xFF800000) >> 23, v & 0x7FFFFF);
	return buf;
}



void main(int argc, char**argv) {
	char buf[256];

	double x = 1.;
	for (int i = 0; i < 16; i++) {
		printf("%3.0f => %s\n", x, double2hex(x, buf));
		x += 1.;
	}

	float y = 1.;
	for (int i = 0; i < 16; i++) {
		printf("%3.0f => %s\n", y, float2hex(y, buf));
		y += 1.;
	}
	printf("%s\n", double2hex(1. / 3., buf));
	printf("%s\n", float2hex(1. / 3., buf));
}


Результат
Код: plaintext
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.
  1 => 3FF-0000000000000
  2 => 400-0000000000000
  3 => 400-8000000000000
  4 => 401-0000000000000
  5 => 401-4000000000000
  6 => 401-8000000000000
  7 => 401-C000000000000
  8 => 402-0000000000000
  9 => 402-2000000000000
 10 => 402-4000000000000
 11 => 402-6000000000000
 12 => 402-8000000000000
 13 => 402-A000000000000
 14 => 402-C000000000000
 15 => 402-E000000000000
 16 => 403-0000000000000
  1 => 07F-000000
  2 => 080-000000
  3 => 080-400000
  4 => 081-000000
  5 => 081-200000
  6 => 081-400000
  7 => 081-600000
  8 => 082-000000
  9 => 082-100000
 10 => 082-200000
 11 => 082-300000
 12 => 082-400000
 13 => 082-500000
 14 => 082-600000
 15 => 082-700000
 16 => 083-000000
3FD-5555555555555
07D-2AAAAB

Давно для этого изобрели формат %a
http://www.cplusplus.com/reference/cstdio/printf/?kw=printf
...
Рейтинг: 0 / 0
01.08.2016, 10:38
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39283704
Фотография mayton
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
mayton
Участник
Dima TСдвигами лечится.

PS у тебя еще в double с мантиссой косяк, не 53, а 52
Ааа точно.
...
Рейтинг: 0 / 0
01.08.2016, 11:06
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39283722
Фотография mayton
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
mayton
Участник
Хм... последний бит мантиссы немогу задействовать...

Код: plaintext
1.
2.
3.
4.
float  = 8388607.000000 	 raw = 0-10010101-11111111111111111111110 
float  = 8388608.000000 	 raw = 0-10010110-00000000000000000000000 
double = 4503599627370495.000000 	 raw = 0-10000110010-1111111111111111111111111111111111111111111111111110 
double = 4503599627370496.000000 	 raw = 0-10000110011-0000000000000000000000000000000000000000000000000000
...
Рейтинг: 0 / 0
01.08.2016, 11:24
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39285374
Dima T
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
Dima T
Участник
Появилась мысль как сделать сравнимым double - округлять по окончанию расчета до необходимого количества знаков, но не более 15-ти, т.е. 14 после запятой.
 
Код: plaintext
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
char* double2hex(double x, char* buf) {
	sprintf(buf + 1, "%016llX", *((uint64_t*)&x));
	buf[0] = buf[1];
	buf[1] = buf[2];
	buf[2] = buf[3];
	buf[3] = '-';
	return buf;
}

int main()
{
	char buf[256];
	double x = 1.123456789012345;
	printf("x = %.15f %s\n", x, double2hex(x, buf));

	double y = 1.123456789012346;
	printf("y = %.15f %s\n", y, double2hex(y, buf));
	x = round(x * 1E14) / 1E14;
	printf("round(x) = %.15f %s\n", x, double2hex(x, buf));
	y = round(y * 1E14) / 1E14;
	printf("round(y) = %.15f %s\n", y, double2hex(y, buf));

	return 0;
}


Результат
Код: plaintext
1.
2.
3.
x =        1.123456789012345 3FF-1F9ADD3746F63
y =        1.123456789012346 3FF-1F9ADD3746F67
round(x) = 1.123456789012350 3FF-1F9ADD3746F79
round(y) = 1.123456789012350 3FF-1F9ADD3746F79

т.е. надо сделать тип, который кроме значения содержит точность, например при умножении точности складываются, при делении устанавливается максимально возможная для результата и т.д. Тогда можно проверять на равенство, т.е. это будет полноценный числовой тип. Да и NULL там есть, в смысле NaN.

Или как минимальный вариант: просто сделать функцию округления до заданного количества десятичных знаков и функцию сравнения, которая при проверке равенства округлит очень близкие значения.

Другой вопрос как затестить, 10^15 уже многовато для перебора, а тут еще варианты с разным количеством знаков после точки 14.1, 13.2, 12.3 и т.д.
...
Рейтинг: 0 / 0
03.08.2016, 14:25
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39285380
Фотография mayton
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
mayton
Участник
Dima T, ну скажи пожалуйста зачем нужен такой тип данных который
нужно округлять после каждой операции с ним? А как
просядет нагрузка?
...
Рейтинг: 0 / 0
03.08.2016, 14:29
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39285402
Dima T
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
Dima T
Участник
maytonDima T, ну скажи пожалуйста зачем нужен такой тип данных который
нужно округлять после каждой операции с ним? А как
просядет нагрузка?
Тоже об этом думаю. Надо округления сводить к минимуму, т.е. в конце расчета например. Фиг с ним с округлением, тормоза при сравнении важнее, а они тоже есть.

Тема не философская, мне надо для C# определиться в чем деньги хранить. Есть быстрый и компактный double и есть тормозной и неудобный decimal (хитрая 128 битная структура)
...
Рейтинг: 0 / 0
03.08.2016, 14:47
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39285448
Фотография mayton
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
mayton
Участник
Dima TТоже об этом думаю. Надо округления сводить к минимуму, т.е. в конце расчета например. Фиг с ним с округлением, тормоза при сравнении важнее, а они тоже есть.

Я-бы не занимался округлением. А просто очертил-бы безопасные операции (присвоение целого). И проверил-бы
какие еще можно назвать такими.

Тема не философская, мне надо для C# определиться в чем деньги хранить. Есть быстрый и компактный double и есть тормозной и неудобный decimal (хитрая 128 битная структура)
Да и нечего думать. Ясен пень храни все в decimal. Деньги важны
и копейку терять нельзя.

А вот если тебе надо создать OLAP-кубики и быстро гонять по ним аналитику
то здесь double подходит идеально. Может даже и float -бы подошел.
Датамайнинг там... принятие решений. Туда-же.
...
Рейтинг: 0 / 0
03.08.2016, 15:24
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39285464
Фотография Изопропил
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
Изопропил
Участник
Dima T(хитрая 128 битная структура)
что там хитрого?
 


The binary representation of a Decimal number consists of a 1-bit sign, a 96-bit integer number, and a scaling factor used to divide the integer number and specify what portion of it is a decimal fraction. The scaling factor is implicitly the number 10, raised to an exponent ranging from 0 to 28.

The return value is a four-element array of 32-bit signed integers.

The first, second, and third elements of the returned array contain the low, middle, and high 32 bits of the 96-bit integer number.

The fourth element of the returned array contains the scale factor and sign. It consists of the following parts:

Bits 0 to 15, the lower word, are unused and must be zero.

Bits 16 to 23 must contain an exponent between 0 and 28, which indicates the power of 10 to divide the integer number.

Bits 24 to 30 are unused and must be zero.

Bit 31 contains the sign: 0 mean positive, and 1 means negative.

Note that the bit representation differentiates between negative and positive zero. These values are treated as being equal in all operations.
...
Рейтинг: 0 / 0
03.08.2016, 15:32
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39285523
nojava
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
nojava
Участник
Dima TПоявилась мысль как сделать сравнимым double - округлять по окончанию расчета до необходимого количества знаков, но не более 15-ти, т.е. 14 после запятой.
 
Код: plaintext
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
char* double2hex(double x, char* buf) {
	sprintf(buf + 1, "%016llX", *((uint64_t*)&x));
	buf[0] = buf[1];
	buf[1] = buf[2];
	buf[2] = buf[3];
	buf[3] = '-';
	return buf;
}

int main()
{
	char buf[256];
	double x = 1.123456789012345;
	printf("x = %.15f %s\n", x, double2hex(x, buf));

	double y = 1.123456789012346;
	printf("y = %.15f %s\n", y, double2hex(y, buf));
	x = round(x * 1E14) / 1E14;
	printf("round(x) = %.15f %s\n", x, double2hex(x, buf));
	y = round(y * 1E14) / 1E14;
	printf("round(y) = %.15f %s\n", y, double2hex(y, buf));

	return 0;
}


Результат
Код: plaintext
1.
2.
3.
x =        1.123456789012345 3FF-1F9ADD3746F63
y =        1.123456789012346 3FF-1F9ADD3746F67
round(x) = 1.123456789012350 3FF-1F9ADD3746F79
round(y) = 1.123456789012350 3FF-1F9ADD3746F79

т.е. надо сделать тип, который кроме значения содержит точность, например при умножении точности складываются, при делении устанавливается максимально возможная для результата и т.д. Тогда можно проверять на равенство, т.е. это будет полноценный числовой тип. Да и NULL там есть, в смысле NaN.

Или как минимальный вариант: просто сделать функцию округления до заданного количества десятичных знаков и функцию сравнения, которая при проверке равенства округлит очень близкие значения.

Другой вопрос как затестить, 10^15 уже многовато для перебора, а тут еще варианты с разным количеством знаков после точки 14.1, 13.2, 12.3 и т.д.

:) у меня на Delphi еще в 99-м году была написана библиотека, с чудными функциями round2(), round100()

фактически да, так и было, любые попытки вычислить sum := round2(price * amount);

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

в общем трах был незабываемый.

что-то вроде этого

Код: pascal
1.
2.
3.
4.
5.
6.
function RoundCorrect(R: Real): LongInt;
begin
  Result:= Trunc(R);       // extract the integer part 
  if Frac(R) >= 0.5 then   // if fractional part >= 0.5 then...
    Result:= Result + 1;   // ...add 1
end;
...
Рейтинг: 0 / 0
03.08.2016, 16:05
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39285548
Dima T
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
Dima T
Участник
maytonДа и нечего думать. Ясен пень храни все в decimal. Деньги важны
и копейку терять нельзя.
Копейки все равно теряются - как ни крути. Округления никто не отменял т.к. учет идет с точностью до копейки. Есть дробные количества, разные методики расчета НДС и т.д. и т.п. Недавно прочитал что оказывается есть даже специальное банковское округление : округление происходит к ближайшему чётному, то есть 2,5 => 2, 3,5 => 4. Наверно в банках при регулярном начислении процентов эти копейки выливаются в круглую сумму.

C double проблемы видятся именно в сравнении, т.к. даже при больше/меньше есть проблемы. Например "цена < 100", а она записана с погрешностью как 99.99999999999 и все, попадет в выборку. Хотя можно написать "цена < 99.9999" но это ж помнить постоянно надо.

ХЗ почему MS похоронил тип money (64-битное целое со сдвигом на 4 разряда при выводе) и придумал этот decimal в C#. Int64 гораздо быстрее чем структура обрабатывается, т.к. нативный он для процов.
...
Рейтинг: 0 / 0
03.08.2016, 16:27
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39285566
Фотография Изопропил
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
Изопропил
Участник
Dima TХЗ почему MS похоронил тип money (64-битное целое со сдвигом на 4 разряда при выводе) и придумал этот decimal в C#.
чтоб NUMERIC(n,m) от SQL сервера получить
...
Рейтинг: 0 / 0
03.08.2016, 16:46
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39285574
nojava
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
nojava
Участник
Dima TmaytonДа и нечего думать. Ясен пень храни все в decimal. Деньги важны
и копейку терять нельзя.
Копейки все равно теряются - как ни крути.

вопрос не в том, что они теряются. вопрос в том, что они должны теряться правильно.
что еще больше усугубляется тем, что калькуляторы используют именно decimal float
ну и базы данных - тоже все числа считают как decimal

соответственно, во избежание расхождений на эти самые копейки - нужно везде использовать тот-же decimal
а money выпилили из-за невместительности, плюс он не бросает исключение на переполнении.

плюс у него есть существенный косяк - он операцию умножения дробных до округления делает не совсем верно.

плюс цены и количества могут иметь более 4-х знаков после запятой. короче тип не годный.
...
Рейтинг: 0 / 0
03.08.2016, 16:51
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39285602
booby
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
booby
Участник
Dima T,
банковское округление - почти случайный термин, оно настолько же банковское, насколько голландское, Гауссово или статистическое.
К счету денег именно как денег - непосредственного отношения не имеет .
Просто в IEEE 754 именно оно оказалось рекомендованным способом округления по умолчанию.
Потому библиотечные коды от Microsoft предпочитают его.
И да, в силу своих статистических свойств (оно дает несмещенную оценку среднего)
удобнее при вычислении баланса в тысячах .

Про деньги - другая история. И округление у денег - с приседом.
(Fixed point ариметика обладает "хорошими" свойствами по сложению, но на умножении
приезжают почти все те же истории.)
Пусть некий процесс счетом суммы по левой стороне дает
12.345,
а по правой - 12.34499999999999999999999999
Это - одно и то же число.
Только обычный "честный" Round(,2) для одного из них даст 12.35, а для другого - 12.34
При округлении в деньгах важно, чтобы в позиции, используемой для решения о том, куда округлять ( в данном случае в третьей) стояла точная цифра.
Этого можно добиться, только если предварительно провести округление до позиции дальше третьей.
+ исторически существовали (может и сейчас есть) деньги с тремя знаками после запятой.
Поэтому в денежном типе у Microsoft заявлено 4 знака.
Процедура приведения к этому типу гарантирует Round(,5) и все получившиеся 4 знака - точные. Теперь, наконец, уже в рамках этого типа, Round(,2) правомерен и дает правильный результат.
Т.е. если ты хочешь писать свой денежный тип, ты, так или иначе, должен повторить для него технику двойного округления.
...
Рейтинг: 0 / 0
03.08.2016, 17:24
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39285712
Dima T
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
Dima T
Участник
Склоняюсь к мысли вести учет в копейках. int32 для цен, int64 для сумм. Как вариант может не экономить и int64 для цен тоже. Есть нагрузка из-за форматирования на входе-выходе, но тут надо потестить. У меня самодельные ToString()/FromString().
...
Рейтинг: 0 / 0
03.08.2016, 19:50
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39285732
Фотография mayton
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
mayton
Участник
42 949 672 рублей 95 копеек в int?

Хватит-ли. Кроме того ограничения могут стрельнуть в другом месте
например если будет расчет арифметического среднего.
...
Рейтинг: 0 / 0
03.08.2016, 20:33
| Ответить | Цитировать | Написать  
inline extern из библиотеки, как правильно декларировать-имплементировать?
    #39285738
Dima T
Скрыть профиль Поместить в игнор-лист Сообщения автора в теме
Dima T
Участник
mayton42 949 672 рублей 95 копеек в int?

Хватит-ли. Кроме того ограничения могут стрельнуть в другом месте
например если будет расчет арифметического среднего.
В моем случае хватит, для цен сейчас хватает smallmoney в MSSQL т.е. максимум 214'748,3648 р., другое дело посчитать sum(price * kol) по большому количеству документов. Переход на копейки даст предел 21'474'836,48 что тоже немного, а int64 даст предел 92'233'720'368'547'758.08 что есть дофига.
...
Рейтинг: 0 / 0
03.08.2016, 20:59
| Ответить | Цитировать | Написать  
25 сообщений из 276, страница 8 из 12
  8  все
Форумы / C++ [игнор отключен] [закрыт для гостей] / inline extern из библиотеки, как правильно декларировать-имплементировать?
Найденые пользователи ...
Разблокировать пользователей ...
Читали тему (0):
Читали форум (0):
Пользователи онлайн (0):
x
x
Закрыть


Просмотр
0 / 0
Close
Debug Console [Select Text]