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