// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// e32\euser\maths\um_atan.cpp
// Floating point arc tangent
// 
//

#include "um_std.h"

#if defined(__USE_VFP_MATH) && !defined(__CPU_HAS_VFP)
#error	__USE_VFP_MATH was defined but not __CPU_HAS_VFP - impossible combination, check variant.mmh 
#endif

#ifndef __USE_VFP_MATH

LOCAL_D const TUint32 ArctanCoeffs[] =
	{
	0x00000000,0x80000000,0x7FFF0000,	// polynomial approximation to arctan(x)
	0xAA84D6EE,0xAAAAAAAA,0x7FFD0001,	// for -(sqr2-1) <= x <= (sqr2-1)
	0x89C77453,0xCCCCCCCC,0x7FFC0000,
	0xEBC0261C,0x9249247B,0x7FFC0001,
	0x940BC4DB,0xE38E3121,0x7FFB0000,
	0x141C32F1,0xBA2DBF36,0x7FFB0001,
	0xA90615E7,0x9D7C807E,0x7FFB0000,
	0x1C632E93,0x87F6A873,0x7FFB0001,
	0x310FCFFD,0xE8BE5D0A,0x7FFA0000,
	0x92289F15,0xB17B930B,0x7FFA0001,
	0x546FE7CE,0xABDE562D,0x7FF90000
	};

LOCAL_D const TUint32 Sqr2m1data[] = {0xE7799211,0xD413CCCF,0x7FFD0000};		// sqr2-1
LOCAL_D const TUint32 Sqr2p1data[] = {0xFCEF3242,0x9A827999,0x80000000};		// sqr2+1
LOCAL_D const TUint32 Onedata[] = {0x00000000,0x80000000,0x7FFF0000};			// 1.0
LOCAL_D const TUint32 PiBy8data[] = {0x2168C235,0xC90FDAA2,0x7FFD0000};			// pi/8
LOCAL_D const TUint32 PiBy2data[] = {0x2168C235,0xC90FDAA2,0x7FFF0000};			// pi/2
LOCAL_D const TUint32 ThreePiBy8data[] = {0x990E91A8,0x96CBE3F9,0x7FFF0000};	// 3*pi/8

LOCAL_C void Arctan(TRealX& y, TRealX& x)
	{
	// Calculate arctan(x), write result to y
	// Algorithm:
	//		If x>1, replace x with 1/x and subtract result from pi/2
	//			( use identity tan(pi/2-x)=1/tan(x) )
	//		If x>sqr(2)-1, replace x with (x-(sqr(2)-1))/(1-(sqr2-1)x)
	//			( use identity tan(x-a)=(tanx-tana)/(1-tana.tanx)
	//			  where a=pi/8, tan a = sqr2-1
	//			and add pi/8 to result
	//		Use polynomial approximation to calculate arctan(x) for
	//		x in the interval [0,sqr2-1]

	const TRealX& Sqr2m1 = *(const TRealX*)Sqr2m1data;
	const TRealX& Sqr2p1 = *(const TRealX*)Sqr2p1data;
	const TRealX& One = *(const TRealX*)Onedata;
	const TRealX& PiBy8 = *(const TRealX*)PiBy8data;
	const TRealX& PiBy2 = *(const TRealX*)PiBy2data;
	const TRealX& ThreePiBy8 = *(const TRealX*)ThreePiBy8data;

	TInt section=0;
	TInt8 sign=x.iSign;
	x.iSign=0;
	if (x>Sqr2p1)
		{
		x=One/x;
		section=3;
		}
	else if (x>One)
		{
		x=(One-Sqr2m1*x)/(x+Sqr2m1);
		section=2;
		}
	else if (x>Sqr2m1)
		{
		x=(x-Sqr2m1)/(One+Sqr2m1*x);
		section=1;
		}
	Math::PolyX(y,x*x,10,(const TRealX*)ArctanCoeffs);
	y*=x;
	if (section==1)
		y+=PiBy8;
	else if (section==2)
		y=ThreePiBy8-y;
	else if (section==3)
		y=PiBy2-y;
	y.iSign=sign;
	}




EXPORT_C TInt Math::ATan(TReal& aTrg, const TReal& aSrc)
/**
Calculates the principal value of the inverse tangent of a number.

@param aTrg A reference containing the result in radians,
            a value between -pi/2 and +pi/2.
@param aSrc The argument of the arctan function,
            a value between +infinity and +infinity.

@return KErrNone if successful, otherwise another of
        the system-wide error codes. 
*/
	{
	TRealX x;
	TInt r=x.Set(aSrc);
	if (r==KErrNone)
		{
		TRealX y;
		Arctan(y,x);
		return y.GetTReal(aTrg);
		}
	if (r==KErrArgument)
		{
		SetNaN(aTrg);
		return KErrArgument;
		}
	aTrg=KPiBy2;		// arctan(+/- infinity) = +/- pi/2
	if (x.iSign&1)
		aTrg=-aTrg;
	return KErrNone;
	}

