gdalgorithms-list

[Algorithms] SIGGRAPH Deadlines

[Nathaniel H. <na...@io...>]

Although most of the SIGGRAPH submission deadlines are past, there are
still several of interest to people in this group.

The late-breaking deadline for talks and posters is the most relevant
(since that's where you would describe actual algorithms). That deadline
is on May 6; instructions on how to submit SIGGRAPH talks are here:
http://www.siggraph.org/s2010/for_submitters/talks. These are 20-minute
talks and are great for describing new graphics algorithms, as well as
practical game production tips and tricks.

Of more indirect relevance:

Live Real-Time Demos
(http://www.siggraph.org/s2010/for_submitters/live_real-time_demos) are
the real-time counterpart to the famous SIGGRAPH Electronic Theater. Your
entire team can show off their abilities by showing your game at Live
Real-Time Demos. The deadline is on April 28 and this submission probably
will take longer to approve at your studio than the others (since it
involves showing the entire game), so if you're interested you need to
move fast!

Finally, the artists on your team can show off their best models /
animations / particle effects in the new SIGGRAPH Dailies! program
(http://www.siggraph.org/s2010/for_submitters/siggraph_dailies). The
deadline for this one is on May 6.

A recent post on my book blog has more information on all three options:
http://www.realtimerendering.com/blog/three-ways-to-show-off-your-game-at-siggraph-2010/

Thanks,

Naty Hoffman

[Algorithms] Converting floats to a specific range

[Zafar Q. <zaf...@co...>]

Hi,

I'm sure this problem is pretty simple, but here goes...

I have a set of float numbers that I'm trying to auto-wrap within a specific range of 0.0 to wrapSize (wrapSize is positive, and not a power of 2)

So, if I choose a wrapSize of 1.0 then I want the following to happen when I feed in numbers...

-739.8 --> 0.2
:
:
-1.1 --> 0.9
-1.0 --> 0.0
-0.9 --> 0.1
:
-0.2 --> 0.8
-0.1 --> 0.9
0.0 --> 0.0
0.1 --> 0.1
:
0.9 --> 0.9
1.0 --> 0.0
1.1 --> 0.1
:

Can anyone think of a bit of maths for this please? Note that it needs to work for any positive value of wrapSize (not just 1.0)

Cheers
Zafar
**********************************************************************************
Disclaimer

The information and attached documentation in this e-mail is intended for the use of the addressee only and is confidential. If you are not the intended recipient please delete it and notify us immediately by telephoning or e-mailing the sender. Please note that without Codemasters’ prior written consent any form of distribution, copying or use of this communication or the information in it is strictly prohibited and may be unlawful. 

Attachments to this e-mail may contain software viruses. You are advised to take all reasonable precautions to minimise this risk and to carry out a virus check on any documents before they are opened.

Any offer contained in this communication is subject to Codemasters’ standard terms & conditions and must be signed by both parties. Except as expressly provided otherwise all information and attached documentation in this e-mail is subject to contract and Codemasters’ board approval.
Any views or opinions expressed are solely those of the author and do not necessarily represent those of Codemasters.

This footnote also confirms that this email message has been swept by
SurfControl for the presence of computer viruses.
**********************************************************************************

Re: [Algorithms] Converting floats to a specific range

[Oscar F. <os...@tr...>]

Unless I'm being daft isn't it just:

x = fmodf( 1.0f + fmodf( f, 1.0f ), 1.0f );

?

And btw 1.0 IS a power of 2.  2^0 in fact ;)

On 7 May 2010 12:36, Zafar Qamar <zaf...@co...> wrote:

> Hi,
>
> I'm sure this problem is pretty simple, but here goes...
>
> I have a set of float numbers that I'm trying to auto-wrap within a
> specific range of 0.0 to wrapSize (wrapSize is positive, and not a power of
> 2)
>
> So, if I choose a wrapSize of 1.0 then I want the following to happen when
> I feed in numbers...
>
> -739.8 --> 0.2
> :
> :
> -1.1 --> 0.9
> -1.0 --> 0.0
> -0.9 --> 0.1
> :
> -0.2 --> 0.8
> -0.1 --> 0.9
> 0.0 --> 0.0
> 0.1 --> 0.1
> :
> 0.9 --> 0.9
> 1.0 --> 0.0
> 1.1 --> 0.1
> :
>
> Can anyone think of a bit of maths for this please? Note that it needs to
> work for any positive value of wrapSize (not just 1.0)
>
> Cheers
> Zafar
>
> **********************************************************************************
> Disclaimer
>
> The information and attached documentation in this e-mail is intended for
> the use of the addressee only and is confidential. If you are not the
> intended recipient please delete it and notify us immediately by telephoning
> or e-mailing the sender. Please note that without Codemasters’ prior written
> consent any form of distribution, copying or use of this communication or
> the information in it is strictly prohibited and may be unlawful.
>
> Attachments to this e-mail may contain software viruses. You are advised to
> take all reasonable precautions to minimise this risk and to carry out a
> virus check on any documents before they are opened.
>
> Any offer contained in this communication is subject to Codemasters’
> standard terms & conditions and must be signed by both parties. Except as
> expressly provided otherwise all information and attached documentation in
> this e-mail is subject to contract and Codemasters’ board approval.
> Any views or opinions expressed are solely those of the author and do not
> necessarily represent those of Codemasters.
>
> This footnote also confirms that this email message has been swept by
> SurfControl for the presence of computer viruses.
>
> **********************************************************************************
>
>
>
> ------------------------------------------------------------------------------
>
> _______________________________________________
> GDAlgorithms-list mailing list
> GDA...@li...
> https://lists.sourceforge.net/lists/listinfo/gdalgorithms-list
> Archives:
> http://sourceforge.net/mailarchive/forum.php?forum_name=gdalgorithms-list

Re: [Algorithms] Converting floats to a specific range

[Fabian G. <ry...@gm...>]

On 07.05.2010 13:36, Zafar Qamar wrote:
> Hi,
>
> I'm sure this problem is pretty simple, but here goes...
>
> I have a set of float numbers that I'm trying to auto-wrap within a specific range of 0.0 to wrapSize (wrapSize is positive, and not a power of 2)
>
> So, if I choose a wrapSize of 1.0 then I want the following to happen when I feed in numbers...
 > [..]

There's a standard C library function, fmod, that nearly does what you 
want. The one thing you need to fix is that fmod(x, wrapSize) is 
negative whenever x is. So the solution to your problem is

   fmod(x, wrapSize) + (x < 0.0 ? wrapSize : 0.0);

The special case for wrapSize == 1 is quite easy, and worth remembering, 
since you get to avoid the conditional: You can just compute

   x - floor(x)

which is always nonnegative.

If your target platform/language doesn't have fmod but does have floor, 
you can usually make do with

   x - wrapSize * floor(x / wrapSize)

but if you use this you need to watch out if you might encounter very 
large values of x in your application - as soon as floor(x / wrapSize) 
gets to the range where neighboring floats are more than 1 apart, this 
expression will break.

-Fabian

Re: [Algorithms] Converting floats to a specific range

[Tom F. <tom...@ee...>]

>    x - floor(x)
> 
> which is always nonnegative.

Obscure fact - I *think* it is always non-negative, but it might not be less
than 1.0. For example, if x is very small and negative, for example x=-1e-10
then floor(x) = -1.0f (correct), and then -1e-10 + 1.0f = 1.0f. It's
possible you may be able to change your math rounding mode to "round down"
and then it will return the smallest number less than 1.0f - I've never
tried it.

But yeah, frac(x) can counter-intuitively return 1.0f sometimes.

TomF.


> -----Original Message-----
> From: Fabian Giesen [mailto:ry...@gm...]
> Sent: Friday, May 07, 2010 4:56 AM
> To: Game Development Algorithms
> Subject: Re: [Algorithms] Converting floats to a specific range
> 
> On 07.05.2010 13:36, Zafar Qamar wrote:
> > Hi,
> >
> > I'm sure this problem is pretty simple, but here goes...
> >
> > I have a set of float numbers that I'm trying to auto-wrap within a
> specific range of 0.0 to wrapSize (wrapSize is positive, and not a
> power of 2)
> >
> > So, if I choose a wrapSize of 1.0 then I want the following to happen
> when I feed in numbers...
>  > [..]
> 
> There's a standard C library function, fmod, that nearly does what you
> want. The one thing you need to fix is that fmod(x, wrapSize) is
> negative whenever x is. So the solution to your problem is
> 
>    fmod(x, wrapSize) + (x < 0.0 ? wrapSize : 0.0);
> 
> The special case for wrapSize == 1 is quite easy, and worth
> remembering,
> since you get to avoid the conditional: You can just compute
> 
>    x - floor(x)
> 
> which is always nonnegative.
> 
> If your target platform/language doesn't have fmod but does have floor,
> you can usually make do with
> 
>    x - wrapSize * floor(x / wrapSize)
> 
> but if you use this you need to watch out if you might encounter very
> large values of x in your application - as soon as floor(x / wrapSize)
> gets to the range where neighboring floats are more than 1 apart, this
> expression will break.
> 
> -Fabian
> 
> -----------------------------------------------------------------------
> -------
> 
> _______________________________________________
> GDAlgorithms-list mailing list
> GDA...@li...
> https://lists.sourceforge.net/lists/listinfo/gdalgorithms-list
> Archives:
> http://sourceforge.net/mailarchive/forum.php?forum_name=gdalgorithms-
> list
> No virus found in this incoming message.
> Checked by AVG - www.avg.com
> Version: 8.5.437 / Virus Database: 271.1.1/2838 - Release Date:
> 05/06/10 18:26:00

Re: [Algorithms] Converting floats to a specific range

[Simon F. <sim...@po...>]

Zafar Qamar wrote:
> Hi,
> 
> I'm sure this problem is pretty simple, but here goes...
> 
> I have a set of float numbers that I'm trying to auto-wrap within a
> specific range of 0.0 to wrapSize (wrapSize is positive, and not a
> power of 2)  
> 
> 
> Can anyone think of a bit of maths for this please? Note that it
> needs to work for any positive value of wrapSize (not just 1.0) 
> 
> Cheers
> Zafar

Do you mean like multiplying by the reciprocal of your range, taking
frac, and scaling back up again? 

Simon

PS: I hope you don't need this to be accurate for huge values (e.g. in
range reducing operations for, say sin(maxfloat))

Re: [Algorithms] Converting floats to a specific range

[Richard F. <ra...@gm...>]

I'll let you use the code i coded for this free of charge!

float makeRight( float val, float wrapsize )
{
 val /= wrapsize;
 switch( (int)val )
{
case 0:
 return wrapsize * val;
case 1:
 return wrapsize * (val-1.0f);
case 2:
 return wrapsize * (val-2.0f);
case 3:
 return wrapsize * (val-3.0f);
case -1:
 return wrapsize * (val+1.0f);
case -2:
 return wrapsize * (val+2.0f);
case -3:
 return wrapsize * (val+2.0f);
}
// just in case you haven't written the case for the incoming value:
return 0.0f;
}

On 7 May 2010 12:36, Zafar Qamar <zaf...@co...> wrote:

> Hi,
>
> I'm sure this problem is pretty simple, but here goes...
>
> I have a set of float numbers that I'm trying to auto-wrap within a
> specific range of 0.0 to wrapSize (wrapSize is positive, and not a power of
> 2)
>
> So, if I choose a wrapSize of 1.0 then I want the following to happen when
> I feed in numbers...
>
> -739.8 --> 0.2
> :
> :
> -1.1 --> 0.9
> -1.0 --> 0.0
> -0.9 --> 0.1
> :
> -0.2 --> 0.8
> -0.1 --> 0.9
> 0.0 --> 0.0
> 0.1 --> 0.1
> :
> 0.9 --> 0.9
> 1.0 --> 0.0
> 1.1 --> 0.1
> :
>
> Can anyone think of a bit of maths for this please? Note that it needs to
> work for any positive value of wrapSize (not just 1.0)
>
> Cheers
> Zafar
>
> **********************************************************************************
> Disclaimer
>
> The information and attached documentation in this e-mail is intended for
> the use of the addressee only and is confidential. If you are not the
> intended recipient please delete it and notify us immediately by telephoning
> or e-mailing the sender. Please note that without Codemasters’ prior written
> consent any form of distribution, copying or use of this communication or
> the information in it is strictly prohibited and may be unlawful.
>
> Attachments to this e-mail may contain software viruses. You are advised to
> take all reasonable precautions to minimise this risk and to carry out a
> virus check on any documents before they are opened.
>
> Any offer contained in this communication is subject to Codemasters’
> standard terms & conditions and must be signed by both parties. Except as
> expressly provided otherwise all information and attached documentation in
> this e-mail is subject to contract and Codemasters’ board approval.
> Any views or opinions expressed are solely those of the author and do not
> necessarily represent those of Codemasters.
>
> This footnote also confirms that this email message has been swept by
> SurfControl for the presence of computer viruses.
>
> **********************************************************************************
>
>
>
> ------------------------------------------------------------------------------
>
> _______________________________________________
> GDAlgorithms-list mailing list
> GDA...@li...
> https://lists.sourceforge.net/lists/listinfo/gdalgorithms-list
> Archives:
> http://sourceforge.net/mailarchive/forum.php?forum_name=gdalgorithms-list




-- 
fabs();
Just because the world is full of people that think just like you, doesn't
mean the other ones can't be right.

Re: [Algorithms] Converting floats to a specific range

[Chris J. <Chr...@ub...>]

float wrap(float x)
{
	Const float wrapSize = 1.0f;

	Return x - floorf(x/wrapSize)*wrapSize;
}

-----Original Message-----
From: Zafar Qamar [mailto:zaf...@co...] 
Sent: 07 May 2010 12:36
To: Game Development Algorithms
Subject: [Algorithms] Converting floats to a specific range

Hi,

I'm sure this problem is pretty simple, but here goes...

I have a set of float numbers that I'm trying to auto-wrap within a specific range of 0.0 to wrapSize (wrapSize is positive, and not a power of 2)

So, if I choose a wrapSize of 1.0 then I want the following to happen when I feed in numbers...

-739.8 --> 0.2
:
:
-1.1 --> 0.9
-1.0 --> 0.0
-0.9 --> 0.1
:
-0.2 --> 0.8
-0.1 --> 0.9
0.0 --> 0.0
0.1 --> 0.1
:
0.9 --> 0.9
1.0 --> 0.0
1.1 --> 0.1
:

Can anyone think of a bit of maths for this please? Note that it needs to work for any positive value of wrapSize (not just 1.0)

Cheers
Zafar
**********************************************************************************
Disclaimer

The information and attached documentation in this e-mail is intended for the use of the addressee only and is confidential. If you are not the intended recipient please delete it and notify us immediately by telephoning or e-mailing the sender. Please note that without Codemasters’ prior written consent any form of distribution, copying or use of this communication or the information in it is strictly prohibited and may be unlawful. 

Attachments to this e-mail may contain software viruses. You are advised to take all reasonable precautions to minimise this risk and to carry out a virus check on any documents before they are opened.

Any offer contained in this communication is subject to Codemasters’ standard terms & conditions and must be signed by both parties. Except as expressly provided otherwise all information and attached documentation in this e-mail is subject to contract and Codemasters’ board approval.
Any views or opinions expressed are solely those of the author and do not necessarily represent those of Codemasters.

This footnote also confirms that this email message has been swept by
SurfControl for the presence of computer viruses.
**********************************************************************************


------------------------------------------------------------------------------

_______________________________________________
GDAlgorithms-list mailing list
GDA...@li...
https://lists.sourceforge.net/lists/listinfo/gdalgorithms-list
Archives:
http://sourceforge.net/mailarchive/forum.php?forum_name=gdalgorithms-list

Re: [Algorithms] Converting floats to a specific range

[Danny K. <dr...@we...>]

>
> There's a standard C library function, fmod, that nearly does what you

want. The one thing you need to fix is that fmod(x, wrapSize) is

negative whenever x is. So the solution to your problem is


A quick unlurk - I've often wondered why mod functions always seem to do
this. Can anyone explain that? I can think of very few occasions when you
want to take the mod of a number and not restrict it to a single range,
rather than maintaining the positive or negative value. I understand that
doing it this way makes the function faster, but given that you usually have
to override it anyway that would seem a bit of a meaningless saving.

Danny

>
>

Re: [Algorithms] Converting floats to a specific range

[Fabian G. <ry...@gm...>]

On 07.05.2010 14:35, Danny Kodicek wrote:
> A quick unlurk - I've often wondered why mod functions always seem to do
> this. Can anyone explain that? I can think of very few occasions when
> you want to take the mod of a number and not restrict it to a single
> range, rather than maintaining the positive or negative value. I
> understand that doing it this way makes the function faster, but given
> that you usually have to override it anyway that would seem a bit of a
> meaningless saving.

It has to do with the rounding semantics of division. The basic 
requirement they're trying to fulfill is that if

   q = a / b;
   r = a % b;

then a should be equal to "q * b + r" (all sensible, so far). Now, C 
doesn't actually specify what (integer) division does when diving a 
negative number by a positive one. The two primary options are truncate 
(round towards zero) and floor (always round down).

If the target platform has "floor" semantics, then r is always 
nonnegative, and e.g. "-1 / 2" evaluates to -1 (this is also the 
behavior you get when you replace divisions by powers of two with 
arithmetic right shifts).

If the target platform has "truncate" semantics, "-1 / 2" evaluates to 
0, and hence the remainder has to be -1. All platforms I've worked with 
so far use this convention, even though it's (as said) not required by 
the C standard - floor would be equally fine.

Interestingly, the C standard does seem to specify that fmod returns 
results as if a truncate-rounding division was used. It's only left 
undefined for integer operations.

-Fabian

Re: [Algorithms] Converting floats to a specific range

[Richard F. <ra...@gm...>]

I don't "know", but MOD is meant to be remainder on computers. It flummoxed
me as I came from a more mathematical background and MOD is defined as not
having negative numbers in the number field stuff

On 7 May 2010 13:35, Danny Kodicek <dr...@we...> wrote:

>  There's a standard C library function, fmod, that nearly does what you
>
> want. The one thing you need to fix is that fmod(x, wrapSize) is
>
> negative whenever x is. So the solution to your problem is
>
>
> A quick unlurk - I've often wondered why mod functions always seem to do
> this. Can anyone explain that? I can think of very few occasions when you
> want to take the mod of a number and not restrict it to a single range,
> rather than maintaining the positive or negative value. I understand that
> doing it this way makes the function faster, but given that you usually have
> to override it anyway that would seem a bit of a meaningless saving.
>
> Danny
>
>>
>>
>
>
> ------------------------------------------------------------------------------
>
>
> _______________________________________________
> GDAlgorithms-list mailing list
> GDA...@li...
> https://lists.sourceforge.net/lists/listinfo/gdalgorithms-list
> Archives:
> http://sourceforge.net/mailarchive/forum.php?forum_name=gdalgorithms-list
>



-- 
fabs();
Just because the world is full of people that think just like you, doesn't
mean the other ones can't be right.

Re: [Algorithms] Converting floats to a specific range

[Zafar Q. <zaf...@co...>]

Cheers for your responses. And for the comedy one :)

