Есть какая нибудь приблада для округления числа до сотен или тысяч. Допустим число 86 округляем до 100, 869 до 1000, 1260 до 2000, 15684 до 16000 и т.д

Если самому писать то думаю только через длину числа и на сравнение последнего символа на 0.

Встроенные функции языка
Окр (Round)
Синтаксис:
Окр(<Число>, <Разрядность>, <Режим округления>)
Параметры:
<Число> (обязательный)
Тип: Число. Исходное число.
<Разрядность> (необязательный)
Тип: Число. Определяет число знаков дробной части, до которых производится округление. Если параметр отрицательный, то число округляется до соответствующего разряда в целой части, начиная с младших разрядов.
Параметр обязательный, если указан параметр <Режим округления>.
Значение по умолчанию: 0

нипаверишь,)
Число = Окр(86145,-3);    
Сообщить(Число);

(2) Внимательно читаем "Определяет число знаков дробной части"

(3) Счаз проверю

(4) а умножить поделить )

(4) внимательно читаем "Если параметр отрицательный ..."

(4) Внимательно читаем: " Если параметр отрицательный, то число округляется до соответствующего разряда в целой части"

Тысяча чертей

Не то

Надо в большую сторону

(10) Раздели - возьми Цел - умножЪ

Блин туплю все вопрос снят

А мне вот надо было округлять до ближайшего(обязательно сверху) целого. Такой функции или режима известных функций не нашел.

(14) раз в неделю такая фигня.... Окр(Твое+0.4999999999)

(15) Наверное ЦЕЛ(Твое+0.5)

а, не... не пойдет

Число = 15684;
Разрядов = СтрДлина(СтрЗаменить(Строка(Число), Символы.НПП,""));
Разрядов = ?(Разрядов<2,2,Разрядов);
Разрядов = ?(Разрядов>3,3,Разрядов);
Делитель = Pow(10,Разрядов);
ЦелЧисло = Цел(Число/Делитель)+1;
Результат = ЦелЧисло * Делитель;

(16) через Цел: Цел(Твое+0,9999999999999999)

2(19) Ну или так...
Или, чтобы не зависеть от количества девяток и точности дробной части в числе:
?(Цел(Твое)=Твое,Твое,Цел(Твое+1))

Твое = Цел(Твое) + (Твое-Цел(Твое)>0.0);

(21) +
// округление 0.5 в большую сторону:
Твое = Цел(Твое) + (Твое-Цел(Твое)>=0.5);

// округление 0.5 в меньшую сторону:
Твое = Цел(Твое) + (Твое-Цел(Твое)>0.5);

(21,22) а как ты число и булево складываешь интересно...

(14) а если число целое? например 13?

(15):-) так я и написал нечто подобное, но таки такого режима округления в типовых функциях нет. Просто научись читать то, что пишет автор, а не то, что думаешь ты :-)

(24)А если число целое, то 13=13 - т.е. никакого округления вверх. поэтому пример в (15) Окр(Твое+0.4999999999) скоропалителен и в общем случае неверен. А у меня именно общий случай и был :-) Т.е. количество необходимых девяток заранее неизвестно. Понятно, что и движок имеет определенную точность вычислений, но дела это не облегчало, поскольку были возможны ситуации типа 13,0...01.

(26) а проверить? окр(13+0,499999999) = 13

а девяток там лепить по желанию...

(28)+ и по точности... в типовых больше 5 точности не видел, так что могу врать... ну да 9 девяток должно хватить полюбому, ибо 1с - не для научных расчетов используется :)

(26) понятно

(29) Мне бы вашу уверенность :)
Сообщить(13.1/13); // в окне будет выведено 1,007692307692307692307692307692307692

(24) А проверить? А вот так убедительно звучит:
Твое = 13.00;
Твое = Цел(Твое) + (Твое-Цел(Твое)>0.0);
Сообщить(Твое); //"13"

Твое = 13.0000000000000000000000000000000000000000000000000000000000000000000000001;
Твое = Цел(Твое) + (Твое-Цел(Твое)>0.0);
Сообщить(Твое); //"14"

(27)Я немного неправильно построил пост. То, что окр(13+0,499999999) = 13 я не сомневаюсь. Неверность в общем случае касалась именно количества девяток.
(28)Мое желание тут ни при чем. Просто разрядность заранее неизвестна и неизвестно, как тот или иной релиз движка будет отрабатывать ситуацию с очень большим числом девяток. Может получиться как с интеловскими процами в свое время, когда народ нарыл, что они из-за некоего упрощения или ошибки в алгоритме ошибаются на некие миллипизерные цифирьки.

(32) я спрашивал надо ли 13 округлять до 14 )))

Я использовал более корректный, но чуть-чуть более сложный алгоритм.

(33) Глянь 20 - работает...

(36)А чего глядеть? Я примерно так и сделал :-) Только реализовал это в виде функции, сходной с Окр()

(32) я всегда думал, что в булево - ложь - это 0, а истина - это не 0

(37)а, понел... :)

(38)+ в смысле, оно не всегда равно 1, и по этому в (32) - некорректное использование

(34) Дык, ведь в (14) спросили :) Я и рад стараться (32)

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

Окр(13.01 + 0.499) = 14.

(40) А что не так?
Булево (Boolean)
Синтаксис:
Булево(<Значение>)
Параметры:
<Значение> (обязательный)
Тип: Число, Булево. Исходное значение.
Возвращаемое значение:
Тип: Булево. Полученное значение.
Описание:
Преобразует полученный параметр в значение типа Булево.
Преобразование числа к типу Булево производится по следующим правилам:
0 преобразуется в Ложь;
ОСТАЛЬНЫЕ ЗНАЧЕНИЯ преобразуются в Истина.

(43) а про обратное преобразование

(44) прочитал

(43) здесь нигде не сказано, что ИСТИНА = 1. То есть в общем случае получается

Твое = Цел(Твое) + ОстальныеЗначения;

Да, поверьте мне на слово :)

Если Твое Тогда
  Соообщить("Любое число - ИСТИНА");
Иначе
  Сообщить("и только 0 - ЛОЖЬ");
КонецЕсли;

(46,47) в правилах преобразования к числу прочитал, что истина к единице преобразуется... в этом плане инетересо Число(Твое=Твое) всегда 1

Ну..
Цел(13.3)+((13.3-Цел(13.3))>0.0)=14, это я в табло проверил
Цел(13)+((13-Цел(13))>0.0) = 13

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

(41) я почему-то решил, что и 13 надо до 14 "округлять" (до ближайшего(обязательно сверху) целого). Я, наверное, один такой )))

(50) ну тогда Цел(Твое)+1 канает

(50) тогда легче, никаких условий не надо...

Шутки-шутками, но дело... 1С позволяет "управлять" округлением, но: в запросах ей "помогает" SQL :) - а у него другие "соображения" насчёт округлений :))