LOCAL_D const TUint32 Pidata[] = {0x2168C235,0xC90FDAA2,0x80000000};
LOCAL_D const TUint32 PiBy4data[] = {0x2168C235,0xC90FDAA2,0x7FFE0000};
LOCAL_D const TUint32 MinusPiBy4data[] = {0x2168C235,0xC90FDAA2,0x7FFE0001};
LOCAL_D const TUint32 ThreePiBy4data[] = {0x990E91A8,0x96CBE3F9,0x80000000};
LOCAL_D const TUint32 MinusThreePiBy4data[] = {0x990E91A8,0x96CBE3F9,0x80000001};
LOCAL_D const TUint32 Zerodata[] = {0x00000000,0x00000000,0x00000000};




EXPORT_C TInt Math::ATan(TReal &aTrg,const TReal &aY,const TReal &aX)
/**
Calculates the angle between the x-axis and a line drawn from the origin
to a point represented by its (x,y) co-ordinates.

The co-ordinates are passed as arguments to the function.
This function returns the same result as arctan(y/x), but:

1. it adds +/-pi to the result, if x is negative

2. it sets the result to +/-pi/2, if x is zero but y is non-zero.

@param aTrg A reference containing the result in radians,
            a value between -pi exclusive and +pi inclusive.
@param aY   The y argument of the arctan(y/x) function. 
@param aX   The x argument of the arctan(y/x) function.

@return KErrNone if successful, otherwise another of
        the system-wide error codes. 
*/
	{
	const TRealX& Zero=*(const TRealX*)Zerodata;
	const TRealX& Pi=*(const TRealX*)Pidata;
	const TRealX& PiBy4=*(const TRealX*)PiBy4data;
	const TRealX& MinusPiBy4=*(const TRealX*)MinusPiBy4data;
	const TRealX& ThreePiBy4=*(const TRealX*)ThreePiBy4data;
	const TRealX& MinusThreePiBy4=*(const TRealX*)MinusThreePiBy4data;

	TRealX x, y;
	TInt rx=x.Set(aX);
	TInt ry=y.Set(aY);
	if (rx!=KErrArgument && ry!=KErrArgument)
		{
		if (x.iExp==0)
			x.iSign=0;
		TRealX q;
		TInt rq=y.Div(q,x);
		if (rq!=KErrArgument)
			{
			TRealX arg;
			Arctan(arg,q);
			if (x<Zero)
				{
				if (y>=Zero)
					arg+=Pi;
				else
					arg-=Pi;
				}
			aTrg=arg;
			return KErrNone;
			}
		if (!x.IsZero())
			{
			// Both x and y must be infinite
			TInt quadrant=((y.iSign & 1)<<1) + (x.iSign&1);
			TRealX arg;
			if (quadrant==0)
				arg=PiBy4;
			else if (quadrant==1)
				arg=ThreePiBy4;
			else if (quadrant==3)
				arg=MinusThreePiBy4;
			else
				arg=MinusPiBy4;
			aTrg=(TReal)arg;
			return KErrNone;
			}
		}
	SetNaN(aTrg);
	return KErrArgument;
	}

#else // __USE_VFP_MATH

LOCAL_D const TUint32 PiBy4data[] = {0x54442D18,0x3FE921FB};
LOCAL_D const TUint32 MinusPiBy4data[] = {0x54442D18,0xBFE921FB};
LOCAL_D const TUint32 ThreePiBy4data[] = {0x7F3321D2,0x4002D97C};
LOCAL_D const TUint32 MinusThreePiBy4data[] = {0x7F3321D2,0xC002D97C};

// definitions come from RVCT math library
extern "C" TReal atan(TReal);
extern "C" TReal atan2(TReal,TReal);

EXPORT_C TInt Math::ATan(TReal& aTrg, const TReal& aSrc)
	{
	aTrg = atan(aSrc);
	if (Math::IsFinite(aTrg))
		return KErrNone;
	SetNaN(aTrg);
	return KErrArgument;
	}

EXPORT_C TInt Math::ATan(TReal &aTrg,const TReal &aY,const TReal &aX)
	{
	aTrg = atan2(aY,aX);
	if (Math::IsFinite(aTrg))
		return KErrNone;
	
	// Return is a NaN, but ARM implementation returns NaN for atan(inf/inf)
	// whereas implementation above returns multiples of pi/4 - fix up here
	SReal64 *pY=(SReal64 *)&aY;
	SReal64 *pX=(SReal64 *)&aX;
	
	if (   pY->msm==0 && pY->lsm==0 && pY->exp==KTReal64SpecialExponent
		&& pX->msm==0 && pX->lsm==0 && pX->exp==KTReal64SpecialExponent)
		{
		TInt quadrant=((pY->sign)<<1) + (pX->sign);
		if (quadrant==0)
			aTrg=*(const TReal*)PiBy4data;
		else if (quadrant==1)
			aTrg=*(const TReal*)ThreePiBy4data;
		else if (quadrant==3)
			aTrg=*(const TReal*)MinusThreePiBy4data;
		else
			aTrg=*(const TReal*)MinusPiBy4data;
		return KErrNone;
		}

	// If we get here then the args weren't inf/inf so one of them must've
	// been a NaN to start with
	SetNaN(aTrg);
	return KErrArgument;
	}

#endif