🌌 SpectraShell

✅ Cloned to:

📄 Viewing: floatobject.h

/* Float object interface */ /* PyFloatObject represents a (double precision) floating point number. */ #ifndef Py_FLOATOBJECT_H #define Py_FLOATOBJECT_H #ifdef __cplusplus extern "C" { #endif typedef struct { PyObject_HEAD double ob_fval; } PyFloatObject; PyAPI_DATA(PyTypeObject) PyFloat_Type; #define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type) #define PyFloat_CheckExact(op) (Py_TYPE(op) == &PyFloat_Type) /* The str() precision PyFloat_STR_PRECISION is chosen so that in most cases, the rounding noise created by various operations is suppressed, while giving plenty of precision for practical use. */ #define PyFloat_STR_PRECISION 12 #ifdef Py_NAN #define Py_RETURN_NAN return PyFloat_FromDouble(Py_NAN) #endif #define Py_RETURN_INF(sign) do \ if (copysign(1., sign) == 1.) { \ return PyFloat_FromDouble(Py_HUGE_VAL); \ } else { \ return PyFloat_FromDouble(-Py_HUGE_VAL); \ } while(0) PyAPI_FUNC(double) PyFloat_GetMax(void); PyAPI_FUNC(double) PyFloat_GetMin(void); PyAPI_FUNC(PyObject *) PyFloat_GetInfo(void); /* Return Python float from string PyObject. Second argument ignored on input, and, if non-NULL, NULL is stored into *junk (this tried to serve a purpose once but can't be made to work as intended). */ PyAPI_FUNC(PyObject *) PyFloat_FromString(PyObject*, char** junk); /* Return Python float from C double. */ PyAPI_FUNC(PyObject *) PyFloat_FromDouble(double); /* Extract C double from Python float. The macro version trades safety for speed. */ PyAPI_FUNC(double) PyFloat_AsDouble(PyObject *); #define PyFloat_AS_DOUBLE(op) (((PyFloatObject *)(op))->ob_fval) /* Write repr(v) into the char buffer argument, followed by null byte. The buffer must be "big enough"; >= 100 is very safe. PyFloat_AsReprString(buf, x) strives to print enough digits so that PyFloat_FromString(buf) then reproduces x exactly. */ PyAPI_FUNC(void) PyFloat_AsReprString(char*, PyFloatObject *v); /* Write str(v) into the char buffer argument, followed by null byte. The buffer must be "big enough"; >= 100 is very safe. Note that it's unusual to be able to get back the float you started with from PyFloat_AsString's result -- use PyFloat_AsReprString() if you want to preserve precision across conversions. */ PyAPI_FUNC(void) PyFloat_AsString(char*, PyFloatObject *v); /* _PyFloat_{Pack,Unpack}{4,8} * * The struct and pickle (at least) modules need an efficient platform- * independent way to store floating-point values as byte strings. * The Pack routines produce a string from a C double, and the Unpack * routines produce a C double from such a string. The suffix (4 or 8) * specifies the number of bytes in the string. * * On platforms that appear to use (see _PyFloat_Init()) IEEE-754 formats * these functions work by copying bits. On other platforms, the formats the * 4- byte format is identical to the IEEE-754 single precision format, and * the 8-byte format to the IEEE-754 double precision format, although the * packing of INFs and NaNs (if such things exist on the platform) isn't * handled correctly, and attempting to unpack a string containing an IEEE * INF or NaN will raise an exception. * * On non-IEEE platforms with more precision, or larger dynamic range, than * 754 supports, not all values can be packed; on non-IEEE platforms with less * precision, or smaller dynamic range, not all values can be unpacked. What * happens in such cases is partly accidental (alas). */ /* The pack routines write 4 or 8 bytes, starting at p. le is a bool * argument, true if you want the string in little-endian format (exponent * last, at p+3 or p+7), false if you want big-endian format (exponent * first, at p). * Return value: 0 if all is OK, -1 if error (and an exception is * set, most likely OverflowError). * There are two problems on non-IEEE platforms: * 1): What this does is undefined if x is a NaN or infinity. * 2): -0.0 and +0.0 produce the same string. */ PyAPI_FUNC(int) _PyFloat_Pack4(double x, unsigned char *p, int le); PyAPI_FUNC(int) _PyFloat_Pack8(double x, unsigned char *p, int le); /* Used to get the important decimal digits of a double */ PyAPI_FUNC(int) _PyFloat_Digits(char *buf, double v, int *signum); PyAPI_FUNC(void) _PyFloat_DigitsInit(void); /* The unpack routines read 4 or 8 bytes, starting at p. le is a bool * argument, true if the string is in little-endian format (exponent * last, at p+3 or p+7), false if big-endian (exponent first, at p). * Return value: The unpacked double. On error, this is -1.0 and * PyErr_Occurred() is true (and an exception is set, most likely * OverflowError). Note that on a non-IEEE platform this will refuse * to unpack a string that represents a NaN or infinity. */ PyAPI_FUNC(double) _PyFloat_Unpack4(const unsigned char *p, int le); PyAPI_FUNC(double) _PyFloat_Unpack8(const unsigned char *p, int le); /* free list api */ PyAPI_FUNC(int) PyFloat_ClearFreeList(void); /* Format the object based on the format_spec, as defined in PEP 3101 (Advanced String Formatting). */ PyAPI_FUNC(PyObject *) _PyFloat_FormatAdvanced(PyObject *obj, char *format_spec, Py_ssize_t format_spec_len); /* Round a C double x to the closest multiple of 10**-ndigits. Returns a Python float on success, or NULL (with an appropriate exception set) on failure. Used in builtin_round in bltinmodule.c. */ PyAPI_FUNC(PyObject *) _Py_double_round(double x, int ndigits); PyAPI_FUNC(void) _PyFloat_DebugMallocStats(FILE* out); #ifdef __cplusplus } #endif #endif /* !Py_FLOATOBJECT_H */

