GuShH's Development Blog » template http://gushh.net/blog This blog is about software, electronics and game development. Wed, 08 Sep 2010 03:02:37 +0000 en hourly 1 http://wordpress.org/?v=3.0.1 Average template http://gushh.net/blog/2009/08/05/average-template/ http://gushh.net/blog/2009/08/05/average-template/#comments Wed, 05 Aug 2009 12:16:52 +0000 GuShH http://gushh.net/blog/?p=161

A tiny template for averaging numbers.
I needed this for a prototype and I didn’t want to “wing it” anymore.

I think there should be a package with similar templates that people could download to enhance the language, I’m just saying… It takes little to come up with this kind of code and in the end it’s always useful to have it around.

Macro Average_Register( _type )
 
	Structure AVERAGE#_type
		sum._type
		average._type
		count.i
	EndStructure
 
	Procedure.i Average#_type#_Create()
		Define.AVERAGE#_type *this = AllocateMemory( SizeOf( AVERAGE#_type ) )
		ProcedureReturn *this
	EndProcedure
 
	Procedure.i Average#_type#_Destroy( *this.AVERAGE#_type )
		FreeMemory( *this )
		*this = #Null
	EndProcedure
 
	Procedure._type Average#_type#_Calculate( *this.AVERAGE#_type )
		If *this\count And *this\sum
			*this\average = ( *this\sum / *this\count )
			ProcedureReturn	*this\average
		EndIf
	EndProcedure
 
	Procedure.i Average#_type#_Reset( *this.AVERAGE#_type )
		*this\sum 	= 0.0
		*this\average 	= 0.0
		*this\count 	= 0
	EndProcedure
 
	Procedure.i Average#_type#_Add( *this.AVERAGE#_type, sample.f )
		*this\sum 	+ sample
		*this\count 	+ 1
	EndProcedure
 
	Procedure.i Average#_type#_Count( *this.AVERAGE#_type )
		ProcedureReturn *this\count
	EndProcedure
 
	Procedure._type Average#_type#_Sum( *this.AVERAGE#_type )
		ProcedureReturn *this\sum
	EndProcedure
 
	Procedure._type Average#_type#_Get( *this.AVERAGE#_type )
		ProcedureReturn *this\average
	EndProcedure
 
EndMacro

You may register it as any numerical type.
Usage example:

Average_Register( f ) ; register with floats.
Define.AVERAGEf test
 
Averagef_Add( test, 1.0 )
Averagef_Add( test, 2.0 )
Averagef_Add( test, 3.0 )
Averagef_Add( test, 4.0 )
Averagef_Add( test, 5.0 )
 
Debug Averagef_Calculate( test )
Debug Averagef_Count( test )
Debug Averagef_Sum( test )
 
Averagef_Reset( test )
 
Debug Averagef_Calculate( test )
Debug Averagef_Count( test )
Debug Averagef_Sum( test )

You can allocate an instance of the structure with the Create function.
For example, if you registered the template as float, then you may create a dynamic “object” in this way:

Define.AVERAGEf *test = Averagef_Create() ; the *test variable holds an instance of the AVERAGEf structure

Likewise, you should call the Destroy() function to get rid of it.

Averagef_Destroy( *test )

Trivial but useful. I’m not particularly happy with the naming convention though. But, let’s not forget that this is not an attempt at emulating OOP at all; it’s just a way of giving flexibility to an encapsulated piece of code. For OOP there are proper languages and there is no point whatsoever in trying to emulate it.

Cheers

]]> http://gushh.net/blog/2009/08/05/average-template/feed/ 0 Macro Templates, by example. http://gushh.net/blog/2009/07/13/macro-templates-by-example/ http://gushh.net/blog/2009/07/13/macro-templates-by-example/#comments Mon, 13 Jul 2009 16:46:50 +0000 GuShH http://gushh.net/blog/?p=114 Heres an example of what I call “macro templates” in PureBasic. A template encapsulates certain functionality, allowing you to dynamically generate the code in a flexible manner.

This example implements a bare-bones n-vector library using a structure and a static array:

