Arcsin c как написать

Описание

         Вычисляет    значение   arcsin(x)    в    диапазоне
         [-пи/2, пи/2].  Значение  аргумента x должно быть в
         диапазоне [-1, 1].

Использование

         #include <math.h>
         double asin(double x);                   /* ANSI */

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

         Возвращает значение  arcsin  от входного аргумента.
         Если значение меньше -1 или больше 1, устанавливает
         errno в EDOM, печатает DOMAIN сообщение об ошибке в
         stderr и возвращает 0. Обработку ошибки можно моди-
         фицировать посредством функции matherr.

Пример

         #include <math.h>
         #include <stdio.h>
         main ()
         {
           double x, y;
           x = .94;
           y = asin(x);
           printf("Арксинус от %f равен %fn", x, y);
         }

Рекомендация

         Смотрите также atan, atan2, acos.

оглавление

In the C Programming Language, the asin function returns the arc sine of x.

Syntax

The syntax for the asin function in the C Language is:

double asin(double x);

Parameters or Arguments

x

A value between -1 and 1. A domain error will occur if x is not between -1 and 1.

Returns

The asin function returns the arc sine of a number represented by x. It will return a value between -π/2 and π/2.

Required Header

In the C Language, the required header for the asin function is:

#include <math.h>

Applies To

In the C Language, the asin function can be used in the following versions:

• ANSI/ISO 9899-1990

asin Example

/* Example using asin by TechOnTheNet.com */

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

int main(int argc, const char * argv[])
{
    /* Define temporary variables */
    double value;
    double result;

    /* Assign the value we will find the asin of */
    value = 0.5;

    /* Calculate the Arc Sine of value */
    result = asin(value);

    /* Display the result of the calculation */
    printf("The Arc Sine of %f is %fn", value, result);

    return 0;
}

When compiled and run, this application will output:

The Arc Sine of 0.500000 is 0.523599

Similar Functions

Other C functions that are similar to the asin function:

• acos function <math.h>
• atan function <math.h>
• atan2 function <math.h>
• cos function <math.h>
• sin function <math.h>
• tan function <math.h>

1-3) Computes the principal value of the arc sine of arg.

4) A set of overloads or a function template accepting an argument of any integral type. Equivalent to 2) (the argument is cast to double).

[edit] Parameters

[edit] Return value

If no errors occur, the arc sine of arg (arcsin(arg)) in the range [- , +], is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

[edit] Error handling

Errors are reported as specified in math_errhandling.

Domain error occurs if arg is outside the range [-1.0, 1.0]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),

• If the argument is ±0, it is returned unmodified
• If |arg| > 1, a domain error occurs and NaN is returned.
• if the argument is NaN, NaN is returned

[edit] Example

#include <cmath>
#include <iostream>
#include <cerrno>
#include <cfenv>
#include <cstring>
 
#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout << "asin(1.0) = " << asin(1) << 'n'
              << "2*asin(1.0) = " << 2*asin(1) << 'n'
              << "asin(-0.5) = " << asin(-0.5) << 'n'
              << "6*asin(-0.5) =" << 6*asin(-0.5) << 'n';
    // special values
    std::cout << "asin(0.0) = " << asin(0) << " asin(-0.0)=" << asin(-0.0) << 'n';
    // error handling
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "asin(1.1) = " << asin(1.1) << 'n';
    if (errno == EDOM)
        std::cout << "    errno == EDOM: " << std::strerror(errno) << 'n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID raised" << 'n';
}

asin(1.0) = 1.5708
2*asin(1.0) = 3.14159
asin(-0.5) = -0.523599
6*asin(-0.5) = -3.14159
asin(0.0) = 0 asin(-0.0)=-0
asin(1.1) = nan
    errno == EDOM: Numerical argument out of domain
    FE_INVALID raised

[edit] See also

Статический класс Math содержит ряд методов и констант для выполнения математических, тригонометрических, логарифмических и других операций. Так как класс статический, то и все его методы также являются статическими, т.е. вызывать эти методы можно без создания объекта типа Math. Рассмотрим основные методы этого класса.

Тригонометрические функции (синус, косинус, тангенс)

Cos(x) — возвращает косинус указанного угла x. Например,

x = Math.Cos(1);//0,5403023058681398
x = Math.Cos(0.5); //0,8775825618903728
x = Math.Cos(0.75);//0,7316888688738209
x = Math.Cos(-1);//0,5403023058681398