A couple of interesting ways of achieving the solution there.

Much appreciated
Zafar


-----Original Message-----
From: Chris Jenner [mailto:Chr...@ub...] 
Sent: 07 May 2010 12:57
To: Game Development Algorithms
Subject: Re: [Algorithms] Converting floats to a specific range

float wrap(float x)
{
	Const float wrapSize = 1.0f;

	Return x - floorf(x/wrapSize)*wrapSize;
}

-----Original Message-----
From: Zafar Qamar [mailto:zaf...@co...] 
Sent: 07 May 2010 12:36
To: Game Development Algorithms
Subject: [Algorithms] Converting floats to a specific range

Hi,

I'm sure this problem is pretty simple, but here goes...

I have a set of float numbers that I'm trying to auto-wrap within a specific range of 0.0 to wrapSize (wrapSize is positive, and not a power of 2)

So, if I choose a wrapSize of 1.0 then I want the following to happen when I feed in numbers...

-739.8 --> 0.2
:
:
-1.1 --> 0.9
-1.0 --> 0.0
-0.9 --> 0.1
:
-0.2 --> 0.8
-0.1 --> 0.9
0.0 --> 0.0
0.1 --> 0.1
:
0.9 --> 0.9
1.0 --> 0.0
1.1 --> 0.1
:

