nuttx/nuttx-update
1
2
Fork 1
Code Issues 1 Pull requests 1 Projects Releases Packages Wiki Activity Actions

lib/math files not follow coding standard; float, double, and long double versions in separate files to reduce size of dumb link

Browse source 
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@5270 42af7a65-404d-4744-a932-0658087f49c3
This commit is contained in:
patacongo 2012-10-28 18:42:09 +00:00
parent 918e70fe8e
commit cee4481eca
84 changed files with 4442 additions and 1209 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
COPYING
View file

@ -192,6 +192,28 @@ lib/string/lib_vikmemcpy.c
3. This notice may not be removed or altered from any source
distribution.
lib/math
^^^^^^^^
If you enable CONFIG_LIB, you will build the math library at lib/math.
This library was taken from the math library developed for the Rhombus
OS by Nick Johnson (https://github.com/nickbjohnson4224/rhombus). This
port was contributed by Darcy Gong. The Rhombus math library has this
compatible MIT license:
Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
Documents/rss.gif
^^^^^^^^^^^^^^^^^

7
ChangeLog
View file

@ -3529,3 +3529,10 @@
the math library from the Rhombus OS
* lib/math: Now contains the math library from the Rhombus OS by Nick Johnson
(submitted by Darcy Gong).
* include/float.h: Add a first cut at the float.h header file. This
really should be an architecture/toolchain-specific header file. It
is only used if CONFIG_ARCH_FLOAT_H is defined.
* lib/math: Files now conform to coding standards. Separated float,
double, and long double versions of code into separate files so that
they don't draw in so much un-necessary code when doing a dumb link.

11
Kconfig
View file

@ -192,6 +192,17 @@ config ARCH_MATH_H
that don't select ARCH_MATH_H, the redirecting math.h header file
will stay out-of-the-way in include/nuttx/.
config ARCH_FLOAT_H
bool "float.h"
default n
---help---
The float.h header file defines the properties of your floating
point implementation. It would always be best to use your
toolchain's float.h header file but if none is avaiable, a default
float.h header file will provided if this option is selected. However
there is no assurance that the settings in this float.h are actually
correct for your platform!
config ARCH_STDARG_H
bool "stdarg.h"
default n

36
Makefile
View file

@ -263,15 +263,47 @@ all: $(BIN)
# Target used to copy include/nuttx/math.h. If CONFIG_ARCH_MATH_H is
# defined, then there is an architecture specific math.h header file
# that will be included indirectly from include/math.h. But first, we
# have to copy math.h from include/nuttx/. to include/.
# have to copy math.h from include/nuttx/. to include/. Logic within
# include/nuttx/math.h will hand the redirection to the architecture-
# specific math.h header file.
#
# If the CONFIG_LIBM is defined, the Rhombus libm will be built at lib/math.
# Definitions and prototypes for the Rhombus libm are also contained in
# include/nuttx/math.h and so the file must also be copied in that case.
#
# If neither CONFIG_ARCH_MATH_H nor CONFIG_LIBM is defined, then no math.h
# header file will be provided. You would want that behavior if (1) you
# don't use libm, or (2) you want to use the math.h and libm provided
# within your toolchain.
ifeq ($(CONFIG_ARCH_MATH_H),y)
NEED_MATH_H = y
else
ifeq ($(CONFIG_LIBM),y)
NEED_MATH_H = y
endif
endif
ifeq ($(NEED_MATH_H),y)
include/math.h: include/nuttx/math.h
@cp -f include/nuttx/math.h include/math.h
else
include/math.h:
endif
# The float.h header file defines the properties of your floating point
# implementation. It would always be best to use your toolchain's float.h
# header file but if none is avaiable, a default float.h header file will
# provided if this option is selected. However there is no assurance that
# the settings in this float.h are actually correct for your platform!
ifeq ($(CONFIG_ARCH_FLOAT_H),y)
include/float.h: include/nuttx/float.h
@cp -f include/nuttx/float.h include/float.h
else
include/float.h:
endif
# Target used to copy include/nuttx/stdarg.h. If CONFIG_ARCH_STDARG_H is
# defined, then there is an architecture specific stdarg.h header file
# that will be included indirectly from include/stdarg.h. But first, we
@ -364,7 +396,7 @@ dirlinks: include/arch include/arch/board include/arch/chip $(ARCH_SRC)/board $(
# the config.h and version.h header files in the include/nuttx directory and
# the establishment of symbolic links to configured directories.
context: check_context include/nuttx/config.h include/nuttx/version.h include/math.h include/stdarg.h dirlinks
context: check_context include/nuttx/config.h include/nuttx/version.h include/math.h include/float.h include/stdarg.h dirlinks
@for dir in $(CONTEXTDIRS) ; do \
$(MAKE) -C $$dir TOPDIR="$(TOPDIR)" context; \
done

8
include/nuttx/compiler.h
View file

@ -196,8 +196,9 @@
/* GCC supports both types double and long long */
# define CONFIG_HAVE_DOUBLE 1
# define CONFIG_HAVE_LONG_LONG 1
# define CONFIG_HAVE_DOUBLE 1
# define CONFIG_HAVE_LONG_DOUBLE 1
/* Structures and unions can be assigned and passed as values */
@ -301,6 +302,7 @@
# undef CONFIG_HAVE_LONG_LONG
# undef CONFIG_HAVE_DOUBLE
# undef CONFIG_HAVE_LONG_DOUBLE
/* Structures and unions cannot be passed as values or used
* in assignments.
@ -403,8 +405,9 @@
* simply do not support long long or double.
*/
# undef CONFIG_HAVE_DOUBLE
# undef CONFIG_HAVE_LONG_LONG
# undef CONFIG_HAVE_DOUBLE
# undef CONFIG_HAVE_LONG_DOUBLE
/* Structures and unions can be assigned and passed as values */
@ -441,6 +444,7 @@
# define inline
# undef CONFIG_HAVE_LONG_LONG
# undef CONFIG_HAVE_DOUBLE
# undef CONFIG_HAVE_LONG_DOUBLE
# undef CONFIG_CAN_PASS_STRUCTS
#endif

225
include/nuttx/float.h Normal file
View file

@ -0,0 +1,225 @@
/****************************************************************************
* include/nuttx/float.h
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Reference: http://pubs.opengroup.org/onlinepubs/009695399/basedefs/float.h.html
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#ifndef __INCLUDE_NUTTX_FLOAT_H
#define __INCLUDE_NUTTX_FLOAT_H
/* TODO: These values could vary with architectures toolchains. This
* logic should be move at least to the include/arch directory.
*/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* Radix of exponent representation, b. */
#define FLT_RADIX 2
/* Number of base-FLT_RADIX digits in the floating-point significand, p. */
#define FLT_MANT_DIG 24
#if CONFIG_HAVE_DOUBLE
# define DBL_MANT_DIG 53
#else
# define DBL_MANT_DIG FLT_MANT_DIG
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
# define LDBL_MANT_DIG DBL_MANT_DIG /* FIX ME */
#else
# define LDBL_MANT_DIG DBL_MANT_DIG
#endif
/* Number of decimal digits, n, such that any floating-point number in the
* widest supported floating type with pmax radix b digits can be rounded
* to a floating-point number with n decimal digits and back again without
* change to the value.
*/
#define DECIMAL_DIG 10
/* Number of decimal digits, q, such that any floating-point number with q
* decimal digits can be rounded into a floating-point number with p radix
* b digits and back again without change to the q decimal digits.
*/
#define FLT_DIG 6
#if CONFIG_HAVE_DOUBLE
# define DBL_DIG 15 /* 10 */
#else
# define DBL_DIG FLT_DIG
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
# define LDBL_DIG DBL_DIG /* FIX ME */
#else
# define LDBL_DIG DBL_DIG
#endif
/* Minimum negative integer such that FLT_RADIX raised to that power minus
* 1 is a normalized floating-point number, emin.
*/
#define FLT_MIN_EXP (-125)
#if CONFIG_HAVE_DOUBLE
# define DBL_MIN_EXP (-1021)
#else
# define DBL_MIN_EXP FLT_MIN_EXP
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
# define LDBL_MIN_EXP DBL_MIN_EXP /* FIX ME */
#else
# define LDBL_MIN_EXP DBL_MIN_EXP
#endif
/* inimum negative integer such that 10 raised to that power is in the range
* of normalized floating-point numbers.
*/
#define FLT_MIN_10_EXP (-37)
#if CONFIG_HAVE_DOUBLE
# define DBL_MIN_10_EXP (-307) /* -37 */
#else
# define DBL_MIN_10_EXP FLT_MIN_10_EXP
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
# define LDBL_MIN_10_EXP DBL_MIN_10_EXP /* FIX ME */
#else
# define LDBL_MIN_10_EXP DBL_MIN_10_EXP
#endif
/* Maximum integer such that FLT_RADIX raised to that power minus 1 is a
* representable finite floating-point number, emax.
*/
#define FLT_MAX_EXP 128
#if CONFIG_HAVE_DOUBLE
# define DBL_MAX_EXP 1024
#else
# define DBL_MAX_EXP FLT_MAX_EXP
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
# define LDBL_MAX_EXP DBL_MAX_EXP /* FIX ME */
#else
# define LDBL_MAX_EXP DBL_MAX_EXP
#endif
/* Maximum integer such that 10 raised to that power is in the range of
* representable finite floating-point numbers.
*/
#define FLT_MAX_10_EXP 38 /* 37 */
#if CONFIG_HAVE_DOUBLE
# define DBL_MAX_10_EXP 308 /* 37 */
#else
# define DBL_MAX_10_EXP FLT_MAX_10_EXP
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
# define LDBL_MAX_10_EXP DBL_MAX_10_EXP /* FIX ME */
#else
# define LDBL_MAX_10_EXP DBL_MAX_10_EXP
#endif
/* Maximum representable finite floating-point number. */
#define FLT_MAX 3.40282347e+38F /* 1E+37 */
#if CONFIG_HAVE_DOUBLE
# define DBL_MAX 1.7976931348623157e+308 /* 1E+37 */
#else
# define DBL_MAX FLT_MAX
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
# define LDBL_MAX DBL_MAX /* FIX ME */
#else
# define LDBL_MAX DBL_MAX
#endif
/* The difference between 1 and the least value greater than 1 that is
* representable in the given floating-point type, b1-p.
*/
#define FLT_EPSILON 1.1920929e-07F /* 1E-5 */
#if CONFIG_HAVE_DOUBLE
# define DBL_EPSILON 2.2204460492503131e-16 /* 1E-9 */
#else
# define DBL_EPSILON FLT_EPSILON
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
# define LDBL_EPSILON DBL_EPSILON /* FIX ME */
#else
# define LDBL_EPSILON DBL_EPSILON
#endif
/* Minimum normalized positive floating-point number, bemin -1. */
#define FLT_MIN 1.17549435e-38F /* 1E-37 */
#if CONFIG_HAVE_DOUBLE
#define DBL_MIN 2.2250738585072014e-308 /* 1E-37 */
#else
# define DBL_MIN FLT_MIN
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
# define LDBL_MIN DBL_MIN /* FIX ME */
#else
# define LDBL_MIN DBL_MIN
#endif
#endif /* __INCLUDE_NUTTX_FLOAT_H */

262
include/nuttx/math.h
View file

@ -50,14 +50,272 @@
#ifdef CONFIG_ARCH_MATH_H
# include <arch/math.h>
#endif
/* If CONFIG_LIB is enabled, then the math library at lib/math will be
* built. This library was taken from the math library developed for the
* Rhombus OS by Nick Johnson (https://github.com/nickbjohnson4224/rhombus).
* The port or the Rhombus math library was contributed by Darcy Gong.
*/
#else if defined CONFIG_LIBM
/****************************************************************************
* Type Definitions
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* General Constants ********************************************************/
#define INFINITY (1.0/0.0)
#define NAN (0.0/0.0)
#define HUGE_VAL INFINITY
#define isnan(x) ((x) != (x))
#define isinf(x) (((x) == INFINITY) || ((x) == -INFINITY))
/* Exponential and Logarithmic constants ************************************/
#define M_E 2.7182818284590452353602874713526625
#define M_SQRT2 1.4142135623730950488016887242096981
#define M_SQRT1_2 0.7071067811865475244008443621048490
#define M_LOG2E 1.4426950408889634073599246810018921
#define M_LOG10E 0.4342944819032518276511289189166051
#define M_LN2 0.6931471805599453094172321214581765
#define M_LN10 2.3025850929940456840179914546843642
/* Trigonometric Constants **************************************************/
#define M_PI 3.1415926535897932384626433832795029
#define M_PI_2 1.5707963267948966192313216916397514
#define M_PI_4 0.7853981633974483096156608458198757
#define M_1_PI 0.3183098861837906715377675267450287
#define M_2_PI 0.6366197723675813430755350534900574
#define M_2_SQRTPI 1.1283791670955125738961589031215452
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
#if defined(__cplusplus)
extern "C" {
#endif
/* General Functions ********************************************************/
float ceilf (float x);
#if CONFIG_HAVE_DOUBLE
double ceil (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double ceill (long double x);
#endif
float floorf(float x);
#if CONFIG_HAVE_DOUBLE
double floor (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double floorl(long double x);
#endif
float fabsf (float x);
#if CONFIG_HAVE_DOUBLE
double fabs (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double fabsl (long double x);
#endif
float modff (float x, float *iptr);
#if CONFIG_HAVE_DOUBLE
double modf (double x, double *iptr);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double modfl (long double x, long double *iptr);
#endif
float fmodf (float x, float div);
#if CONFIG_HAVE_DOUBLE
double fmod (double x, double div);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double fmodl (long double x, long double div);
#endif
/* Exponential and Logarithmic Functions ************************************/
float powf (float b, float e);
#if CONFIG_HAVE_DOUBLE
double pow (double b, double e);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double powl (long double b, long double e);
#endif
float expf (float x);
#if CONFIG_HAVE_DOUBLE
double exp (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double expl (long double x);
#endif
float logf (float x);
#if CONFIG_HAVE_DOUBLE
double log (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double logl (long double x);
#endif
float log10f(float x);
#if CONFIG_HAVE_DOUBLE
double log10 (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double log10l(long double x);
#endif
float log2f (float x);
#if CONFIG_HAVE_DOUBLE
double log2 (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double log2l (long double x);
#endif
float sqrtf (float x);
#if CONFIG_HAVE_DOUBLE
double sqrt (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double sqrtl (long double x);
#endif
float ldexpf(float x, int n);
#if CONFIG_HAVE_DOUBLE
double ldexp (double x, int n);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double ldexpl(long double x, int n);
#endif
float frexpf(float x, int *exp);
#if CONFIG_HAVE_DOUBLE
double frexp (double x, int *exp);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double frexpl(long double x, int *exp);
#endif
/* Trigonometric Functions **************************************************/
float sinf (float x);
#if CONFIG_HAVE_DOUBLE
double sin (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double sinl (long double x);
#endif
float cosf (float x);
#if CONFIG_HAVE_DOUBLE
double cos (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double cosl (long double x);
#endif
float tanf (float x);
#if CONFIG_HAVE_DOUBLE
double tan (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double tanl (long double x);
#endif
float asinf (float x);
#if CONFIG_HAVE_DOUBLE
double asin (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double asinl (long double x);
#endif
float acosf (float x);
#if CONFIG_HAVE_DOUBLE
double acos (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double acosl (long double x);
#endif
float atanf (float x);
#if CONFIG_HAVE_DOUBLE
double atan (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double atanl (long double x);
#endif
float atan2f(float y, float x);
#if CONFIG_HAVE_DOUBLE
double atan2 (double y, double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double atan2l(long double y, long double x);
#endif
float sinhf (float x);
#if CONFIG_HAVE_DOUBLE
double sinh (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double sinhl (long double x);
#endif
float coshf (float x);
#if CONFIG_HAVE_DOUBLE
double cosh (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double coshl (long double x);
#endif
float tanhf (float x);
#if CONFIG_HAVE_DOUBLE
double tanh (double x);
#endif
#ifdef CONFIG_HAVE_LONG_DOUBLE
long double tanhl (long double x);
#endif
#if defined(__cplusplus)
}
#endif
#endif /* CONFIG_LIBM */
#endif /* __INCLUDE_NUTTX_MATH_H */

22
lib/Kconfig
View file

@ -30,27 +30,7 @@ config LIB_HOMEDIR
---help---
The home directory to use with operations like such as 'cd ~'
config LIBM
bool "Math library"
default n
depends on !ARCH_MATH_H
---help---
By default, no math library will be provided by NuttX. In this this case, it
is assumed that (1) no math library is required, or (2) you will be using the
math.h header file and the libm library provided by your toolchain.
This is may be a very good choice is possible because your toolchain may have
have a highly optimized version of libm.
Another possibility is that you have a custom, architecture-specific math
libary and that the corresponding math.h file resides at arch/<architecture>/include/math.h.
The option is selected via ARCH_MATH_H. If ARCH_MATH_H is selected,then the include/nuttx/math.h
header file will be copied to include/math.h where it can be used by your applications.
If ARCH_MATH_H is not defined, then this option can be selected to build a generic,
math library built into NuttX. This math library comes from the Rhombus OS and
was written by Nick Johnson. The Rhombus OS math library port was contributed by
Darcy Gong.
source lib/math/Kconfig
config NOPRINTF_FIELDWIDTH
bool "Disable sprintf support fieldwidth"

1
lib/Makefile
View file

@ -50,6 +50,7 @@ include pthread/Make.defs
include semaphore/Make.defs
include signal/Make.defs
include mqueue/Make.defs
include math/Make.defs
include fixedmath/Make.defs
include net/Make.defs
include time/Make.defs

54
lib/lib_internal.h
View file

@ -117,56 +117,56 @@ extern bool g_dbgenable;
/* Defined in lib_streamsem.c */
#if CONFIG_NFILE_STREAMS > 0
extern void stream_semtake(FAR struct streamlist *list);
extern void stream_semgive(FAR struct streamlist *list);
void stream_semtake(FAR struct streamlist *list);
void stream_semgive(FAR struct streamlist *list);
#endif
/* Defined in lib_libnoflush.c */
#ifdef CONFIG_STDIO_LINEBUFFER
extern int lib_noflush(FAR struct lib_outstream_s *this);
int lib_noflush(FAR struct lib_outstream_s *this);
#endif
/* Defined in lib_libsprintf.c */
extern int lib_sprintf(FAR struct lib_outstream_s *obj,
int lib_sprintf(FAR struct lib_outstream_s *obj,
const char *fmt, ...);
/* Defined lib_libvsprintf.c */
extern int lib_vsprintf(FAR struct lib_outstream_s *obj,
FAR const char *src, va_list ap);
int lib_vsprintf(FAR struct lib_outstream_s *obj,
FAR const char *src, va_list ap);
/* Defined lib_rawprintf.c */
extern int lib_rawvprintf(const char *src, va_list ap);
int lib_rawvprintf(const char *src, va_list ap);
/* Defined lib_lowprintf.c */
extern int lib_lowvprintf(const char *src, va_list ap);
int lib_lowvprintf(const char *src, va_list ap);
/* Defined in lib_dtoa.c */
#ifdef CONFIG_LIBC_FLOATINGPOINT
extern char *__dtoa(double d, int mode, int ndigits,
int *decpt, int *sign, char **rve);
char *__dtoa(double d, int mode, int ndigits, int *decpt, int *sign,
char **rve);
#endif
/* Defined in lib_libwrite.c */
extern ssize_t lib_fwrite(FAR const void *ptr, size_t count, FAR FILE *stream);
ssize_t lib_fwrite(FAR const void *ptr, size_t count, FAR FILE *stream);
/* Defined in lib_libfread.c */
extern ssize_t lib_fread(FAR void *ptr, size_t count, FAR FILE *stream);
ssize_t lib_fread(FAR void *ptr, size_t count, FAR FILE *stream);
/* Defined in lib_libfflush.c */
extern ssize_t lib_fflush(FAR FILE *stream, bool bforce);
ssize_t lib_fflush(FAR FILE *stream, bool bforce);
/* Defined in lib_rdflush.c */
extern int lib_rdflush(FAR FILE *stream);
int lib_rdflush(FAR FILE *stream);
/* Defined in lib_wrflush.c */
@ -175,25 +175,37 @@ int lib_wrflush(FAR FILE *stream);
/* Defined in lib_sem.c */
#if CONFIG_STDIO_BUFFER_SIZE > 0
extern void lib_sem_initialize(FAR struct file_struct *stream);
extern void lib_take_semaphore(FAR struct file_struct *stream);
extern void lib_give_semaphore(FAR struct file_struct *stream);
void lib_sem_initialize(FAR struct file_struct *stream);
void lib_take_semaphore(FAR struct file_struct *stream);
void lib_give_semaphore(FAR struct file_struct *stream);
#endif
/* Defined in lib_libgetbase.c */
extern int lib_getbase(const char *nptr, const char **endptr);
int lib_getbase(const char *nptr, const char **endptr);
/* Defined in lib_skipspace.c */
extern void lib_skipspace(const char **pptr);
void lib_skipspace(const char **pptr);
/* Defined in lib_isbasedigit.c */
extern bool lib_isbasedigit(int ch, int base, int *value);
bool lib_isbasedigit(int ch, int base, int *value);
/* Defined in lib_checkbase.c */
extern int lib_checkbase(int base, const char **pptr);
int lib_checkbase(int base, const char **pptr);
/* Defined in lib_expi.c */
#ifdef CONFIG_LIBM
double lib_expi(size_t n);
#endif
/* Defined in lib_libsqrtapprox.c */
#ifdef CONFIG_LIBM
float lib_sqrtapprox(float x);
#endif
#endif /* __LIB_LIB_INTERNAL_H */

22
lib/math/Kconfig
View file

@ -2,3 +2,25 @@
# For a description of the syntax of this configuration file,
# see misc/tools/kconfig-language.txt.
#
config LIBM
bool "Math library"
default n
depends on !ARCH_MATH_H
---help---
By default, no math library will be provided by NuttX. In this this case, it
is assumed that (1) no math library is required, or (2) you will be using the
math.h header file and the libm library provided by your toolchain.
This is may be a very good choice is possible because your toolchain may have
have a highly optimized version of libm.
Another possibility is that you have a custom, architecture-specific math
libary and that the corresponding math.h file resides at arch/<architecture>/include/math.h.
The option is selected via ARCH_MATH_H. If ARCH_MATH_H is selected,then the include/nuttx/math.h
header file will be copied to include/math.h where it can be used by your applications.
If ARCH_MATH_H is not defined, then this option can be selected to build a generic,
math library built into NuttX. This math library comes from the Rhombus OS and
was written by Nick Johnson. The Rhombus OS math library port was contributed by
Darcy Gong.

15
lib/math/Make.defs
View file

@ -33,17 +33,30 @@
#
############################################################################
if ($(CONFIG_LIBM),y)
ifeq ($(CONFIG_LIBM),y)
# Add the floating point math C files to the build
CSRCS += lib_acosf.c lib_asinf.c lib_atan2f.c lib_atanf.c lib_ceilf.c lib_cosf.c
CSRCS += lib_coshf.c lib_expf.c lib_fabsf.c lib_floorf.c lib_fmodf.c lib_frexpf.c
CSRCS += lib_ldexpf.c lib_logf.c lib_log10f.c lib_log2f.c lib_modff.c lib_powf.c
CSRCS += lib_sinf.c lib_sinhf.c lib_sqrtf.c lib_tanf.c lib_tanhf.c
CSRCS += lib_acos.c lib_asin.c lib_atan.c lib_atan2.c lib_ceil.c lib_cos.c
CSRCS += lib_cosh.c lib_exp.c lib_fabs.c lib_floor.c lib_fmod.c lib_frexp.c
CRRCS += lib_ldexp.c lib_log.c lib_log10.c lib_log2.c lib_modf.c lib_pow.c
CSRCS += lib_sin.c lib_sinh.c lib_sqrt.c lib_tan.c lib_tanh.c
CSRCS += lib_acosl.c lib_asinl.c lib_atan2l.c lib_atanl.c lib_ceill.c lib_cosl.c
CSRCS += lib_coshl.c lib_expl.c lib_fabsl.c lib_floorl.c lib_fmodl.c lib_frexpl.c
CSRCS += lib_ldexpl.c lib_logl.c lib_log10l.c lib_log2l.c lib_modfl.c lib_powl.c
CSRCS += lib_sinl.c lib_sinhl.c lib_sqrtl.c lib_tanl.c lib_tanhl.c
CSRCS += lib_libexpi.c lib_libsqrtapprox.c
# Add the floating point math directory to the build
DEPPATH += --dep-path math
VPATH += :math
endif

100
lib/math/Makefile
View file

@ -1,100 +0,0 @@
############################################################################
# nuttx/lib/math/Makefile
#
# Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
# Author: Gregory Nutt <gnutt@nuttx.org>
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# 3. Neither the name NuttX nor the names of its contributors may be
# used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
############################################################################
-include $(TOPDIR)/.config
-include $(TOPDIR)/Make.defs
include $(APPDIR)/Make.defs
# NSH Library
ASRCS =
CSRCS =
ifeq ($(CONFIG_MATHEXT_LIBRARY),y)
CSRCS += m_cos.c m_log2.c m_fmod.c m_sin.c m_fabs.c m_exp.c m_asin.c m_tan.c \
m_modf.c m_ldexp.c m_acos.c m_frexp.c m_atan.c m_log.c m_tanh.c m_ceil.c \
m_sinh.c m_sqrt.c m_pow.c m_cosh.c m_floor.c m_atan2.c m_log10.c
endif
AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT))
SRCS = $(ASRCS) $(CSRCS)
OBJS = $(AOBJS) $(COBJS)
ifeq ($(WINTOOL),y)
BIN = "${shell cygpath -w $(APPDIR)/libapps$(LIBEXT)}"
else
BIN = "$(APPDIR)/libapps$(LIBEXT)"
endif
ROOTDEPPATH = --dep-path .
VPATH =
# Build targets
all: .built
.PHONY: context .depend depend clean distclean
$(AOBJS): %$(OBJEXT): %.S
$(call ASSEMBLE, $<, $@)
$(COBJS): %$(OBJEXT): %.c
$(call COMPILE, $<, $@)
.built: $(OBJS)
@( for obj in $(OBJS) ; do \
$(call ARCHIVE, $(BIN), $${obj}); \
done ; )
@touch .built
context:
.depend: Makefile $(SRCS)
@$(MKDEP) $(ROOTDEPPATH) \
$(CC) -- $(CFLAGS) -- $(SRCS) >Make.dep
@touch $@
depend: .depend
clean:
@rm -f *.o *~ .*.swp .built
$(call CLEAN)
distclean: clean
@rm -f Make.dep .depend
-include Make.dep

44
lib/math/lib_acos.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_acos.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,19 +22,25 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
float acosf(float x) {
return (M_PI_2 - asinf(x));
}
double acos(double x) {
return (M_PI_2 - asin(x));
}
long double acosl(long double x) {
return (M_PI_2 - asinl(x));
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double acos(double x)
{
return (M_PI_2 - asin(x));
}
#endif

41
lib/math/lib_acosf.c Normal file
View file

@ -0,0 +1,41 @@
/************************************************************************
* lib/math/lib_acosf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float acosf(float x)
{
return (M_PI_2 - asinf(x));
}

46
lib/math/lib_acosl.c Normal file
View file

@ -0,0 +1,46 @@
/************************************************************************
* lib/math/lib_acos.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double acosl(long double x)
{
return (M_PI_2 - asinl(x));
}
#endif

111
lib/math/lib_asin.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_sin.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,77 +22,48 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
#include <float.h>
float asinf(float x) {
long double y, y_sin, y_cos;
/************************************************************************
* Public Functions
************************************************************************/
y = 0;
#if CONFIG_HAVE_DOUBLE
double asin(double x)
{
long double y, y_sin, y_cos;
while (1) {
y_sin = sinf(y);
y_cos = cosf(y);
y = 0;
if (y > M_PI_2 || y < -M_PI_2) {
y = fmodf(y, M_PI);
}
while (1)
{
y_sin = sin(y);
y_cos = cos(y);
if (y_sin + DBL_EPSILON >= x && y_sin - DBL_EPSILON <= x) {
break;
}
if (y > M_PI_2 || y < -M_PI_2)
{
y = fmod(y, M_PI);
}
y = y - (y_sin - x) / y_cos;
}
if (y_sin + DBL_EPSILON >= x && y_sin - DBL_EPSILON <= x)
{
break;
}
return y;
y = y - (y_sin - x) / y_cos;
}
return y;
}
double asin(double x) {
long double y, y_sin, y_cos;
y = 0;
while (1) {
y_sin = sin(y);
y_cos = cos(y);
if (y > M_PI_2 || y < -M_PI_2) {
y = fmod(y, M_PI);
}
if (y_sin + DBL_EPSILON >= x && y_sin - DBL_EPSILON <= x) {
break;
}
y = y - (y_sin - x) / y_cos;
}
return y;
}
long double asinl(long double x) {
long double y, y_sin, y_cos;
y = 0;
while (1) {
y_sin = sinl(y);
y_cos = cosl(y);
if (y > M_PI_2 || y < -M_PI_2) {
y = fmodl(y, M_PI);
}
if (y_sin + LDBL_EPSILON >= x && y_sin - LDBL_EPSILON <= x) {
break;
}
y = y - (y_sin - x) / y_cos;
}
return y;
}
#endif

65
lib/math/lib_asinf.c Normal file
View file

@ -0,0 +1,65 @@
/************************************************************************
* lib/math/lib_sinf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
#include <float.h>
/************************************************************************
* Public Functions
************************************************************************/
float asinf(float x)
{
long double y, y_sin, y_cos;
y = 0;
while (1)
{
y_sin = sinf(y);
y_cos = cosf(y);
if (y > M_PI_2 || y < -M_PI_2)
{
y = fmodf(y, M_PI);
}
if (y_sin + FLT_EPSILON >= x && y_sin - FLT_EPSILON <= x)
{
break;
}
y = y - (y_sin - x) / y_cos;
}
return y;
}

69
lib/math/lib_asinl.c Normal file
View file

@ -0,0 +1,69 @@
/************************************************************************
* lib/math/lib_sinl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
#include <float.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double asinl(long double x)
{
long double y, y_sin, y_cos;
y = 0;
while (1)
{
y_sin = sinl(y);
y_cos = cosl(y);
if (y > M_PI_2 || y < -M_PI_2)
{
y = fmodl(y, M_PI);
}
if (y_sin + LDBL_EPSILON >= x && y_sin - LDBL_EPSILON <= x)
{
break;
}
y = y - (y_sin - x) / y_cos;
}
return y;
}
#endif

44
lib/math/lib_atan.c
View file

@ -1,5 +1,15 @@
/*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
/************************************************************************
* lib/math/lib_atan.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@ -12,21 +22,27 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
#include <stddef.h>
#include <stdint.h>
float atanf(float x) {
return asinf(x / sqrtf(x * x + 1));
}
/************************************************************************
* Public Functions
************************************************************************/
double atan(double x) {
return asin(x / sqrt(x * x + 1));
}
long double atanl(long double x) {
return asinl(x / sqrtl(x * x + 1));
#if CONFIG_HAVE_DOUBLE
double atan(double x)
{
return asin(x / sqrt(x * x + 1));
}
#endif

176
lib/math/lib_atan2.c
View file

@ -1,5 +1,15 @@
/*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
/************************************************************************
* lib/math/lib_atan2.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@ -12,109 +22,65 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
float atan2f(float y, float x) {
if (y == 0.0) {
if (x >= 0.0) {
return 0.0;
}
else {
return M_PI;
}
}
else if (y > 0.0) {
if (x == 0.0) {
return M_PI_2;
}
else if (x > 0.0) {
return atanf(y / x);
}
else {
return M_PI - atanf(y / x);
}
}
else {
if (x == 0.0) {
return M_PI + M_PI_2;
}
else if (x > 0.0) {
return 2 * M_PI - atanf(y / x);
}
else {
return M_PI + atanf(y / x);
}
}
}
double atan2(double y, double x) {
if (y == 0.0) {
if (x >= 0.0) {
return 0.0;
}
else {
return M_PI;
}
}
else if (y > 0.0) {
if (x == 0.0) {
return M_PI_2;
}
else if (x > 0.0) {
return atan(y / x);
}
else {
return M_PI - atan(y / x);
}
}
else {
if (x == 0.0) {
return M_PI + M_PI_2;
}
else if (x > 0.0) {
return 2 * M_PI - atan(y / x);
}
else {
return M_PI + atan(y / x);
}
}
}
long double atan2l(long double y, long double x) {
if (y == 0.0) {
if (x >= 0.0) {
return 0.0;
}
else {
return M_PI;
}
}
else if (y > 0.0) {
if (x == 0.0) {
return M_PI_2;
}
else if (x > 0.0) {
return atanl(y / x);
}
else {
return M_PI - atanl(y / x);
}
}
else {
if (x == 0.0) {
return M_PI + M_PI_2;
}
else if (x > 0.0) {
return 2 * M_PI - atanl(y / x);
}
else {
return M_PI + atanl(y / x);
}
}
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double atan2(double y, double x)
{
if (y == 0.0)
{
if (x >= 0.0)
{
return 0.0;
}
else
{
return M_PI;
}
}
else if (y > 0.0)
{
if (x == 0.0)
{
return M_PI_2;
}
else if (x > 0.0)
{
return atan(y / x);
}
else
{
return M_PI - atan(y / x);
}
}
else
{
if (x == 0.0)
{
return M_PI + M_PI_2;
}
else if (x > 0.0)
{
return 2 * M_PI - atan(y / x);
}
else
{
return M_PI + atan(y / x);
}
}
}
#endif

81
lib/math/lib_atan2f.c Normal file
View file

@ -0,0 +1,81 @@
/************************************************************************
* lib/math/lib_atan2f.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float atan2f(float y, float x)
{
if (y == 0.0)
{
if (x >= 0.0)
{
return 0.0;
}
else
{
return M_PI;
}
}
else if (y > 0.0)
{
if (x == 0.0)
{
return M_PI_2;
}
else if (x > 0.0)
{
return atanf(y / x);
}
else
{
return M_PI - atanf(y / x);
}
}
else
{
if (x == 0.0)
{
return M_PI + M_PI_2;
}
else if (x > 0.0)
{
return 2 * M_PI - atanf(y / x);
}
else
{
return M_PI + atanf(y / x);
}
}
}

87
lib/math/lib_atan2l.c Normal file
View file

@ -0,0 +1,87 @@
/************************************************************************
* lib/math/lib_atan2l.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double atan2l(long double y, long double x)
{
if (y == 0.0)
{
if (x >= 0.0)
{
return 0.0;
}
else
{
return M_PI;
}
}
else if (y > 0.0)
{
if (x == 0.0)
{
return M_PI_2;
}
else if (x > 0.0)
{
return atanl(y / x);
}
else
{
return M_PI - atanl(y / x);
}
}
else
{
if (x == 0.0)
{
return M_PI + M_PI_2;
}
else if (x > 0.0)
{
return 2 * M_PI - atanl(y / x);
}
else
{
return M_PI + atanl(y / x);
}
}
}
#endif

43
lib/math/lib_atanf.c Normal file
View file

@ -0,0 +1,43 @@
/************************************************************************
* lib/math/lib_atanf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
#include <stddef.h>
#include <stdint.h>
/************************************************************************
* Public Functions
************************************************************************/
float atanf(float x)
{
return asinf(x / sqrtf(x * x + 1));
}

48
lib/math/lib_atanl.c Normal file
View file

@ -0,0 +1,48 @@
/************************************************************************
* lib/math/lib_atanl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
#include <stddef.h>
#include <stdint.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double atanl(long double x)
{
return asinl(x / sqrtl(x * x + 1));
}
#endif

57
lib/math/lib_ceil.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_ceil.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,26 +22,31 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
float ceilf(float x) {
modff(x, &x);
if (x > 0.0) x += 1.0;
return x;
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double ceil(double x)
{
modf(x, &x);
if (x > 0.0)
{
x += 1.0;
}
return x;
}
double ceil(double x) {
modf(x, &x);
if (x > 0.0) x += 1.0;
return x;
}
long double ceill(long double x) {
modfl(x, &x);
if (x > 0.0) x += 1.0;
return x;
}
#endif

47
lib/math/lib_ceilf.c Normal file
View file

@ -0,0 +1,47 @@
/************************************************************************
* lib/math/lib_ceilf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float ceilf(float x)
{
modff(x, &x);
if (x > 0.0)
{
x += 1.0;
}
return x;
}

52
lib/math/lib_ceill.c Normal file
View file

@ -0,0 +1,52 @@
/************************************************************************
* lib/math/lib_ceil;.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double ceill(long double x)
{
modfl(x, &x);
if (x > 0.0)
{
x += 1.0;
}
return x;
}
#endif

47
lib/math/lib_cos.c
View file

@ -1,5 +1,15 @@
/*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
/************************************************************************
* lib/math/lib_cos.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@ -12,20 +22,25 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <stdint.h>
#include <float.h>
#include <apps/math.h>
/************************************************************************
* Included Files
************************************************************************/
float cosf(float x) {
return sinf(x + M_PI_2);
}
double cos(double x) {
return sin(x + M_PI_2);
}
long double cosl(long double x) {
return sinl(x + M_PI_2);
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double cos(double x)
{
return sin(x + M_PI_2);
}
#endif

41
lib/math/lib_cosf.c Normal file
View file

@ -0,0 +1,41 @@
/************************************************************************
* lib/math/lib_cosf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float cosf(float x)
{
return sinf(x + M_PI_2);
}

50
lib/math/lib_cosh.c
View file

@ -1,5 +1,15 @@
/*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
/************************************************************************
* lib/math/lib_cosh.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@ -12,22 +22,26 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
float coshf(float x) {
x = expf(x);
return ((x + (1.0 / x)) / 2.0);
}
double cosh(double x) {
x = exp(x);
return ((x + (1.0 / x)) / 2.0);
}
long double coshl(long double x) {
x = expl(x);
return ((x + (1.0 / x)) / 2.0);
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double cosh(double x)
{
x = exp(x);
return ((x + (1.0 / x)) / 2.0);
}
#endif

42
lib/math/lib_coshf.c Normal file
View file

@ -0,0 +1,42 @@
/************************************************************************
* lib/math/lib_coshf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float coshf(float x)
{
x = expf(x);
return ((x + (1.0 / x)) / 2.0);
}

47
lib/math/lib_coshl.c Normal file
View file

@ -0,0 +1,47 @@
/************************************************************************
* lib/math/lib_coshl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double coshl(long double x)
{
x = expl(x);
return ((x + (1.0 / x)) / 2.0);
}
#endif

46
lib/math/lib_cosl.c Normal file
View file

@ -0,0 +1,46 @@
/************************************************************************
* lib/math/lib_cosl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double cosl(long double x)
{
return sinl(x + M_PI_2);
}
#endif

332
lib/math/lib_exp.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_exp.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,242 +22,104 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
#include <stdint.h>
#include <stdbool.h>
#include <unistd.h>
/************************************************************************
* Included Files
************************************************************************/
#define M_E2 (M_E * M_E)
#define M_E4 (M_E2 * M_E2)
#define M_E8 (M_E4 * M_E4)
#define M_E16 (M_E8 * M_E8)
#define M_E32 (M_E16 * M_E16)
#define M_E64 (M_E32 * M_E32)
#define M_E128 (M_E64 * M_E64)
#define M_E256 (M_E128 * M_E128)
#define M_E512 (M_E256 * M_E256)
#define M_E1024 (M_E512 * M_E512)
#include <nuttx/config.h>
#include <nuttx/compiler.h>
static double _expi_square_tbl[11] = {
M_E, // e^1
M_E2, // e^2
M_E4, // e^4
M_E8, // e^8
M_E16, // e^16
M_E32, // e^32
M_E64, // e^64
M_E128, // e^128
M_E256, // e^256
M_E512, // e^512
M_E1024, // e^1024
#include <math.h>
#include "lib_internal.h"
#if CONFIG_HAVE_DOUBLE
/************************************************************************
* Private Data
************************************************************************/
static double _dbl_inv_fact[] =
{
1.0 / 1.0, // 1 / 0!
1.0 / 1.0, // 1 / 1!
1.0 / 2.0, // 1 / 2!
1.0 / 6.0, // 1 / 3!
1.0 / 24.0, // 1 / 4!
1.0 / 120.0, // 1 / 5!
1.0 / 720.0, // 1 / 6!
1.0 / 5040.0, // 1 / 7!
1.0 / 40320.0, // 1 / 8!
1.0 / 362880.0, // 1 / 9!
1.0 / 3628800.0, // 1 / 10!
1.0 / 39916800.0, // 1 / 11!
1.0 / 479001600.0, // 1 / 12!
1.0 / 6227020800.0, // 1 / 13!
1.0 / 87178291200.0, // 1 / 14!
1.0 / 1307674368000.0, // 1 / 15!
1.0 / 20922789888000.0, // 1 / 16!
1.0 / 355687428096000.0, // 1 / 17!
1.0 / 6402373705728000.0, // 1 / 18!
};
static double _expi(size_t n) {
size_t i;
double val;
/************************************************************************
* Public Functions
************************************************************************/
if (n > 1024) {
return INFINITY;
}
double exp(double x)
{
size_t int_part;
bool invert;
double value;
double x0;
size_t i;
val = 1.0;
if (x == 0)
{
return 1;
}
else if (x < 0)
{
invert = true;
x = -x;
}
else
{
invert = false;
}
for (i = 0; n; i++) {
if (n & (1 << i)) {
n &= ~(1 << i);
val *= _expi_square_tbl[i];
}
}
/* Extract integer component */
return val;
}
static float _flt_inv_fact[] = {
1.0 / 1.0, // 1/0!
1.0 / 1.0, // 1/1!
1.0 / 2.0, // 1/2!
1.0 / 6.0, // 1/3!
1.0 / 24.0, // 1/4!
1.0 / 120.0, // 1/5!
1.0 / 720.0, // 1/6!
1.0 / 5040.0, // 1/7!
1.0 / 40320.0, // 1/8!
1.0 / 362880.0, // 1/9!
1.0 / 3628800.0, // 1/10!
};
float expf(float x) {
size_t int_part;
bool invert;
float value;
float x0;
size_t i;
if (x == 0) {
return 1;
}
else if (x < 0) {
invert = true;
x = -x;
}
else {
invert = false;
}
/* extract integer component */
int_part = (size_t) x;
/* set x to fractional component */
x -= (float) int_part;
/* perform Taylor series approximation with eleven terms */
value = 0.0;
x0 = 1.0;
for (i = 0; i < 10; i++) {
value += x0 * _flt_inv_fact[i];
x0 *= x;
}
/* multiply by exp of the integer component */
value *= _expi(int_part);
if (invert) {
return (1.0 / value);
}
else {
return value;
}
}
static double _dbl_inv_fact[] = {
1.0 / 1.0, // 1 / 0!
1.0 / 1.0, // 1 / 1!
1.0 / 2.0, // 1 / 2!
1.0 / 6.0, // 1 / 3!
1.0 / 24.0, // 1 / 4!
1.0 / 120.0, // 1 / 5!
1.0 / 720.0, // 1 / 6!
1.0 / 5040.0, // 1 / 7!
1.0 / 40320.0, // 1 / 8!
1.0 / 362880.0, // 1 / 9!
1.0 / 3628800.0, // 1 / 10!
1.0 / 39916800.0, // 1 / 11!
1.0 / 479001600.0, // 1 / 12!
1.0 / 6227020800.0, // 1 / 13!
1.0 / 87178291200.0, // 1 / 14!
1.0 / 1307674368000.0, // 1 / 15!
1.0 / 20922789888000.0, // 1 / 16!
1.0 / 355687428096000.0, // 1 / 17!
1.0 / 6402373705728000.0, // 1 / 18!
};
double exp(double x) {
size_t int_part;
bool invert;
double value;
double x0;
size_t i;
if (x == 0) {
return 1;
}
else if (x < 0) {
invert = true;
x = -x;
}
else {
invert = false;
}
/* extract integer component */
int_part = (size_t) x;
/* set x to fractional component */
x -= (double) int_part;
/* perform Taylor series approximation with nineteen terms */
value = 0.0;
x0 = 1.0;
for (i = 0; i < 19; i++) {
value += x0 * _dbl_inv_fact[i];
x0 *= x;
}
/* multiply by exp of the integer component */
value *= _expi(int_part);
if (invert) {
return (1.0 / value);
}
else {
return value;
}
}
static long double _ldbl_inv_fact[] = {
1.0 / 1.0, // 1 / 0!
1.0 / 1.0, // 1 / 1!
1.0 / 2.0, // 1 / 2!
1.0 / 6.0, // 1 / 3!
1.0 / 24.0, // 1 / 4!
1.0 / 120.0, // 1 / 5!
1.0 / 720.0, // 1 / 6!
1.0 / 5040.0, // 1 / 7!
1.0 / 40320.0, // 1 / 8!
1.0 / 362880.0, // 1 / 9!
1.0 / 3628800.0, // 1 / 10!
1.0 / 39916800.0, // 1 / 11!
1.0 / 479001600.0, // 1 / 12!
1.0 / 6227020800.0, // 1 / 13!
1.0 / 87178291200.0, // 1 / 14!
1.0 / 1307674368000.0, // 1 / 15!
1.0 / 20922789888000.0, // 1 / 16!
1.0 / 355687428096000.0, // 1 / 17!
1.0 / 6402373705728000.0, // 1 / 18!
};
long double expl(long double x) {
size_t int_part;
bool invert;
long double value;
long double x0;
size_t i;
if (x == 0) {
return 1;
}
else if (x < 0) {
invert = true;
x = -x;
}
else {
invert = false;
}
/* extract integer component */
int_part = (size_t) x;
/* set x to fractional component */
x -= (long double) int_part;
/* perform Taylor series approximation with nineteen terms */
value = 0.0;
x0 = 1.0;
for (i = 0; i < 19; i++) {
value += x0 * _ldbl_inv_fact[i];
x0 *= x;
}
/* multiply by exp of the integer component */
value *= _expi(int_part);
if (invert) {
return (1.0 / value);
}
else {
return value;
}
int_part = (size_t) x;
/* Set x to fractional component */
x -= (double)int_part;
/* Perform Taylor series approximation with nineteen terms */
value = 0.0;
x0 = 1.0;
for (i = 0; i < 19; i++)
{
value += x0 * _dbl_inv_fact[i];
x0 *= x;
}
/* Multiply by exp of the integer component */
value *= lib_expi(int_part);
if (invert)
{
return (1.0 / value);
}
else
{
return value;
}
}
#endif

112
lib/math/lib_expf.c Normal file
View file

@ -0,0 +1,112 @@
/************************************************************************
* lib/math/lib_expf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <sys/types.h>
#include <math.h>
#include "lib_internal.h"
/************************************************************************
* Private Data
************************************************************************/
static float _flt_inv_fact[] =
{
1.0 / 1.0, // 1/0!
1.0 / 1.0, // 1/1!
1.0 / 2.0, // 1/2!
1.0 / 6.0, // 1/3!
1.0 / 24.0, // 1/4!
1.0 / 120.0, // 1/5!
1.0 / 720.0, // 1/6!
1.0 / 5040.0, // 1/7!
1.0 / 40320.0, // 1/8!
1.0 / 362880.0, // 1/9!
1.0 / 3628800.0, // 1/10!
};
/************************************************************************
* Public Functions
************************************************************************/
float expf(float x)
{
size_t int_part;
bool invert;
float value;
float x0;
size_t i;
if (x == 0)
{
return 1;
}
else if (x < 0)
{
invert = true;
x = -x;
}
else
{
invert = false;
}
/* Extract integer component */
int_part = (size_t) x;
/* set x to fractional component */
x -= (float)int_part;
/* Perform Taylor series approximation with eleven terms */
value = 0.0;
x0 = 1.0;
for (i = 0; i < 10; i++)
{
value += x0 * _flt_inv_fact[i];
x0 *= x;
}
/* Multiply by exp of the integer component */
value *= lib_expi(int_part);
if (invert)
{
return (1.0 / value);
}
else
{
return value;
}
}

126
lib/math/lib_expl.c Normal file
View file

@ -0,0 +1,126 @@
/************************************************************************
* lib/math/lib_expl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <sys/types.h>
#include <math.h>
#include "lib_internal.h"
#if CONFIG_HAVE_LONG_DOUBLE
/************************************************************************
* Private Data
************************************************************************/
static long double _ldbl_inv_fact[] =
{
1.0 / 1.0, // 1 / 0!
1.0 / 1.0, // 1 / 1!
1.0 / 2.0, // 1 / 2!
1.0 / 6.0, // 1 / 3!
1.0 / 24.0, // 1 / 4!
1.0 / 120.0, // 1 / 5!
1.0 / 720.0, // 1 / 6!
1.0 / 5040.0, // 1 / 7!
1.0 / 40320.0, // 1 / 8!
1.0 / 362880.0, // 1 / 9!
1.0 / 3628800.0, // 1 / 10!
1.0 / 39916800.0, // 1 / 11!
1.0 / 479001600.0, // 1 / 12!
1.0 / 6227020800.0, // 1 / 13!
1.0 / 87178291200.0, // 1 / 14!
1.0 / 1307674368000.0, // 1 / 15!
1.0 / 20922789888000.0, // 1 / 16!
1.0 / 355687428096000.0, // 1 / 17!
1.0 / 6402373705728000.0, // 1 / 18!
};
/************************************************************************
* Public Functions
************************************************************************/
long double expl(long double x)
{
size_t int_part;
bool invert;
long double value;
long double x0;
size_t i;
if (x == 0)
{
return 1;
}
else if (x < 0)
{
invert = true;
x = -x;
}
else
{
invert = false;
}
/* Extract integer component */
int_part = (size_t) x;
/* Set x to fractional component */
x -= (long double)int_part;
/* Perform Taylor series approximation with nineteen terms */
value = 0.0;
x0 = 1.0;
for (i = 0; i < 19; i++)
{
value += x0 * _ldbl_inv_fact[i];
x0 *= x;
}
/* Multiply by exp of the integer component */
value *= lib_expi(int_part);
if (invert)
{
return (1.0 / value);
}
else
{
return value;
}
}
#endif

44
lib/math/lib_fabs.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_fabs.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,19 +22,25 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
float fabsf(float x) {
return ((x < 0) ? -x : x);
}
double fabs(double x) {
return ((x < 0) ? -x : x);
}
long double fabsl(long double x) {
return ((x < 0) ? -x : x);
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double fabs(double x)
{
return ((x < 0) ? -x : x);
}
#endif

41
lib/math/lib_fabsf.c Normal file
View file

@ -0,0 +1,41 @@
/************************************************************************
* lib/math/lib_fabsf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float fabsf(float x)
{
return ((x < 0) ? -x : x);
}

46
lib/math/lib_fabsl.c Normal file
View file

@ -0,0 +1,46 @@
/************************************************************************
* lib/math/lib_fabsl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double fabsl(long double x)
{
return ((x < 0) ? -x : x);
}
#endif

57
lib/math/lib_floor.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_floor.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,26 +22,31 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
float floorf(float x) {
modff(x, &x);
if (x < 0.0) x -= 1.0;
return x;
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double floor(double x)
{
modf(x, &x);
if (x < 0.0)
{
x -= 1.0;
}
return x;
}
double floor(double x) {
modf(x, &x);
if (x < 0.0) x -= 1.0;
return x;
}
long double floorl(long double x) {
modfl(x, &x);
if (x < 0.0) x -= 1.0;
return x;
}
#endif

47
lib/math/lib_floorf.c Normal file
View file

@ -0,0 +1,47 @@
/************************************************************************
* lib/math/lib_floorf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float floorf(float x)
{
modff(x, &x);
if (x < 0.0)
{
x -= 1.0;
}
return x;
}

52
lib/math/lib_floorl.c Normal file
View file

@ -0,0 +1,52 @@
/************************************************************************
* lib/math/lib_floorl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double floorl(long double x)
{
modfl(x, &x);
if (x < 0.0)
{
x -= 1.0;
}
return x;
}
#endif

83
lib/math/lib_fmod.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_fmod.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,56 +22,31 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
/* If GCC/CLang builtins are available, use them */
#ifdef __GNUC__
#include <nuttx/config.h>
#include <nuttx/compiler.h>
float fmodf(float x, float div) {
return __builtin_fmodf(x, div);
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double fmod(double x, double div)
{
double n0;
x /= div;
x = modf(x, &n0);
x *= div;
return x;
}
double fmod(double x, double div) {
return __builtin_fmod(x, div);
}
long double fmodl(long double x, long double div) {
return __builtin_fmodl(x, div);
}
#else
float fmodf(float x, float div) {
float n0;
x /= div;
x = modff(x, &n0);
x *= div;
return x;
}
double fmod(double x, double div) {
double n0;
x /= div;
x = modf(x, &n0);
x *= div;
return x;
}
long double fmodl(long double x, long double div) {
long double n0;
x /= div;
x = modfl(x, &n0);
x *= div;
return x;
}
#endif

47
lib/math/lib_fmodf.c Normal file
View file

@ -0,0 +1,47 @@
/************************************************************************
* lib/math/lib_fmodf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float fmodf(float x, float div)
{
float n0;
x /= div;
x = modff(x, &n0);
x *= div;
return x;
}

52
lib/math/lib_fmodl.c Normal file
View file

@ -0,0 +1,52 @@
/************************************************************************
* lib/math/lib_fmodl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double fmodl(long double x, long double div)
{
long double n0;
x /= div;
x = modfl(x, &n0);
x *= div;
return x;
}
#endif

49
lib/math/lib_frexp.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_frexp.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,23 +22,26 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
float frexpf(float x, int *exp) {
*exp = (int) ceilf(log2f(x));
return x / ldexpf(1.0, *exp);
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double frexp(double x, int *exponent)
{
*exponent = (int)ceil(log2(x));
return x / ldexp(1.0, *exponent);
}
double frexp(double x, int *exp) {
*exp = (int) ceil(log2(x));
return x / ldexp(1.0, *exp);
}
long double frexpl(long double x, int *exp) {
*exp = (int) ceill(log2(x));
return x / ldexpl(1.0, *exp);
}
#endif

42
lib/math/lib_frexpf.c Normal file
View file

@ -0,0 +1,42 @@
/************************************************************************
* lib/math/lib_frexpf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float frexpf(float x, int *exponent)
{
*exponent = (int)ceilf(log2f(x));
return x / ldexpf(1.0, *exponent);
}

47
lib/math/lib_frexpl.c Normal file
View file

@ -0,0 +1,47 @@
/************************************************************************
* lib/math/lib_frexpl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double frexpl(long double x, int *exponent)
{
*exponent = (int)ceill(log2(x));
return x / ldexpl(1.0, *exponent);
}
#endif

45
lib/math/lib_ldexp.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_ldexp.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,20 +22,25 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
float ldexpf(float x, int n) {
return (x * powf(2.0, (float) n));
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double ldexp(double x, int n)
{
return (x * pow(2.0, (double)n));
}
double ldexp(double x, int n) {
return (x * pow(2.0, (double) n));
}
long double ldexpl(long double x, int n) {
return (x * powl(2.0, (long double) n));
}
#endif

41
lib/math/lib_ldexpf.c Normal file
View file

@ -0,0 +1,41 @@
/************************************************************************
* lib/math/lib_ldexpf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float ldexpf(float x, int n)
{
return (x * powf(2.0, (float)n));
}

46
lib/math/lib_ldexpl.c Normal file
View file

@ -0,0 +1,46 @@
/************************************************************************
* lib/math/lib_ldexpl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double ldexpl(long double x, int n)
{
return (x * powl(2.0, (long double)n));
}
#endif

103
lib/math/lib_libexpi.c Normal file
View file

@ -0,0 +1,103 @@
/************************************************************************
* lib/math/lib_libexpi.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <sys/types.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
/************************************************************************
* Pre-processor Definitions
************************************************************************/
#define M_E2 (M_E * M_E)
#define M_E4 (M_E2 * M_E2)
#define M_E8 (M_E4 * M_E4)
#define M_E16 (M_E8 * M_E8)
#define M_E32 (M_E16 * M_E16)
#define M_E64 (M_E32 * M_E32)
#define M_E128 (M_E64 * M_E64)
#define M_E256 (M_E128 * M_E128)
#define M_E512 (M_E256 * M_E256)
#define M_E1024 (M_E512 * M_E512)
/************************************************************************
* Private Data
************************************************************************/
static double _expi_square_tbl[11] =
{
M_E, // e^1
M_E2, // e^2
M_E4, // e^4
M_E8, // e^8
M_E16, // e^16
M_E32, // e^32
M_E64, // e^64
M_E128, // e^128
M_E256, // e^256
M_E512, // e^512
M_E1024, // e^1024
};
/************************************************************************
* Public Functions
************************************************************************/
static double lib_expi(size_t n)
{
size_t i;
double val;
if (n > 1024)
{
return INFINITY;
}
val = 1.0;
for (i = 0; n; i++)
{
if (n & (1 << i))
{
n &= ~(1 << i);
val *= _expi_square_tbl[i];
}
}
return val;
}

50
lib/math/lib_libsqrtapprox.c Normal file
View file

@ -0,0 +1,50 @@
/************************************************************************
* lib/math/lib_libsqrtapprox.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <stdint.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float lib_sqrtapprox(float x)
{
int32_t i;
/* Floats + bit manipulation = +inf fun! */
i = *((int32_t *) & x);
i = 0x1fc00000 + (i >> 1);
x = *((float *)&i);
return x;
}

149
lib/math/lib_log.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_log.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,102 +22,61 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
#include <float.h>
float logf(float x) {
float y, y_old, ey, epsilon;
/************************************************************************
* Public Functions
************************************************************************/
y = 0.0;
y_old = 1.0;
epsilon = FLT_EPSILON;
#if CONFIG_HAVE_DOUBLE
double log(double x)
{
double y, y_old, ey, epsilon;
while (y > y_old + epsilon || y < y_old - epsilon) {
y_old = y;
ey = exp(y);
y -= (ey - x) / ey;
y = 0.0;
y_old = 1.0;
epsilon = DBL_EPSILON;
if (y > 700.0) {
y = 700.0;
}
if (y < -700.0) {
y = -700.0;
}
while (y > y_old + epsilon || y < y_old - epsilon)
{
y_old = y;
ey = exp(y);
y -= (ey - x) / ey;
epsilon = (fabs(y) > 1.0) ? fabs(y) * FLT_EPSILON : FLT_EPSILON;
}
if (y > 700.0)
{
y = 700.0;
}
if (y == 700.0) {
return INFINITY;
}
if (y == -700.0) {
return INFINITY;
}
if (y < -700.0)
{
y = -700.0;
}
return y;
epsilon = (fabs(y) > 1.0) ? fabs(y) * DBL_EPSILON : DBL_EPSILON;
}
if (y == 700.0)
{
return INFINITY;
}
if (y == -700.0)
{
return INFINITY;
}
return y;
}
double log(double x) {
double y, y_old, ey, epsilon;
y = 0.0;
y_old = 1.0;
epsilon = DBL_EPSILON;
while (y > y_old + epsilon || y < y_old - epsilon) {
y_old = y;
ey = exp(y);
y -= (ey - x) / ey;
if (y > 700.0) {
y = 700.0;
}
if (y < -700.0) {
y = -700.0;
}
epsilon = (fabs(y) > 1.0) ? fabs(y) * DBL_EPSILON : DBL_EPSILON;
}
if (y == 700.0) {
return INFINITY;
}
if (y == -700.0) {
return INFINITY;
}
return y;
}
long double logl(long double x) {
long double y, y_old, ey, epsilon;
y = 0.0;
y_old = 1.0;
epsilon = 1e-6; //fixme
while (y > y_old + epsilon || y < y_old - epsilon) {
y_old = y;
ey = expl(y);
y -= (ey - x) / ey;
if (y > 700.0) {
y = 700.0;
}
if (y < -700.0) {
y = -700.0;
}
}
if (y == 700.0) {
return INFINITY;
}
if (y == -700.0) {
return INFINITY;
}
return y;
}
#endif

44
lib/math/lib_log10.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_log10.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,19 +22,25 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
float log10f(float x) {
return (logf(x) / M_LN10);
}
double log10(double x) {
return (log(x) / M_LN10);
}
long double log10l(long double x) {
return (logl(x) / M_LN10);
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double log10(double x)
{
return (log(x) / M_LN10);
}
#endif

41
lib/math/lib_log10f.c Normal file
View file

@ -0,0 +1,41 @@
/************************************************************************
* lib/math/lib_log10f.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float log10f(float x)
{
return (logf(x) / M_LN10);
}

46
lib/math/lib_log10l.c Normal file
View file

@ -0,0 +1,46 @@
/************************************************************************
* lib/math/lib_log10l.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double log10l(long double x)
{
return (logl(x) / M_LN10);
}
#endif

44
lib/math/lib_log2.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_log2.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,19 +22,25 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
float log2f(float x) {
return (logf(x) / M_LN2);
}
double log2(double x) {
return (log(x) / M_LN2);
}
long double log2l(long double x) {
return (logl(x) / M_LN2);
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double log2(double x)
{
return (log(x) / M_LN2);
}
#endif

41
lib/math/lib_log2f.c Normal file
View file

@ -0,0 +1,41 @@
/************************************************************************
* lib/math/lib_log2f.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float log2f(float x)
{
return (logf(x) / M_LN2);
}

46
lib/math/lib_log2l.c Normal file
View file

@ -0,0 +1,46 @@
/************************************************************************
* lib/math/lib_log2l.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double log2l(long double x)
{
return (logl(x) / M_LN2);
}
#endif

77
lib/math/lib_logf.c Normal file
View file

@ -0,0 +1,77 @@
/************************************************************************
* lib/math/lib_logf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
#include <float.h>
/************************************************************************
* Public Functions
************************************************************************/
float logf(float x)
{
float y, y_old, ey, epsilon;
y = 0.0;
y_old = 1.0;
epsilon = FLT_EPSILON;
while (y > y_old + epsilon || y < y_old - epsilon)
{
y_old = y;
ey = exp(y);
y -= (ey - x) / ey;
if (y > 700.0)
{
y = 700.0;
}
if (y < -700.0)
{
y = -700.0;
}
epsilon = (fabs(y) > 1.0) ? fabs(y) * FLT_EPSILON : FLT_EPSILON;
}
if (y == 700.0)
{
return INFINITY;
}
if (y == -700.0)
{
return INFINITY;
}
return y;
}

80
lib/math/lib_logl.c Normal file
View file

@ -0,0 +1,80 @@
/************************************************************************
* lib/math/lib_lol.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
#include <float.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double logl(long double x)
{
long double y, y_old, ey, epsilon;
y = 0.0;
y_old = 1.0;
epsilon = LDBL_EPSILON;
while (y > y_old + epsilon || y < y_old - epsilon)
{
y_old = y;
ey = expl(y);
y -= (ey - x) / ey;
if (y > 700.0)
{
y = 700.0;
}
if (y < -700.0)
{
y = -700.0;
}
}
if (y == 700.0)
{
return INFINITY;
}
if (y == -700.0)
{
return INFINITY;
}
return y;
}
#endif

89
lib/math/lib_modf.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_modf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,54 +22,37 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <apps/math.h>
#include <float.h>
#include <stdint.h>
#include <math.h>
float modff(float x, float *iptr) {
if (fabsf(x) >= 8388608.0) {
*iptr = x;
return 0.0;
}
else if (fabs(x) < 1.0) {
*iptr = 0.0;
return x;
}
else {
*iptr = (float) (int) x;
return (x - *iptr);
}
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double modf(double x, double *iptr)
{
if (fabs(x) >= 4503599627370496.0)
{
*iptr = x;
return 0.0;
}
else if (fabs(x) < 1.0)
{
*iptr = 0.0;
return x;
}
else
{
*iptr = (double)(int64_t) x;
return (x - *iptr);
}
}
double modf(double x, double *iptr) {
if (fabs(x) >= 4503599627370496.0) {
*iptr = x;
return 0.0;
}
else if (fabs(x) < 1.0) {
*iptr = 0.0;
return x;
}
else {
*iptr = (double) (int64_t) x;
return (x - *iptr);
}
}
long double modfl(long double x, long double *iptr) {
if (fabs(x) >= 4503599627370496.0) {
*iptr = x;
return 0.0;
}
else if (fabs(x) < 1.0) {
*iptr = 0.0;
return x;
}
else {
*iptr = (long double) (int64_t) x;
return (x - *iptr);
}
}
#endif

55
lib/math/lib_modff.c Normal file
View file

@ -0,0 +1,55 @@
/************************************************************************
* lib/math/lib_modff.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float modff(float x, float *iptr)
{
if (fabsf(x) >= 8388608.0)
{
*iptr = x;
return 0.0;
}
else if (fabs(x) < 1.0)
{
*iptr = 0.0;
return x;
}
else
{
*iptr = (float)(int)x;
return (x - *iptr);
}
}

61
lib/math/lib_modfl.c Normal file
View file

@ -0,0 +1,61 @@
/************************************************************************
* lib/math/lib_modfl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <stdint.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double modfl(long double x, long double *iptr)
{
if (fabs(x) >= 4503599627370496.0)
{
*iptr = x;
return 0.0;
}
else if (fabs(x) < 1.0)
{
*iptr = 0.0;
return x;
}
else
{
*iptr = (long double)(int64_t) x;
return (x - *iptr);
}
}
#endif

44
lib/math/lib_pow.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_pow.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,19 +22,25 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
float powf(float b, float e) {
return expf(e * logf(b));
}
double pow(double b, double e) {
return exp(e * log(b));
}
long double powl(long double b, long double e) {
return expl(e * logl(b));
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double pow(double b, double e)
{
return exp(e * log(b));
}
#endif

41
lib/math/lib_powf.c Normal file
View file

@ -0,0 +1,41 @@
/************************************************************************
* lib/math/lib_powf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float powf(float b, float e)
{
return expf(e * logf(b));
}

46
lib/math/lib_powl.c Normal file
View file

@ -0,0 +1,46 @@
/************************************************************************
* lib/math/lib_powl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double powl(long double b, long double e)
{
return expl(e * logl(b));
}
#endif

220
lib/math/lib_sin.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_sin.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,141 +22,93 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <stdint.h>
#include <unistd.h>
#include <float.h>
#include <apps/math.h>
/************************************************************************
* Included Files
************************************************************************/
static float _flt_inv_fact[] = {
1.0 / 1.0, // 1 / 1!
1.0 / 6.0, // 1 / 3!
1.0 / 120.0, // 1 / 5!
1.0 / 5040.0, // 1 / 7!
1.0 / 362880.0, // 1 / 9!
1.0 / 39916800.0, // 1 / 11!
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <sys/types.h>
#include <math.h>
#if CONFIG_HAVE_DOUBLE
/************************************************************************
* Private Data
************************************************************************/
static double _dbl_inv_fact[] =
{
1.0 / 1.0, // 1 / 1!
1.0 / 6.0, // 1 / 3!
1.0 / 120.0, // 1 / 5!
1.0 / 5040.0, // 1 / 7!
1.0 / 362880.0, // 1 / 9!
1.0 / 39916800.0, // 1 / 11!
1.0 / 6227020800.0, // 1 / 13!
1.0 / 1307674368000.0, // 1 / 15!
1.0 / 355687428096000.0, // 1 / 17!
1.0 / 121645100408832000.0, // 1 / 19!
};
float sinf(float x) {
float x_squared;
float sin_x;
size_t i;
/* move x to [-pi, pi) */
x = fmodf(x, 2 * M_PI);
if (x >= M_PI) x -= 2 * M_PI;
if (x < -M_PI) x += 2 * M_PI;
/************************************************************************
* Public Functions
************************************************************************/
/* move x to [-pi/2, pi/2) */
if (x >= M_PI_2) x = M_PI - x;
if (x < -M_PI_2) x = -M_PI - x;
double sin(double x)
{
double x_squared;
double sin_x;
size_t i;
x_squared = x * x;
sin_x = 0.0;
/* Move x to [-pi, pi) */
/* perform Taylor series approximation for sin(x) with six terms */
for (i = 0; i < 6; i++) {
if (i % 2 == 0) {
sin_x += x * _flt_inv_fact[i];
}
else {
sin_x -= x * _flt_inv_fact[i];
}
x = fmod(x, 2 * M_PI);
if (x >= M_PI)
{
x -= 2 * M_PI;
}
x *= x_squared;
}
if (x < -M_PI)
{
x += 2 * M_PI;
}
return sin_x;
/* Move x to [-pi/2, pi/2) */
if (x >= M_PI_2)
{
x = M_PI - x;
}
if (x < -M_PI_2)
{
x = -M_PI - x;
}
x_squared = x * x;
sin_x = 0.0;
/* Perform Taylor series approximation for sin(x) with ten terms */
for (i = 0; i < 10; i++)
{
if (i % 2 == 0)
{
sin_x += x * _dbl_inv_fact[i];
}
else
{
sin_x -= x * _dbl_inv_fact[i];
}
x *= x_squared;
}
return sin_x;
}
static double _dbl_inv_fact[] = {
1.0 / 1.0, // 1 / 1!
1.0 / 6.0, // 1 / 3!
1.0 / 120.0, // 1 / 5!
1.0 / 5040.0, // 1 / 7!
1.0 / 362880.0, // 1 / 9!
1.0 / 39916800.0, // 1 / 11!
1.0 / 6227020800.0, // 1 / 13!
1.0 / 1307674368000.0, // 1 / 15!
1.0 / 355687428096000.0, // 1 / 17!
1.0 / 121645100408832000.0, // 1 / 19!
};
double sin(double x) {
double x_squared;
double sin_x;
size_t i;
/* move x to [-pi, pi) */
x = fmod(x, 2 * M_PI);
if (x >= M_PI) x -= 2 * M_PI;
if (x < -M_PI) x += 2 * M_PI;
/* move x to [-pi/2, pi/2) */
if (x >= M_PI_2) x = M_PI - x;
if (x < -M_PI_2) x = -M_PI - x;
x_squared = x * x;
sin_x = 0.0;
/* perform Taylor series approximation for sin(x) with ten terms */
for (i = 0; i < 10; i++) {
if (i % 2 == 0) {
sin_x += x * _dbl_inv_fact[i];
}
else {
sin_x -= x * _dbl_inv_fact[i];
}
x *= x_squared;
}
return sin_x;
}
static long double _ldbl_inv_fact[] = {
1.0 / 1.0, // 1 / 1!
1.0 / 6.0, // 1 / 3!
1.0 / 120.0, // 1 / 5!
1.0 / 5040.0, // 1 / 7!
1.0 / 362880.0, // 1 / 9!
1.0 / 39916800.0, // 1 / 11!
1.0 / 6227020800.0, // 1 / 13!
1.0 / 1307674368000.0, // 1 / 15!
1.0 / 355687428096000.0, // 1 / 17!
1.0 / 121645100408832000.0, // 1 / 19!
};
long double sinl(long double x) {
long double x_squared;
long double sin_x;
size_t i;
/* move x to [-pi, pi) */
x = fmodl(x, 2 * M_PI);
if (x >= M_PI) x -= 2 * M_PI;
if (x < -M_PI) x += 2 * M_PI;
/* move x to [-pi/2, pi/2) */
if (x >= M_PI_2) x = M_PI - x;
if (x < -M_PI_2) x = -M_PI - x;
x_squared = x * x;
sin_x = 0.0;
/* perform Taylor series approximation for sin(x) with ten terms */
for (i = 0; i < 10; i++) {
if (i % 2 == 0) {
sin_x += x * _ldbl_inv_fact[i];
}
else {
sin_x -= x * _ldbl_inv_fact[i];
}
x *= x_squared;
}
return sin_x;
}
#endif

104
lib/math/lib_sinf.c Normal file
View file

@ -0,0 +1,104 @@
/************************************************************************
* lib/math/lib_sinf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <sys/types.h>
#include <math.h>
/************************************************************************
* Private Data
************************************************************************/
static float _flt_inv_fact[] =
{
1.0 / 1.0, // 1 / 1!
1.0 / 6.0, // 1 / 3!
1.0 / 120.0, // 1 / 5!
1.0 / 5040.0, // 1 / 7!
1.0 / 362880.0, // 1 / 9!
1.0 / 39916800.0, // 1 / 11!
};
/************************************************************************
* Public Functions
************************************************************************/
float sinf(float x)
{
float x_squared;
float sin_x;
size_t i;
/* Move x to [-pi, pi) */
x = fmodf(x, 2 * M_PI);
if (x >= M_PI)
{
x -= 2 * M_PI;
}
if (x < -M_PI)
{
x += 2 * M_PI;
}
/* Move x to [-pi/2, pi/2) */
if (x >= M_PI_2)
{
x = M_PI - x;
}
if (x < -M_PI_2)
{
x = -M_PI - x;
}
x_squared = x * x;
sin_x = 0.0;
/* Perform Taylor series approximation for sin(x) with six terms */
for (i = 0; i < 6; i++)
{
if (i % 2 == 0)
{
sin_x += x * _flt_inv_fact[i];
}
else
{
sin_x -= x * _flt_inv_fact[i];
}
x *= x_squared;
}
return sin_x;
}

48
lib/math/lib_sinh.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_sinh.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,22 +22,26 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
float sinhf(float x) {
x = expf(x);
return ((x - (1.0 / x)) / 2.0);
}
double sinh(double x) {
x = exp(x);
return ((x - (1.0 / x)) / 2.0);
}
long double sinhl(long double x) {
x = expl(x);
return ((x - (1.0 / x)) / 2.0);
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double sinh(double x)
{
x = exp(x);
return ((x - (1.0 / x)) / 2.0);
}
#endif

42
lib/math/lib_sinhf.c Normal file
View file

@ -0,0 +1,42 @@
/************************************************************************
* lib/math/lib_sinhf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float sinhf(float x)
{
x = expf(x);
return ((x - (1.0 / x)) / 2.0);
}

47
lib/math/lib_sinhl.c Normal file
View file

@ -0,0 +1,47 @@
/************************************************************************
* lib/math/lib_sinhl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double sinhl(long double x)
{
x = expl(x);
return ((x - (1.0 / x)) / 2.0);
}
#endif

114
lib/math/lib_sinl.c Normal file
View file

@ -0,0 +1,114 @@
/************************************************************************
* lib/math/lib_sinl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <sys/types.h>
#include <math.h>
#if CONFIG_HAVE_LONG_DOUBLE
/************************************************************************
* Private Data
************************************************************************/
static long double _ldbl_inv_fact[] =
{
1.0 / 1.0, // 1 / 1!
1.0 / 6.0, // 1 / 3!
1.0 / 120.0, // 1 / 5!
1.0 / 5040.0, // 1 / 7!
1.0 / 362880.0, // 1 / 9!
1.0 / 39916800.0, // 1 / 11!
1.0 / 6227020800.0, // 1 / 13!
1.0 / 1307674368000.0, // 1 / 15!
1.0 / 355687428096000.0, // 1 / 17!
1.0 / 121645100408832000.0, // 1 / 19!
};
/************************************************************************
* Public Functions
************************************************************************/
long double sinl(long double x)
{
long double x_squared;
long double sin_x;
size_t i;
/* Move x to [-pi, pi) */
x = fmodl(x, 2 * M_PI);
if (x >= M_PI)
{
x -= 2 * M_PI;
}
if (x < -M_PI)
{
x += 2 * M_PI;
}
/* Move x to [-pi/2, pi/2) */
if (x >= M_PI_2)
{
x = M_PI - x;
}
if (x < -M_PI_2)
{
x = -M_PI - x;
}
x_squared = x * x;
sin_x = 0.0;
/* Perform Taylor series approximation for sin(x) with ten terms */
for (i = 0; i < 10; i++)
{
if (i % 2 == 0)
{
sin_x += x * _ldbl_inv_fact[i];
}
else
{
sin_x -= x * _ldbl_inv_fact[i];
}
x *= x_squared;
}
return sin_x;
}
#endif

177
lib/math/lib_sqrt.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_sqrt.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,105 +22,78 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <stdint.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
#include <errno.h>
#include <apps/math.h>
static float __sqrt_approx(float x) {
int32_t i;
#include "lib_internal.h"
// floats + bit manipulation = +inf fun!
i = *((int32_t*) &x);
i = 0x1FC00000 + (i >> 1);
x = *((float*) &i);
/************************************************************************
* Public Functions
************************************************************************/
return x;
}
float sqrtf(float x) {
float y;
// filter out invalid/trivial inputs
if (x < 0.0) { errno = EDOM; return NAN; }
if (isnan(x)) return NAN;
if (isinf(x)) return INFINITY;
if (x == 0.0) return 0.0;
// guess square root (using bit manipulation)
y = __sqrt_approx(x);
// perform three iterations of approximation
// this number (3) is definitely optimal
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
return y;
}
double sqrt(double x) {
long double y, y1;
// filter out invalid/trivial inputs
if (x < 0.0) { errno = EDOM; return NAN; }
if (isnan(x)) return NAN;
if (isinf(x)) return INFINITY;
if (x == 0.0) return 0.0;
// guess square root (using bit manipulation)
y = __sqrt_approx(x);
// perform four iterations of approximation
// this number (4) is definitely optimal
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
// if guess was terribe (out of range of float)
// repeat approximation until convergence
if (y * y < x - 1.0 || y * y > x + 1.0) {
y1 = -1.0;
while (y != y1) {
y1 = y;
y = 0.5 * (y + x / y);
}
}
return y;
}
long double sqrtl(long double x) {
long double y, y1;
// filter out invalid/trivial inputs
if (x < 0.0) { errno = EDOM; return NAN; }
if (isnan(x)) return NAN;
if (isinf(x)) return INFINITY;
if (x == 0.0) return 0.0;
// guess square root (using bit manipulation)
y = __sqrt_approx(x);
// perform four iterations of approximation
// this number (4) is definitely optimal
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
// if guess was terribe (out of range of float)
// repeat approximation until convergence
if (y * y < x - 1.0 || y * y > x + 1.0) {
y1 = -1.0;
while (y != y1) {
y1 = y;
y = 0.5 * (y + x / y);
}
}
return y;
#if CONFIG_HAVE_DOUBLE
double sqrt(double x)
{
long double y, y1;
if (x < 0.0)
{
errno = EDOM;
return NAN;
}
if (isnan(x))
{
return NAN;
}
if (isinf(x))
{
return INFINITY;
}
if (x == 0.0)
{
return 0.0;
}
/* Guess square root (using bit manipulation) */
y = lib_sqrtapprox(x);
/* Perform four iterations of approximation. This number (4) is
* definitely optimal
*/
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
/* If guess was terribe (out of range of float). Repeat approximation
* until convergence.
*/
if (y * y < x - 1.0 || y * y > x + 1.0)
{
y1 = -1.0;
while (y != y1)
{
y1 = y;
y = 0.5 * (y + x / y);
}
}
return y;
}
#endif

84
lib/math/lib_sqrtf.c Normal file
View file

@ -0,0 +1,84 @@
/************************************************************************
* lib/math/lib_sqrtf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
#include <errno.h>
#include "lib_internal.h"
/************************************************************************
* Public Functions
************************************************************************/
float sqrtf(float x)
{
float y;
/* Filter out invalid/trivial inputs */
if (x < 0.0)
{
errno = EDOM;
return NAN;
}
if (isnan(x))
{
return NAN;
}
if (isinf(x))
{
return INFINITY;
}
if (x == 0.0)
{
return 0.0;
}
/* Guess square root (using bit manipulation) */
y = lib_sqrtapprox(x);
/* Perform three iterations of approximation. This number (3) is
* definitely optimal
*/
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
return y;
}

101
lib/math/lib_sqrtl.c Normal file
View file

@ -0,0 +1,101 @@
/************************************************************************
* lib/math/lib_sqrtl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
#include <errno.h>
#include "lib_internal.h"
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double sqrtl(long double x)
{
long double y, y1;
/* Filter out invalid/trivial inputs */
if (x < 0.0)
{
errno = EDOM;
return NAN;
}
if (isnan(x))
{
return NAN;
}
if (isinf(x))
{
return INFINITY;
}
if (x == 0.0)
{
return 0.0;
}
/* Guess square root (using bit manipulation) */
y = lib_sqrtapprox(x);
/* Perform four iterations of approximation. This number (4) is
* definitely optimal
*/
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
y = 0.5 * (y + x / y);
/* If guess was terribe (out of range of float). Repeat approximation
* until convergence
*/
if (y * y < x - 1.0 || y * y > x + 1.0)
{
y1 = -1.0;
while (y != y1)
{
y1 = y;
y = 0.5 * (y + x / y);
}
}
return y;
}
#endif

45
lib/math/lib_tan.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_tan.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,20 +22,25 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <stdint.h>
#include <float.h>
#include <apps/math.h>
/************************************************************************
* Included Files
************************************************************************/
float tanf(float x) {
return (sinf(x) / cosf(x));
}
double tan(double x) {
return (sin(x) / cos(x));
}
long double tanl(long double x) {
return (sinl(x) / cosl(x));
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double tan(double x)
{
return (sin(x) / cos(x));
}
#endif

41
lib/math/lib_tanf.c Normal file
View file

@ -0,0 +1,41 @@
/************************************************************************
* lib/math/lib_tanf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float tanf(float x)
{
return (sinf(x) / cosf(x));
}

54
lib/math/lib_tanh.c
View file

@ -1,4 +1,14 @@
/*
/************************************************************************
* lib/math/lib_tanh.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
@ -12,28 +22,28 @@
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
*
************************************************************************/
#include <apps/math.h>
#include <float.h>
/************************************************************************
* Included Files
************************************************************************/
float tanhf(float x) {
float x0 = expf(x);
float x1 = 1.0 / x0;
#include <nuttx/config.h>
#include <nuttx/compiler.h>
return ((x0 + x1) / (x0 - x1));
}
double tanh(double x) {
double x0 = exp(x);
double x1 = 1.0 / x0;
return ((x0 + x1) / (x0 - x1));
}
long double tanhl(long double x) {
long double x0 = exp(x);
long double x1 = 1.0 / x0;
return ((x0 + x1) / (x0 - x1));
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_DOUBLE
double tanh(double x)
{
double x0 = exp(x);
double x1 = 1.0 / x0;
return ((x0 + x1) / (x0 - x1));
}
#endif

44
lib/math/lib_tanhf.c Normal file
View file

@ -0,0 +1,44 @@
/************************************************************************
* lib/math/lib_tanhf.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
float tanhf(float x)
{
float x0 = expf(x);
float x1 = 1.0 / x0;
return ((x0 + x1) / (x0 - x1));
}

49
lib/math/lib_tanhl.c Normal file
View file

@ -0,0 +1,49 @@
/************************************************************************
* lib/math/lib_tanhl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double tanhl(long double x)
{
long double x0 = exp(x);
long double x1 = 1.0 / x0;
return ((x0 + x1) / (x0 - x1));
}
#endif

46
lib/math/lib_tanl.c Normal file
View file

@ -0,0 +1,46 @@
/************************************************************************
* lib/math/lib_tanl.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Ported by: Darcy Gong
*
* It derives from the Rhombs OS math library by Nick Johnson which has
* a compatibile, MIT-style license:
*
* Copyright (C) 2009, 2010 Nick Johnson <nickbjohnson4224 at gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <math.h>
/************************************************************************
* Public Functions
************************************************************************/
#if CONFIG_HAVE_LONG_DOUBLE
long double tanl(long double x)
{
return (sinl(x) / cosl(x));
}
#endif