// 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_exp.cpp
// Floating point exponentiation
// 
//

#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 ExpCoeffs[] =
	{
	0x00000000,0x80000000,0x7FFF0000,	// polynomial approximation to 2^(x/8)
	0xD1CF79AC,0xB17217F7,0x7FFB0000,	// for 0<=x<=1
	0x1591EF2B,0xF5FDEFFC,0x7FF60000,
	0x23B940A9,0xE35846B9,0x7FF10000,
	0xDD73C23F,0x9D955ADE,0x7FEC0000,
	0x8728EBE7,0xAEC4616C,0x7FE60000,
	0xAF177130,0xA1646F7D,0x7FE00000,
	0xC44EAC22,0x8542C46E,0x7FDA0000
	};

LOCAL_D const TUint32 TwoToNover8[] =
	{
	0xEA8BD6E7,0x8B95C1E3,0x7FFF0000,	// 2^0.125
	0x8DB8A96F,0x9837F051,0x7FFF0000,	// 2^0.250
	0xB15138EA,0xA5FED6A9,0x7FFF0000,	// 2^0.375
	0xF9DE6484,0xB504F333,0x7FFF0000,	// 2^0.500
	0x5506DADD,0xC5672A11,0x7FFF0000,	// 2^0.625
	0xD69D6AF4,0xD744FCCA,0x7FFF0000,	// 2^0.750
	0xDD24392F,0xEAC0C6E7,0x7FFF0000	// 2^0.875
	};

LOCAL_D const TUint32 EightLog2edata[] = {0x5C17F0BC,0xB8AA3B29,0x80020000};	// 8/ln2




EXPORT_C TInt Math::Exp(TReal& aTrg, const TReal& aSrc)
/**
Calculates the value of e to the power of x.

@param aTrg A reference containing the result. 
@param aSrc The power to which e is to be raised. 

@return KErrNone if successful, otherwise another of
        the system-wide error codes. 
*/	
	{
	// Calculate exp(aSrc) and write result to aTrg
	// Algorithm:
	//		Let x=aSrc/ln2 and calculate 2^x
	//		2^x = 2^int(x).2^frac(x)
	//		2^int(x) just adds int(x) to the final result exponent
	//		Reduce frac(x) to the range [0,0.125] (modulo 0.125)
	//		Use polynomial to calculate 2^x for 0<=x<=0.125
	//		Multiply by 2^(n/8) for n=0,1,2,3,4,5,6,7 to give 2^frac(x)

	const TRealX& EightLog2e=*(const TRealX*)EightLog2edata;

	TRealX x;
	TRealX y;
	TInt r=x.Set(aSrc);
	if (r==KErrNone)
		{
		x*=EightLog2e;
		TInt n=(TInt)x;
		if (n<16384 && n>-16384)
			{
			if (x.iSign&1)
				n--;
			x-=TRealX(n);
			PolyX(y,x,7,(const TRealX*)ExpCoeffs);
			y.iExp=TUint16(TInt(y.iExp)+(n>>3));
			n&=7;
			if (n)
				y*= (*(const TRealX*)(TwoToNover8+3*n-3));
			return y.GetTReal(aTrg);
			}
		else
			{
			if (n<0)
				{
				SetZero(aTrg);
				r=KErrUnderflow;
				}
			else
				{
				SetInfinite(aTrg,0);
				r=KErrOverflow;
				}
			return r;
			}
		}
	else
		{
		if (r==KErrArgument)
			SetNaN(aTrg);
		if (r==KErrOverflow)
			{
			if (x.iSign&1)
				{
				SetZero(aTrg);
				r=KErrUnderflow;
				}
			else
				{
				SetInfinite(aTrg,0);
				}
			}
		return r;
		}
	}

#else // __USE_VFP_MATH

// definitions come from RVCT math library
extern "C" TReal exp(TReal);

EXPORT_C TInt Math::Exp(TReal& aTrg, const TReal& aSrc)
	{
	aTrg = exp(aSrc);
	if (Math::IsZero(aTrg))
		return KErrUnderflow;
	if (Math::IsFinite(aTrg))
		return KErrNone;
	if (Math::IsInfinite(aTrg))
		return KErrOverflow;
	SetNaN(aTrg);
	return KErrArgument;
	}

#endif