from .... import emulators
from ..cstd import CStdModel


class Acos(CStdModel):
    name = "acos"

    def model(self, emulator: emulators.Emulator) -> None:
        # double acos(double x);
        raise NotImplementedError()


class Acosf(CStdModel):
    name = "acosf"

    def model(self, emulator: emulators.Emulator) -> None:
        # float acosf(float x);
        raise NotImplementedError()


class Acosl(CStdModel):
    name = "acosl"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double acosl(long double x);
        raise NotImplementedError()


class Asin(CStdModel):
    name = "asin"

    def model(self, emulator: emulators.Emulator) -> None:
        # double asin(double x);
        raise NotImplementedError()


class Asinf(CStdModel):
    name = "asinf"

    def model(self, emulator: emulators.Emulator) -> None:
        # float asinf(float x);
        raise NotImplementedError()


class Asinl(CStdModel):
    name = "asinl"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double asinl(long double x);
        raise NotImplementedError()


class Asinh(CStdModel):
    name = "asinh"

    def model(self, emulator: emulators.Emulator) -> None:
        # double asinh(double x);
        raise NotImplementedError()


class Asinhf(CStdModel):
    name = "asinhf"

    def model(self, emulator: emulators.Emulator) -> None:
        # float asinhf(float x);
        raise NotImplementedError()


class Asinhl(CStdModel):
    name = "asinhl"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double asinhl(long double x);
        raise NotImplementedError()


class Atan(CStdModel):
    name = "atan"

    def model(self, emulator: emulators.Emulator) -> None:
        # double atan(double x);
        raise NotImplementedError()


class Atanf(CStdModel):
    name = "atanf"

    def model(self, emulator: emulators.Emulator) -> None:
        # float atanf(double x);
        raise NotImplementedError()


class Atanl(CStdModel):
    name = "atanl"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double atanl(long double x);
        raise NotImplementedError()


class Atan2(CStdModel):
    name = "atan2"

    def model(self, emulator: emulators.Emulator) -> None:
        # double atan2(double x, double y);
        raise NotImplementedError()


class Atan2f(CStdModel):
    name = "atan2f"

    def model(self, emulator: emulators.Emulator) -> None:
        # float atan2(float x, float y);
        raise NotImplementedError()


class Atan2l(CStdModel):
    name = "atan2l"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double atan2l(long double x, long double y);
        raise NotImplementedError()


class Atanh(CStdModel):
    name = "atanh"

    def model(self, emulator: emulators.Emulator) -> None:
        # double atanh(double x);
        raise NotImplementedError()


class Atanhf(CStdModel):
    name = "atanhf"

    def model(self, emulator: emulators.Emulator) -> None:
        # float atanhf(float x);
        raise NotImplementedError()


class Atanhl(CStdModel):
    name = "atanhl"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double atanhl(long double x);
        raise NotImplementedError()


class Cbrt(CStdModel):
    name = "cbrt"

    def model(self, emulator: emulators.Emulator) -> None:
        # double cbrt(double x);
        raise NotImplementedError()


class Cbrtf(CStdModel):
    name = "cbrtf"

    def model(self, emulator: emulators.Emulator) -> None:
        # float cbrtf(float x);
        raise NotImplementedError()


class Cbrtl(CStdModel):
    name = "cbrtl"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double long cbrtl(double x);
        raise NotImplementedError()


class Ceil(CStdModel):
    name = "ceil"

    def model(self, emulator: emulators.Emulator) -> None:
        # double ceil(double x);
        raise NotImplementedError()


class Ceilf(CStdModel):
    name = "ceilf"

    def model(self, emulator: emulators.Emulator) -> None:
        # float ceilf(float x);
        raise NotImplementedError()


class Ceill(CStdModel):
    name = "ceill"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double ceill(long double x);
        raise NotImplementedError()


class Copysign(CStdModel):
    name = "copysign"

    def model(self, emulator: emulators.Emulator) -> None:
        # double copysign(double x, double y);
        raise NotImplementedError()


class Copysignf(CStdModel):
    name = "copysignf"

    def model(self, emulator: emulators.Emulator) -> None:
        # float copysignf(float x, float y);
        raise NotImplementedError()


class Copysignl(CStdModel):
    name = "copysignl"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double copysignl(long double x, long double y);
        raise NotImplementedError()


class Cos(CStdModel):
    name = "cos"

    def model(self, emulator: emulators.Emulator) -> None:
        # double cos(double x);
        raise NotImplementedError()


class Cosf(CStdModel):
    name = "cosf"

    def model(self, emulator: emulators.Emulator) -> None:
        # float cosf(float x);
        raise NotImplementedError()


class Cosl(CStdModel):
    name = "cosl"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double cosl(long double x);
        raise NotImplementedError()


class Cosh(CStdModel):
    name = "cosh"

    def model(self, emulator: emulators.Emulator) -> None:
        # double cosh(double x);
        raise NotImplementedError()


class Coshf(CStdModel):
    name = "coshf"

    def model(self, emulator: emulators.Emulator) -> None:
        # float coshf(float x);
        raise NotImplementedError()


class Coshl(CStdModel):
    name = "coshl"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double coshl(long double x);
        raise NotImplementedError()


class Exp(CStdModel):
    name = "exp"

    def model(self, emulator: emulators.Emulator) -> None:
        # double exp(double x);
        raise NotImplementedError()


class Expf(CStdModel):
    name = "expf"

    def model(self, emulator: emulators.Emulator) -> None:
        # float expf(float x);
        raise NotImplementedError()


class Expl(CStdModel):
    name = "expl"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double expl(long double x);
        raise NotImplementedError()


class Exp2(CStdModel):
    name = "exp2"

    def model(self, emulator: emulators.Emulator) -> None:
        # double exp2(double x);
        raise NotImplementedError()


class Exp2f(CStdModel):
    name = "exp2f"

    def model(self, emulator: emulators.Emulator) -> None:
        # float exp2f(float x);
        raise NotImplementedError()


class Exp2l(CStdModel):
    name = "exp2l"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double exp2l(long double x);
        raise NotImplementedError()


class Expm1(CStdModel):
    name = "expm1"

    def model(self, emulator: emulators.Emulator) -> None:
        # double expm1(double x);
        raise NotImplementedError()


class Expm1f(CStdModel):
    name = "expm1f"

    def model(self, emulator: emulators.Emulator) -> None:
        # float expm1f(float x);
        raise NotImplementedError()


class Expm1l(CStdModel):
    name = "expm1l"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double expm1l(long double x);
        raise NotImplementedError()


class Erf(CStdModel):
    name = "erf"

    def model(self, emulator: emulators.Emulator) -> None:
        # double erf(double x);
        raise NotImplementedError()


class Erff(CStdModel):
    name = "erff"

    def model(self, emulator: emulators.Emulator) -> None:
        # float erff(float x);
        raise NotImplementedError()


class Erfl(CStdModel):
    name = "erfl"

    def model(self, emulator: emulators.Emulator) -> None:
        # long double erfl(long double x);
        raise NotImplementedError()
