Арифметические типы

Логический тип

• _Bool (также доступен как макрос bool)(до C23)bool(начиная с C23) — тип, способный хранить одно из двух значений: 1 и 0 (также доступные как макросы true и false)(до C23)true и false(начиная с C23).

Обратите внимание, что преобразование к _Bool(до C23)bool(начиная с C23) работает не так, как преобразование к другим целочисленным типам: (bool)0.5 вычисляется как true, тогда как (int)0.5 вычисляется как 0.

• longlongint (также доступен как longlong)
• unsignedlonglongint (также доступен как unsignedlonglong)

• _BitInt(n) (также доступен как signed_BitInt(n)), целочисленные типы со знаковым значением и точной битовой шириной (вместо n указывается целочисленное константное выражение, задающее точную ширину, включая бит знака; она не может превышать BITINT_MAXWIDTH из <limits.h>)
• unsigned_BitInt(n), целочисленные типы беззнакового значения и точной битовой шириной (вместо n указывается целочисленное константное выражение, задающее точную ширину; она не может превышать BITINT_MAXWIDTH из <limits.h>)

Если реализация предварительно определяет макрос-константу __STDC_IEC_60559_DFP__, поддерживаются также следующие десятичные типы с плавающей точкой.

• _Decimal32 — представляет формат IEEE-754 decimal32.
• _Decimal64 — представляет формат IEEE-754 decimal64.
• _Decimal128 — представляет формат IEEE-754 decimal128.

В противном случае эти десятичные типы с плавающей точкой не поддерживаются.

Комплексные типы с плавающей точкой

Комплексные типы с плавающей точкой моделируют математические комплексные числа, то есть числа, которые можно представить в виде суммы вещественного числа и вещественного числа, умноженного на мнимую единицу: a + bi

Существуют три комплексных типа:

• float _Complex (также доступен как float complex, если подключён <complex.h>)
• double _Complex (также доступен как double complex, если подключён <complex.h>)
• long double _Complex (также доступен как long double complex, если подключён <complex.h>)

Примечание: как и для всех спецификаторов типов, допускается любой порядок: long double complex, complex long double и даже double complex long обозначают один и тот же тип.

#include <complex.h>
#include <stdio.h>

int main(void)
{
    double complex z = 1 + 2*I;
    z = 1 / z;
    printf("1/(1.0+2.0i) = %.1f%+.1fi\n", creal(z), cimag(z));
}

Вывод:

1/(1.0+2.0i) = 0.2-0.4i

Каждый комплексный тип имеет такое же представление объекта и требования к выравниванию, как и массив из двух элементов соответствующего вещественного типа (float для float complex, double для double complex, long double для long double complex). Первый элемент массива содержит вещественную часть, а второй — мнимую.

float a[4] = {1, 2, 3, 4};
float complex z1, z2;
memcpy(&z1, a, sizeof z1); // z1 becomes 1.0 + 2.0i
memcpy(&z2, a+2, sizeof z2); // z2 becomes 3.0 + 4.0i

Комплексные числа можно использовать с арифметическими операторами + - * и /, возможно, вместе с мнимыми и вещественными числами. В <complex.h> определено множество математических функций для комплексных чисел. Как встроенные операторы, так и библиотечные функции могут вызывать исключения с плавающей точкой и устанавливать errno, как описано в math_errhandling.

Инкремент и декремент для комплексных типов не определены.

Операторы сравнения для комплексных типов не определены (понятие «меньше» отсутствует).

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

Чтобы поддержать модель одной бесконечности в арифметике комплексных чисел, C считает любое комплексное значение, у которого хотя бы одна часть бесконечна, бесконечностью, даже если другая часть является NaN, гарантирует, что все операторы и функции соблюдают основные свойства бесконечностей, и предоставляет cproj для преобразования всех бесконечностей к канонической (точные правила см. в разделе арифметические операторы).

#include <complex.h>
#include <math.h>
#include <stdio.h>

int main(void)
{
    double complex z = (1 + 0*I) * (INFINITY + I*INFINITY);
//  textbook formula would give
//  (1+i0)(∞+i∞) ⇒ (1×∞ – 0×∞) + i(0×∞+1×∞) ⇒ NaN + I*NaN
//  but C gives a complex infinity
    printf("%f%+f*i\n", creal(z), cimag(z));

//  textbook formula would give
//  cexp(∞+iNaN) ⇒ exp(∞)×(cis(NaN)) ⇒ NaN + I*NaN
//  but C gives  ±∞+i*nan
    double complex y = cexp(INFINITY + I*NAN);
    printf("%f%+f*i\n", creal(y), cimag(y));
}

Возможный вывод:

inf+inf*i 
inf+nan*i

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

умножение мнимой единицы на вещественную бесконечность даёт мнимую бесконечность с правильным знаком: i × ∞ = i∞. Кроме того, i × (∞ – i∞) = ∞ + i∞ указывает на правильный квадрант.

Мнимые типы с плавающей точкой

Мнимые типы с плавающей точкой моделируют математические мнимые числа, то есть числа, которые можно представить как вещественное число, умноженное на мнимую единицу: bi. Существуют три мнимых типа:

• float _Imaginary (также доступен как float imaginary, если подключён <complex.h>)
• double _Imaginary (также доступен как double imaginary, если подключён <complex.h>)
• long double _Imaginary (также доступен как long double imaginary, если подключён <complex.h>)

Примечание: как и для всех спецификаторов типов, допускается любой порядок: long double imaginary, imaginary long double и даже double imaginary long обозначают один и тот же тип.

#include <complex.h>
#include <stdio.h>

int main(void)
{
    double imaginary z = 3*I;
    z = 1 / z;
    printf("1/(3.0i) = %+.1fi\n", cimag(z));
}

Вывод:

1/(3.0i) = -0.3i

Каждый из трёх мнимых типов имеет такое же представление объекта и требование к выравниванию, как и его соответствующий вещественный тип (float для float imaginary, double для double imaginary, long double для long double imaginary).

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

Мнимые числа можно использовать с арифметическими операторами + - * и /, возможно, вместе с комплексными и вещественными числами. В <complex.h> определено множество математических функций для мнимых чисел. Как встроенные операторы, так и библиотечные функции могут вызывать исключения с плавающей точкой и устанавливать errno, как описано в math_errhandling.

Инкремент и декремент для мнимых типов не определены.

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

Мнимые числа позволяют естественным образом представлять все комплексные числа в виде x + I*y (где I определяется как _Imaginary_I). Без мнимых типов некоторые особые комплексные значения нельзя естественным образом создать. Например, если I определён как _Complex_I, то выражение 0.0 + I*INFINITY задаёт NaN в качестве вещественной части, и вместо него необходимо использовать CMPLX(0.0, INFINITY). То же относится к числам с отрицательным нулём в мнимой части, имеющим значение при работе с библиотечными функциями с разрезами ветвей, такими как csqrt: результатом 1.0 - 0.0*I будет положительный ноль в мнимой части, если I определён как _Complex_I; для получения отрицательного нуля в мнимой части необходимо использовать CMPLX или conj.

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