Математика является основой любого программинга. Те кто знаком хоть с одним языком программирования конечно же знают такие простые действия ,как +,-,*,/. Приведем пример этих действий на C#. Они вообщем ничем не отличаются.

К примеру простой пример сложения двух чисел:

int answer = 1 + 2; //присваивает переменной answer значение 3

Также можно сложить две численные переменные, как буд-то они и есть числа:

int a = 5;
int b = 10;
int c = a + b; //присваивает переменной с значение 15

Остальные обычные операции работают так же. Мы используем "-" для отнимания,"*" для умножения и "/" для деления:

int sub = num1 - num2;
int mul = num1 * num2;
int div = num1 / num2;

Стоит опасаться деления, т.к. попытка деления на 0 может привести к краху программы. Конечно, целые не могут содержать в себе дроби, поэтому остаток будет просто отброшен при передаче ответа. Если нам нужна дробь, мы используем такой тип данных, где присутствует дробь, например double.

А что, если нам нужен действительный остаток, а не его дробное представление? И на это есть свой прием:
int mod = num1 % num2;

Оператор "%" в английском называется modulus. Он находит остаток от деления одного числа на другое. Например, 11 % 5 в результате вернет 1 (ведь 5 содержится в 11 два раза. Остаток 1).
Замечу, что мы не ограничены количеством операций.
К примеру код:
int big = (a -  * c + a;

Надо запомнить, что сначала выполнается выражение в скобках, потом умножение(или деление), а затем сложение(или вычитание). Это общепринятые правила математики.

.NET framework содержит библиотеку с обычными математическими функциями, известную как библиотека "Math".

Например, у нас есть 2 числа и мы хотим знать, какое из них больше. Просто делаем так:

int maximum = Math.Max(a, ;
... теперь "maximum" будет содержать значение либо a или b, вернее , большее из них. Все точно так же работает и с меньшим числом:

int minimum = Math.Min(a, ;

Давайте рассмотрим случай деления одного числа на другое. Ну и к примеру у нас получиться число 42.4351433462. Не очень приятно видеть такое число. Надо бы его округлить. Округляем мы числа так
double а = 42.4341433462;
double result= Math.Round(a,2));

Эта команда округлит значение переменной a до двух чисел после запятой, т.е. получим 42.44. Первое значени, которое мы передали, "а" - это число, которое нам надо округлить. "2" определяет то количество цифр после запятой, которое мы хотим увидеть в результате. Если бы нужно было округлить число до близжайшего целого, мы бы просто вписали "0" :

double res = Math.Round(a, 0));

А результат, конечно же будет 42.

Кстати, возможно нам когда-нибудь понадобится использовать число Пи (РІ). Но нам не надо выписывать его вручную для этого в библиотеке Math есть метод возвращающий значение числа ПИ.

double chislopi = Math.PI;

Так как Пи не меняется, то нам не обязательно держать его значение в переменной. Можно использовать Math.PI в случае надобности, вот так:

double circumference = 50 * Math.PI;

Вычисление степеней тоже просто. Следующий код прямо выводит значение степеней двойки (без использования переменных) :

Console.WriteLine("2 в степени 2 = " + Math.Pow(2, 2));
Console.WriteLine("2 в степени 3 = " + Math.Pow(2, 3));
Console.WriteLine("2 в степени 4 = " + Math.Pow(2, 4));

И еще кое-что очень важное! Обратим внимание на следующий код:

double badAnswer = 12 / 5;

Можно подумать, что если мы используем double для хранения результата деления, то она будет содержать и дробную часть. На самом деле - нет. Из-за того, что мы делим два целых , 12 и 5, С# думает что мы хотим произвести деление целых, не обращая внимание на тип переменной, в которой будет ответ. Так или иначе, мы можем заставить С# принимать эти числа как double-вот так:

double goodAnswer = 12.0 / 5.0;

Хотя это не меняет значение чисел, это все-таки меняет то, как С# видит их. Из-за того, что мы добавили десятичную точку, С# теперь думает, что мы работаем с double. А что если :

goodAnswer = 12 / 5.0;
Не смотря на то, что один из чисел операции - целое, С# все равно будет обращаться с ней как с дробным, а не целым делением. Если выражение содержит несколько членов разных типов, С# автоматически будет использовать самый точный из возможных типов деления (опираясь на типы переменных в выражении). В данном случае самый точный тип - double, поэтому С# обращается с обоими членами как с double.

А как насчет переменных? Ну, следующий код даст тот же "плохой" результат, как и раньше:

int X = 12;
int Y = 5;
badAnswer = X / Y;

Из-за того, что обе переменных целые, происходит "целое" деление и остаток будет потерян. Чтобы этого избежать, мы должны "приведение" ("cast") для хотя бы одного члена выражения. Следующий код заставляет С# думать, что X - double, значит и действия проводит как над дробями:

goodAnswer = (double)X / Y;

Чаще всего в замешательство приводят ошибки именно такого типа: мы проводим "целое" деление, не осознавая этого. Так что, всегда надо быть внимательным к типу данных при делении чисел!

Также в C# есть конвертор, причем не только чисел. Приведем пример:

int a;
double b=42.2221;
a=Convert.ToInt32(;
в данном случае функция Convert.ToInt32 преобразует действительное число b к типу int.

А теперь общий код, в котором можно увидеть все, что мы узнали в этом посте:
using System;

namespace D_Math
{
class Class1
{
[STAThread]
static void Main(string[] args)
{
// Объявим два числа
int num1 = 15;
int num2 = 10;
// Произведем над ними математические действия(сохраним результаты)
int addAnswer = num1 + num2;
int subAnswer = num1 - num2;
int mulAnswer = num1 * num2;
int divAnswer = num1 / num2;
int modAnswer = num1 % num2;
int bigAnswer = (num1 - num2) * num2 + num1;
// Выведем результат
Console.WriteLine("number1 == {0}, и number2 == {1}...", num1, num2);
Console.WriteLine("Результат сложения: " + addAnswer);
Console.WriteLine("Результат вычитания: " + subAnswer);
Console.WriteLine("Результат умножения: " + mulAnswer);
Console.WriteLine("Результат деления: " + divAnswer);
Console.WriteLine("Остаток деления: " + modAnswer);
Console.WriteLine("Результат \"(num1 - num2) * num2 + num1\": " + bigAnswer);

// Обычное сравнение чисел (не сохраняем результаты)
Console.WriteLine("Наибольшее число: " + Math.Max(num1, num2));
Console.WriteLine("Наименьшее число: " + Math.Min(num1, num2));

// Округление
double num3 = 94.537;
Console.WriteLine(Environment.NewLine + "Оригинальное число:\t" + num3);
Console.WriteLine("Округляем до...");
Console.WriteLine("2 цифры после запятой:\t" + Math.Round(num3, 2));
Console.WriteLine("1 цифра после запятой:\t" + Math.Round(num3, 1));
Console.WriteLine("0 цифр после запятой:\t" + Math.Round(num3, 0));

// Пи? - Нет ничего легче!
Console.WriteLine(Environment.NewLine + "Пи = " + Math.PI);

// Степени
Console.WriteLine(Environment.NewLine + "2 в степени 1 = " + Math.Pow(2, 1));
Console.WriteLine("2 в степени 2 = " + Math.Pow(2, 2));
Console.WriteLine("2 в степени 3 = " + Math.Pow(2, 3));
Console.WriteLine("2 в степени 4 = " + Math.Pow(2, 4));

// Простенький калькулятор
Console.Write(Environment.NewLine + "Введите 1-е число для умножения: ");
double mul1 = Convert.ToInt32( Console.ReadLine() );
Console.Write("Введите 2-е число: ");
double mul2 = Convert.ToInt32( Console.ReadLine() );
Console.WriteLine("{0} * {1} = {2}", mul1, mul2, (mul1 * mul2));

// Опасно! Неправильное деление! Не влезай, убъет!
Console.WriteLine(Environment.NewLine + "12 / 5 = ?");
double badAnswer = 12 / 5;
double goodAnswer = 12.0 / 5.0;
Console.WriteLine("Неправильый результат: {0}\n
Правильый результат: {1}",
badAnswer, goodAnswer);

// А теперь попросим пользователя нажать "Enter" для выхода из программы
Console.WriteLine("Программа завершена. Нажмите \"Enter\" для выхода...");
Console.ReadLine();
}
}
}

© Hintax