Can anyone think of a bit of maths for this please? Note that it needs to work for any positive value of wrapSize (not just 1.0)

Cheers
Zafar
**********************************************************************************
Disclaimer

The information and attached documentation in this e-mail is intended for the use of the addressee only and is confidential. If you are not the intended recipient please delete it and notify us immediately by telephoning or e-mailing the sender. Please note that without Codemasters’ prior written consent any form of distribution, copying or use of this communication or the information in it is strictly prohibited and may be unlawful. 

Attachments to this e-mail may contain software viruses. You are advised to take all reasonable precautions to minimise this risk and to carry out a virus check on any documents before they are opened.

Any offer contained in this communication is subject to Codemasters’ standard terms & conditions and must be signed by both parties. Except as expressly provided otherwise all information and attached documentation in this e-mail is subject to contract and Codemasters’ board approval.
Any views or opinions expressed are solely those of the author and do not necessarily represent those of Codemasters.

This footnote also confirms that this email message has been swept by
SurfControl for the presence of computer viruses.
**********************************************************************************


------------------------------------------------------------------------------

_______________________________________________
GDAlgorithms-list mailing list
GDA...@li...
https://lists.sourceforge.net/lists/listinfo/gdalgorithms-list
Archives:
http://sourceforge.net/mailarchive/forum.php?forum_name=gdalgorithms-list
------------------------------------------------------------------------------

