Как округлить число в си шарп
Перейти к содержимому

Как округлить число в си шарп

  • автор:

Math. Ceiling Метод

Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.

Возвращает наименьшее целое число, которое больше или равно указанному числу.

Перегрузки

Возвращает наименьшее целое число, которое больше или равно заданному десятичному числу.

Возвращает наименьшее целое число, которое больше или равно заданному числу с плавающей запятой двойной точности.

Комментарии

Поведение этого метода соответствует стандарту IEEE 754, раздел 4. Такое округление иногда называют округлением в сторону положительной бесконечности.

Ceiling(Decimal)

Возвращает наименьшее целое число, которое больше или равно заданному десятичному числу.

public: static System::Decimal Ceiling(System::Decimal d);
public static decimal Ceiling (decimal d);
static member Ceiling : decimal -> decimal
Public Shared Function Ceiling (d As Decimal) As Decimal
Параметры
Возвращаемое значение

Наименьшее целое число, которое больше или равно d . Обратите внимание, что данный метод возвращает не целочисленное значение, а значение типа Decimal.

Примеры

В следующем примере показан Math.Ceiling(Decimal) метод и он контрастирует с методом Floor(Decimal) .

decimal[] values = ; Console.WriteLine(" Value Ceiling Floor\n"); foreach (decimal value in values) Console.WriteLine("  ", value, Math.Ceiling(value), Math.Floor(value)); // The example displays the following output to the console: // Value Ceiling Floor // // 7.03 8 7 // 7.64 8 7 // 0.12 1 0 // -0.12 0 -1 // -7.1 -7 -8 // -7.6 -7 -8 
// The ceil and floor functions may be used instead. let values = [ 7.03m; 7.64m; 0.12m; -0.12m; -7.1m; -7.6m ] printfn " Value Ceiling Floor\n" for value in values do printfn $"  " // The example displays the following output to the console: // Value Ceiling Floor // // 7.03 8 7 // 7.64 8 7 // 0.12 1 0 // -0.12 0 -1 // -7.1 -7 -8 // -7.6 -7 -8 
Dim values() As Decimal = Console.WriteLine(" Value Ceiling Floor") Console.WriteLine() For Each value As Decimal In values Console.WriteLine("  ", _ value, Math.Ceiling(value), Math.Floor(value)) Next ' The example displays the following output to the console: ' Value Ceiling Floor ' ' 7.03 8 7 ' 7.64 8 7 ' 0.12 1 0 ' -0.12 0 -1 ' -7.1 -7 -8 ' -7.6 -7 -8 

Комментарии

Поведение этого метода соответствует стандарту IEEE 754, раздел 4. Такое округление иногда называют округлением в сторону положительной бесконечности. Иными словами, если d является положительным, то наличие любого дробного компонента приводит d к округлению до следующего наибольшего целого числа. Если d значение отрицательное, операция округления приводит к отмене любого дробного компонента d . Операция этого метода отличается от Floor(Decimal) метода , который поддерживает округление в сторону отрицательной бесконечности.

См. также раздел

Применяется к

Ceiling(Double)

Возвращает наименьшее целое число, которое больше или равно заданному числу с плавающей запятой двойной точности.

public: static double Ceiling(double a);
public static double Ceiling (double a);
static member Ceiling : double -> double
Public Shared Function Ceiling (a As Double) As Double
Параметры

Число двойной точности с плавающей запятой.

Возвращаемое значение

Наименьшее целое число, которое больше или равно a . Если значение параметра a равно NaN, NegativeInfinity или PositiveInfinity, возвращается это значение. Обратите внимание, что данный метод возвращает не целочисленное значение, а значение типа Double.

Примеры

В следующем примере показан Math.Ceiling(Double) метод и он контрастирует с методом Floor(Double) .

double[] values = ; Console.WriteLine(" Value Ceiling Floor\n"); foreach (double value in values) Console.WriteLine("  ", value, Math.Ceiling(value), Math.Floor(value)); // The example displays the following output to the console: // Value Ceiling Floor // // 7.03 8 7 // 7.64 8 7 // 0.12 1 0 // -0.12 0 -1 // -7.1 -7 -8 // -7.6 -7 -8 
// The ceil and floor functions may be used instead. let values = [ 7.03; 7.64; 0.12; -0.12; -7.1; -7.6 ] printfn " Value Ceiling Floor\n" for value in values do printfn $"  " // The example displays the following output to the console: // Value Ceiling Floor // // 7.03 8 7 // 7.64 8 7 // 0.12 1 0 // -0.12 0 -1 // -7.1 -7 -8 // -7.6 -7 -8 
Dim values() As Double = Console.WriteLine(" Value Ceiling Floor") Console.WriteLine() For Each value As Double In values Console.WriteLine("  ", _ value, Math.Ceiling(value), Math.Floor(value)) Next ' The example displays the following output to the console: ' Value Ceiling Floor ' ' 7.03 8 7 ' 7.64 8 7 ' 0.12 1 0 ' -0.12 0 -1 ' -7.1 -7 -8 ' -7.6 -7 -8 