Sin(x) — возвращает синус указанного угла x. Например,

x = Math.Sin(1);//0,8414709848078965
x = Math.Sin(0.5); //0,479425538604203
x = Math.Sin(0.75);//0,6816387600233341
x = Math.Sin(-1);//-0,8414709848078965

Tan(x) — возвращает тангенс указанного угла x. Например,

x = Math.Tan(1);//1,5574077246549023
x = Math.Tan(0.5); //0,5463024898437905
x = Math.Tan(0.75);//0,9315964599440725
x = Math.Tan(-1);//-1,5574077246549023

Обратные тригонометрические функции (арккосинус, арксинус, арктангенс)

Acos(x) — вычисляет арккосинус заданного числа. Параметр x должен находиться в диапазоне от -1 до 1.  Значение, возвращаемое методом — радианы. Пример:

x = Math.Acos(1); //0
x = Math.Acos(0); //1,5707963267948966
x = Math.Acos(-1);//3,141592653589793
x = Math.Acos(0.5);//1,0471975511965979

Asin(x) — вычисляет арксинус числа. Параметр x должен находиться в диапазоне от -1 до 1. Например,

x = Math.Asin(1); //1,5707963267948966
x = Math.Asin(0); // 0
x = Math.Asin(10);//ошибка x>1
x = Math.Asin(-1);//-1,5707963267948966
x = Math.Asin(0.6);//0,6435011087932844

Atan(x) — возвращает арктангенс числа. Значение, возвращаемое методом лежит в диапазоне от -Пи/2 до +Пи/2. Например,

x = Math.Atan(1); //0,7853981633974483
x = Math.Atan(0); //0 
x = Math.Atan(10);//1,4711276743037347
x = Math.Atan(-1);//-0,7853981633974483
x = Math.Atan(0.6);//0,5404195002705842

Atan2(x, y) — возвращает арктангенс для точки в декартовой системе координат с координатами (x,y). Например, 

x = Math.Atan2(1,1); //0,7853981633974483
x = Math.Atan2(1,-1); //2,356194490192345 
x = Math.Atan2(-1,1);//-0,7853981633974483
x = Math.Atan2(-1,-1);//-2,356194490192345

Этот метод возвращает значение (θ), в зависимости от того, в каком квадранте располагается точка, а именно:

• для (x, y) в квадранте 1: 0 < θ < π/2.
• для (x, y) в квадранте 2: π/2 < θ ≤ π.
• для (x, y) в квадранте 3: -π < θ < -π/2.
• для (x, y) в квадранте 4: -π/2 < θ < 0.

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

• если y равно 0, и x не является отрицательным, то θ = 0.
• если y равно 0, и x является отрицательным, то θ = π.
• если y — положительное число, а x равно 0, то θ = π/2.
• если y — отрицательное число, а х равно 0, то θ = -π/2.
• если y равен 0, и х равен 0, то θ = 0.

Гиперболические функции (гаперболический косинус, гиперболический синус, гиперболический тангенс)

Cosh(x) — вычисляет гиперболический косинус указанного угла

x = Math.Cosh(1);//1,5430806348152437
x = Math.Cosh(0.5); //1,1276259652063807
x = Math.Cosh(0.75);//1,2946832846768448
x = Math.Cosh(-1);//1,5430806348152437

Sinh(x) — вычисляет гиперболический синус указанного угла

x = Math.Sinh(1);//1,1752011936438014
x = Math.Sinh(0.5); //0,5210953054937474
x = Math.Sinh(0.75);//0,82231673193583
x = Math.Sinh(-1);//-1,1752011936438014

Tanh(x) — вычисляет гиперболический тангенс указанного угла

x = Math.Tanh(1);//0,7615941559557649
x = Math.Tanh(0.5); //0,46211715726000974
x = Math.Tanh(0.75);//0,6351489523872873
x = Math.Tanh(-1);//-0,7615941559557649

Обратные гиперболические функции (ареакосинус, ареасинус, ареатангенс)

Acosh(x) — вычисляет ареакосинус. Параметр x должен быть больше 1. Например,

x = Math.Acosh(1); //0
x = Math.Acosh(0); // ошибка - x<1
x = Math.Acosh(10);//2,993222846126381
x = Math.Acosh(3.14);//1,810991348900196
x = Math.Acosh(10000);//9,903487550036129

Asinh(x) — вычисляет ареасинус. Например,  

