// 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