Комментарии

Поведение этого метода соответствует стандарту IEEE 754, раздел 4. Такое округление иногда называют округлением в сторону положительной бесконечности. Иными словами, если a является положительным, то наличие любого дробного компонента приводит a к округлению до следующего наибольшего целого числа. Если a значение отрицательное, операция округления приводит к отмене любого дробного компонента a . Операция этого метода отличается от Floor(Double) метода , который поддерживает округление в сторону отрицательной бесконечности.

Начиная с Visual Basic 15.8, производительность преобразования double-to-integer оптимизирована при передаче значения, возвращаемого методом, в любую из функций целочисленного преобразования или если значение Double, возвращаемое , автоматически преобразуется в целое число с параметром Ceiling Ceiling Option Strict, равным Off. Эта оптимизация позволяет коду выполняться быстрее — до двух раз быстрее для кода, который выполняет большое количество преобразований в целочисленные типы. В следующем примере показаны такие оптимизированные преобразования:

Dim d1 As Double = 1043.75133 Dim i1 As Integer = CInt(Math.Ceiling(d1)) ' Result: 1044 Dim d2 As Double = 7968.4136 Dim i2 As Integer = CInt(Math.Ceiling(d2)) ' Result: 7969 

Учимся округлять в C#

А знаете ли вы, что Math.Round(1.5) == Math.Round(2.5) == 2 ? Можете ли сходу сказать, сколько будет -7%3 и 7%-3 ? Помните ли, чем отличаются Math.Round , Math.Floor , Math.Ceiling , Math.Truncate ? А как происходит округление при использовании string.Format ? Давайте немного погрузимся в мир округлений и разберёмся с нюансами, которые не для всех могут быть очевидными.

Math.Round

 Math.Round — это метод округления к ближайшему числу или к ближайшему числу с заданным количеством знаков после запятой. Работает с типами decimal и double , в параметрах можно встретить три вида параметров:
  • value : округляемое число
  • digits : количество знаков в дробной части, которые нужно оставить
  • mode : параметр, который определяет в какую сторону округлять число, которое находится ровно посередине между двумя вариантами

Параметр mode используется, когда округляемое значение находится ровно посередине между двумя вариантами. Принимает значение из следующего перечисления:

Обратите внимание, что по умолчанию mode == MidpointRounding.ToEven , поэтому Math.Round(1.5) == Math.Round(2.5) == 2 .

Math.Floor, Math.Ceiling, Math.Truncate

Сводная таблица

Сориентироваться в методах округления может помочь следующая табличка:

Округление проводится в соответствии со стандартом IEEE Standard 754, section 4.

Целочисленное деление и взятие по модулю

В C# есть два замечательных оператора над целыми числами: / для целочисленного деления (MSDN) и % для взятия остатка от деления (MSDN). Деление производится по следующим правилам:

  • При целочисленном делении результат всегда округляется по направлению к нулю.
  • При взятии остатка от деления должно выполняться следующее правило: x % y = x – (x / y) * y

Также можно пользоваться шпаргалкой:

string.Format

При форматировании чисел в виде строки можно пользоваться функцией string.Format (см. Standard Numeric Format Strings, Custom Numeric Format Strings). Например, для вывода числа с двумя знаками после десятичной точки можно воспользоваться string.Format(«», value) или string.Format(«», value) . Округление происходит по принципу AwayFromZero . Проиллюстрируем правила округления очередной табличкой:

", value) |       

Задачи

На приведённую тему есть две задачки в ProblemBook.NET: Rounding1, Rounding2.

  • GitHub
  • Twitter
  • RSS

Округление в C#

Есть число типа double Нужно округлить данное число до N знаков после запятой используя округления: математическое (обычное школьное), банкирское (к ближайшемо чётному), обрезание (просто обрезать до N знаков после запятой) Как это сделать средствами языка C# ? Пример: value = 0.428509, N = 3 мат. :0.429 банк. :0.428 обрез. :0.428

Отслеживать
8,592 4 4 золотых знака 29 29 серебряных знаков 53 53 бронзовых знака
задан 5 мар 2018 в 22:25
197 1 1 серебряный знак 12 12 бронзовых знаков

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