x = Math.Asinh(1);//0,881373587019543
x = Math.Asinh(0.5); //0,48121182505960347
x = Math.Asinh(0.75);//0,6931471805599453
x = Math.Asinh(-1);//-0,881373587019543

Atanh(x) — вычисляет ареатангенс. Значение x должно быть в пределах от -1 до 1. Например,

x = Math.Atanh(-0.5);//-0,5493061443340549
x = Math.Atanh(0.5); //0,5493061443340549
x = Math.Atanh(0.75);//0,9729550745276566
x = Math.Atanh(-0.75);//-0,9729550745276566

ILogB(x) —  вычисляет целочисленный логарифм с основанием 2 указанного числа, то есть значение (int)log2(x).

x = Math.ILogB(15);//3

Log2(x) — вычисляет логарифм с основанием 2 указанного числа.

x = Math.Log2(15);//3,9068905956085187

Log(x) — вычисляет натуральный логарифм (с основанием e) указанного числа.

x = Math.Log(15);//2,70805020110221

Log(x, y) — вычисляет логарифм указанного числа x по основанию y.

x = Math.Log(15, 2);//3,9068905956085187

Log10(x) — вычисляет логарифм с основанием 10 указанного числа

x = Math.Log10(15);//1,1760912590556813

Методы округления чисел в C#

Ceiling(x) — возвращает наименьшее целое число, которое больше или равно заданному числу 

x = Math.Ceiling(7.256);//8

Floor(x) — возвращает наибольшее целое число, которое меньше или равно указанному числу 

x = Math.Floor(7.256);//7

Round(x) — округляет значение до ближайшего целого значения; значения посередине округляются до ближайшего четного числа

x = Math.Round(7.256);//7

Round(x, Int32 y) — округляет значение до указанного числа знаков после запятой; значения посередине округляются до ближайшего четного числа.

x = Math.Round(7.256, 1);//7,3

Round(x, Int32 y, MidpointRounding) — округляет значение до указанного числа дробных цифр, используя указанное соглашение о округлении

            x = Math.Round(7.256, 2, MidpointRounding.ToZero);//7,25
x = Math.Round(7.256, 2, MidpointRounding.ToPositiveInfinity);//7,26
x = Math.Round(7.256, 2, MidpointRounding.ToNegativeInfinity);//7,25
x = Math.Round(7.256, 2, MidpointRounding.ToEven);//7,26

Round(x, MidpointRounding) — округляет значение на целое число, используя указанное соглашение об округлении

x = Math.Round(7.256, MidpointRounding.ToZero);//7

Truncate(x) — вычисляет целую часть заданного числа 

x = Math.Truncate(7.256);//7

Сравнение различных методов округления в C#

Возведение в степень и извлечение корней в C#

Cbrt(x) — возвращает кубический корень из x.

x = Math.Cbrt(27);//3

Exp(x) — возвращает e, возведенное в указанную степень x.

x = Math.Exp(3);//20,085536923187668

Pow(x, y) — возвращает число x, возведенное в степень y.

x = Math.Pow(3,3);//27

Sqrt(x) — возвращает квадратный корень из числа x.

x = Math.Sqrt(9);//3

Прочие математические операции

Abs(x) — возвращает абсолютное значение числа

x = Math.Abs(-2.7);//2.7
x = Math.Abs(2.7);//2.7

BigMul(Int32, Int32) — умножает два 32-битовых числа и возвращает значение в Int64.

double x = Math.BigMul(Int32.MaxValue, Int32.MaxValue);//4,6116860141324206E+18

BitDecrement(x) — возвращает ближайшее самое маленькое значение, которое меньше, чем x.

x = Math.BitDecrement(1);//0,9999999999999999
x = Math.BitDecrement(-1);//-1,0000000000000002

BitIncrement(Double) — возвращает наименьшее ближайшее значение, которое больше указанного значения

x = Math.BitIncrement(1);//1,0000000000000002
x = Math.BitIncrement(-1);//-0,9999999999999999

Clamp(x, min, max) — Возвращает x, ограниченное диапазоном от min до max включительно.

x = Math.Clamp(3, 5, 10);//5
x = Math.Clamp(4, 5, 10);//5
x = Math.Clamp(11, 5, 10);//10

CopySign(Double, Double) — возвращает значение с величиной x и знаком y.

double x = Math.CopySign(-3, 5);//3 (знак + взят у 5)
x = Math.CopySign(5, -10);//-5 (знак - взят у -10)

