Lines Matching refs:X
5191 fmov.x %fp0,X(%a6) # X IS R
5203 eor.l %d1,X(%a6) # X IS NOW R'= SGN*R
5230 fadd.x X(%a6),%fp0 # last inst - possible exception set
5287 fmul.x X(%a6),%fp0
5298 #--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.
5299 #--IF |X| < 2**(-40), RETURN X OR 1.
5316 fmov.x X(%a6),%fp0 # last inst - possible exception set
5327 #--SIN(X) = X FOR DENORMALIZED X
5333 #--COS(X) = 1 FOR DENORMALIZED X
5346 fmov.x %fp0,X(%a6)
5350 and.l &0x7FFFFFFF,%d1 # COMPACTIFY X
5352 cmp.l %d1,&0x3FD78000 # |X| >= 2**(-40)?
5357 cmp.l %d1,&0x4004BC7E # |X| < 15 PI?
5362 #--THIS IS THE USUAL CASE, |X| <= 15 PI.
5367 fmul.d TWOBYPI(%pc),%fp1 # X*2/PI
5377 fsub.x (%a1)+,%fp0 # X-Y1
5378 fsub.s (%a1),%fp0 # FP0 IS R = (X-Y1)-Y2
5457 fadd.x RPRIME(%a6),%fp1 # COS(X)
5459 fadd.s POSNEG1(%a6),%fp0 # SIN(X)
5530 fadd.s POSNEG1(%a6),%fp1 # COS(X)
5532 fadd.x RPRIME(%a6),%fp0 # SIN(X)
5552 fmov.x X(%a6),%fp0
5558 #--SIN AND COS OF X FOR DENORMALIZED X
5605 #--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.
5626 #--THAT INT( X * (2/PI) / 2**(L) ) < 2**29.
5639 fmul.x FP_SCR0(%a6),%fp2 # fp2 = X * 2**(-L)*(2/PI)
6151 # fp0 = arctan(X) #
6160 # Step 1. If |X| >= 16 or |X| < 1/16, go to Step 5. #
6162 # Step 2. Let X = sgn * 2**k * 1.xxxxxxxx...x. #
6165 # significant bits of X with a bit-1 attached at the 6-th #
6166 # bit position. Define u to be u = (X-F) / (1 + X*F). #
6173 # Step 5. If |X| >= 16, go to Step 7. #
6175 # Step 6. Approximate arctan(X) by an odd polynomial in X. Exit. #
6177 # Step 7. Define X' = -1/X. Approximate arctan(X') by an odd #
6178 # polynomial in X'. #
6336 set X,FP_SCR0
6337 set XDCARE,X+2
6338 set XFRAC,X+4
6339 set XFRACLO,X+8
6346 #--ENTRY POINT FOR ATAN(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
6389 mov.l &0x00000000,XFRACLO(%a6) # LOCATION OF X IS NOW F
6391 fmov.x %fp0,%fp1 # FP1 IS X
6392 fmul.x X(%a6),%fp1 # FP1 IS X*F, NOTE THAT X*F > 0
6393 fsub.x X(%a6),%fp0 # FP0 IS X-F
6394 fadd.s &0x3F800000,%fp1 # FP1 IS 1 + X*F
6395 fdiv.x %fp1,%fp0 # FP0 IS U = (X-F)/(1+X*F)
6402 mov.l %d1,%d2 # THE EXP AND 16 BITS OF X
6446 fadd.x ATANF(%a6),%fp0 # ATAN(X)
6450 #--|X| IS IN d0 IN COMPACT FORM. FP1, d0 SAVED.
6451 #--FP0 IS X AND |X| <= 1/16 OR |X| >= 16.
6453 bgt.w ATANBIG # I.E. |X| >= 16
6456 #--|X| <= 1/16
6457 #--IF |X| < 2^(-40), RETURN X AS ANSWER. OTHERWISE, APPROXIMATE
6458 #--ATAN(X) BY X + X*Y*(B1+Y*(B2+Y*(B3+Y*(B4+Y*(B5+Y*B6)))))
6459 #--WHICH IS X + X*Y*( [B1+Z*(B3+Z*B5)] + [Y*(B2+Z*(B4+Z*B6)] )
6460 #--WHERE Y = X*X, AND Z = Y*Y.
6468 fmul.x %fp0,%fp0 # FPO IS Y = X*X
6489 fmul.x X(%a6),%fp0 # X*Y
6493 fmul.x %fp1,%fp0 # X*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))])
6498 fadd.x X(%a6),%fp0
6502 #--|X| < 2^(-40), ATAN(X) = X
6506 fmov.x X(%a6),%fp0 # last inst - possible exception set
6511 #--IF |X| > 2^(100), RETURN SIGN(X)*(PI/2 - TINY). OTHERWISE,
6512 #--RETURN SIGN(X)*PI/2 + ATAN(-1/X).
6516 #--APPROXIMATE ATAN(-1/X) BY
6517 #--X'+X'*Y*(C1+Y*(C2+Y*(C3+Y*(C4+Y*C5)))), X' = -1/X, Y = X'*X'
6519 #--X'+X'*Y*( [C1+Z*(C3+Z*C5)] + [Y*(C2+Z*C4)] ), Z = Y*Y.
6529 fmul.x %fp0,%fp0 # FP0 IS Y = X'*X'
6530 fmov.x %fp1,X(%a6) # X IS REALLY X'
6552 fmul.x %fp1,%fp0 # X'*Y*([B1+Z*(B3+Z*B5)]
6646 #--THIS IS THE USUAL CASE, |X| < 1
6647 #--ASIN(X) = ATAN( X / SQRT( (1-X)(1+X) ) )
6651 fsub.x %fp0,%fp1 # 1-X
6654 fadd.x %fp0,%fp2 # 1+X
6655 fmul.x %fp2,%fp1 # (1+X)(1-X)
6657 fsqrt.x %fp1 # SQRT([1-X][1+X])
6658 fdiv.x %fp1,%fp0 # X/SQRT([1-X][1+X])
6659 fmovm.x &0x01,-(%sp) # save X/SQRT(...)
6660 lea (%sp),%a0 # pass ptr to X/SQRT(...)
6662 add.l &0xc,%sp # clear X/SQRT(...) from stack
6666 fabs.x %fp0 # |X|
6670 #--|X| = 1, ASIN(X) = +- PI/2.
6674 and.l &0x80000000,%d1 # SIGN BIT OF X
6676 mov.l %d1,-(%sp) # push SIGN(X) IN SGL-FMT
6681 #--|X| < 2^(-40), ATAN(X) = X
6689 #--ASIN(X) = X FOR DENORMALIZED X
6702 # fp0 = arccos(X) #
6713 # 1. If |X| >= 1, go to 3. #
6715 # 2. (|X| < 1) Calculate acos(X) by #
6716 # z := (1-X) / (1+X) #
6717 # acos(X) = 2 * atan( sqrt(z) ). #
6720 # 3. If |X| > 1, go to 5. #
6722 # 4. (|X| = 1) If X > 0, return 0. Otherwise, return Pi. Exit. #
6724 # 5. (|X| > 1) Generate an invalid operation by 0 * infinity. #
6739 #--THIS IS THE USUAL CASE, |X| < 1
6740 #--ACOS(X) = 2 * ATAN( SQRT( (1-X)/(1+X) ) )
6744 fadd.x %fp0,%fp1 # 1+X
6745 fneg.x %fp0 # -X
6746 fadd.s &0x3F800000,%fp0 # 1-X
6747 fdiv.x %fp1,%fp0 # (1-X)/(1+X)
6748 fsqrt.x %fp0 # SQRT((1-X)/(1+X))
6753 bsr satan # ATAN(SQRT([1-X]/[1+X]))
6765 #--|X| = 1, ACOS(X) = 0 OR PI
6766 tst.b (%a0) # is X positive or negative?
6769 #--X = -1
6781 #--ACOS(X) = PI/2 FOR DENORMALIZED X
6980 # Step 2. Return ans := X + ans. Exit. #
6981 # Notes: This will return X with the appropriate rounding #
6987 # Step 1. Check |X| #
6988 # 1.1 If |X| >= 1/4, go to Step 1.3. #
6990 # 1.3 If |X| < 70 log(2), go to Step 2. #
6993 # However, it is conceivable |X| can be small very often #
6994 # because EXPM1 is intended to evaluate exp(X)-1 #
6995 # accurately when |X| is small. For further details on #
6998 # Step 2. Calculate N = round-to-nearest-int( X * 64/log2 ). #
6999 # 2.1 N := round-to-nearest-integer( X * 64/log2 ). #
7009 # Step 3. Calculate X - N*log2/64. #
7010 # 3.1 R := X + N*L1, #
7015 # shows that |R| <= 0.0055 (note that |X| <= 70 log2 in #
7046 # Step 6. Reconstruction of exp(X)-1 #
7047 # exp(X)-1 = 2^M * ( 2^(J/64) + p - 2^(-M) ). #
7058 # Step 7. exp(X)-1 for |X| < 1/4. #
7059 # 7.1 If |X| >= 2^(-65), go to Step 9. #
7062 # Step 8. Calculate exp(X)-1, |X| < 2^(-65). #
7063 # 8.1 If |X| < 2^(-16312), goto 8.3 #
7064 # 8.2 Restore FPCR; return ans := X - 2^(-16382). #
7066 # 8.3 X := X * 2^(140). #
7072 # the best we can. For |X| >= 2^(-16312), the #
7076 # Step 9. Calculate exp(X)-1, |X| < 1/4, by a polynomial #
7077 # p = X + X*X*(B1 + X*(B2 + ... + X*B12)) #
7083 # |p - (exp(X)-1)| < |X| 2^(-70.6) #
7084 # for all |X| <= 0.251. #
7088 # X + ( S*B1 + Q ) where S = X*X and #
7089 # Q = X*S*(B2 + X*(B3 + ... + X*B12)) #
7092 # Q = [ X*S*(B2 + S*(B4 + ... + S*B12)) ] + #
7095 # Step 10. Calculate exp(X)-1 for |X| >= 70 log 2. #
7096 # 10.1 If X >= 70log2 , exp(X) - 1 = exp(X) for all #
7098 # 10.2 If X <= -70log2, exp(X) - 1 = -1 for all practical #
7208 #--entry point for EXP(X), here X is finite, non-zero, and not NaN's
7706 # cosh(X) := Fact * exp(Y'). #
7821 # sinh(X) := sgnFact * exp(Y'). #
8122 # 1/2 <= X < 3/2. #
8306 set X,FP_SCR0
8307 set XDCARE,X+2
8308 set XFRAC,X+4
8318 #--ENTRY POINT FOR LOG(X) FOR X FINITE, NON-ZERO, NOT NAN'S
8435 fsub.s one(%pc),%fp1 # FP1 IS X-1
8436 fadd.s one(%pc),%fp0 # FP0 IS X+1
8437 fadd.x %fp1,%fp1 # FP1 IS 2(X-1)
8438 #--LOG(X) = LOG(1+U/2)-LOG(1-U/2) WHICH IS AN ODD POLYNOMIAL
8439 #--IN U, U = 2(X-1)/(X+1) = FP1/FP0
8486 #--ENTRY POINT FOR LOG(X) FOR DENORMALIZED INPUT
8513 mov.l %d3,X(%a6)
8518 fmov.x X(%a6),%fp0
8520 lea X(%a6),%a0
8521 bra.w LOGBGN # begin regular log(X)
8535 mov.l %d3,X(%a6)
8540 fmov.x X(%a6),%fp0
8542 lea X(%a6),%a0
8543 bra.w LOGBGN # begin regular log(X)
8546 #--ENTRY POINT FOR LOG(1+X) FOR X FINITE, NON-ZERO, NOT NAN'S
8946 # 2**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r). #
8959 # r := ((X - N*L1)-N*L2) * L10 #
8962 # 10**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r). #
8981 # 1. Generate overflow by Huge * Huge if X > 0; otherwise, #
8985 # 1. Return 1 + X. #
9075 set X,FP_SCR0
9076 set XDCARE,X+2
9077 set XFRAC,X+4
9090 #--ENTRY POINT FOR 2**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
9180 fmov.s &0x3F800000,%fp0 # RETURN 1 + X
9187 #--ENTRY POINT FOR 10**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
9304 fmov.s &0x3F800000,%fp0 # RETURN 1 + X
9569 # a0 = pointer to double-extended source operand X #
9573 # fp0 = scale(X,Y) #
10076 #..R = 2^(-j)X - Q Y = Y, thus R = 0 and quotient = 2^j (Q+1)