Для начала, округление не до целого числа не имеет смысла для чисел типа double , т. к. числа наподобие 0.1 вовсе не могут быть представлены точно в виде двоичных дробей.

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

Заметьте, что разные типы округления дают разные результаты только в случае, когда исходное число заканчивается на 5, и округление происходит на один разряд. В противном случае округление всегда идёт вниз для последней цифры меньше 5, или вверх для больше 5. В вашем примере последняя цифра — не 5, и правильный результат для банковского округления — тоже 0.429m . Результат 0.428m был бы для числа 0.4285m . ( m в конце обозначает константу типа decimal )

Для банковского округления есть стандартная функция:

decimal value = 0.428509m; int N = 3; decimal bankers = decimal.Round(value, N, MidpointRounding.ToEven); 

Если вы подразумеваете под обычным школьным округлением округление, которое для чисел заканчивающихся на 5 округляет вверх, используйте

 decimal standard = decimal.Round(value, N, MidpointRounding.AwayFromZero); 

Для truncate (обрезания) поддержки в стандартной библиотеке нет, и вам нужно сначала вычислить 10m в степени N (умножением в цикле), умножить value на получившееся число, выполнить decimal.Truncate , а затем поделить назад. Код, надеюсь, напишете сами?

Округление десятичных значений в C#

Тип данных decimal используется для хранения чисел с высоким уровнем точности. Потенциально большое количество знаков после запятой полезно для многих математических или статистических расчетов. Тем не менее, иногда необходимо и округлять эти значения. Эта проблема не так часто волнует разработчиков, пишущих программы на заказ, но для студентов или самостоятельно изучающих язык C# статья ниже может оказаться весьма полезной.

Округление значения

C# предоставляет три собственные числовые типы данных для хранения значений с плавающей запятой. К ним относятся одинарной точности, двойной точности и десятичные числа, которые объявляются с помощью «float», «double» и «decimal» ключевых слов соответственно. Каждый из этих типов имеет различный диапазон возможных значений с различной степенью точности. Тип » float » является наименее точным с наименьшим диапазоном значений. Тип «decimal» имеет самый большой диапазон и наибольшую точность. Выбор типа значения для использования в любых целях является компромиссом между требованиями размера и точности чисел и объемом памяти, используемой объявленной переменной.

В этой статье мы будем работать с типом данных decimal, но акцентируем внимание не на его размере и точности, а на дополнительной функциональности, присущей этому типу в отличие от двух других вариантов. В частности, мы будем использовать четыре статических метода округления, которые доступны только для десятичных значений. Конечно, это можно использовать и для одно- и двойной чисел точности тоже. Однако в этих случаях необходимо сначала привести к или преобразовать значение в decimal или использовать члены класса Math.

Обратите внимание: Методы, описанные в этой статье, требуют .NET Framework версии 2.0 или более поздней версии. Некоторые из функций доступны в .NET 1.1, но там использование может быть ограничено.

Одним из основных способов округления decimal является Truncate (усечение). При усечении, все дробные цифры просто удаляются из числа, оставляя только целую часть, хотя по-прежнему число удерживается в десятичной системе. Это можно легко продемонстрировать с помощью следующего кода. Обратите внимание, как дробная часть удаляется, а значения округляются вниз до ближайшего целого числа в первых двух строках. В третьей строке значение остается неизменным, так как нет дробной части. В двух последних строках отрицательные значения эффективно округляются в сторону увеличения.

decimal pr; pr = decimal.Truncate(1.1M); // pr = 1 pr = decimal.Truncate(1.8M); // pr = 1 pr = decimal.Truncate(1M); // pr = 1 pr = decimal.Truncate(-1.1M); // pr = -1 pr = decimal.Truncate(-1.8M); // pr = -1

Floor и Ceiling

Статические методы Floor и Ceiling выполняют аналогичные функции усечения: они удаляют дробную часть числа и возвращают целое число. Опять же целое число возвращается в десятичной структуре. Основное различие между этими методами и Truncate является то, что направление округления фиксируется как для положительных и отрицательных чисел. Для функции Floor округление всегда вниз, а Ceilin всегда вверх, как можно видеть в результатах примере кода ниже.

decimal res; res = decimal.Floor(1.1M); // res = 1 res = decimal.Floor(1.8M); // res = 1 res = decimal.Floor(1M); // res = 1 res = decimal.Floor(-1.1M); // res = -2 res = decimal.Floor(-1.8M); // res = -2 res = decimal.Ceiling(1.1M); // res = 2 res = decimal.Ceiling(1.8M); // res = 2 res = decimal.Ceiling(1M); // res = 1 res = decimal.Ceiling(-1.1M); // res = -1 res = decimal.Ceiling(-1.8M); // res = -1