_______________________________________________
GDAlgorithms-list mailing list
GDA...@li...
https://lists.sourceforge.net/lists/listinfo/gdalgorithms-list
Archives:
http://sourceforge.net/mailarchive/forum.php?forum_name=gdalgorithms-list
**********************************************************************************
Disclaimer

The information and attached documentation in this e-mail is intended for the use of the addressee only and is confidential. If you are not the intended recipient please delete it and notify us immediately by telephoning or e-mailing the sender. Please note that without Codemasters’ prior written consent any form of distribution, copying or use of this communication or the information in it is strictly prohibited and may be unlawful. 

Attachments to this e-mail may contain software viruses. You are advised to take all reasonable precautions to minimise this risk and to carry out a virus check on any documents before they are opened.

Any offer contained in this communication is subject to Codemasters’ standard terms & conditions and must be signed by both parties. Except as expressly provided otherwise all information and attached documentation in this e-mail is subject to contract and Codemasters’ board approval.
Any views or opinions expressed are solely those of the author and do not necessarily represent those of Codemasters.

This footnote also confirms that this email message has been swept by
SurfControl for the presence of computer viruses.
**********************************************************************************

Re: [Algorithms] Converting floats to a specific range

[Richard F. <ra...@gm...>]

NP, but remember, if you're going for performance: try all the different
techniques you can find and don't assume anything. Different solutions are
optimal for different hardware situations. All the solutions presented here
except mine which is crapola no matter what hardware you have, have their
merits.

