// 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_ln.cpp

// Natural log.

// 

//

#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 ArtanhCoeffs[] =

	{

	0x5C17F0BC,0xB8AA3B29,0x80010000,	// polynomial approximation to (4/ln2)artanh(x)

	0xD02489EE,0xF6384EE1,0x7FFF0000,	// for |x| <= (sqr2-1)/(sqr2+1)

	0x7008CA5F,0x93BB6287,0x7FFF0000,

	0xE32D1D6B,0xD30BB16D,0x7FFE0000,

	0x461D071E,0xA4257CE2,0x7FFE0000,

	0xC3B0EC87,0x8650D459,0x7FFE0000,

	0x53BEC0CD,0xE23137E3,0x7FFD0000,

	0xC523F21B,0xDAF79221,0x7FFD0000

	};

LOCAL_D const TUint32 Ln2By2data[] = {0xD1CF79AC,0xB17217F7,0x7FFD0000};	// (ln2)/2

LOCAL_D const TUint32 Sqr2data[] = {0xF9DE6484,0xB504F333,0x7FFF0000};		// sqr2

LOCAL_D const TUint32 Sqr2Invdata[] = {0xF9DE6484,0xB504F333,0x7FFE0000};	// 1/sqr2

LOCAL_D const TUint32 Onedata[] = {0x00000000,0x80000000,0x7FFF0000};		// 1.0

EXPORT_C TInt Math::Ln(TReal& aTrg, const TReal& aSrc)

/**

Calculates the natural logarithm of a number.

@param aTrg A reference containing the result. 

@param aSrc The number whose natural logarithm is required.

@return KErrNone if successful, otherwise another of

        the system-wide error codes. 

*/

	{

	// Calculate ln(aSrc) and write to aTrg

	// Algorithm:

	//		Calculate log2(aSrc) and multiply by ln2

	//		log2(aSrc)=log2(2^e.m) e=exponent of aSrc, m=mantissa 1<=m<2

	//		log2(aSrc)=e+log2(m)

	//		If e=-1 (0.5<=aSrc<1), let x=aSrc else let x=mantissa(aSrc)

	//		If x>Sqr2, replace x with x/Sqr2

	//		If x<Sqr2/2, replace x with x*Sqr2

	//		Replace x with (x-1)/(x+1)

	//		Use polynomial to calculate artanh(x) for |x| <= (sqr2-1)/(sqr2+1)

	//			( use identity ln(x) = 2artanh((x-1)/(x+1)) )

	TRealX x;

	const TRealX& Ln2By2=*(const TRealX*)Ln2By2data;

	const TRealX& Sqr2=*(const TRealX*)Sqr2data;

	const TRealX& Sqr2Inv=*(const TRealX*)Sqr2Invdata;

	const TRealX& One=*(const TRealX*)Onedata;

	TInt r=x.Set(aSrc);

	if (r==KErrNone)

		{

		if (x.iExp==0)

			{

			SetInfinite(aTrg,1);

			return KErrOverflow;

			}

		if (x.iSign&1)

			{

			SetNaN(aTrg);

			return KErrArgument;

			}

		TInt n=(x.iExp-0x7FFF)<<1;

		x.iExp=0x7FFF;

		if (n!=-2)

			{

			if (x>Sqr2)

				{

				x*=Sqr2Inv;

				n++;

				}

			}

		else 

			{

			n=0;

			x.iExp=0x7FFE;

			if (x<Sqr2Inv)

				{

				x*=Sqr2;

				n--;

				}

			}

		x=(x-One)/(x+One);	// ln(x)=2artanh((x-1)/(x+1))

		TRealX y;

		PolyX(y,x*x,7,(const TRealX*)ArtanhCoeffs);

		y*=x;

		y+=TRealX(n);

		y*=Ln2By2;

		return y.GetTReal(aTrg);

		}

	if (r==KErrArgument || (r==KErrOverflow && (x.iSign&1)))

		{

		SetNaN(aTrg);

		return KErrArgument;

		}

	SetInfinite(aTrg,0);

	return KErrOverflow;

	}

#else // __USE_VFP_MATH

// definitions come from RVCT math library

extern "C" TReal log(TReal);

EXPORT_C TInt Math::Ln(TReal& aTrg, const TReal& aSrc)

	{

	aTrg = log(aSrc);

	if (Math::IsFinite(aTrg))

		return KErrNone;

	if (Math::IsInfinite(aTrg))

		return KErrOverflow;

	SetNaN(aTrg);

	return KErrArgument;

	}

#endif