Контролируемые округления

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

В заключительной части этой статьи мы рассмотрим метод Round более подробно.

Простое округление

Самый простой способ, которым можно использовать метод Round, это с одним параметром, содержащим число, которое надо изменить. При использовании таким образом возвращаемое значение содержит целое число, которое ближе всего к переданному значению.

decimal res; res = decimal.Round(1.1M); // res = 1 res = decimal.Round(1.8M); // res = 2 res = decimal.Round(1M); // res = 1

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

result = decimal.Round(1.5M); // result = 2 result = decimal.Round(2.5M); // result = 2

Можно было бы ожидать, что оба значения округляются в сторону увеличения и метод возвратит 2 и 3 соответственно. Однако, по умолчанию, этот метод использует правило средней точки (медианы), которое гласит, что когда значение округляется ровно на полпути между двумя целыми числами, всегда выбирается ближайшее значение.

Правила медианы

Два правила средней точки доступны при округлении значений. Первое правило по умолчанию, что мы видели в предыдущем примере. Это «сравнять» правило. В качестве альтернативы есть правило «от нуля», которое гласит, что, когда округляемое значение находится на полпути между двумя возможными результатами, всегда выбирают значение, которое дальше от нуля. При положительных значениях это означает, что округление вверх и для отрицательных чисел результат округляется вниз.

Чтобы задать правило, параметр MidpointRounding добавляется к вызову метода.

decimal res; res = decimal.Round(1.5M, MidpointRounding.ToEven); // res = 2 res = decimal.Round(2.5M, MidpointRounding.ToEven); // res = 2 res = decimal.Round(1.5M, MidpointRounding.AwayFromZero); // res = 2 res = decimal.Round(2.5M, MidpointRounding.AwayFromZero); // res = 3 res = decimal.Round(-2.5M, MidpointRounding.AwayFromZero); // res = -3

Округление до указанного количества десятичных знаков

Все примеры до сих пор рассматривали округление значения, когда в результате возвращается целое число. Однако метод Round позволяет также округление до определенного количества знаков после запятой. Это достигается путем определения необходимого количества знаков после запятой в качестве второго параметра метода, как показано в следующих примерах:

decimal res; res = decimal.Round(1.2345M, 1); // res = 1.2 res = decimal.Round(1.2345M, 2); // res = 1.23 res = decimal.Round(1.2345M, 3); // res = 1.234

Здесь правило медианы по умолчанию «ToEven» применяется для округления, за исключением того, что конченая цифра округляется до ближайшего четного числа.

res= decimal.Round(1.25M, 1); // res= 1.2 res = decimal.Round(1.35M, 1); // res = 1.4

Вы можете изменить правило медианы, используется при округлении до количества знаков после запятой. Чтобы сделать это, просто добавьте значение MidpointRounding в качестве третьего параметра:

res = decimal.Round(1.25M, 1, MidpointRounding.AwayFromZero); // res = 1.3 res = decimal.Round(1.35M, 1, MidpointRounding.AwayFromZero); // res = 1.4

Примечание из msdn.microsoft.com к Math.Round

Из-за потери точности, которая может быть результатом представления десятичных значений как чисел с плавающей точкой и выполнения арифметических операций с плавающей запятой, в некоторых случаях в Round(Double, Int32) может отсутствовать округление среднего значения до ближайшего четного значения цифр десятичной позиции. Это показано в следующем примере, где 2.135 округляется до 2,13 вместо 2.14. Это происходит потому, что внутренний метод умножает значение на 10 разрядов, и операция умножения в этом случае страдает от потери точности.

Console.WriteLine( “2.135 -->” + Math.Round(2.135, 2); // 2.135 --> 2.13

Таким образом, в статье мы попробовали немного прояснить ситуацию с округлением decimal. Как видим, все не так уж и сложно, но есть нюансы, которые необходимо иметь в виду при написании программ. Кстати, программы на заказ пишу и я. Недорого, быстро и с гарантией.

Автор этого материала — я — Пахолков Юрий. Я оказываю услуги по написанию программ на языках Java, C++, C# (а также консультирую по ним) и созданию сайтов. Работаю с сайтами на CMS OpenCart, WordPress, ModX и самописными. Кроме этого, работаю напрямую с JavaScript, PHP, CSS, HTML — то есть могу доработать ваш сайт или помочь с веб-программированием. Пишите сюда.

статьи IT, си шарп, округление, decimal

Оставить комментарий
Отправляя сообщение я подтверждаю, что ознакомлен и согласен с политикой конфиденциальности данного сайта.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *