Home
last modified time | relevance | path

Searched full:log1p (Results 1 – 25 of 2159) sorted by relevance

12345678910>>...87

/aosp_15_r20/external/python/cpython3/Lib/test/
Dmath_testcases.txt374 -- log1p: log(1 + x), without precision loss for small x --
378 log1p0000 log1p 0.0 -> 0.0
379 log1p0001 log1p -0.0 -> -0.0
380 log1p0002 log1p inf -> inf
381 log1p0003 log1p -inf -> nan invalid
382 log1p0004 log1p nan -> nan
385 log1p0010 log1p -1.0 -> -inf divide-by-zero
386 log1p0011 log1p -0.9999999999999999 -> -36.736800569677101
389 log1p0020 log1p -1.0000000000000002 -> nan invalid
390 log1p0021 log1p -1.1 -> nan invalid
[all …]
/aosp_15_r20/external/arm-optimized-routines/pl/math/
H A Dlog1p_2u.c34 /* log1p approximation using polynomial on reduced interval. Largest
38 log1p(-0x1.2e1aea97b3e5cp-2) got -0x1.65fb8659a2f9p-2
41 log1p (double x) in log1p() function
53 /* x == -0 => log1p(x) = -0. in log1p()
54 x == Inf => log1p(x) = Inf. */ in log1p()
59 /* x == -1 => log1p(x) = -Inf. */ in log1p()
65 /* x == +/-NaN => log1p(x) = NaN. */ in log1p()
68 /* x < -1 => log1p(x) = NaN. in log1p()
69 x == -Inf => log1p(x) = NaN. */ in log1p()
75 log1p(x) = k*log(2) + log1p(f). in log1p()
[all …]
H A Dv_log1p_2u5.c46 return v_call_f64 (log1p, x, y, special); in special_case()
49 /* Vector log1p approximation using polynomial on reduced interval. Routine is
50 a modification of the algorithm used in scalar log1p, with no shortcut for
54 VPCS_ATTR float64x2_t V_NAME_D1 (log1p) (float64x2_t x) in V_NAME_D1() argument
72 log1p(x) = k*log(2) + log1p(f). in V_NAME_D1()
76 c << m: at very small x, log1p(x) ~ x, hence: in V_NAME_D1()
79 We therefore calculate log1p(x) by k*log2 + log1p(f) + c/m. */ in V_NAME_D1()
101 /* Approximate log1p(x) on the reduced input using a polynomial. Because in V_NAME_D1()
102 log1p(0)=0 we choose an approximation of the form: in V_NAME_D1()
121 PL_SIG (V, D, 1, log1p, -0.9, 10.0)
[all …]
H A Dsv_log1p_2u5.c44 return sv_call_f64 (log1p, x, y, special); in special_case()
47 /* Vector approximation for log1p using polynomial on reduced interval. Maximum
51 svfloat64_t SV_NAME_D1 (log1p) (svfloat64_t x, svbool_t pg) in SV_NAME_D1() argument
61 log1p(x) = k*log(2) + log1p(f). in SV_NAME_D1()
65 c << m: at very small x, log1p(x) ~ x, hence: in SV_NAME_D1()
68 We therefore calculate log1p(x) by k*log2 + log1p(f) + c/m. */ in SV_NAME_D1()
90 /* Approximate log1p(x) on the reduced input using a polynomial. Because in SV_NAME_D1()
91 log1p(0)=0 we choose an approximation of the form: in SV_NAME_D1()
110 PL_SIG (SV, D, 1, log1p, -0.9, 10.0)
111 PL_TEST_ULP (SV_NAME_D1 (log1p), 1.97)
[all …]
H A Dv_log1pf_2u1.c61 VPCS_ATTR float32x4_t V_NAME_F1 (log1p) (float32x4_t x) in V_NAME_F1() argument
81 log1p(x) = log(t) + log(2^k) = log1p(m) + k*log(2). in V_NAME_F1()
83 We approximate log1p(m) with a polynomial, then scale by in V_NAME_F1()
120 PL_SIG (V, F, 1, log1p, -0.9, 10.0)
121 PL_TEST_ULP (V_NAME_F1 (log1p), 1.53)
122 PL_TEST_EXPECT_FENV (V_NAME_F1 (log1p), WANT_SIMD_EXCEPT)
123 PL_TEST_SYM_INTERVAL (V_NAME_F1 (log1p), 0.0, 0x1p-23, 30000)
124 PL_TEST_SYM_INTERVAL (V_NAME_F1 (log1p), 0x1p-23, 1, 50000)
125 PL_TEST_INTERVAL (V_NAME_F1 (log1p), 1, inf, 50000)
126 PL_TEST_INTERVAL (V_NAME_F1 (log1p), -1.0, -inf, 1000)
H A Dsv_log1pf_1u3.c41 svfloat32_t SV_NAME_F1 (log1p) (svfloat32_t x, svbool_t pg) in SV_NAME_F1() argument
50 log1p(x) = log(t) + log(2^k) = log1p(m) + k*log(2). in SV_NAME_F1()
52 We approximate log1p(m) with a polynomial, then scale by in SV_NAME_F1()
92 PL_SIG (SV, F, 1, log1p, -0.9, 10.0)
93 PL_TEST_ULP (SV_NAME_F1 (log1p), 0.77)
94 PL_TEST_SYM_INTERVAL (SV_NAME_F1 (log1p), 0, 0x1p-23, 5000)
95 PL_TEST_SYM_INTERVAL (SV_NAME_F1 (log1p), 0x1p-23, 1, 5000)
96 PL_TEST_INTERVAL (SV_NAME_F1 (log1p), 1, inf, 10000)
97 PL_TEST_INTERVAL (SV_NAME_F1 (log1p), -1, -inf, 10)
/aosp_15_r20/external/llvm-libc/test/src/math/
H A Dlog1p_test.cpp1 //===-- Unittests for log1p -----------------------------------------------===//
12 #include "src/math/log1p.h"
25 EXPECT_FP_EQ(aNaN, LIBC_NAMESPACE::log1p(aNaN)); in TEST_F()
26 EXPECT_FP_EQ(inf, LIBC_NAMESPACE::log1p(inf)); in TEST_F()
27 EXPECT_FP_IS_NAN_WITH_EXCEPTION(LIBC_NAMESPACE::log1p(neg_inf), FE_INVALID); in TEST_F()
28 EXPECT_FP_IS_NAN_WITH_EXCEPTION(LIBC_NAMESPACE::log1p(-2.0), FE_INVALID); in TEST_F()
29 EXPECT_FP_EQ(zero, LIBC_NAMESPACE::log1p(0.0)); in TEST_F()
30 EXPECT_FP_EQ(neg_zero, LIBC_NAMESPACE::log1p(-0.0)); in TEST_F()
31 EXPECT_FP_EQ_WITH_EXCEPTION(neg_inf, LIBC_NAMESPACE::log1p(-1.0), in TEST_F()
71 EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x, in TEST_F()
[all …]
/aosp_15_r20/external/llvm-libc/test/src/math/smoke/
H A Dlog1p_test.cpp1 //===-- Unittests for log1p -----------------------------------------------===//
12 #include "src/math/log1p.h"
19 EXPECT_FP_EQ(aNaN, LIBC_NAMESPACE::log1p(aNaN)); in TEST_F()
20 EXPECT_FP_EQ(inf, LIBC_NAMESPACE::log1p(inf)); in TEST_F()
21 EXPECT_FP_IS_NAN_WITH_EXCEPTION(LIBC_NAMESPACE::log1p(neg_inf), FE_INVALID); in TEST_F()
22 EXPECT_FP_IS_NAN_WITH_EXCEPTION(LIBC_NAMESPACE::log1p(-2.0), FE_INVALID); in TEST_F()
23 EXPECT_FP_EQ(zero, LIBC_NAMESPACE::log1p(0.0)); in TEST_F()
24 EXPECT_FP_EQ(neg_zero, LIBC_NAMESPACE::log1p(-0.0)); in TEST_F()
25 EXPECT_FP_EQ_WITH_EXCEPTION(neg_inf, LIBC_NAMESPACE::log1p(-1.0), in TEST_F()
29 LIBC_NAMESPACE::log1p(0x1.9b536cac3a09dp1023)); in TEST_F()
[all …]
/aosp_15_r20/prebuilts/go/linux-x86/src/math/
Dlog1p.go22 // double log1p(double x)
36 // 2. Approximation of log1p(f).
54 // log1p(f) = f - (hfsq - s*(hfsq+R)).
56 // 3. Finally, log1p(x) = k*ln2 + log1p(f).
63 // log1p(x) is NaN with signal if x < -1 (including -INF) ;
64 // log1p(+INF) is +INF; log1p(-1) is -INF with signal;
65 // log1p(NaN) is that NaN with no signal.
78 // algorithm can be used to compute log1p(x) to within a few ULP:
86 // Log1p returns the natural logarithm of 1 plus its argument x.
91 // Log1p(+Inf) = +Inf
[all …]
/aosp_15_r20/libcore/ojluni/src/test/java/lang/Math/
H A DLog1pTests.java30 * @summary Tests for {Math, StrictMath}.log1p (use -Dseed=X to set PRNG seed)
65 * Therefore, for small values of x, log1p(x) ~= x. For large
66 * values of x, log1p(x) ~= log(x).
99 // For |x| < 2^-54 log1p(x) ~= x in testLog1p()
106 // For x > 2^53 log1p(x) ~= log(x) in testLog1p()
138 // and we test that log1p(pcNeighbors[i]) <= log1p(pcNeighbors[i+1]) in testLog1p()
154 pcNeighborsLog1p[j] = Math.log1p(pcNeighbors[j]); in testLog1p()
155 pcNeighborsStrictLog1p[j] = StrictMath.log1p(pcNeighbors[j]); in testLog1p()
160 Assert.fail("Monotonicity failure for Math.log1p on " + in testLog1p()
168 Assert.fail("Monotonicity failure for StrictMath.log1p on " + in testLog1p()
[all …]
/aosp_15_r20/external/arm-optimized-routines/pl/math/test/testcases/directed/
H A Dlog1p.tst1 ; log1p.tst
6 func=log1p op1=7ff80000.00000001 result=7ff80000.00000001 errno=0
7 func=log1p op1=fff80000.00000001 result=7ff80000.00000001 errno=0
8 func=log1p op1=7ff00000.00000001 result=7ff80000.00000001 errno=0 status=i
9 func=log1p op1=fff00000.00000001 result=7ff80000.00000001 errno=0 status=i
10 func=log1p op1=fff02000.00000000 result=7ff80000.00000001 errno=0 status=i
11 func=log1p op1=7ff00000.00000000 result=7ff00000.00000000 errno=0
15 func=log1p op1=00000000.00000000 result=00000000.00000000 errno=0
16 func=log1p op1=80000000.00000000 result=80000000.00000000 errno=0
21 func=log1p op1=00000000.00000001 result=00000000.00000001 errno=0 maybestatus=ux
[all …]
/aosp_15_r20/bionic/libm/upstream-freebsd/lib/msun/src/
H A Ds_log1p.c12 /* double log1p(double x)
26 * 2. Approximation of log1p(f).
44 * log1p(f) = f - (hfsq - s*(hfsq+R)).
46 * 3. Finally, log1p(x) = k*ln2 + log1p(f).
53 * log1p(x) is NaN with signal if x < -1 (including -INF) ;
54 * log1p(+INF) is +INF; log1p(-1) is -INF with signal;
55 * log1p(NaN) is that NaN with no signal.
68 * algorithm can be used to compute log1p(x) to within a few ULP:
98 log1p(double x) in log1p() function
109 if(x==-1.0) return -two54/vzero; /* log1p(-1)=+inf */ in log1p()
[all …]
/aosp_15_r20/art/test/123-inline-execute2/
H A Dexpected-stdout.txt92 Math.log1p(-3.0) = NaN
100 Math.log1p(-2.0) = NaN
108 Math.log1p(-1.0) = -Infinity
116 Math.log1p(0.0) = 0.000000000000
124 Math.log1p(1.0) = 0.693147180560
132 Math.log1p(2.0) = 1.098612288668
140 Math.log1p(3.0) = 1.386294361120
243 StrictMath.log1p(-3.0) = NaN
251 StrictMath.log1p(-2.0) = NaN
259 StrictMath.log1p(-1.0) = -Infinity
[all …]
/aosp_15_r20/external/trusty/musl/src/math/
Dlog1p.c12 /* double log1p(double x)
29 * 3. Finally, log1p(x) = k*ln2 + log(1+f) + c/u. See log.c
32 * log1p(x) is NaN with signal if x < -1 (including -INF) ;
33 * log1p(+INF) is +INF; log1p(-1) is -INF with signal;
34 * log1p(NaN) is that NaN with no signal.
47 * algorithm can be used to compute log1p(x) to within a few ULP:
69 double log1p(double x) in log1p() function
81 return x/0.0; /* log1p(-1) = -inf */ in log1p()
82 return (x-x)/0.0; /* log1p(x<-1) = NaN */ in log1p()
/aosp_15_r20/external/musl/src/math/
H A Dlog1p.c12 /* double log1p(double x)
29 * 3. Finally, log1p(x) = k*ln2 + log(1+f) + c/u. See log.c
32 * log1p(x) is NaN with signal if x < -1 (including -INF) ;
33 * log1p(+INF) is +INF; log1p(-1) is -INF with signal;
34 * log1p(NaN) is that NaN with no signal.
47 * algorithm can be used to compute log1p(x) to within a few ULP:
69 double log1p(double x) in log1p() function
81 return x/0.0; /* log1p(-1) = -inf */ in log1p()
82 return (x-x)/0.0; /* log1p(x<-1) = NaN */ in log1p()
/aosp_15_r20/prebuilts/rust/linux-x86/1.81.0.u1/lib/rustlib/src/rust/vendor/compiler_builtins/libm/src/math/
H A Dlog1p.rs12 /* double log1p(double x)
29 * 3. Finally, log1p(x) = k*ln2 + log(1+f) + c/u. See log.c
32 * log1p(x) is NaN with signal if x < -1 (including -INF) ;
33 * log1p(+INF) is +INF; log1p(-1) is -INF with signal;
34 * log1p(NaN) is that NaN with no signal.
47 * algorithm can be used to compute log1p(x) to within a few ULP:
69 pub fn log1p(x: f64) -> f64 { in log1p() function
92 return x / 0.0; /* log1p(-1) = -inf */ in log1p()
94 return (x - x) / 0.0; /* log1p(x<-1) = NaN */ in log1p()
/aosp_15_r20/prebuilts/rust/linux-x86/1.80.1/lib/rustlib/src/rust/vendor/compiler_builtins/libm/src/math/
H A Dlog1p.rs12 /* double log1p(double x)
29 * 3. Finally, log1p(x) = k*ln2 + log(1+f) + c/u. See log.c
32 * log1p(x) is NaN with signal if x < -1 (including -INF) ;
33 * log1p(+INF) is +INF; log1p(-1) is -INF with signal;
34 * log1p(NaN) is that NaN with no signal.
47 * algorithm can be used to compute log1p(x) to within a few ULP:
69 pub fn log1p(x: f64) -> f64 { in log1p() function
92 return x / 0.0; /* log1p(-1) = -inf */ in log1p()
94 return (x - x) / 0.0; /* log1p(x<-1) = NaN */ in log1p()
/aosp_15_r20/prebuilts/rust/linux-musl-x86/1.80.1/lib/rustlib/src/rust/vendor/compiler_builtins/libm/src/math/
H A Dlog1p.rs12 /* double log1p(double x)
29 * 3. Finally, log1p(x) = k*ln2 + log(1+f) + c/u. See log.c
32 * log1p(x) is NaN with signal if x < -1 (including -INF) ;
33 * log1p(+INF) is +INF; log1p(-1) is -INF with signal;
34 * log1p(NaN) is that NaN with no signal.
47 * algorithm can be used to compute log1p(x) to within a few ULP:
69 pub fn log1p(x: f64) -> f64 { in log1p() function
92 return x / 0.0; /* log1p(-1) = -inf */ in log1p()
94 return (x - x) / 0.0; /* log1p(x<-1) = NaN */ in log1p()
/aosp_15_r20/prebuilts/rust/linux-x86/1.81.0/lib/rustlib/src/rust/vendor/compiler_builtins/libm/src/math/
H A Dlog1p.rs12 /* double log1p(double x)
29 * 3. Finally, log1p(x) = k*ln2 + log(1+f) + c/u. See log.c
32 * log1p(x) is NaN with signal if x < -1 (including -INF) ;
33 * log1p(+INF) is +INF; log1p(-1) is -INF with signal;
34 * log1p(NaN) is that NaN with no signal.
47 * algorithm can be used to compute log1p(x) to within a few ULP:
69 pub fn log1p(x: f64) -> f64 { in log1p() function
92 return x / 0.0; /* log1p(-1) = -inf */ in log1p()
94 return (x - x) / 0.0; /* log1p(x<-1) = NaN */ in log1p()
/aosp_15_r20/prebuilts/rust/linux-musl-x86/1.81.0/lib/rustlib/src/rust/vendor/compiler_builtins/libm/src/math/
H A Dlog1p.rs12 /* double log1p(double x)
29 * 3. Finally, log1p(x) = k*ln2 + log(1+f) + c/u. See log.c
32 * log1p(x) is NaN with signal if x < -1 (including -INF) ;
33 * log1p(+INF) is +INF; log1p(-1) is -INF with signal;
34 * log1p(NaN) is that NaN with no signal.
47 * algorithm can be used to compute log1p(x) to within a few ULP:
69 pub fn log1p(x: f64) -> f64 { in log1p() function
92 return x / 0.0; /* log1p(-1) = -inf */ in log1p()
94 return (x - x) / 0.0; /* log1p(x<-1) = NaN */ in log1p()
/aosp_15_r20/external/rust/android-crates-io/crates/libm/src/math/
Dlog1p.rs12 /* double log1p(double x)
29 * 3. Finally, log1p(x) = k*ln2 + log(1+f) + c/u. See log.c
32 * log1p(x) is NaN with signal if x < -1 (including -INF) ;
33 * log1p(+INF) is +INF; log1p(-1) is -INF with signal;
34 * log1p(NaN) is that NaN with no signal.
47 * algorithm can be used to compute log1p(x) to within a few ULP:
69 pub fn log1p(x: f64) -> f64 { in log1p() function
92 return x / 0.0; /* log1p(-1) = -inf */ in log1p()
94 return (x - x) / 0.0; /* log1p(x<-1) = NaN */ in log1p()
/aosp_15_r20/cts/tests/tests/renderscript/src/android/renderscript/cts/generated/
H A DTestLog1p.rscript24 return log1p(inV);
28 return log1p(inV);
32 return log1p(inV);
36 return log1p(inV);
40 return log1p(inV);
44 return log1p(inV);
48 return log1p(inV);
52 return log1p(inV);
/aosp_15_r20/external/pytorch/c10/test/util/
H A Dcomplex_math_test_common.h205 // log1p(x) = log(1 + x) in C10_DEFINE_TEST()
208 c10::complex<float> l1 = std::log1p(x); in C10_DEFINE_TEST()
215 c10::complex<double> l1 = std::log1p(x); in C10_DEFINE_TEST()
226 c10::complex<float> l = std::log1p(x); in C10_DEFINE_TEST()
232 c10::complex<double> l = std::log1p(x); in C10_DEFINE_TEST()
242 c10::complex<float> l = std::log1p(x); in C10_DEFINE_TEST()
248 c10::complex<float> l = std::log1p(x); in C10_DEFINE_TEST()
254 c10::complex<float> l = std::log1p(x); in C10_DEFINE_TEST()
260 c10::complex<float> l = std::log1p(x); in C10_DEFINE_TEST()
266 c10::complex<float> l = std::log1p(x); in C10_DEFINE_TEST()
[all …]
/aosp_15_r20/external/python/cpython2/Modules/
D_math.c33 * acosh(x) := log1p(t+sqrt(2.0*t+t*t)); where t=x-1.
84 * := sign(x)*log1p(|x| + x^2/(1 + sqrt(1+x^2)))
118 * atanh(x) = --- * log(1 + -------) = 0.5 * log1p(2 * -------)
122 * atanh(x) = 0.5*log1p(2x+2x*x/(1-x))
187 /* log1p(x) = log(1+x). The log1p function is designed to avoid the
196 /* Some platforms supply a log1p function but don't respect the sign of in _Py_log1p()
197 zero: log1p(-0.0) gives 0.0 instead of the correct result of -0.0. in _Py_log1p()
206 return log1p(x); in _Py_log1p()
243 happens, then results from log1p will be inaccurate in _Py_log1p()
/aosp_15_r20/external/tensorflow/tensorflow/compiler/mlir/tfrt/python_tests/
H A Dtf_log1p_test.py15 """Tests for tf.Log1p JIT compilation."""
31 func.func @log1p(%arg0: tensor<?xf32>) -> tensor<?xf32> {
32 %0 = "tf.Log1p"(%arg0): (tensor<?xf32>) -> tensor<?xf32>
39 func.func @log1p(%arg0: tensor<?x?xf32>) -> tensor<?x?xf32> {
40 %0 = "tf.Log1p"(%arg0): (tensor<?x?xf32>) -> tensor<?x?xf32>
50 compiled = jitrt.compile(fn(), "log1p", specialize)
57 np.testing.assert_allclose(res, np.log1p(arg), atol=1e-06)

12345678910>>...87