Обучение
Модуль
Выполнение основных операций с числами в C# - Training
Сведения об операторах и методах, используемых для выполнения базовых математических операций с числовыми данными.
Этот браузер больше не поддерживается.
Выполните обновление до Microsoft Edge, чтобы воспользоваться новейшими функциями, обновлениями для системы безопасности и технической поддержкой.
В этом разделе определяется поведение различных операторов M.
Если выражение содержит несколько операторов, порядок вычисления этих операторов определяется их приоритетом. Например, выражение x + y * z
вычисляется так, x + (y * z)
как *
оператор имеет более высокий приоритет, чем двоичный +
оператор. Приоритет оператора устанавливается определением связанной рабочей грамматики. Например, аддитивное выражение состоит из последовательности мультипликативных выражений, разделенных +
или -
операторов, что дает +
и -
операторам более низкий приоритет, чем *
операторы./
Рабочую среду с скобками можно использовать для изменения порядка приоритета по умолчанию.
круглые скобки:
(
выражение)
Например:
1 + 2 * 3 // 7
(1 + 2) * 3 // 9
В следующей таблице перечислены операторы M, в котором перечислены категории операторов в порядке приоритета от самого высокого до низкого. Операторы в одной категории имеют одинаковый приоритет.
Категория | Expression | Description |
---|---|---|
Основной |
i @ i |
Выражение идентификатора |
(x) | Скобки выражения | |
x[i] | Подстановка | |
x{y} | Доступ к элементам | |
x(...) | Вызов функции | |
{x, y, ...} | Инициализация списком | |
[ i = x, ... ] | Инициализация записей | |
... | Не реализовано | |
Унарный | + x | Идентификация |
- x | Отрицание | |
not
x |
Логическое отрицание | |
Метаданные |
xmeta y |
Связывание метаданных |
Мультипликативные | x * y | Умножение |
x / y | Подразделение | |
Аддитивный | x + y | Дополнение |
x - y | Вычитание | |
Реляционная | x< y | Меньше |
x > y | Больше | |
x<= y | Меньше или равно | |
x >= y | Больше или равно | |
Equality | x = y | Equal |
x<> y | Not equal | |
Утверждение типа |
xas y |
Совместим с типом или ошибкой, допускающей значение NULL |
Соответствие типам |
xis y |
Проверьте, совместим ли совместимый тип nullable-primitive |
Логическое И |
xand y |
Сочетание коротких каналов |
Логическое ИЛИ |
xor y |
Короткое прерывание |
Coalesce |
x?? y |
Оператор объединения с NULL |
Каждое значение имеет связанное значение записи, которое может содержать дополнительные сведения о значении. Эта запись называется записью метаданных для значения. Запись метаданных может быть связана с любым типом значения, даже null
. Результатом такой связи является новое значение с заданными метаданными.
Запись метаданных — это только обычная запись, которая может содержать любые поля и значения, которые может выполнять обычная запись, и сама по себе имеет запись метаданных. Связывание записи метаданных со значением является "ненавязчивым". Он не изменяет поведение значения в оценках, за исключением тех, которые явно проверяют записи метаданных.
Каждое значение имеет запись метаданных по умолчанию, даже если она не указана. Запись метаданных по умолчанию пуста. В следующих примерах показано, как получить доступ к записи метаданных текстового значения с помощью стандартной Value.Metadata
функции библиотеки:
Value.Metadata( "Mozart" ) // []
Записи метаданных обычно не сохраняются при использовании значения с оператором или функцией, которая создает новое значение. Например, если два текстовых значения объединяются с помощью &
оператора, метаданные результирующего текстового значения — пустая запись []
. Следующие выражения эквивалентны:
"Amadeus " & ("Mozart" meta [ Rating = 5 ])
"Amadeus " & "Mozart"
Стандартные функции Value.RemoveMetadata
библиотеки и Value.ReplaceMetadata
могут использоваться для удаления всех метаданных из значения и замены метаданных значения (а не слияния метаданных в возможно существующие метаданные).
Единственным оператором, возвращающим результаты, которые несут метаданные, является мета-оператор.
Значения могут быть циклическими. Например:
let l = {0, @l} in l
// {0, {0, {0, ... }}}
[A={B}, B={A}]
// [A = {{ ... }}, B = {{ ... }}]
M обрабатывает циклические значения, сохраняя построение записей, списков и таблиц с отложенными. Попытка создать циклическое значение, которое не получает преимущества от перемешанных структурированных значений, приводит к ошибке:
[A=B, B=A]
// [A = Error.Record("Expression.Error",
// "A cyclic reference was encountered during evaluation"),
// B = Error.Record("Expression.Error",
// "A cyclic reference was encountered during evaluation"),
// ]
Некоторые операторы в M определяются структурным рекурсией. Например, равенство записей и списков определяется соответствующим равенством соответствующих полей записей и списков элементов соответственно.
Для нециклических значений применение структурной рекурсии дает конечное расширение значения: общие вложенные значения будут проходить многократно, но процесс рекурсии всегда завершается.
Циклическое значение имеет бесконечное расширение при применении структурной рекурсии. Семантика M не предусматривает специальных операций для такого бесконечного расширения — например, при попытке сравнить цикличные значения на равенство обычно расходуются все ресурсы и сравнение завершается с исключением.
Операторы выбора и проекции позволяют извлекать данные из списка и значений записей.
Значение может быть выбрано из списка или таблицы на основе его нулевой позиции в этом списке или таблице с помощью выражения доступа к элементу.
выражение-доступа-к-элементу:
выбор-элемента
выбор-необязательного-элемента
выбор-элемента:
элемент-селектор первичного выражения{
}
выбор-необязательного-элемента:
элемент-селектор первичного выражения{
} ?
селектор-элементов:
выражение
Выражение item-access-expressionx{y}
возвращает:
Для списка x
и числа y
элемент списка x
в позиции y
. Первый элемент списка считается порядковый индекс нулевым. Если запрошенная позиция не существует в списке, возникает ошибка.
Для таблицы x
и числа y
строка таблицы x
в позиции y
. Первая строка таблицы считается порядковой индекс нулевой. Если запрошенная позиция не существует в таблице, возникает ошибка.
Для таблицы x
и записи y
x
строка таблицыy
, которая соответствует значениям полей для полей с именами полей, соответствующими именам столбцов таблицы. Если в таблице нет уникальной строки сопоставления, возникает ошибка.
Например:
{"a","b","c"}{0} // "a"
{1, [A=2], 3}{1} // [A=2]
{true, false}{2} // error
#table({"A","B"},{{0,1},{2,1}}){0} // [A=0,B=1]
#table({"A","B"},{{0,1},{2,1}}){[A=2]} // [A=2,B=1]
#table({"A","B"},{{0,1},{2,1}}){[B=3]} // error
#table({"A","B"},{{0,1},{2,1}}){[B=1]} // error
Выражение item-access-expression также поддерживает форму x{y}?
, которая возвращается null
, когда позиция (или совпадение) y
не существует в списке или таблице x
. При наличии нескольких совпадений y
возникает ошибка.
Например:
{"a","b","c"}{0}? // "a"
{1, [A=2], 3}{1}? // [A=2]
{true, false}{2}? // null
#table({"A","B"},{{0,1},{2,1}}){0}? // [A=0,B=1]
#table({"A","B"},{{0,1},{2,1}}){[A=2]}? // [A=2,B=1]
#table({"A","B"},{{0,1},{2,1}}){[B=3]}? // null
#table({"A","B"},{{0,1},{2,1}}){[B=1]}? // error
Доступ к элементам не принудительно проверяет элементы списка или таблицы, отличные от доступного к элементу. Например:
{ error "a", 1, error "c"}{1} // 1
{ error "a", error "b"}{1} // error "b"
Ниже приведено значение, когда вычисляется оператор x{y}
доступа к элементу:
Ошибки, возникающие во время оценки выражений x
или y
распространяются.
Выражение x
создает список или табличное значение.
Выражение y
создает числовое значение или, если x
создает табличное значение, значение записи.
При y
создании числа и отрицательном y
значении возникает ошибка с кодом "Expression.Error"
причины.
Если y
создается число и значение y
больше или равно количеству x
, возникает ошибка с кодом "Expression.Error"
причины, если не используется необязательная форма x{y}?
оператора, в этом случае возвращается значение null
.
Если x
создается табличное значение и создается значение записи и y
отсутствуют совпадения y
x
, возникает ошибка с кодом "Expression.Error"
причины, если не используется необязательная форма x{y}?
оператора, в этом случае возвращается значение null
.
Если x
вы создаете табличное значение и создает значение записи и y
имеется несколько совпадений y
x
, возникает ошибка с кодом "Expression.Error"
причины.
Элементы, отличные от того, что находится в x
позиции y
, вычисляются во время процесса выбора элемента. (Для потоковых списков или таблиц элементы или строки, предшествующие позиции y
, пропускаются, что может привести к их оценке в зависимости от источника списка или таблицы.)
Выражение field-access-expression используется для выбора значения из записи или для проецировать запись или таблицу в одну с меньшим количеством полей или столбцов соответственно.
выражение-доступа-к-полю:
выбор-поля
выбор-неявного-целевого-поля
проекция
неявная-целевая-проекция
выбор-поля:
основное-выражение селектор-поля
селектор поля:
селектор-обязательного-поля
селектор-необязательного-поля
селектор-обязательного-поля:
[
имя поля]
необязательный селектор полей:
[
имя поля] ?
имя-поля:
обобщенный-идентификатор
нестандартный-идентификатор
выбор-неявного-целевого-поля:
селектор поля
проекция:
основное-выражение обязательная-проекция
основное-выражение необязательная-проекция
обязательная-проекция:
[
обязательный список селекторов ]
необязательная проекция:
[
обязательный список селекторов ] ?
список-обязательных-селекторов:
селектор-обязательного-поля
обязательный селектор,
списка обязательных полей-селектор
неявная-целевая-проекция:
обязательная-проекция
необязательная-проекция
Простейшая форма доступа к полю — это обязательный выбор поля. Он использует оператор x[y]
для поиска поля в записи по имени поля. Если поле y
не существует x
, возникает ошибка.
x[y]?
Форма используется для выполнения необязательного выбора поля и возвращаетсяnull
, если запрошенное поле не существует в записи.
Например:
[A=1,B=2][B] // 2
[A=1,B=2][C] // error
[A=1,B=2][C]? // null
Коллективный доступ к нескольким полям поддерживается операторами для обязательной проекции записей и необязательной проекции записей. Оператор x[[y1],[y2],...]
проектируют запись в новую запись с меньшим количеством полей (выбранным параметром y1
, y2
). ...
Если выбранное поле не существует, возникает ошибка. Оператор x[[y1],[y2],...]?
проектируют запись в новую запись с полями, выбранными y1
параметром , y2
...
; если поле отсутствует, null
используется вместо него.
Например:
[A=1,B=2][[B]] // [B=2]
[A=1,B=2][[C]] // error
[A=1,B=2][[B],[C]]? // [B=2,C=null]
Формы [y]
и [y]?
поддерживаются в качестве краткой ссылки на идентификатор _
(подчеркивание). Следующие два выражения эквивалентны:
[A]
_[A]
В следующем примере показана сокращенная форма доступа к полю:
let _ = [A=1,B=2] in [A] //1
[[y1],[y2],...]
Форма и [[y1],[y2],...]?
также поддерживаются как сокращенные и следующие два выражения также эквивалентны:
[[A],[B]]
_[[A],[B]]
Кратковременная форма особенно полезна в сочетании с each
сокращенной, способ представить функцию одного параметра с именем _
(дополнительные сведения см . в упрощенных объявлениях). Вместе два коротких выражения упрощают распространенные функциональные выражения более высокого порядка:
List.Select( {[a=1, b=1], [a=2, b=4]}, each [a] = [b])
// {[a=1, b=1]}
Приведенное выше выражение эквивалентно следующему более криптографическому просмотру:
List.Select( {[a=1, b=1], [a=2, b=4]}, (_) => _[a] = _[b])
// {[a=1, b=1]}
Доступ к полям не принудительно выполняет оценку полей, отличных от доступа к полям. Например:
[A=error "a", B=1, C=error "c"][B] // 1
[A=error "a", B=error "b"][B] // error "b"
В следующих случаях при оценке оператора x[y]
x[y]?
x[[y]]
доступа к полю или x[[y]]?
оценки:
Ошибки, возникающие при оценке выражения x
, распространяются.
Ошибки, возникающие при оценке поля, постоянно связаны с полем y
y
, а затем распространяются. Любой будущий доступ к полю y
приведет к той же ошибке.
Выражение x
создает запись или табличное значение, или возникает ошибка.
Если идентификатор y
именуется поле, которое не существует x
, возникает ошибка с кодом "Expression.Error"
причины, если не используется необязательная форма ...?
оператора, в этом случае возвращается значение null
.
Ни один из полей, отличных от x
именованного y
, вычисляется во время процесса доступа к полям.
Запись метаданных для значения изменяется с помощью мета-оператора (x meta y
).
выражение-метаданных:
unary-expression
унарное выражениеmeta
унарное выражение
В следующем примере создается текстовое значение с записью метаданных с помощью meta
оператора, а затем получает доступ к записи метаданных результирующего значения с помощью Value.Metadata
:
Value.Metadata( "Mozart" meta [ Rating = 5 ] )
// [Rating = 5 ]
Value.Metadata( "Mozart" meta [ Rating = 5 ] )[Rating]
// 5
В следующих случаях при применении оператора x meta y
объединения метаданных:
Ошибки, возникающие при оценке выражений x
, y
распространяются.
Выражение y
должно быть записью или возникает ошибка с кодом "Expression.Error"
причины.
Результирующая запись метаданных — x
это запись метаданных, объединенная с y
. (Семантика слияния записей см. в разделе .Запись слияния.)
Результирующее значение — это значение из x
выражения без его метаданных, при этом только что вычисляемая запись метаданных подключена.
Стандартные функции Value.RemoveMetadata
библиотеки и Value.ReplaceMetadata
могут использоваться для удаления всех метаданных из значения и замены метаданных значения (а не слияния метаданных в возможно существующие метаданные). Следующие выражения эквивалентны:
x meta y
Value.ReplaceMetadata(x, Value.Metadata(x) & y)
Value.RemoveMetadata(x) meta (Value.Metadata(x) & y)
Оператор =
равенства используется для определения того, равны ли два значения. Оператор <>
неравенства используется для определения того, не равны ли два значения.
выражение-равенства:
relational-expression
реляционное=
выражение равенства
реляционное<>
выражение равенства
Например:
1 = 1 // true
1 = 2 // false
1 <> 1 // false
1 <> 2 // true
null = true // false
null = null // true
Метаданные не являются частью сравнения равенства или неравенства. Например:
(1 meta [ a = 1 ]) = (1 meta [ a = 2 ]) // true
(1 meta [ a = 1 ]) = 1 // true
При применении операторов x = y
равенства и x <> y
:
Ошибки, возникающие при оценке выражений x
, y
распространяются.
Оператор =
имеет результат, true
если значения равны и false
в противном случае.
Оператор <>
имеет результат, false
если значения равны и true
в противном случае.
Записи метаданных не включаются в сравнение.
Если значения, созданные путем x
вычисления выражений y
, не совпадают с типом значения, то значения не равны.
Если значения, созданные при оценке x
выражения, y
совпадают с типом значения, существуют определенные правила для определения того, равны ли они, как определено ниже.
Следующее выражение всегда является истинным.
(x = y) = not (x <> y)
Операторы равенства определяются для следующих типов:
null
равно только самому себе. null = null // true
null = true // false
null = false // false
true
и false
равны только себе. Например: true = true // true
false = false // true
true = false // false
true = 1 // false
Числа сравниваются с помощью указанной точности:
Если любое число равно #nan
, то числа не совпадают.
Если ни число не равно #nan
, то числа сравниваются с помощью битового сравнения числового значения.
#nan
— единственное значение, которое не равно самому себе.
Например:
1 = 1, // true
1.0 = 1 // true
2 = 1 // false
#nan = #nan // false
#nan <> #nan // true
Две длительности равны, если они представляют одинаковое число 100-наносекунд галок.
Два раза равны, если величины их частей (час, минута, вторая) равны.
Две даты равны, если величины их частей (год, месяц, день) равны.
Два значения даты равны, если величины их частей (год, месяц, день, час, минута, вторая) равны.
Два даты и времени равны, если соответствующие даты и времени UTC равны. Чтобы прибыть в соответствующее время в формате UTC, смещение часов и минут вычитается из компонента datetimezone.
Два текстовых значения равны при использовании порядкового номера, учета регистра, нечувствительного к языку и региональных параметров, они имеют одинаковую длину и равные символы в соответствующих позициях.
Два значения списка равны, если все из следующих значений имеют значение true:
Оба списка содержат одинаковое количество элементов.
Значения каждого позиционально соответствующего элемента в списках равны. Это означает, что не только списки должны содержать равные элементы, элементы должны находиться в одном порядке.
Например:
{1, 2} = {1, 2} // true
{2, 1} = {1, 2} // false
{1, 2, 3} = {1, 2} // false
Две записи равны, если все из следующих значений имеют значение true:
Число полей совпадает.
Каждое имя поля одной записи также присутствует в другой записи.
Значение каждого поля одной записи равно аналогичному полю в другой записи.
Например:
[ A = 1, B = 2 ] = [ A = 1, B = 2 ] // true
[ B = 2, A = 1 ] = [ A = 1, B = 2 ] // true
[ A = 1, B = 2, C = 3 ] = [ A = 1, B = 2 ] // false
[ A = 1 ] = [ A = 1, B = 2 ] // false
Две таблицы равны, если все из следующих значений имеют значение true:
Число столбцов совпадает.
Каждое имя столбца в одной таблице также присутствует в другой таблице.
Число строк совпадает.
Каждая строка имеет равные значения в соответствующих ячейках.
Например:
#table({"A","B"},{{1,2}}) = #table({"A","B"},{{1,2}}) // true
#table({"A","B"},{{1,2}}) = #table({"X","Y"},{{1,2}}) // false
#table({"A","B"},{{1,2}}) = #table({"B","A"},{{2,1}}) // true
Значение функции равно самому себе, но может быть или не равно другому значению функции. Если два значения функции считаются равными, они будут вести себя одинаково при вызове.
Два заданных значения функции всегда будут иметь одинаковые отношения равенства.
Значение типа равно самому себе, но может или не равно другому значению типа. Если два значения типа считаются равными, они будут вести себя одинаково при запросе на соответствие.
Два заданных значения типа всегда будут иметь одинаковые отношения равенства.
Операторы <
, >
<=
и >=
операторы называются реляционными операторами.
выражение-отношения:
additive-expression
реляционное выражение аддитивного выражения<
реляционное выражение аддитивного выражения>
реляционное выражение аддитивного выражения<=
реляционное выражение аддитивного выражения>=
Эти операторы используются для определения относительной упорядочения между двумя значениями, как показано в следующей таблице:
Операция | Результат |
---|---|
x < y |
true Значение , если x меньше y , false в противном случае |
x > y |
true Значение , x если y больше , false в противном случае |
x <= y |
true Значение y , false в противном случае |
x >= y |
true Значение , если x больше или равно y , false в противном случае |
Например:
0 <= 1 // true
null < 1 // null
null <= null // null
"ab" < "abc" // true
#nan >= #nan // false
#nan <= #nan // false
При оценке выражения, содержащего реляционные операторы, следует учитывать следующее:
Ошибки, возникающие при оценке выражений x
или y
операндов, распространяются.
Значения, созданные при x
y
вычислении как выражений, должны быть двоичными, датами, датой, временем, длительностью, логическим, числом, значением null, текстом или временем. В противном случае возникает ошибка с кодом "Expression.Error"
причины.
Оба операнда должны быть одинаковыми или null
одинаковыми. В противном случае возникает ошибка с кодом "Expression.Error"
причины.
Если оба операнда null
являются, результатом является null
значение.
Два двоичных файла сравниваются байтами байтов.
Две даты сравниваются по сравнению с их частями года и, если равны, их месяцы и, если равны, их дни.
Два даты и времени сравниваются по сравнению с частями года и, если равны, их месяцы и, если равны, их дневные части и, если равны, их часовые части и, если равны, их минутные части и, если равны, их второй части.
Два даты и времени сравниваются путем нормализации их с UTC, вычитая их смещение часа в минуту, а затем сравнивая их компоненты даты и времени.
По сравнению с общим количеством 100-наносекундных тиков, которые они представляют, сравниваются с двумя длительностью.
Два логических выражения сравниваются таким образом, что true
считается больше false
.
Два числа x
и y
сравниваются в соответствии с правилами стандарта IEEE 754:
Если один из операндов является #nan
результатом false
для всех реляционных операторов.
Если ни операнды, операторы сравнивают значения двух операндов #nan
с плавающей запятой относительно порядка -∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞
, где минимальное и максимальное значение являются наименьшими и самыми большими положительными конечными значениями, которые могут быть представлены. Имена M для -∞ и +∞.-#infinity
#infinity
Важные эффекты этого упорядочения:
Отрицательные и положительные нули считаются равными.
-#infinity
Значение считается меньше всех остальных значений чисел, но равно другому-#infinity
.
#infinity
Значение считается больше всех остальных значений чисел, но равно другому#infinity
.
Два текста сравниваются с помощью порядкового порядкового номера символов, учета регистра и региональных параметров.
Два раза сравниваются путем сравнения их часовых частей и, если равны, их минутные части и, если равны, их второй части.
and
Операторы or
называются условными логическими операторами.
выражение-логического-ИЛИ:
логическое и выражение логических и
выражений логических и выраженийor
выражение-логического-И:
выражение-is
выражение is-expressionand
логического и-выражения
Оператор or
возвращает true
по крайней мере один из операндов true
. Правый операнд оценивается, если и только если левый операнд не true
является.
Оператор and
возвращает false
по крайней мере один из операндов false
. Правый операнд оценивается, если и только если левый операнд не false
является.
Таблицы истины для or
and
операторов показаны ниже, с результатом оценки левого операнда на вертикальной оси и результатом оценки правого операнда на горизонтальной оси.
and |
true |
false |
null |
error |
---|---|---|---|---|
true |
true |
false |
null |
error |
false |
false |
false |
false |
false |
null |
null |
false |
null |
error |
error |
error |
error |
error |
error |
or |
true |
false |
null |
error |
---|---|---|---|---|
or |
true |
false |
null |
error |
true |
true |
true |
true |
true |
false |
true |
false |
null |
error |
null |
true |
null |
null |
error |
error |
error |
error |
error |
error |
При оценке выражения, содержащего условные логические операторы, следует учитывать следующее:
Ошибки, возникающие при оценке выражений x
, y
распространяются.
Условные логические операторы определяются по типам logical
и null
. Если значения операнда не относятся к этим типам, возникает ошибка с кодом "Expression.Error"
причины.
Результатом является логическое значение.
В выражении x
или y
y
выражение будет оцениваться только в том случае, если x
оно не оцениваетсяtrue
.
В выражении и выражение будет оцениваться только в том случае, если x
оно не вычисляетсяy
.y
x
false
Последние два свойства дают условным логическим операторам их "условный" квалификацию; свойства также называются "коротким замыканием". Эти свойства полезны для записи компактных защищенных предикатов. Например, следующие выражения эквивалентны:
d <> 0 and n/d > 1 if d <> 0 then n/d > 1 else false
+
-
Операторы *
, и /
операторы являются арифметическими операторами.
выражение-сложения:
multiplicative-expression
аддитивное+
выражение умножения выражения
аддитивное-
выражение умножения выражения
выражение-умножения:
выражение-метаданных
умножение-выражение метаданных-выражений*
умножение-выражение метаданных-выражений/
Числа в M хранятся с помощью различных представлений для хранения максимальной информации о числах, поступающих из различных источников. Числа преобразуются только из одного представления в другое по мере необходимости операторами, примененными к ним. В M поддерживаются две точности:
Точность | семантика |
---|---|
Precision.Decimal |
128-разрядное десятичное представление с диапазоном от ±1,0 x 10-28 до ±7,9 x 10-28 и 28-29 значащими цифрами. |
Precision.Double |
Научное представление с помощью мантиссы и экспонента; соответствует 64-разрядной двоичной двойной точности IEEE 754 арифметического стандарта IEEE 754-2008. |
Арифметические операции выполняются путем выбора точности, преобразования обоих операндов в эту точность (при необходимости), а затем выполнения фактической операции и, наконец, возвращения числа в выбранной точности.
Встроенные арифметические операторы (+
, , -
) *
/
используют двойную точность. Стандартные функции библиотеки (Value.Add
, Value.Subtract
, Value.Multiply
) Value.Divide
можно использовать для запроса этих операций с помощью определенной модели точности.
Числовой переполнение невозможно: #infinity
или -#infinity
представлять значения слишком больших величин, которые должны быть представлены.
Числовой поток не может быть возможным: 0
и -0
представляет значения слишком небольших значений, которые должны быть представлены.
Специальное значение IEEE 754 #nan
(NaN — "не является числом") используется для выявления арифметически недопустимых вариантов, таких как деление ноля на ноль.
Преобразование из десятичного и двойного точности выполняется путем округления десятичных чисел до ближайшего эквивалентного двойного значения.
Преобразование из Double в десятичную точность выполняется путем округления двойных чисел до ближайшего эквивалентного десятичного значения и при необходимости переполнения #infinity
или -#infinity
значений.
Интерпретация оператора сложения (x + y
) зависит от типа вычисляемых выражений x и y, как показано ниже.
x | г | Результат | Интерпретация |
---|---|---|---|
type number |
type number |
type number |
Числовая сумма |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type duration |
type duration |
Числовая сумма величины |
type duration |
null |
null |
|
null |
type duration |
null |
|
type
datetime |
type duration |
type
datetime |
Смещение даты и времени по длительности |
type duration |
type
datetime |
type
datetime |
|
type
datetime |
null |
null |
|
null |
type
datetime |
null |
В таблице type
дата и время обозначает любой из type date
, type datetime
type datetimezone
или type time
. При добавлении длительности и значения определенного типа datetime результирующее значение имеет тот же тип.
Для других сочетаний значений, отличных от перечисленных в таблице, возникает ошибка с кодом "Expression.Error"
причины. Каждая комбинация рассматривается в следующих разделах.
Ошибки, возникающие при оценке операнда, распространяются.
Сумма двух чисел вычисляется с помощью оператора сложения, создающего число.
Например:
1 + 1 // 2
#nan + #infinity // #nan
Оператор сложения +
по числам использует двойную точность. Стандартная функция Value.Add
библиотеки может использоваться для указания десятичной точности. В следующих случаях при вычислении суммы чисел:
Сумма в двойной точности вычисляется в соответствии с правилами 64-разрядного двоичного двоичного двойника IEEE 754 арифметического IEEE 754-2008. В следующей таблице перечислены результаты всех возможных сочетаний ненулевого конечного значения, нули, неопределенных значений и naN. В таблице x
и y
являются конечными значениями ненулевого значения и z
являются результатом x + y
. Если x
и y
имеют ту же величину, но противоположные признаки, z
является положительным нулем. Если x + y
слишком большой для представления в целевом типе, z
то это бесконечность с тем же знаком, что x + y
и .
+ | г | +0 | 0– | +∞ | -∞ | Не число |
---|---|---|---|---|---|---|
x | z | x | x | +∞ | -∞ | Не число |
+0 | г | +0 | +0 | +∞ | -∞ | Не число |
-0 | г | +0 | 0– | +∞ | -∞ | Не число |
+∞ | +∞ | +∞ | +∞ | +∞ | Не число | Не число |
-∞ | -∞ | -∞ | -∞ | Не число | -∞ | Не число |
NaN | Не число | Не число | Не число | Не число | Не число | Не число |
Сумма в десятичной точности вычисляется без потери точности. Масштаб результата — это больше масштабов двух операндов.
Сумма двух длительности — это длительность, представляющая сумму числа 100наносеконд, представленных длительностью. Например:
#duration(2,1,0,15.1) + #duration(0,1,30,45.3)
// #duration(2, 2, 31, 0.4)
Дата иx
длительность y
могут быть добавлены для x + y
вычисления нового времени даты и времени , расстояние от x
которого на линейной временной шкале является точно величиной y
.
Здесь дата и время имеет любой тип Date
, DateTime
DateTimeZone
или Time
результат, отличный от NULL. Смещение даты и времени может быть вычислено следующим образом:
Если дата и время с момента указания значения эпохи, создайте новое время даты и времени со следующими элементами информации:
Вычислите новые дни с эпохи, эквивалентной делении величины y на число 100-наносекунд в течение 24-часового периода, усечение десятичной части результата и добавление этого значения в дни x с эпохи.
Вычислите новые галочки с полночью эквивалента добавлению величины y к тикам x с полуночи, модулировать число 100-наносекунд в течение 24-часового периода. Если x не указывает значение для галок с полуночи, предполагается значение 0.
Скопируйте значение x для смещения минут из UTC без изменений.
Если дни даты и времени с момента значения эпохи не указаны, создайте новое время даты и времени со следующими элементами информации:
Вычислите новые галочки с полночью эквивалента добавлению величины y к тикам x с полуночи, модулировать число 100-наносекунд в течение 24-часового периода. Если x не указывает значение для галок с полуночи, предполагается значение 0.
Скопируйте значения x в течение нескольких дней с момента смещения эпохи и минут от UTC без изменений.
В следующих примерах показано вычисление абсолютной временной суммы, когда дата и время указывает дни с эпохи:
#date(2010,05,20) + #duration(0,8,0,0)
//#datetime( 2010, 5, 20, 8, 0, 0 )
//2010-05-20T08:00:00
#date(2010,01,31) + #duration(30,08,0,0)
//#datetime(2010, 3, 2, 8, 0, 0)
//2010-03-02T08:00:00
#datetime(2010,05,20,12,00,00,-08) + #duration(0,04,30,00)
//#datetime(2010, 5, 20, 16, 30, 0, -8, 0)
//2010-05-20T16:30:00-08:00
#datetime(2010,10,10,0,0,0,0) + #duration(1,0,0,0)
//#datetime(2010, 10, 11, 0, 0, 0, 0, 0)
//2010-10-11T00:00:00+00:00
В следующем примере показано вычисление смещения даты и времени в течение заданного времени:
#time(8,0,0) + #duration(30,5,0,0)
//#time(13, 0, 0)
//13:00:00
Интерпретация оператора вычитания (x - y
) зависит от типа вычисляемых выражений x
и y
следующим образом:
x | Y | Результат | Интерпретация |
---|---|---|---|
type number |
type number |
type number |
Числовое различие |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type duration |
type duration |
Числовое различие величин |
type duration |
null |
null |
|
null |
type duration |
null |
|
type
datetime |
type
datetime |
type duration |
Длительность между датами и временем |
type
datetime |
type duration |
type
datetime |
Смещение даты и времени на отрицание длительности |
type
datetime |
null |
null |
|
null |
type
datetime |
null |
В таблице type
дата и время обозначает любой из type date
, type datetime
type datetimezone
или type time
. При вычитание длительности из значения определенного типа datetime результирующее значение имеет тот же тип.
Для других сочетаний значений, отличных от перечисленных в таблице, возникает ошибка с кодом "Expression.Error"
причины. Каждая комбинация рассматривается в следующих разделах.
Ошибки, возникающие при оценке операнда, распространяются.
Разница между двумя числами вычисляется с помощью оператора вычитания, создающего число. Например:
1 - 1 // 0
#nan - #infinity // #nan
Оператор вычитания -
по числам использует двойную точность; стандартная функция Value.Subtract
библиотеки может использоваться для указания десятичной точности. В следующих случаях при вычислении разницы чисел:
Разница в двойной точности вычисляется в соответствии с правилами 64-разрядной двоичной двойной точности IEEE 754 арифметической IEEE 754-2008. В следующей таблице перечислены результаты всех возможных сочетаний ненулевого конечного значения, нули, неопределенных значений и naN. В таблице x
и y
являются конечными значениями ненулевого значения и z
являются результатом x - y
. Если x
и y
равны, z
положительный нуль. Если x - y
слишком большой для представления в целевом типе, z
то это бесконечность с тем же знаком, что x - y
и .
- | г | +0 | 0– | +∞ | -∞ | Не число |
---|---|---|---|---|---|---|
x | z | x | x | -∞ | +∞ | Не число |
+0 | -y | +0 | +0 | -∞ | +∞ | Не число |
-0 | -y | 0– | +0 | -∞ | +∞ | Не число |
+∞ | +∞ | +∞ | +∞ | Не число | +∞ | Не число |
-∞ | -∞ | -∞ | -∞ | -∞ | Не число | Не число |
NaN | Не число | Не число | Не число | Не число | Не число | Не число |
Разница в десятичной точности вычисляется без потери точности. Масштаб результата — это больше масштабов двух операндов.
Разница в двух длительности — это длительность, представляющая разницу между числом 100-наносекунд, представленных каждой длительностью. Например:
#duration(1,2,30,0) - #duration(0,0,0,30.45)
// #duration(1, 2, 29, 29.55)
Дата иx
длительность y
могут вычитаться с помощью x - y
вычисления нового даты и времени. Здесь дата и время обозначает любой из date
, datetime
datetimezone
или time
.
Результат даты и времени имеет расстояние от x
линейной временной шкалы, которая именно величинаy
, в направлении, противоположном знакуy
. Вычитание положительных длительности дает результаты, которые возвращаются назад во времени относительно x
, а вычитание отрицательных значений дает результаты, которые перенаправляются во времени.
#date(2010,05,20) - #duration(00,08,00,00)
//#datetime(2010, 5, 19, 16, 0, 0)
//2010-05-19T16:00:00
#date(2010,01,31) - #duration( 30,08,00,00)
//#datetime(2009, 12, 31, 16, 0, 0)
//2009-12-31T16:00:00
Два t
времени могут вычитаться с помощью u
вычисления длительности между ними. Здесь дата и время обозначает любой из date
, datetime
datetimezone
или time
. Длительность, созданная путем вычитания u
из t
нее, должна быть получена t
при добавлении u
.
#date(2010,01,31) - #date(2010,01,15)
// #duration(16,00,00,00)
// 16.00:00:00
#date(2010,01,15)- #date(2010,01,31)
// #duration(-16,00,00,00)
// -16.00:00:00
#datetime(2010,05,20,16,06,00,-08,00) -
#datetime(2008,12,15,04,19,19,03,00)
// #duration(521,22,46,41)
// 521.22:46:41
Вычитание t - u
при u > t
получении отрицательной длительности:
#time(01,30,00) - #time(08,00,00)
// #duration(0, -6, -30, 0)
При вычитания двух дат и времени используется t - u
следующее:
Интерпретация оператора умножения (x * y
) зависит от типа вычисляемых выражений x и y, как показано ниже.
X | Y | Результат | Интерпретация |
---|---|---|---|
type number |
type number |
type number |
Числовое произведение |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type number |
type duration |
Несколько длительности |
type number |
type duration |
type duration |
Несколько длительности |
type duration |
null |
null |
|
null |
type duration |
null |
Для других сочетаний значений, отличных от перечисленных в таблице, возникает ошибка с кодом "Expression.Error"
причины. Каждая комбинация рассматривается в следующих разделах.
Ошибки, возникающие при оценке операнда, распространяются.
Продукт из двух чисел вычисляется с помощью оператора умножения, создающего число. Например:
2 * 4 // 8
6 * null // null
#nan * #infinity // #nan
Оператор умножения *
по числам использует двойную точность. Стандартная функция Value.Multiply
библиотеки может использоваться для указания десятичной точности. В следующих случаях при вычислении продукта чисел:
Продукт в Double Precision вычисляется в соответствии с правилами 64-разрядной двоичной двойной точности IEEE 754 арифметической IEEE 754-2008. В следующей таблице перечислены результаты всех возможных сочетаний ненулевого конечного значения, нули, неопределенных значений и naN. В таблице x
и y
являются положительными конечными значениями.
z
x * y
результат . Если результат слишком велик для целевого типа, z
бесконечность. Если результат слишком мал для типа назначения, z
равно нулю.
* | +y | -y | +0 | 0– | +∞ | -∞ | Не число |
---|---|---|---|---|---|---|---|
+x | +z | -Z | +0 | 0– | +∞ | -∞ | Не число |
-x | -Z | +z | 0– | +0 | -∞ | +∞ | Не число |
+0 | +0 | 0– | +0 | 0– | Не число | Не число | Не число |
-0 | 0– | +0 | 0– | +0 | Не число | Не число | Не число |
+∞ | +∞ | -∞ | Не число | Не число | +∞ | -∞ | Не число |
-∞ | -∞ | +∞ | Не число | Не число | -∞ | +∞ | Не число |
NaN | Не число | Не число | Не число | Не число | Не число | Не число | Не число |
Продукт в десятичной точности вычисляется без потери точности. Масштаб результата — это больше масштабов двух операндов.
Произведение длительности и числа — это длительность, представляющая число 1000 тиков, представленных длительностью операнды, число операндов. Например:
#duration(2,1,0,15.1) * 2
// #duration(4, 2, 0, 30.2)
Интерпретация оператора деления (x / y
) зависит от типа вычисляемых выражений x
и y
следующим образом:
X | Y | Результат | Интерпретация |
---|---|---|---|
type number |
type number |
type number |
Числовой кавыч |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type number |
type duration |
Доля длительности |
type duration |
type duration |
type number |
Числовое значение длительности |
type duration |
null |
null |
|
null |
type duration |
null |
Для других сочетаний значений, отличных от перечисленных в таблице, возникает ошибка с кодом "Expression.Error"
причины. Каждая комбинация рассматривается в следующих разделах.
Ошибки, возникающие при оценке операнда, распространяются.
Коэффициент двух чисел вычисляется с помощью оператора деления, создающего число. Например:
8 / 2 // 4
8 / 0 // #infinity
0 / 0 // #nan
0 / null // null
#nan / #infinity // #nan
Оператор /
деления по числам использует двойную точность. Стандартная функция Value.Divide
библиотеки может использоваться для указания десятичной точности. В следующих случаях при вычислении квотиента чисел:
Коэффициент в двойной точности вычисляется в соответствии с правилами 64-разрядной двойной точности IEEE 754 арифметической IEEE 754-2008. В следующей таблице перечислены результаты всех возможных сочетаний ненулевого конечного значения, нули, неопределенных значений и naN. В таблице x
и y
являются положительными конечными значениями.
z
x / y
результат . Если результат слишком велик для целевого типа, z
бесконечность. Если результат слишком мал для типа назначения, z
равно нулю.
/ | +y | -y | +0 | 0– | +∞ | -∞ | Не число |
---|---|---|---|---|---|---|---|
+x | +z | -Z | +∞ | -∞ | +0 | 0– | Не число |
-x | -Z | +z | -∞ | +∞ | 0– | +0 | Не число |
+0 | +0 | 0– | Не число | Не число | +0 | 0– | Не число |
-0 | 0– | +0 | Не число | Не число | 0– | +0 | Не число |
+∞ | +∞ | -∞ | +∞ | -∞ | Не число | Не число | Не число |
-∞ | -∞ | +∞ | -∞ | +∞ | Не число | Не число | Не число |
NaN | Не число | Не число | Не число | Не число | Не число | Не число | Не число |
Сумма в десятичной точности вычисляется без потери точности. Масштаб результата — это больше масштабов двух операндов.
Кворот из двух длительности — это число, представляющее кворот числа 1000 нэносеконд, представленных длительностью. Например:
#duration(2,0,0,0) / #duration(0,1,30,0)
// 32
Цитент длительности x
и числа y
— это длительность, представляющая кворот числа 100-наносекунд, представленных x
длительностью и числом y
. Например:
#duration(2,0,0,0) / 32
// #duration(0,1,30,0)
Оператор сочетания (x & y
) определяется по следующим типам значений:
X | Y | Результат | Интерпретация |
---|---|---|---|
type text |
type text |
type text |
Объединение |
type text |
null |
null |
|
null |
type text |
null |
|
type date |
type time |
type datetime |
Слияние |
type date |
null |
null |
|
null |
type time |
null |
|
type list |
type list |
type list |
Объединение |
type record |
type record |
type record |
Слияние |
type table |
type table |
type table |
Объединение |
Два текста, два списка или два значения таблицы можно объединить с помощью x & y
.
В следующем примере показано объединение текстовых значений:
"AB" & "CDE" // "ABCDE"
В следующем примере показано объединение списков:
{1, 2} & {3} // {1, 2, 3}
При объединениях двух значений используется x & y
следующее:
Ошибки, возникающие при оценке выражений x
, y
распространяются.
Ошибка не распространяется, если элемент либо x
y
содержит ошибку.
Результат объединения двух текстовых значений — текстовое значение, содержащее значение x сразу после y. Если один из операндов имеет значение NULL, а другой — текстовое значение, результат имеет значение NULL.
Результат объединения двух списков — это список, содержащий все элементы x
, за которыми следует все элементы y
.
Результат объединения двух таблиц — это таблица с объединением двух столбцов операнда. Порядок столбцов x
сохраняется, а затем столбцы отображаются только в y
, сохраняя их относительное упорядочение. Для столбцов, отображаемых только в одном из операндов, null
используется для заполнения значений ячеек для другого операнда.
Две записи можно объединить с помощью x & y
, создав запись, содержащую поля из обоих x
и y
.
В следующих примерах показано объединение записей:
[ x = 1 ] & [ y = 2 ] // [ x = 1, y = 2 ]
[ x = 1, y = 2 ] & [ x = 3, z = 4 ] // [ x = 3, y = 2, z = 4 ]
При слиянии двух записей при слиянии двух записей используется x + y
следующее:
Ошибки, возникающие при оценке выражений x
, y
распространяются.
Если поле отображается как в обоихx
, y
так и y
значение используется.
Порядок полей в результирующей записи состоит в том, что x
поля, за которыми не y
входят, x
в том же порядке, в который они отображаютсяy
.
Объединение записей не приводит к оценке значений.
Ошибка не возникает, так как поле содержит ошибку.
Результатом является запись.
Дата x
может быть объединена с использованием y
времениx & y
, создавая дату, которая объединяет части из обоих x
иy
.
В следующем примере показано объединение даты и времени:
#date(2013,02,26) & #time(09,17,00)
// #datetime(2013,02,26,09,17,00)
При слиянии двух записей при слиянии двух записей используется x + y
следующее:
Ошибки, возникающие при оценке выражений x
, y
распространяются.
Результатом является дата и время.
Операторы +
, -
и not
операторы являются унарными операторами.
унарное-выражение:
выражение-типа
+
унарное выражение
-
унарное выражение
not
унарное выражение
Унарный оператор плюс (+x
) определяется для следующих типов значений:
X | Результат | Интерпретация |
---|---|---|
type number |
type number |
Унарный плюс |
type duration |
type duration |
Унарный плюс |
null |
'NULL |
Для других значений возникает ошибка с кодом "Expression.Error"
причины.
Унарный оператор плюс позволяет применять знак к числу +
, дате или значению NULL. Результатом является то же значение. Например:
+ - 1 // -1
+ + 1 // 1
+ #nan // #nan
+ #duration(0,1,30,0) // #duration(0,1,30,0)
При оценке унарного оператора +x
плюс:
Ошибки, возникающие при оценке x
, распространяются.
Если результат оценки x
не является числом, возникает ошибка с кодом "Expression.Error"
причины.
Унарный оператор минус (-x
) определяется для следующих типов значений:
X | Результат | Интерпретация |
---|---|---|
type number |
type number |
Отрицание |
type duration |
type duration |
Отрицание |
null |
null |
Для других значений возникает ошибка с кодом "Expression.Error"
причины.
Унарный оператор минус используется для изменения знака числа или длительности. Например:
- (1 + 1) // -2
- - 1 // 1
- - - 1 // -1
- #nan // #nan
- #infinity // -#infinity
- #duration(1,0,0,0) // #duration(-1,0,0,0)
- #duration(0,1,30,0) // #duration(0,-1,-30,0)
При оценке унарного оператора -x
минус:
Ошибки, возникающие при оценке x
, распространяются.
Если выражение является числом, результатом является число из выражения x
с измененным знаком. Если значение равно NaN, результат также является NaN.
Оператор логического отрицания (not
) определяется для следующих типов значений:
X | Результат | Интерпретация |
---|---|---|
type logical |
type logical |
Отрицание |
null |
null |
Этот оператор вычисляет логическую операцию с заданным логическим not
значением. Например:
not true // false
not false // true
not (true and true) // false
При оценке оператора not x
логического отрицания необходимо следующее:
Ошибки, возникающие при оценке x
, распространяются.
Значение, полученное из вычисления выражения x, должно быть логическим значением или ошибкой с кодом "Expression.Error"
причины должно быть поднято. Если значение равно true
, результатом является false
. Если операнд имеет значение false
, результатом является true
.
Результатом является логическое значение.
Операторы is
и as
называются операторами типа.
Оператор совместимости типов x is y
определяется для следующих типов значений:
X | Y | Результат |
---|---|---|
type any |
тип-примитива-допускающий-значение-NULL | type logical |
Выражение x is y
возвращаетсяtrue
, если атрибутизированный тип x
совместим с y
, и возвращаетсяfalse
, если атрибутизированный тип x
несовместим.y
y
должен быть примитивным типом, допускаемым значением NULL.
выражение-is:
выражение-as
is-expressionis
nullable-primitive-type
тип-примитива-допускающий-значение-NULL:
nullable
необязательно тип-примитива
Совместимость типов, поддерживаемая is
оператором, представляет собой подмножество общего типа совместимости и определяется с помощью следующих правил:
Если x
значение null, то оно совместимо, если y
тип, тип any
null
или тип, допускающий значение NULL.
Если значение не равно null, то если x
оно совместимо, если примитивный тип x
совпадает y
.
При оценке выражения x is y
необходимо следующее:
x
, распространяется.Оператор x as y
утверждения типа определяется для следующих типов значений:
X | Y | Результат |
---|---|---|
type any |
тип-примитива-допускающий-значение-NULL | type any |
Выражение x as y
утверждает, что значение x
совместимо с y
оператором is
. Если оно несовместимо, возникает ошибка.
y
должен быть типом nullable-primitive.
выражение-as:
выражение-равенства
as-expressionas
nullable-primitive-type
Выражение x as y
вычисляется следующим образом:
Проверка x is y
совместимости типов выполняется, а утверждение возвращается x
без изменений, если этот тест выполнен успешно.
Если проверка совместимости завершается ошибкой, возникает ошибка с кодом "Expression.Error"
причины.
Примеры:
1 as number // 1
"A" as number // error
null as nullable number // null
При оценке выражения x as y
необходимо следующее:
x
, распространяется.Оператор объединения ??
возвращает результат своего левого операнда, если он не равен NULL, в противном случае возвращается результат правого операнда. Правый операнд вычисляется только в том случае, если левый операнд равен NULL.
Обучение
Модуль
Выполнение основных операций с числами в C# - Training
Сведения об операторах и методах, используемых для выполнения базовых математических операций с числовыми данными.