On 10 May 2010 13:41, Zafar Qamar <zaf...@co...> wrote:

> Cheers for your responses. And for the comedy one :)
>
> A couple of interesting ways of achieving the solution there.
>
> Much appreciated
> Zafar
>
>
> -----Original Message-----
> From: Chris Jenner [mailto:Chr...@ub...]
> Sent: 07 May 2010 12:57
> To: Game Development Algorithms
> Subject: Re: [Algorithms] Converting floats to a specific range
>
> float wrap(float x)
> {
>        Const float wrapSize = 1.0f;
>
>        Return x - floorf(x/wrapSize)*wrapSize;
> }
>
> -----Original Message-----
> From: Zafar Qamar [mailto:zaf...@co...]
> Sent: 07 May 2010 12:36
> To: Game Development Algorithms
> Subject: [Algorithms] Converting floats to a specific range
>
> Hi,
>
> I'm sure this problem is pretty simple, but here goes...
>
> I have a set of float numbers that I'm trying to auto-wrap within a
> specific range of 0.0 to wrapSize (wrapSize is positive, and not a power of
> 2)
>
> So, if I choose a wrapSize of 1.0 then I want the following to happen when
> I feed in numbers...
>
> -739.8 --> 0.2
> :
> :
> -1.1 --> 0.9
> -1.0 --> 0.0
> -0.9 --> 0.1
> :
> -0.2 --> 0.8
> -0.1 --> 0.9
> 0.0 --> 0.0
> 0.1 --> 0.1
> :
> 0.9 --> 0.9
> 1.0 --> 0.0
> 1.1 --> 0.1
> :
>
> Can anyone think of a bit of maths for this please? Note that it needs to
> work for any positive value of wrapSize (not just 1.0)
>
> Cheers
> Zafar
>
> **********************************************************************************
> Disclaimer
>
> The information and attached documentation in this e-mail is intended for
> the use of the addressee only and is confidential. If you are not the
> intended recipient please delete it and notify us immediately by telephoning
> or e-mailing the sender. Please note that without Codemasters’ prior written
> consent any form of distribution, copying or use of this communication or
> the information in it is strictly prohibited and may be unlawful.
>
> Attachments to this e-mail may contain software viruses. You are advised to
> take all reasonable precautions to minimise this risk and to carry out a
> virus check on any documents before they are opened.
>
> Any offer contained in this communication is subject to Codemasters’
> standard terms & conditions and must be signed by both parties. Except as
> expressly provided otherwise all information and attached documentation in
> this e-mail is subject to contract and Codemasters’ board approval.
> Any views or opinions expressed are solely those of the author and do not
> necessarily represent those of Codemasters.
>
> This footnote also confirms that this email message has been swept by
> SurfControl for the presence of computer viruses.
>
> **********************************************************************************
>
>
>
> ------------------------------------------------------------------------------
>
> _______________________________________________
> GDAlgorithms-list mailing list
> GDA...@li...
> https://lists.sourceforge.net/lists/listinfo/gdalgorithms-list
> Archives:
> http://sourceforge.net/mailarchive/forum.php?forum_name=gdalgorithms-list
>
> ------------------------------------------------------------------------------
>
> _______________________________________________
> GDAlgorithms-list mailing list
> GDA...@li...
> https://lists.sourceforge.net/lists/listinfo/gdalgorithms-list
> Archives:
> http://sourceforge.net/mailarchive/forum.php?forum_name=gdalgorithms-list
>
> **********************************************************************************
> Disclaimer
>
> The information and attached documentation in this e-mail is intended for
> the use of the addressee only and is confidential. If you are not the
> intended recipient please delete it and notify us immediately by telephoning
> or e-mailing the sender. Please note that without Codemasters’ prior written
> consent any form of distribution, copying or use of this communication or
> the information in it is strictly prohibited and may be unlawful.
>
> Attachments to this e-mail may contain software viruses. You are advised to
> take all reasonable precautions to minimise this risk and to carry out a
> virus check on any documents before they are opened.
>
> Any offer contained in this communication is subject to Codemasters’
> standard terms & conditions and must be signed by both parties. Except as
> expressly provided otherwise all information and attached documentation in
> this e-mail is subject to contract and Codemasters’ board approval.
> Any views or opinions expressed are solely those of the author and do not
> necessarily represent those of Codemasters.
>
> This footnote also confirms that this email message has been swept by
> SurfControl for the presence of computer viruses.
>
> **********************************************************************************
>
> ------------------------------------------------------------------------------
>
> _______________________________________________
> GDAlgorithms-list mailing list
> GDA...@li...
> https://lists.sourceforge.net/lists/listinfo/gdalgorithms-list
> Archives:
> http://sourceforge.net/mailarchive/forum.php?forum_name=gdalgorithms-list
>



-- 
fabs();
Just because the world is full of people that think just like you, doesn't
mean the other ones can't be right.