Macro Vector_Register( _n, _type )
 
	Structure VECTOR#_n#_type
		vector._type[_n]
	EndStructure
 
	Procedure._type Vector#_n#_type#_Add( *r.VECTOR#_n#_type, *a.VECTOR#_n#_type, *b.VECTOR#_n#_type )
		Define.i i
		For i=0 To _n - 1
			*r\vector[i] = *a\vector[i] + *b\vector[i]
		Next
	EndProcedure
 
	Procedure._type Vector#_n#_type#_Subtract( *r.VECTOR#_n#_type, *a.VECTOR#_n#_type, *b.VECTOR#_n#_type )
		Define.i i
		For i=0 To _n - 1
			*r\vector[i] = *a\vector[i] - *b\vector[i]
		Next
	EndProcedure
 
	Procedure._type Vector#_n#_type#_Divide( *r.VECTOR#_n#_type, *a.VECTOR#_n#_type, *b.VECTOR#_n#_type )
		Define.i i
		For i=0 To _n - 1
			If *b\vector[i] <> 0.0 And *a\vector[i] <> 0.0
				*r\vector[i] = *a\vector[i] / *b\vector[i]
			EndIf
		Next
	EndProcedure
 
	Procedure._type Vector#_n#_type#_Multiply( *r.VECTOR#_n#_type, *a.VECTOR#_n#_type, *b.VECTOR#_n#_type )
		Define.i i
		For i=0 To _n - 1
			*r\vector[i] = *a\vector[i] * *b\vector[i]
		Next
	EndProcedure
 
	Procedure._type Vector#_n#_type#_DotProduct( *a.VECTOR#_n#_type, *b.VECTOR#_n#_type )
		Define.i i
		Define._type result
		For i=0 To _n - 1
			result + ( *a\vector[i] * *b\vector[i] )
		Next
		ProcedureReturn result
	EndProcedure
 
	Procedure._type Vector#_n#_type#_Length( *v.VECTOR#_n#_type )
		ProcedureReturn Sqr( Vector#_n#_type#_DotProduct( *v, *v ) )
	EndProcedure
 
	Procedure._type Vector#_n#_type#_Distance( *a.VECTOR#_n#_type, *b.VECTOR#_n#_type )
		Define.VECTOR#_n#_type temp
		Vector#_n#_type#_Subtract( temp, *a, *b )
		ProcedureReturn Vector#_n#_type#_Length( temp )
	EndProcedure
 
	Procedure.s Vector#_n#_type#_Debug( *v.VECTOR#_n#_type, Decimals.i=#PB_Default )
		Define.i i
		Define.s tmp = "["
		For i=0 To _n-1
			tmp + StrF( *v\vector[i], Decimals.i )
			If i <> _n-1
				tmp + ", "
			EndIf
		Next
		tmp + "]"
		Debug tmp
		ProcedureReturn tmp
	EndProcedure
 
EndMacro

It might look strange/complicated at first, but once you read it you’ll realize it’s fairly simple.

Let’s see the usage of this particular template:

Vector_Register(3, f )	; Register a float "vec3".
Define.VECTOR3f a,b,c	; Define a few vectors with the new structure.
 
a\vector[0] = 10.0
a\vector[1] = 20.0
a\vector[2] = 30.0
 
b\vector[0] = 100.0
b\vector[1] = 200.0
b\vector[2] = 300.0
 
Vector3f_Add(c, a, b)	; c = a + b
Vector3f_Debug(c)	; show each element using the debug output.
 
Debug Vector3f_DotProduct( a, b )
Debug Vector3f_Length( a )
Debug Vector3f_Distance( a, b )

Cool, huh?. And you can define any amount of elements with any basic type.

Of course we sacrificed speed for flexibility. In those cases where we have to define n-vectors, this would be an ideal solution. For everything else, I suggest a specific library, such as my vec3 macro lib.

Using this principle you can abstract almost anything, within reason. One good example is my object factory template.  Ideally one would have arrays, lists, etc. Implemented in this very same way, in such case the possibilities would be endless and you’d be able to define dynamic lists/arrays inside structures, etc.

I strongly advice you to implement at least one of those templates, even if it’s just for an exercise.

Having the extra tools can’t hurt!

Cheers.

]]> http://gushh.net/blog/2009/07/13/macro-templates-by-example/feed/ 0