DivRem(Int32, Int32, Int32) — Вычисляет частное чисел и возвращает остаток в выходном параметре

x = Math.DivRem(-3, 5, out int y);//x = 0; y = -3
x = Math.DivRem(10, 10, out int z);//x = 1; z = 0

FusedMultiplyAdd(x, y, z) — возвращает значение (x * y) + z, округленное в рамках одной тернарной операции. 

x = Math.FusedMultiplyAdd(10.4566d, 5.56012f, 10.83789f);//68,97784156904221
x = (10.4566d * 5.56012f) + 10.83789f;                   //68,9778415690422

Метод FusedMultiplyAdd округляет значение один раз — в конце вычислений, в то время как обычное вычисление (x * y) + z вначале округляет значение, полученное в скобках, затем добавляет к полученному значению z и ещё раз округляет результат.

IEEERemainder(x, y) — Возвращает остаток от деления одного указанного числа на другое указанное число

double x = Math.IEEERemainder(10, 3);//1

Функция IEEERemainder не совпадает с оператором %, который также вычисляет остаток от деления. Различие заключается в формулах, используемых при вычислениях. Оператор действует следующим образом:

a % b =  (Math.Abs(а) - (Math.Abs(b) * (Math.Floor(Math.Abs(a) / Math.Abs(b))))) * Math.Sign(a)  

в то время, как метод IEEERemainder производит вычисления следующим образом:

IEEERemainder(а,b) = a-(b * Math.Round(a/b))

x = Math.IEEERemainder(-16.3, 4.1);//0,09999999999999787
x = -16.3 % 4.1;//-4,000000000000002

Max(x, y) — возвращает большее из чисел

x = Math.Max(-16.3, 4.1);//4,1
x = Math.Max(10, 5);//10

MaxMagnitude(x, y) — возвращает большую величину из двух чисел двойной точности с плавающей запятой. При сравнении двух чисел не учитывается знак

x = Math.MaxMagnitude(-16.3, 4.1);//-16,3
x = Math.MaxMagnitude(10, 5);//10

Min(Byte, Byte) — возвращает меньшее из двух чисел

x = Math.Min(-16.3, 4.1);//-16,3
x = Math.Min(10, 5);//5

MinMagnitude(x, y) — возвращает меньшую величину из чисел. При сравнении не учитывается знак

x = Math.MinMagnitude(-16.3, 4.1);//4.1
x = Math.MinMagnitude(10, -5);//-5

ScaleB(x, y) — Возвращает значение x * 2^n, вычисленное наиболее эффективно.

x = Math.ScaleB(-16.3, 8);//4172,8

Sign(x) — возвращает целое число, указывающее знак десятичного числа.

x = Math.Sign(-16.3);//-1
x = Math.Sign(10);//1
x = Math.Sign(0);//0

Константы класса Math

В классе Math также определены две константы — E и PI:

x = Math.E;//2,718281828459045
x = Math.PI;//3,141592653589793

Итого

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

The asin() function returns the arc sine (inverse sine) of a number in radians.

double asin(double x);

 int x = 0;
 double result;
 result = asin(double(x));

float asinf(float x);
long double asinl(long double x);

#include <stdio.h>
#include <math.h>
int main()
{
    // constant PI is defined
    const double PI =  3.1415926;
    double x, result;

    x =  -0.5;
    result = asin(x);
    printf("Inverse of sin(%.2f) = %.2lf in radiansn", x, result);

    // converting radians to degree
    result = asin(x)*180/PI;
    printf("Inverse of sin(%.2f) = %.2lf in degreesn", x, result);

    // paramter not in range
    x = 1.2;
    result = asin(x);
    printf("Inverse of sin(%.2f) = %.2lf", x, result);

    return 0;
}

Inverse of sin(-0.50) = -0.52 in radians
Inverse of sin(-0.50) = -30.00 in degrees
Inverse of sin(1.20) = nan

#include <stdio.h>
#include <math.h>
int main()
{
    float fx, fasinx;
    long double lx, ldasinx;

    // arc sinine of type float
    fx = -0.505405;
    fasinx = asinf(fx);

    // arc sinine of type long double
    lx = -0.50540593;
    ldasinx = asinf(lx);

    printf("asinf(x) = %f in radiansn", fasinx);
    printf("asinl(x) = %Lf in radians", ldasinx);

    return 0;
}

asinf(x) = -0.529851 in radians
asinl(x) = -0.529852 in radians