/* * Copyright ( c ) 2016 , 2021 , Intel Corporation . All rights reserved . * Intel Math Library ( LIBM ) Source Code * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER . * * This code is free software ; you can redistribute it and / or modify it * under the terms of the GNU General Public License version 2 only , as * published by the Free Software Foundation . * * This code is distributed in the hope that it will be useful , but WITHOUT * ANY WARRANTY ; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE . See the GNU General Public License * version 2 for more details ( a copy is included in the LICENSE file that * accompanied this code ) . * * You should have received a copy of the GNU General Public License version * 2 along with this work ; if not , write to the Free Software Foundation , * Inc . , 51 Franklin St , Fifth Floor , Boston , MA 02110 - 1301 USA . * * Please contact Oracle , 500 Oracle Parkway , Redwood Shores , CA 94065 USA * or visit www . oracle . com if you need additional information or have any * questions . * #include "precompiled.hpp" #include "macroAssembler_x86.hpp" #include "stubGenerator_x86_64.hpp" /******************************************************************************/ // ALGORITHM DESCRIPTION - COS() // --------------------- // // 1. RANGE REDUCTION // // We perform an initial range reduction from X to r with // // X =~= N * pi/32 + r // // so that |r| <= pi/64 + epsilon. We restrict inputs to those // where |N| <= 932560. Beyond this, the range reduction is // insufficiently accurate. For extremely small inputs, // denormalization can occur internally, impacting performance. // This means that the main path is actually only taken for // 2^-252 <= |X| < 90112. // // To avoid branches, we perform the range reduction to full // accuracy each time. // // X - N * (P_1 + P_2 + P_3) // // where P_1 and P_2 are 32-bit numbers (so multiplication by N // is exact) and P_3 is a 53-bit number. Together, these // approximate pi well enough for all cases in the restricted // range. // // The main reduction sequence is: // // y = 32/pi * x // N = integer(y) // (computed by adding and subtracting off SHIFTER) // // m_1 = N * P_1 // m_2 = N * P_2 // r_1 = x - m_1 // r = r_1 - m_2 // (this r can be used for most of the calculation) // // c_1 = r_1 - r // m_3 = N * P_3 // c_2 = c_1 - m_2 // c = c_2 - m_3 // // 2. MAIN ALGORITHM // // The algorithm uses a table lookup based on B = M * pi / 32 // where M = N mod 64. The stored values are: // sigma closest power of 2 to cos(B) // C_hl 53-bit cos(B) - sigma // S_hi + S_lo 2 * 53-bit sin(B) // // The computation is organized as follows: // // sin(B + r + c) = [sin(B) + sigma * r] + // r * (cos(B) - sigma) + // sin(B) * [cos(r + c) - 1] + // cos(B) * [sin(r + c) - r] // // which is approximately: // // [S_hi + sigma * r] + // C_hl * r + // S_lo + S_hi * [(cos(r) - 1) - r * c] + // (C_hl + sigma) * [(sin(r) - r) + c] // // and this is what is actually computed. We separate this sum // into four parts: // // hi + med + pols + corr // // where // // hi = S_hi + sigma r // med = C_hl * r // pols = S_hi * (cos(r) - 1) + (C_hl + sigma) * (sin(r) - r) // corr = S_lo + c * ((C_hl + sigma) - S_hi * r) // // 3. POLYNOMIAL // // The polynomial S_hi * (cos(r) - 1) + (C_hl + sigma) * // (sin(r) - r) can be rearranged freely, since it is quite // small, so we exploit parallelism to the fullest. // // psc4 = SC_4 * r_1 // msc4 = psc4 * r // r2 = r * r // msc2 = SC_2 * r2 // r4 = r2 * r2 // psc3 = SC_3 + msc4 // psc1 = SC_1 + msc2 // msc3 = r4 * psc3 // sincospols = psc1 + msc3 // pols = sincospols * // <S_hi * r^2 | (C_hl + sigma) * r^3> // // 4. CORRECTION TERM // // This is where the "c" component of the range reduction is // taken into account; recall that just "r" is used for most of // the calculation. // // -c = m_3 - c_2 // -d = S_hi * r - (C_hl + sigma) // corr = -c * -d + S_lo // // 5. COMPENSATED SUMMATIONS // // The two successive compensated summations add up the high // and medium parts, leaving just the low parts to add up at // the end. // // rs = sigma * r // res_int = S_hi + rs // k_0 = S_hi - res_int // k_2 = k_0 + rs // med = C_hl * r // res_hi = res_int + med // k_1 = res_int - res_hi // k_3 = k_1 + med // // 6. FINAL SUMMATION // // We now add up all the small parts: // // res_lo = pols(hi) + pols(lo) + corr + k_1 + k_3 // // Now the overall result is just: // // res_hi + res_lo // // 7. SMALL ARGUMENTS // // Inputs with |X| < 2^-252 are treated specially as // 1 - |x|. // // Special cases: // cos(NaN) = quiet NaN, and raise invalid exception // cos(INF) = NaN and raise invalid exception // cos(0) = 1 // /******************************************************************************/ #define __ _masm->this , "StubRoutines" , "libmCos" );_0_1;_0_1;11_0_1;// required for proper stackwalking of RuntimeStub frame #ifdef _WIN64#endif 16 );8 ), xmm0);12 ));/*rscratch*/); //0x6dc9c883UL, 0x40245f30UL 2147418112 );808452096 );281346048 );/*rscratch*/); //0x00000000UL, 0x3fe00000UL, 0x00000000UL, 0x3fe00000UL /*rscratch*/); //0x00000000UL, 0x80000000UL /*rscratch*/); //0x1a600000UL, 0x3d90b461UL, 0x1a600000UL, 0x3d90b461UL /*rscratch*/); //0x54400000UL, 0x3fb921fbUL 1865232 );63 );/*rscratch*/); //0xa556c734UL, 0x3ec71de3UL, 0x1a01a01aUL, 0x3efa01a0UL 5 );/*rscratch*/); //0x2e037073UL, 0x3b63198aUL 8 ));/*rscratch*/); //0x11111111UL, 0x3f811111UL, 0x55555555UL, 0x3fa55555UL 0 ));24 ));/*rscratch*/); //0x1a01a01aUL, 0xbf2a01a0UL, 0x16c16c17UL, 0xbf56c16cUL 0 ));/*rscratch*/); //0x55555555UL, 0xbfc55555UL, 0x00000000UL, 0xbfe00000UL 8 ));8 ));16 ));3 );32767 );3 );/*rscratch*/); // 0x00000000UL, 0x3ff00000UL 3 );32752 );32752 );3 );32752 );16224 );7 );65532 );20 ));24 ));21 );11 );16 ));12 ));32 );32 );32 );32 );32 );8 ));4 ));32 );32 );32 );32 );32 );0 ));32 );32 );3 );19 );32768 );4 );2047 );1023 );32 );1 );29 );536870911 );268435456 );0 );32 );0 );29 );64 );1 );4 );16368 );3 );/*rscratch*/); //0x40000000UL, 0x3fe921fbUL, 0x18469899UL, 0x3e64442dUL 8 ), rbx /*rscratch*/); //0x3fe921fbUL, 0x18469899UL, 0x3e64442dUL 1008 );3 );16 );31 );29 );/*rscratch*/); //0x6dc9c883UL, 0x40245f30UL /*rscratch*/); //0x00000000UL, 0x3fe00000UL, 0x00000000UL, 0x3fe00000UL /*rscratch*/); //0x00000000UL, 0x80000000UL /*rscratch*/); //0x54400000UL, 0x3fb921fbUL /*rscratch*/); //0x1a600000UL, 0x3d90b461UL, 0x1a600000UL, 0x3d90b461UL 3 );1865232 );63 );/*rscratch*/); //0xa556c734UL, 0x3ec71de3UL, 0x1a01a01aUL, 0x3efa01a0UL 5 );/*rscratch*/); //0x2e037073UL, 0x3b63198aUL 8 ));0 ));24 ));/*rscratch*/); //0x11111111UL, 0x3f811111UL, 0x55555555UL, 0x3fa55555UL /*rscratch*/); //0x1a01a01aUL, 0xbf2a01a0UL, 0x16c16c17UL, 0xbf56c16cUL 0 ));/*rscratch*/); //0x55555555UL, 0xbfc55555UL, 0x00000000UL, 0xbfe00000UL 8 ));8 ));16 ));64 );0 );0 );64 );0 );64 );32 );0 );3 );536870912 );32 );32 );536870912 );0 );0 );32768 );0 x100000000);0 );0 );32768 );3 );536870912 );8 ));/*rscratch*/); //0x00000000UL, 0x80000000UL 0 ), xmm0);16 );#ifdef _WIN64#endif // required for proper stackwalking of RuntimeStub frame 0 );return start;#undef __
Messung V0.5 in Prozent C=97 H=99 G=97
¤ Dauer der Verarbeitung: 0.10 Sekunden
(vorverarbeitet am 2026-06-10)
¤ *© Formatika GbR, Deutschland