Wordfairy

Terms and Conditions

We guarantee your data privacy

Terms and Conditions

Welcome to Word Fairy AI! These terms and conditions outline the rules and regulations for the use of our Artificial Intelligence Writing Tool, provided by Word Fairy AI. By accessing and using our services, you agree to comply with these terms and conditions. Please read them carefully before using our platform.

1. Introduction
1.1 Company Details
Word Fairy AI is a leading provider of an Artificial Intelligence Writing Tool. We offer an innovative platform that utilizes advanced AI technology to assist users in generating written content.

2. Acceptance of Terms
2.1 Agreement
By accessing and using our services, you acknowledge that you have read, understood, and agreed to be bound by these terms and conditions. If you do not agree with any part of these terms, you may not use our platform.

3. Use of Services
3.1 Eligibility
You must be at least 18 years old or have the legal capacity to enter into a contract to use our services. By using our platform, you represent and warrant that you meet these requirements.

3.2 License
We grant you a non-exclusive, non-transferable license to use our Artificial Intelligence Writing Tool for personal or commercial purposes. This license is subject to your compliance with these terms and conditions.

3.3 Prohibited Activities
You agree not to engage in any activities that may harm, disrupt, or interfere with our services. Prohibited activities include but are not limited to:
- Reverse engineering, modifying, or creating derivative works of our platform.
- Violating any applicable laws or regulations.
- Uploading or transmitting any harmful or malicious content.

4. User Accounts
4.1 Registration
To access certain features of our platform, you may need to create a user account. You agree to provide accurate and complete information during the registration process.

4.2 Account Security
You are responsible for maintaining the confidentiality of your account credentials and for all activities that occur under your account. Notify us immediately of any unauthorized use or security breach.

5. Intellectual Property
5.1 Ownership
All intellectual property rights, including copyrights and trademarks, in our platform and its content are owned by Word Fairy AI. You may not use our intellectual property without our prior written consent.

5.2 User Content
By using our platform, you grant us a non-exclusive, worldwide, royalty-free license to use, reproduce, modify, and distribute your content for the purpose of providing our services. You retain ownership of your content.

6. Limitation of Liability
6.1 Disclaimer
Our platform is provided on an "as is" and "as available" basis, without any warranties or guarantees. We do not warrant that our services will be uninterrupted, error-free, or secure.

6.2 Indemnification
You agree to indemnify and hold Word Fairy AI harmless from any claims, damages, losses, or expenses arising out of your use of our platform or violation of these terms and conditions.

7. Termination
7.1 Suspension or Termination
We reserve the right to suspend or terminate your access to our services at any time, without prior notice, for any reason. Upon termination, your rights to use our platform will cease immediately.

8. Governing Law
8.1 Jurisdiction
These terms and conditions shall be governed by and construed in accordance with the laws of [Jurisdiction]. Any disputes arising out of or in connection with these terms shall be subject to the exclusive jurisdiction of the courts of [Jurisdiction].

9. Modifications
9.1 Changes to Terms
We reserve the right to modify or update these terms and conditions at any time. Any changes will be effective immediately upon posting on our platform. It is your responsibility to review these terms periodically.

10. Contact Information
10.1 Support
If you have any questions or concerns regarding these terms and conditions, please contact us at Admin@Wordfairy.ai. We strive to provide prompt assistance and address any issues promptly.

By using our Artificial Intelligence Writing Tool, you agree to abide by these terms and conditions. If you do not agree with any part of these terms, please refrain from using our platform. Thank you for choosing Word Fairy AI!

I Agree, Let's Sign Up I Agree, Let's Login