|
А как 1С хранит числа в памяти? | ☑ | ||
---|---|---|---|---|
0
Ненавижу 1С
гуру
02.05.12
✎
15:20
|
Собственно сабж, числовые значения как хранятся?
|
|||
1
el-gamberro
02.05.12
✎
15:22
|
В виде нулей и единиц.
|
|||
2
IamAlexy
02.05.12
✎
15:22
|
в памяти.. в памяти они хранятся..
иногда в файловом кеше... |
|||
3
Ахиллес
02.05.12
✎
15:23
|
Где голосовалка с традиционным пунктом?
|
|||
4
romix
02.05.12
✎
15:23
|
Вещественно, кажись. Размерность можно выяснить делениями наподобие 1/3.
|
|||
5
Адинэснег
02.05.12
✎
15:23
|
не знаю как одинэс, а одинэсник должен одно число хранить в памяти... 86 400
|
|||
6
IamAlexy
02.05.12
✎
15:24
|
(5) правильный 1сник напишет 24*60*60
|
|||
7
el-gamberro
02.05.12
✎
15:25
|
А как 1С хранит в памяти NULL и Неопределено?
|
|||
8
Ахиллес
02.05.12
✎
15:25
|
(7) В виде дырки от бублика.
|
|||
9
КМ155
02.05.12
✎
15:26
|
(0) флоат в формате IEEE тебя устроит ?
|
|||
10
marvak
02.05.12
✎
15:27
|
(0)
1C на MC++ вроде написан же? Как тот представляет так и 1С. Типа Int, Float. |
|||
11
pumbaEO
02.05.12
✎
15:28
|
еще вопрос почему "неопределенно" лишилось одной буквы "н" в 1С?
|
|||
12
orefkov
02.05.12
✎
15:28
|
(0)
Смотри в 1С++ исходники класса CNumeric. В 8ке ничего не поменялось. Вкратце там указатель на буфер DWORD'ов, каждый из которых кодирует 9 знаков числа, число - позиция точки и знак. |
|||
13
romix
02.05.12
✎
15:29
|
||||
14
romix
02.05.12
✎
15:38
|
Вот кстати интересный код:
//******************************************* Процедура Сформировать() d=1; n=0; Пока 1=1 Цикл n=n+1; d=d*2; Сообщить("n="+n+" d="+d); КонецЦикла; КонецПроцедуры Его вывод: n=1 d=2 n=2 d=4 n=3 d=8 n=4 d=16 n=5 d=32 n=6 d=64 n=7 d=128 n=8 d=256 n=9 d=512 n=10 d=1024 n=11 d=2048 n=12 d=4096 .... n=210 d=1645504557321206042154969182557350504982735865633579863348609024 n=211 d=3291009114642412084309938365114701009965471731267159726697218048 n=212 d=6582018229284824168619876730229402019930943462534319453394436096 n=213 d=1316403645856964833723975346045880403986188692506863890678887219 n=214 d=2632807291713929667447950692091760807972377385013727781357774438 n=215 d=5265614583427859334895901384183521615944754770027455562715548876 .... |
|||
15
romix
02.05.12
✎
15:39
|
Где-то с 200-го умножения на 2 получается сбой в арифметике!
|
|||
16
Ненавижу 1С
гуру
02.05.12
✎
15:40
|
(12) спасибо
как всегда первая десятка флудеры )) |
|||
17
romix
02.05.12
✎
15:43
|
А вот что происходит с последовательными делениями на 2:
n=1 d=0.5 n=2 d=0.25 n=3 d=0.125 n=4 d=0.0625 n=5 d=0.03125 n=6 d=0.015625 n=7 d=0.0078125 n=8 d=0.00390625 n=9 d=0.001953125 n=10 d=0.0009765625 n=11 d=0.00048828125 n=12 d=0.000244140625 n=13 d=0.0001220703125 n=14 d=0.00006103515625 n=15 d=0.000030517578125 n=16 d=0.0000152587890625 n=17 d=0.00000762939453125 n=18 d=0.000003814697265625 n=19 d=0.0000019073486328125 n=20 d=0.00000095367431640625 n=21 d=0.00000047683715820313 n=22 d=0.00000023841857910156 n=23 d=0.00000011920928955078 n=24 d=0.00000005960464477539 n=25 d=0.0000000298023223877 n=26 d=0.00000001490116119385 n=27 d=0.00000000745058059692 n=28 d=0.00000000372529029846 n=29 d=0.00000000186264514923 n=30 d=0.00000000093132257462 n=31 d=0.00000000046566128731 n=32 d=0.00000000023283064365 n=33 d=0.00000000011641532183 n=34 d=0.00000000005820766091 n=35 d=0.00000000002910383046 n=36 d=0.00000000001455191523 n=37 d=0.00000000000727595761 n=38 d=0.00000000000363797881 n=39 d=0.0000000000018189894 n=40 d=0.0000000000009094947 n=41 d=0.00000000000045474735 n=42 d=0.00000000000022737368 n=43 d=0.00000000000011368684 n=44 d=0.00000000000005684342 n=45 d=0.00000000000002842171 n=46 d=0.00000000000001421085 n=47 d=0.00000000000000710543 n=48 d=0.00000000000000355271 n=49 d=0.00000000000000177636 n=50 d=0.00000000000000088818 n=51 d=0.00000000000000044409 n=52 d=0.00000000000000022204 n=53 d=0.00000000000000011102 n=54 d=0.00000000000000005551 n=55 d=0.00000000000000002776 n=56 d=0.00000000000000001388 n=57 d=0.00000000000000000694 n=58 d=0.00000000000000000347 n=59 d=0.00000000000000000173 n=60 d=0.00000000000000000087 n=61 d=0.00000000000000000043 n=62 d=0.00000000000000000022 n=63 d=0.00000000000000000011 n=64 d=0.00000000000000000005 n=65 d=0.00000000000000000003 n=66 d=0.00000000000000000001 n=67 d=0.00000000000000000001 n=68 d=0 n=69 d=0 n=70 d=0 ... (но тут вроде все правильно) |
|||
18
НикДляЗапросов
02.05.12
✎
15:44
|
(16) как всегда ТС поленился написать чего ему надо
|
|||
19
orefkov
02.05.12
✎
15:45
|
(15)
Сбой не в арифметике, а в форматировании при выводе числа. Потенциально число в 1С - безразмерное, выдержит цифр, насколько памяти хватит. Единственно, при делении вроде до 13 знака идет округление. |
|||
20
romix
02.05.12
✎
15:47
|
(19) Вот еще здесь прикол в арифметике:
d=9999999999999999999999999999999999999999999999999999999999999999; n=0; Пока 1=1 Цикл n=n+1; d=d+1; Сообщить("n="+n+" d="+d); КонецЦикла; Вывод: ... n=96 d=1000000000000000000000000000000000000000000000000000000000000009 n=97 d=1000000000000000000000000000000000000000000000000000000000000009 n=98 d=1000000000000000000000000000000000000000000000000000000000000009 n=99 d=1000000000000000000000000000000000000000000000000000000000000009 n=100 d=1000000000000000000000000000000000000000000000000000000000000009 n=101 d=100000000000000000000000000000000000000000000000000000000000001 n=102 d=100000000000000000000000000000000000000000000000000000000000001 n=103 d=100000000000000000000000000000000000000000000000000000000000001 ... |
|||
21
orefkov
02.05.12
✎
15:47
|
(17), (19)
Ага, вижу что до 20го знака. Давно уже это было, позабывал все. |
|||
22
zzerro
02.05.12
✎
15:50
|
(15) Просто разрядности числа (всего 64 знака) не хватает и все последние цифры обрезаются.
|
|||
23
orefkov
02.05.12
✎
15:50
|
(20)
Еще раз скажу - проблем в арифметике там нет. Есть проблемы преобразования из числа в строку при выводе, и из строки в число при вводе. (а d=9999999999999999999999999999999999999999999999999999999999999999; и есть преобразование компилятором из строки-текста программы в число). |
|||
24
Ненавижу 1С
гуру
02.05.12
✎
15:50
|
(18) кто хотел понять - понял, а ты не кусайся ))
|
|||
25
NS
02.05.12
✎
15:51
|
(15) Ошибаешься. Нет там сбоя. Ограничение метода Сообщить() там есть.
Которое легко можно обойти. |
|||
26
НикДляЗапросов
02.05.12
✎
15:52
|
(24) Да я сам всегда так делаю, на собственном опыте вывод ))
|
|||
27
romix
02.05.12
✎
15:58
|
(23) Да, действительно, 1000 умножений на 2 и затем 1000 делений на 2 возвращает результат к 1.
d=1; n=0; Для й=1 по 1000 Цикл n=n+1; d=d*2; Сообщить("n="+n+" d="+d); КонецЦикла; n=0; Для й=1 по 1000 Цикл n=n+1; d=d/2; Сообщить("n="+n+" d="+d); КонецЦикла; |
|||
28
romix
02.05.12
✎
16:02
|
(23) Вот в этом опыте точно косяк с арифметикой: :-)
z=1+(1/3); d=1; n=0; Для й=1 по 1000 Цикл n=n+1; d=d*z; Сообщить("n="+n+" d="+d); КонецЦикла; n=0; Для й=1 по 1000 Цикл n=n+1; d=d/z; Сообщить("n="+n+" d="+d); КонецЦикла; Последнее значение выдачи: n=1000 d=0.99999999999999997559 |
|||
29
romix
02.05.12
✎
16:04
|
Или так и должно быть...
|
|||
30
H A D G E H O G s
02.05.12
✎
16:04
|
(28) Или с бесконечной дробью
|
|||
31
romix
02.05.12
✎
16:04
|
Попробую ей буфер переполнить...
|
|||
32
NS
02.05.12
✎
16:07
|
(28) До точки при операциях 1С хранит все знаки. После точки - не все.
Я пример на 7.7 выкладывал ( в восьмерке тоже самое) Сейчас найду. |
|||
33
romix
02.05.12
✎
16:09
|
100000 умножений на 2 и потом делений - полет нормальный.
z=2; d=1; n=0; Для й=1 по 100000 Цикл n=n+1; d=d*z; Состояние("n="+n+" d="+d); КонецЦикла; n=0; Для й=1 по 100000 Цикл n=n+1; d=d/z; Состояние("n="+n+" d="+d); КонецЦикла; Сообщить("d="+d); Когда же она переполнится? :0) |
|||
34
NS
02.05.12
✎
16:15
|
(33) ОФФ встроенный язык 1С не умеет умножать.
Пост (28) Штатно считает корень из двух с 1000 знаками после точки. |
|||
35
NS
02.05.12
✎
16:17
|
Буфер переполнить врятли сможешь.
С увеличением числа скорость операции умножения резко падает. В итоге до переполнения не доходит. |
|||
36
Serginio1
02.05.12
✎
16:17
|
||||
37
romix
02.05.12
✎
16:25
|
(35) При возведении в квадрат на 20 шаге резко призадумалась. Снял задачу. :-)
|
|||
38
romix
02.05.12
✎
16:31
|
Похоже, 8 байт выделяет на "после точки" и произвольное число байт - "до точки".
|
|||
39
romix
02.05.12
✎
16:42
|
Но перемножение чисел длиной 2097152 шестн. знаков друг на дружку выполняется что-то намного дольше (не дождался исполнения), чем умножение чисел длиной 1048576 знаков. Похоже там где-то уже после мегабайта цЫфр идет сбой матрицы, 2 мегабайта уже не переваривает.
|
|||
40
romix
02.05.12
✎
17:13
|
(36) Да вряд ли, там как раз дробный хвост выглядит размерностью 8 байт, а так было бы неэкономно в 20 байтах хранить то что можно в 8-и, и выравнивание в ОЗУ и все скорости исполнения бы пострадали.
|
|||
41
romix
02.05.12
✎
17:18
|
(12) А может число с фиксированной точкой - их по идее легче реализовывать. Два DWORD-а на хвост после запятой...
|
|||
42
romix
02.05.12
✎
17:19
|
А вот так подвешивает 1С-ку 7.7 (нехватка ОЗУ и подвисание) на шаге 28:
стр=" "; н=0; Для й= 1 По 30 Цикл н=н+1; стр=стр+стр; Сообщить("н="+н+" "+СтрДлина(стр)); КонецЦикла; |
|||
43
Serginio1
02.05.12
✎
17:27
|
Ну строка то у тебя 2 в 28 плюс возможна фрагментация памяти.
|
|||
44
NS
02.05.12
✎
17:31
|
(38) ошибаешься. При умножении 1С хранит все знаки.
25-ый релиз на дворе, а 1С так умножать и не научилась. Вот тут оригинал ветки из (34) |
|||
45
romix
02.05.12
✎
17:44
|
(43) В 8.2 тоже обрушивает 1С.
(44) Так я же про дробную часть: на нее выделено 8 байт, это целая часть может разрастаться до мегабайта (потом все подвисает). А вообще круто - кажется нигде больше такого нет. Можно посчитать атомы в Галактике. :-) |
|||
46
Serginio1
02.05.12
✎
18:14
|
К оглавлению
ГЛАВА 4 Классы-оболочки Числовые классы Класс Boolean Класс Character Класс Biglnteger Класс BigDecimal Класс Class Java — полностью объектно-ориентированный язык. Это означает, что все, что только можно, в Java представлено объектами. Восемь примитивных типов нарушают это правило. Они оставлены в Java из-за многолетней привычки к числам и символам. Да и арифметические действия удобнее и быстрее производить с обычными числами, а не с объектами классов. Но и для этих типов в языке Java есть соответствующие классы — классы-оболочки (wrapper) примитивных типов. Конечно, они предназначены не для вычислений, а для действий, типичных при работе с классами — создания объектов, преобразования объектов, получения численных значений объектов в разных формах и передачи объектов в методы по ссылке. На рис. 4.1 показана одна из ветвей иерархии классов Java. Для каждого примитивного типа есть соответствующий класс. Числовые классы имеют общего предка — абстрактный класс Number , в котором описаны шесть методов, возвращающих числовое значение, содержащееся в классе, приведенное к соответствующему примитивному типу: bytevalue (), doubievalue () , floatValue (), intValue(), longValue (), shortValue () . Эти методы переопределены в каждом из шести числовых классов-оболочек. Рис. 4.1. Классы примитивных типов Помимо метода сравнения объектов equals о, переопределенного из класса object , все описанные в этой главе классы, кроме Boolean и class , имеют метод compareTo () , сравнивающий числовое значение, содержащееся в данном объекте, с числовым значением объекта — аргумента метода compareTo() . В результате работы метода получается целое значение: 0, если значения равны; отрицательное число (—1), если числовое значение в данном объекте меньше, чем в объекте-аргументе; положительное число (+1), если числовое значение в данном объекте больше числового значения, содержащегося в аргументе. Что полезного в классах-оболочках? Числовые классы В каждом из шести числовых классов-оболочек есть статические методы преобразования строки символов типа string лредставляющей число, в соответствующий примитивный тип: Byte.parseByte(), Double.parseDouble(), Float.parseFloat(), Integer.parselnt(), Long.parseLong(), Short.parseShort() . Исходная строка типа string , как всегда в статических методах, задается как аргумент метода. Эти методы полезны при вводе данных в поля ввода, обработке параметров командной строки, т. е. всюду, где числа представляются строками цифр со знаками плюс или минус и десятичной точкой. В каждом из этих классов есть статические константы MAX_VALUE и MIN_VALUE , показывающие диапазон числовых значений соответствующих примитивных типов. В классах Double и Float есть еще константы POSITIVE_INFINITY, NEGATIVE_INFINITY, NaN , о которых шла речь в главе 1, и логические методы проверки isNan() , isInfinite() . Если вы хорошо знаете двоичное представление вещественных чисел, то можете воспользоваться статическими методами floatTointBits() и doubieToLongBits() , преобразующими вещественное значение в целое. Вещественное число задается как аргумент метода. Затем вы можете изменить отдельные биты побитными операциями и преобразовать измененное целое число обратно в вещественное значение методами intsitsToFioat() и longBitsToDouble() . Статическими методами toBinaryString(), toHexString() и toOctalString() классов integer и Long можно преобразовать целые значения типов int и long , заданные как аргумент метода, в строку символов, показывающую двоичное, шестнадцатеричное или восьмеричное представление числа. В листинге 4.1 показано применение этих методов, а рис. 4.2 демонстрирует вывод результатов. Рис. 4.2. Методы числовых классов ; Листинг 4.1. Методы числовых классов class NumberTest{ public static void main(String[] args){ int i = 0; short sh = 0; double d = 0; Integer kl = new Integer(55); Integer k2 = new Integer(100); Double dl = new Double(3.14); try{ i = Integer.parselnt(args[0]); sh = Short.parseShort(args[0]); d = Double.parseDouble(args[1]); dl = new Double(args[1]); kl = new Integer(args[0]); }catch(Exception e){} double x = 1.0/0.0; System.out.println("i = " + i) ; System.outjprintln("sh - " + sh) ; System.out.println("d. = " + d) ; System.out.println("kl.intValue() = " + kl.intValue()); System.out.println("dl.intValue() '= "'+ dl.intValuei)); System.out.println("kl > k2? " + kl.compareTo(k2)); System.out.println ("x = " + x); System.out.println("x isNaN? " + Double.isNaN(x)); System.out.println("x islnfinite? " + Double.islnfinite(x)); System.out.println("x == Infinity? " + (x == Double.POSITIVE_INFINITY) ); System.out.println("d = " + Double.doubleToLongBits(d)); System.out.println("i = " + Integer.toBinaryString(i)); System.out.println("i = " + Integer.toHexString(i)); System.out.println("i = " + Integer.toOctalString(i)); } } Методы parseint() и конструкторы классов требуют обработки исключений, поэтому в листинг 4.1 вставлен блок try{} catch(){} . Обработку исключительных ситуаций мы разберем в главе 16. Класс Boolean Это очень небольшой класс, предназначенный главным образом для того, чтобы передавать логические значения в методы по ссылке. Конструктор Boolean (String s) создает объект, содержащий значение true , если строка s равна " true " в любом сочетании регистров букв, и значение false — для любой другой строки. Логический метод booieanvalue() возвращает логическое значение, хранящееся в объекте. Класс Character В этом классе собраны статические константы и методы для работы с отдельными символами. Статический метод digit(char ch, in radix) переводит цифру ch системы счисления с основанием radix в ее числовое значение типа int . Статический метод forDigit(int digit, int radix) производит обратное преобразование целого числа digit в соответствующую цифру (тип char ) в системе счисления с основанием radix . Основание системы счисления должно находиться в диапазоне от Character.MIN_RADIX до Character.MAX_RADIX. Метод tostring() переводит символ, содержащийся в классе, в строку с тем же символом. Статические методы toLowerCase() , touppercase(), toTitieCase() возвращают символ, содержащийся в классе, в указанном регистре. Последний из этих методов предназначен для правильного перевода в верхний регистр четырех кодов Unicode, не выражающихся одним символом. Множество статических логических методов проверяют различные характеристики символа, переданного в качестве аргумента метода: isDef ined() — выясняет, определен ли символ в кодировке Unicode; isDigit() — проверяет, является ли символ цифрой Unicode; isidentifierignorable() — выясняет, нельзя ли использовать символ в идентификаторах; isisocontroi() — определяет, является ли символ управляющим; isJavaidentifierPart() — выясняет, можно ли использовать символ в идентификаторах; isjavaidentifierstart() — определяет, может ли символ начинать идентификатор; isLetter() — проверяет, является ли символ буквой Java; IsLetterOrDigit() — Проверяет, является ли символ буквой или цифрой Unicode; isLowerCase() — определяет, записан ли символ в нижнем регистре; isSpaceChar() — выясняет, является ли символ пробелом в смысле Unicode; isTitieCase() — проверяет, является ли символ титульным; isUnicodeldentifierPart() — выясняет, можно ли использовать символ в именах Unicode; isunicodeidentifierstart() — проверяет, является ли символ буквой Unicode; isUpperCase() — проверяет, записан ли символ в верхнем регистре; isWhitespace() — выясняет, является ли символ пробельным. Точные диапазоны управляющих символов, понятия верхнего и нижнего регистра, титульного символа, пробельных символов, лучше всего посмотреть по документации Java API. Листинг 4.2 демонстрирует использование этих методов, а на рис. 4.3 показан вывод этой программы. Листинг 4.2. Методы класса Character в программе CharacterTest class CharacterTest{ public static void main(String[] args){ char ch = '9'; Character cl = new Character(ch); System.out.println("ch = " + ch); System.out.println("cl.charValue() = " + c1.charValue()); System.out.println("number of 'A' = " + Character.digit('A', 16}}; System.out.println("digit for 12 = " + Character.forDigit(12, 16}}; System.out.printlnC'cl = " + cl.toString() ); System.out.println("ch isDefined? " + Character.isDefined(ch)); System.out.println("ch isDigit? " + Character.isDigit(ch)); System.out.println("ch isldentifierlgnorable? " + Character.isldentifierlgnorable(ch)); System.out.println("ch isISOControl? " + Character.isISOControl(ch)); System.out.println("ch isJavaldentifierPart? " + Character.isJavaldentifierPart(ch)); System.out.println("ch isJavaldentifierStart? " + Character.isJavaldentifierStart(ch)); System.out.println("ch isLetter? " + Character.isLetter(ch)); System.out.println("ch isLetterOrDigit? " + Character.isLetterOrDigit(ch)); System.out.println("ch isLowerCase? " + Character.isLowerCase(ch)); System.out.println("ch isSpaceChar? " + Character.isSpaceChar(ch)); System.out.println("ch isTitleCase? " + Character.isTitleCase(ch)); System.out.println("ch isUnicodeldentifierPart? " + Character.isUnicodeldentifierPart(ch)); System.out.println("ch isUnicodeldentifierStart? " + Character.isUnicodeldentifierStart(ch)); System.out.println("ch isUpperCase? " + Character.isUpperCase(ch)); System.out.println("ch isWhitespace? " + Character.isWhitespace(ch)); } } В класс Character вложены классы Subset и UnicodeBlock , причем класс Unicode и еще один класс, inputSubset , являются расширениями класса Subset , как это видно на рис. 4.1. Объекты этого класса содержат подмножества Unicode. Рис. 4.3. Методы класса Character в программе CharacterTest Вместе с классами-оболочками удобно рассмотреть два класса для работы со сколь угодно большими числами. Класс Biglnteger Все примитивные целые типы имеют ограниченный диапазон значений. В целочисленной арифметике Java нет переполнения, целые числа приводятся по модулю, равному диапазону значений. Для того чтобы было можно производить целочисленные вычисления с любой разрядностью, в состав Java API введен класс Biglnteger , хранящийся в пакете java.math . Этот класс расширяет класс Number , следовательно, в нем переопределены методы doubleValue(), floatValue(), intValue(), longValue() . Методы byteVaiue() и shortvalue() не переопределены, а прямо наследуются от класса Number . Действия с объектами класса Biglnteger не приводят ни к переполнению, ни к приведению по модулю. Если результат операции велик, то число разрядов просто увеличивается. Числа хранятся в двоичной форме с дополнительным кодом. Класс Big Decimal Класс BigDecimal расположен В пакете java.math . Каждый объект этого класса хранит два целочисленных значения: мантиссу вещественного числа в виде объекта класса Biglnteger , и неотрицательный десятичный порядок числа типа int . Например, для числа 76.34862 будет храниться мантисса 7 634 862 в объекте класса Biglnteger , и порядок 5 как целое число типа int . Таким образом, мантисса может содержать любое количество цифр, а порядок ограничен значением константы integer.MAX_VALUE . Результат операции над объектами класса BigDecimal округляется по одному из восьми правил, определяемых следующими статическими целыми константами: |
|||
47
Serginio1
02.05.12
✎
18:16
|
(45) плохо скопировал. Есть в яве
Класс Biglnteger Все примитивные целые типы имеют ограниченный диапазон значений. В целочисленной арифметике Java нет переполнения, целые числа приводятся по модулю, равному диапазону значений. Для того чтобы было можно производить целочисленные вычисления с любой разрядностью, в состав Java API введен класс Biglnteger , хранящийся в пакете java.math . Этот класс расширяет класс Number , следовательно, в нем переопределены методы doubleValue(), floatValue(), intValue(), longValue() . Методы byteVaiue() и shortvalue() не переопределены, а прямо наследуются от класса Number . Действия с объектами класса Biglnteger не приводят ни к переполнению, ни к приведению по модулю. Если результат операции велик, то число разрядов просто увеличивается. Числа хранятся в двоичной форме с дополнительным кодом. Класс Big Decimal Класс BigDecimal расположен В пакете java.math . Каждый объект этого класса хранит два целочисленных значения: мантиссу вещественного числа в виде объекта класса Biglnteger , и неотрицательный десятичный порядок числа типа int . Например, для числа 76.34862 будет храниться мантисса 7 634 862 в объекте класса Biglnteger , и порядок 5 как целое число типа int . Таким образом, мантисса может содержать любое количество цифр, а порядок ограничен значением константы integer.MAX_VALUE . Результат операции над объектами класса BigDecimal округляется по одному из восьми правил, определяемых следующими статическими целыми константами: |
|||
48
Злопчинский
02.05.12
✎
18:18
|
году этак перед 90-ым.. когда поплотнее столкнулся... был поражен до глубины души.. когда выяснилось что числа хранятся как текст... я понял, что этот мир обречен...
|
|||
49
Злопчинский
02.05.12
✎
18:18
|
про DBF речь...
|
|||
50
Fragster
гуру
02.05.12
✎
18:21
|
(42) а зачем два счетчика?
|
|||
51
Fragster
гуру
02.05.12
✎
18:22
|
ну и максимальная точность - 32 почему-то
|
|||
52
Kreont
02.05.12
✎
18:27
|
(0) Можно попробовать проверить через DynamicWrapperX, прямо читая с памяти
Я когда так добирался к строкам то узнал много нового :) И про уникод, и про то что строка начинается через 4 байта вроде и тп. |
|||
53
H A D G E H O G s
02.05.12
✎
18:30
|
(52) Как адрес переменной узнаешь?
|
|||
54
orefkov
02.05.12
✎
18:30
|
(45)
Да нет там разницы в хранении до запятой и после. Есть буфер, в котором лежат цифры числа. И одно число, показывающее, где в этом буфере десятичная точка. При умножении сохраняются все цифры числа, при делении округляет до 20 знаков после запятой. |
|||
55
Kreont
02.05.12
✎
18:39
|
(53) о нашел мануал:
http://www.script-coding.com/dynwrapx.html под 7-ку, вроде так: Wrapper = CreateObject("DynamicWrapperX"); а=5.00001; Сообщить(Wrapper.NumGet(а,0,"l")); Сообщить(Wrapper.NumGet(а,1,"l")); Сообщить(Wrapper.NumGet(а,2,"l")); Сообщить(Wrapper.NumGet(а,3,"l")); // хз, что-так можно пробовать |
|||
56
NS
02.05.12
✎
18:44
|
(45) и я про дробную часть. В примере 1. И куча знаков после точки. Нет ограничения.
|
|||
57
romix
02.05.12
✎
19:14
|
(54) А здорово. Немножко не допилили до совершенства, а так было бы всем системам на зависть.
|
|||
58
ILM
гуру
02.05.12
✎
19:49
|
На баше вроде было: - Невье..бено большая сумма.
|
|||
59
Кирпич
03.05.12
✎
08:20
|
Насчет бесконечно больших чисел в 1с. Про функцию Exp написано:
Если значение параметра настолько велико, что вызывает при вычислении арифметическое переполнение (параметр превышает 709.78271289338397, при этом значение последнего разряда не оказывает влияние на результат), то происходит ошибка "Неправильное значение аргумента встроенной функции (Exp)". |
|||
60
Torquader
03.05.12
✎
23:29
|
(55) а при передаче значений через ole-контекст происходит преобразование к стандартному типу double или currency,так как внутренние типы 1С наружу не передаются.
|
Форум | Правила | Описание | Объявления | Секции | Поиск | Книга знаний | Вики-миста |