.Map :: MoHAA Mapping

Code: Select all

//*****************************************************************//
//*This method is used to calculate a fast approximate square root*//
//*****************************************************************//
sqrt local.arg:

	if(local.arg == 1)
		end 1

	local.Xn = float(1)
	
	for(local.i = 1; local.i <= 100; local.i++)
	{
		local.v1 = float(local.Xn) / float(2)
		local.v2 = float(local.arg) / ( float(2) * float(local.Xn) )
		local.Xn = local.v1 + local.v2
	}
	
	local.return = local.Xn
	
end local.return

Code: Select all

// fast square-root
// only usuable near x=1
// McLaurin expansion
sqrt1 local.x:
end (1.0 + 0.5 * (local.x - 1.0) - 0.125 * (local.x - 1.0) * (local.x - 1.0))

// square-root
// more accurate than pow^.5
sqrt local.x:
	// sqrt(2)
	local.SQRT_2 = 1.4142135623730951

	// known values, how convenient
	if(local.x == 0.0)
	{
		local.result = 0.0
	}
	else if(local.x == 1.0)
	{
		local.result = 1.0
	}
	else if(local.x == 2.0)
	{
		local.result = local.SQRT_2
	}
	else if (local.x < 0.0)
	{
		// error
		println "ERROR[math::sqrt]: sqrt(" local.x ") has no real solution"
		local.result = 0.0
	}
	else
	{
		// reduce x to [1,2] domain
		local.wx = local.x
		local.steps = 0
		local.dividesteps = 0
		
		// reduce below 2.0
		while (local.wx > 2.0)
		{
			local.wx = 0.5 * local.wx
			local.steps++
		}
		
		// increase above 1.0
		while(local.wx < 1.0)
		{
			local.wx = 2.0 * local.wx
			local.dividesteps++
		}
		
		// evaluate in [1,2] domain
		if(local.wx == 1.0)
		{
			local.eval = 1.0
		}
		else if (local.wx == 2.0)
		{
			local.eval = local.SQRT_2
		}
		else
		{
			// approximation
			local.EVALSLOPE = 0.4267766953
			local.EVALMOD = 1.224744871 - 1.51 * local.EVALSLOPE
			local.eval = local.EVALSLOPE * local.wx + local.EVALMOD
		}
		
		// multiply back to original domain
		for(local.i = 1; local.i <= local.steps; local.i++)
		{
			local.eval = local.eval * local.SQRT_2
		}
		
		// divide back to original domain
		for(local.i = 1; local.i <= local.dividesteps; local.i++)
		{
			local.eval = local.eval / local.SQRT_2
		}
	
		// correct until required accuracy has been reached
		local.MAXREFINEMENTSTEPS = 2;

		for(local.i = 1; local.i <= local.MAXREFINEMENTSTEPS; local.i++)
		{
			local.fact = local.eval * local.eval / local.x
			local.eval = local.eval / (waitthread sqrt1 local.fact)
		}
		
		local.result = local.eval
	}
end local.result