suggestion: math.mod

BlitzMax Forums/BlitzMax Module Tweaks/suggestion: math.mod

Red	(Posted 2005) [#1]

- GetDistance
- GetAngle

Takuan

(Posted 2005) [#2]

splines calculating stuff would be handy too...

Perturbatio

(Posted 2005) [#3]

here's a start:

Rem
bbdoc: returns the distance between two points in 2D space
about: return value is an absolute float
EndRem
Function GetDistance2D:Float(X1:Float, Y1:Float, X2:Float, Y2:Float)
	Local l1:float = Abs(x1-x2)
	Local l2:float = Abs(y1-y2)
	Return Sqr((l1*l1)+(l2*l2))
End Function

Rem
bbdoc: returns the distance between two points in 3D space
about: return value is an absolute float
EndRem
Function GetDistance3D:Float(X1:Float, Y1:Float, Z1:Float, X2:Float, Y2:Float, Z2:Float)
	Local l1:float = Abs(x1-x2)
	Local l2:float = Abs(y1-y2)
	Local l3:float = Abs(z1-z2)
	Return Sqr((l1*l1)+(l2*l2)+(l3*l3))
End Function

klepto2

(Posted 2005) [#4]

And here is something to get the 2d angle:


Rem
bbdoc: returns an angle between 0 and 360 degrees
about: return value is an Float
EndRem

Function GetAngle2D:Float(X1:Float,Y1:Float,X2:Float,Y2:Float)
         local dx# = x2 - x1
         local dy# = y2 - y1
         Return ATAN2(dy#,dx#)+360) MOD 360
End Function

Beaker

(Posted 2005) [#5]

Pert - why are you NOT using Floats/Doubles for your functions local variables?

N	(Posted 2005) [#6]

Friendly-friendly math code for peoples.

Import Brl.Math

Strict

Const RAD_TO_DEGREE! = 180!/Pi
Const DEGREE_TO_RAD! = Pi/180!

Function DegreeToRad!( d! )
	Return d*DEGREE_TO_RAD
End Function

Function RadToDegree!( r! )
	Return r*RAD_TO_DEGREE
End Function

Function Cotangent!( A! )
	Return Tan( 90! - A )
End Function

' Hackjob
Function NearestPower:Int( i:Int )
	Local q:Int,r:Int=1
	While Not ( i < r And i > q )
		q=r
		r=q*2
	Wend
	Local da:Int=i-q
	Local db:Int=r-i
	If da > db Then
		Return r
	Else
		Return q
	EndIf
End Function

'' Ports of Jeremy Allessi's old (public domain) code
Function Slope!( x1!, y1!, x2!, y2! )
	Local m! = ( y1-y2 )/( x1-x2 )
	If m <= .0001! And m > 0! Then Return .0001!
	If m >= -.0001! And m < 0! Then Return -.0001!
	Return m
End Function

Function YIntercept!( x1!, y1!, x2!, y2! )
	Return y1 - ( Slope( x1, y1, x2, y2 ) * x1 )
End Function

Function ReturnedY!( x!, x1!, y1!, x2!, y2! )
	Return Slope( x1, y1, x2, y2 ) * x + YIntercept( x1, y1, x2, y2 )
End Function

' 4x4 Matrix
Type Matrix
	Field m00# = 1, m01# = 0, m02# = 0, m03# = 0
	Field m10# = 0, m11# = 1, m12# = 0, m13# = 0
	Field m20# = 0, m21# = 0, m22# = 1, m23# = 0
	Field m30# = 0, m31# = 0, m32# = 0, m33# = 1
	
	Method Copy:Matrix( )
		Local i:Matrix = New Matrix
		MemCopy( Varptr i.m00, Varptr m00, 64 )
		Return i
	End Method
	
	Method Translate( x#, y#, z# )
		m03 = x
		m13 = y
		m23 = z
	End Method
	
	Method Scale( x#, y#, z# )
		m00 :* x
		m10 :* x
		m20 :* x
		
		m01 :* y
		m11 :* y
		m21 :* y
		
		m02 :* z
		m12 :* z
		m22 :* z
	End Method
	
	Method TransformMat:Matrix( i:Matrix )
		Local r:Matrix = New Matrix
		
		r.m00 = m00 * i.m00 + m01 * i.m10 + m02 * i.m20 + m03 * i.m30
		r.m01 = m00 * i.m01 + m01 * i.m11 + m02 * i.m21 + m03 * i.m31
		r.m02 = m00 * i.m02 + m01 * i.m12 + m02 * i.m22 + m03 * i.m32
		r.m03 = m00 * i.m03 + m01 * i.m13 + m02 * i.m23 + m03 * i.m33
		
		r.m10 = m10 * i.m00 + m11 * i.m10 + m12 * i.m20 + m13 * i.m30
		r.m11 = m10 * i.m01 + m11 * i.m11 + m12 * i.m21 + m13 * i.m31
		r.m12 = m10 * i.m02 + m11 * i.m12 + m12 * i.m22 + m13 * i.m32
		r.m13 = m10 * i.m03 + m11 * i.m13 + m12 * i.m23 + m13 * i.m33
		
		r.m20 = m20 * i.m00 + m21 * i.m10 + m22 * i.m20 + m23 * i.m30
		r.m21 = m20 * i.m01 + m21 * i.m11 + m22 * i.m21 + m23 * i.m31
		r.m22 = m20 * i.m02 + m21 * i.m12 + m22 * i.m22 + m23 * i.m32
		r.m23 = m20 * i.m03 + m21 * i.m13 + m22 * i.m23 + m23 * i.m33
		
		r.m30 = m30 * i.m00 + m31 * i.m10 + m32 * i.m20 + m33 * i.m30
		r.m31 = m30 * i.m01 + m31 * i.m11 + m32 * i.m21 + m33 * i.m31
		r.m32 = m30 * i.m02 + m31 * i.m12 + m32 * i.m22 + m33 * i.m32
		r.m33 = m30 * i.m03 + m31 * i.m13 + m32 * i.m23 + m33 * i.m33
		
		Return r
	End Method
	
	Method TransformVec:Vector( i:Vector )
		Local r:Vector = New Vector
		Local w# = 1.0/( m30 + m31 + m32 + m33 )
		
		r.x = ( ( m00*i.x ) + ( m01*i.y ) + ( m02*i.z ) + m03 ) * w
		r.y = ( ( m10*i.x ) + ( m11*i.y ) + ( m12*i.z ) + m13 ) * w
		r.z = ( ( m20*i.x ) + ( m21*i.y ) + ( m22*i.z ) + m23 ) * w
		
		Return r
	End Method
	
	Method Add:Matrix( i:Matrix )
		Local a:Float Ptr = GetPtr( )
		Local b:Float Ptr = GetPtr( )
		Local r:Matrix = New Matrix
		Local c:Float Ptr = r.GetPtr( )
		For Local n:Int = 0 To 15
			c[n]=a[n]+b[n]
		Next
		Return r
	End Method
	
	Method Subtract:Matrix( i:Matrix )
	 Local a:Float Ptr = GetPtr( )
		Local b:Float Ptr = GetPtr( )
		Local r:Matrix = New Matrix
		Local c:Float Ptr = r.GetPtr( )
		For Local n:Int = 0 To 15
			c[n]=a[n]-b[n]
		Next
		Return r
	End Method
	
	Method Transpose:Matrix( )
	 Local x:Int,y:Int
	 Local r:Matrix = New Matrix
	 Local a:Float Ptr = GetPtr( )
	 Local b:Float Ptr = r.GetPtr( )
	 For x = 0 To 3
		 For y = 0 To 3
			 b[x*4+y] = a[y*4+x]
		 Next
	 Next
	 Return r
	End Method
	
	Method GetPtr:Float Ptr( )
		Return Varptr m00
	End Method
	
	Method ToArray:Float[]( )
		Local r:Float[16]
		MemCopy( Varptr r[0], GetPtr( ), 64 )
		Return r
	End Method
	
	Function FromArray:Matrix( arr:Float[] )
		Return FromPtr( Varptr arr[0] )
	End Function
	
	Function FromPtr:Matrix( arr:Float Ptr )
		Local r:Matrix = New Matrix
		Local p:Float Ptr = r.GetPtr( )
		MemCopy( p, arr, 64 )
		Return r
	End Function
End Type

Type Vector
	Field x#,y#,z#
	
	Method Add:Vector( i:Vector )
		Local r:Vector = New Vector
		r.x = x+i.x
		r.y = y+i.y
		r.z = z+i.z
		Return r
	End Method
	
	Method Subtract:Vector( i:Vector )
		Local r:Vector = New Vector
		r.x = x-i.x
		r.y = y-i.y
		r.z = z-i.z
		Return r
	End Method
	
	Method Multiply:Vector( i:Vector )
		Local r:Vector = New Vector
		r.x = x*i.x
		r.y = y*i.y
		r.z = z*i.z
		Return r
	End Method
	
	Method Divide:Vector( i:Vector )
		Local r:Vector = New Vector
		r.x = x/i.x
		r.y = y/i.y
		r.z = z/i.z
		Return r
	End Method
	
	Method Scale:Vector( i:Float )
		Local r:Vector = New Vector
		r.x = x*i
		r.y = y*i
		r.z = z*i
		Return r
	End Method
	
	Method Dot:Float( i:Vector )
		Return x*i.x+y*i.y+z*i.z
	End Method
	
	Method Magnitude:Float( )
		Return Sqr( x*x + y*y + z*z )
	End Method
	
	Method Normalize( )
		Local s:Float = 1.0 / Magnitude( )
		x:*s
		y:*s
		z:*s
	End Method
	
	Method Cross:Vector( i:Vector )
		Local r:Vector = New Vector
		r.x = y*i.z - z*i.y
		r.y = x*i.z - z*i.x
		r.z = x*i.y - y*i.x
	End Method
	
	Method Reflect:Vector( i:Vector )
		Local f:Float = 2*Dot( i )
		Return Subtract( i.Scale( f ) )
	End Method
	
	Method RotationTo:Quat( dest:Vector )
		' Based on the Axiom engine's Vector3.GetRotationTo method code
		' Which is in turn based on Stan Melax's article in Game Programming Gems
		Local q:Quat = New Quat
		
		Local v0:Vector = Vector.Create( x, y, z )
		Local v1:Vector = New Vector
	 
		Local c:Vector = v0.Cross( v1 )
		Local d:Float = v0.Dot( v1 )
		
		If d >= 1.0 Then Return New Quat
	 
		Local s:Float = Sqr( ( 1+d ) * 2 )
		Local inverse:Float = 1.0 / s
		
		q.x = c.x * inverse
		q.y = c.y * inverse
		q.z = c.z * inverse
		q.w = s*.5
	 
		Return q
	End Method
	
	Method Floor( i:Vector )
		If i.x < x Then x = i.x
		If i.y < y Then y = i.y
		If i.z < z Then z = i.z
	End Method
	
	Method Ceil( i:Vector )
		If i.x > x Then x = i.x
		If i.y > y Then y = i.y
		If i.z > z Then z = i.z
	End Method
	
	Method GetPtr:Float Ptr( )
		Return Varptr x
	End Method
	
	Method ToArray:Float[]( )
		Local r:Float[3]
		MemCopy( Varptr r[0], GetPtr( ), 12 )
		Return r
	End Method
	
	Method Copy:Vector( )
		Local i:Vector = New Vector
		MemCopy( i.GetPtr( ), GetPtr( ), 12 )
		Return i
	End Method
	
	Function Create:Vector( x#, y#, z# )
		Local i:Vector = New Vector
		i.x = x
		i.y = y
		i.z = z
		Return i
	End Function
	
	Function FromArray:Vector( arr:Float[] )
		Return FromPtr( Varptr arr[0] )
	End Function
	
	Function FromPtr:Vector( arr:Float Ptr )
		Local r:Vector = New Vector
		Local p:Float Ptr = r.GetPtr( )
		MemCopy( p, arr, 12 )
		Return r
	End Function
End Type

'' A lot of code in this class is based off of that in Axiom
Type Quat
	Field w#=1,x#=0,y#=0,z#=0
	
	Method Magnitude:Float( )
		Return Sqr( w*w + x*x + y*y + z*z )
	End Method
	
	Method Normalize( )
		Local s:Float = 1.0 / Magnitude( )
		w:*s
		x:*s
		y:*s
		z:*s
	End Method
	
	Method MultiplyQuat:Quat( i:Quat )
		Local r:Quat = New Quat
		
		r.w = w*i.w - x*i.x - y*i.y - z*i.z
		r.x = w*i.x - x*i.w - y*i.z - z*i.y
		r.y = w*i.y - y*i.w - z*i.x - x*i.z
		r.z = w*i.z - z*i.w - x*i.y - y*i.x
		
		Return r
	End Method
	
	Method MultiplyVec:Vector( i:Vector )
		Local a:Vector,b:Vector,c:Vector=Vector.FromArray( [x,y,z] )
		a=c.Cross( i )
		b=c.Cross( a )
		a.Scale( 2*w )
		b.Scale( 2 )
		
		Return i.Add( a.Add( b ) )
	End Method
	
	Method Scale:Quat( f:Float )
		Local r:Quat = New Quat
		r.w = w*f
		r.x = x*f
		r.y = y*f
		r.z = z*f
		Return r
	End Method
	
	Method Add:Quat( i:Quat )
		Local r:Quat = New Quat
		r.w = w+i.w
		r.x = x+i.x
		r.y = y+i.y
		r.z = z+i.z
		Return r
	End Method
	
	Method Subtract:Quat( i:Quat )
		Local r:Quat = New Quat
		r.w = w+i.w
		r.x = x+i.x
		r.y = y+i.y
		r.z = z+i.z
		Return r
	End Method
	
	Method Dot:Float( i:Quat )
		Return w*i.w + x*i.x + y*i.y + z*i.z
	End Method
	
	Function Slerp:Quat( time:Float, a:Quat, b:Quat, useShortest = False )
		' Based off of code in Axiom
		Local cs:Float = a.Dot( b )
		Local angle:Float = ACos( cs )
		
		If Abs(angle) < .0001 Then Return a.Copy( )
		
		Local sn:Float = Sin( angle )
		Local iSin:Float = 1.0/sn
		Local co1:Float = Sin( ( 1.0-time ) * angle ) * iSin
		Local co2:Float = Sin( time * angle ) * iSin
		
		Local r:Quat
		
		If cs < .0 And useShortest > 0 Then
			co1 = -co1
			r = a.Scale( co1 ).Add( b.Scale( co2 ) )
			r.Normalize( )
		Else
			r = a.Scale( co1 ).Add( b.Scale( co2 ) )
		EndIf
		
		Return r
	End Function
	
	Function FromAngleAxis:Quat( a:Float, ax:Vector )
		' Based off of code in Axiom
		Local r:Quat = New Quat
		
		Local ha:Float = .5*a
		Local sn:Float = Sin( ha )
		
		r.w = Cos( ha )
		r.x = sn*ax.x
		r.y = sn*ax.y
		r.z = sn*ax.z
		
		Return r
	End Function
	
	Function Squad:Quat( t:Float, p:Quat, a:Quat, b:Quat, q:Quat, useShortest = False )
		' Based off of code in Axiom
		Local time:Float = 2*t*( 1.0-t )
		
		Local slerpA:Quat = Slerp( t, p, q, useShortest )
		Local slerpB:Quat = Slerp( t, a, b )
		
		Return Slerp( time, slerpA, slerpB )
	End Function
	
	Method ToAngleAxis( angle:Float Var, ax:Vector Var )
		' Based off of code in Axiom
		Local sqrLen:Float = x*x + y*y + z*z
		
		If sqrLen > 0 Then
			angle = 2 * ACos( w )
			Local invLength:Float = 1.0 / Sqr( sqrLen )
			ax.x = x * invLength
			ax.y = y * invLength
			ax.z = z * invLength
		Else
			angle = 0
			ax.x = 1
			ax.y = 0
			ax.z = 0
		EndIf
	End Method
	
	Method ToMatrix:Matrix( )
		' Based off of code in Axiom
		Local m:Matrix = New Matrix
		
		Local tx# = 2*x
		Local ty# = 2*y
		Local tz# = 2*z
		Local twx# = tx*w
		Local twy# = ty*w
		Local twz# = tz*w
		Local txx# = tx*x
		Local txy# = ty*x
		Local txz# = tz*x
		Local tyy# = ty*y
		Local tyz# = tz*y
		Local tzz# = tz*z
		
		m.m00 = 1.0-(tyy+tzz)
		m.m01 = txy-twz
		m.m02 = txz+twy
		m.m10 = txy+twz
		m.m11 = 1.0-(txx+tzz)
		m.m12 = tyz-twx
		m.m20 = txz-twy
		m.m21 = tyz+twx
		m.m22 = 1.0-(txx+tyy)
		
		Return m
	End Method
	
	Method Inverse:Quat( )
		Local norm:Float = Dot( Self )
		If norm > 0 Then
			Local r:Quat = New Quat
			Local inorm:Float = 1.0 / norm
			r.w = w * inorm
			r.x = -x * inorm
			r.y = -y * inorm
			r.z = -z * inorm
			Return r
		EndIf
		
		Return Quat.Zero( )
	End Method
	
	Method ToAxes( xAxis:Vector Var, yAxis:Vector Var, zAxis:Vector Var )
		xAxis = New Vector
		yAxis = New Vector
		zAxis = New Vector
		
		Local rot:Matrix = ToMatrix( )
		
		xAxis.x = rot.m00
		xAxis.y = rot.m10
		xAxis.z = rot.m20
		
		yAxis.x = rot.m01
		yAxis.y = rot.m11
		yAxis.z = rot.m21
		
		zAxis.x = rot.m02
		zAxis.y = rot.m12
		zAxis.z = rot.m22
	End Method
	
	Method FromAxes( xAxis:Vector, yAxis:Vector, zAxis:Vector )
		Local rot:Matrix = New Matrix
		
		rot.m00 = xAxis.x
		rot.m10 = xAxis.y
		rot.m20 = xAxis.z
		
		rot.m01 = yAxis.x
		rot.m11 = yAxis.y
		rot.m21 = yAxis.z
		
		rot.m02 = zAxis.x
		rot.m12 = zAxis.y
		rot.m22 = zAxis.z
		
		Local q:Quat = FromRotationMatrix( rot )
		MemCopy( GetPtr( ), q.GetPtr( ), 16 )
	End Method
	
	Function FromRotationMatrix:Quat( mat:Matrix )
		Local this:Quat = New Quat
		
		Local trace:Float = mat.m00 + mat.m11 + mat.m22
		Local root:Float = 0
		
		If trace > 0 Then
			root = Sqr( trace + 1 )
			this.w = .5 * root
			root = .5 / root
			this.x = ( mat.m21-mat.m12 ) * root
			this.y = ( mat.m02-mat.m20 ) * root
			this.z = ( mat.m10-mat.m01 ) * root
		Else
			Local p:Float Ptr = mat.GetPtr( )
			Local i:Int = 0
			If mat.m11 > mat.m00 Then i=1
			If mat.m22 > p[i*4+i] Then i=2
			
			Local j:Int = _next( i )
			Local k:Int = _next( j )
			
			root = Sqr( p[i*4+i] - p[j*4+j] - p[k*4+k] + 1.0 )
			
			Local aq:Float Ptr = this.GetPtr( )
			aq[i] = .5 * root
			this.w = .5 / root
			aq[j] = (p[j+i*4] + p[i+j*4])*root
			aq[k] = (p[k+i*4] + p[i+k*4])*root
		EndIf
		
		Return this
		
		Function _next( i:Int )
			Select i
				Case 0
					Return 1
				Case 1
					Return 2
				Case 2
					Return 0
			End Select
		End Function
	End Function
	
	Method Log:Quat( )
		Local r:Quat = Quat.Zero( )
		If Abs( w ) < 1.0 Then
			Local angle:Float = ACos( w )
			Local sn:Float = Sin( angle )
			
			If Abs( sn ) > .0001 Then
				Local co:Float = angle / sn
				r.x = co*x
				r.y = co*y
				r.z = co*z
			Else
				r.x = x
				r.y = y
				r.z = z
			EndIf
		EndIf
		
		Return r
	End Method
	
	Function Zero:Quat( )
		Return Create( 0, 0, 0, 0 )
	End Function
	
	Function Create:Quat( w# = 1, x# = 0, y# = 0, z# = 0 )
		Local r:Quat = New Quat
		r.w = w; r.x = x; r.y = y; r.z = z
		Return r
	End Function
	
	Method ToArray:Float[]( )
		Local r:Float[4]
		MemCopy( Varptr r[0], GetPtr( ), 16 )
		Return r
	End Method
	
	Method GetPtr:Float Ptr( )
		Return Varptr w
	End Method
	
	Function FromArray:Quat( arr:Float[] )
		Return FromPtr( Varptr arr[0] )
	End Function
	
	Function FromPtr:Quat( arr:Float Ptr )
		Local r:Quat = New Quat
		MemCopy( r.GetPtr( ), arr, 16 )
		Return r
	End Function
	
	Method Copy:Quat( )
		Local r:Quat = New Quat
		MemCopy( r.GetPtr( ), GetPtr( ), 16 )
		Return r
	End Method
End Type

Type Plane
	Field norm:Vector, d#
	
	Method New( )
		norm = Vector.Create( 0, 1, 0 )
		d = 1
	End Method
	
	Method Distance#( p:Vector )
		Return norm.Dot( p ) + d
	End Method
	
	Method Side( p:Vector )
		Local di:Float = Distance( p )
		
		If di > 0 Then
			Return 1
		ElseIf di < 0 Then
			Return -1
		EndIf
		Return 0
	End Method
	
	Method GetNormal:Vector( )
		Return norm.Copy( )
	End Method
	
	Function Create:Plane( normal:Vector, d# )
		Local i:Plane = New Plane
		i.norm = normal.Copy( )
		i.d = d
		Return i
	End Function
	
	Function FromArray:Plane( arr:Float[] )
		Return FromPtr( Varptr arr[0] )
	End Function
	
	Function FromPtr:Plane( arr:Float Ptr )
		Local i:Plane = New Plane
		i.norm = Vector.FromPtr( arr )
		i.d = arr[3]
		Return i
	End Function
	
	'' Can't do a standard memory copy for Planes, as they have a Vector reference
	Method Copy:Plane( )
		Local i:Plane = New Plane
		i.d = d
		i.norm = norm.Copy( )
		Return i
	End Method
End Type

Type Rect
	Field x#, y#, w#, h#
	
	Method Intersects( other:Rect )
		If x > other.x+other.w Or..
			x+w < other.x Or..
			y > other.y+other.h Or..
			y+h < other.y Then Return 0
		Return 1
	End Method
	
	Method PointInside( p:Point )
		If p.x < x+w And p.y < y+h And p.x > x And p.y > y Then Return 1
		Return 0
	End Method
End Type

' AKA Vector2
'' I didn't include the extras like FromPtr/FromArray/etc. since
'' this is only a 2-component vector.	Use Create if you need a new one.
Type Point
	Field x#, y#
	
	Method Magnitude#( )
		Return Sqr( x*x + y*y )
	End Method
	
	Method Subtract:Point( i:Point )
		Return Create( x-i.x, y-i.y )
	End Method
	
	Method Add:Point( i:Point )
		Return Create( x+i.x, y+i.y )
	End Method
	
	Method Multiply:Point( i:Point )
		Return Create( x*i.x, y*i.y )
	End Method
	
	Method Divide:Point( i:Point )
		Return Create( x/i.x, y/i.y )
	End Method
	
	Function Create:Point( x#, y# )
		Local i:Point = New Point
		i.x = x
		i.y = y
		Return i
	End Function
	
	Method Copy:Point( )
		Return Create( x, y )
	End Method
End Type

Garred

(Posted 2005) [#7]

Maybe this is wrong:

Type Quat
...
	Method MultiplyQuat:Quat( i:Quat )
		Local r:Quat = New Quat
		
		r.w = w*i.w - x*i.x - y*i.y - z*i.z
		r.w = w*i.x - x*i.w - y*i.z - z*i.y
		r.w = w*i.y - y*i.w - z*i.x - x*i.z
		r.w = w*i.z - z*i.w - x*i.y - y*i.x
		
		Return r
	End Method
...
End Type

Why to redefine the same variable 4 times?

N	(Posted 2005) [#8]

Woops, forgot to write all the diferent stuff in :P

Red	(Posted 2005) [#9]

Thx dude

I hope they will be official commands