Algorithms

Luc Pattyn wrote:

If you need to add code to prevent integers from overflowing, you should consider floats,
since unpredictable conditional branches are very bad for performance.

void Function(bool condition)
{
    for(int i = 0; i < 1000; i++)
    {
        if(condition)
        {
            // Do stuff.
        }
        else
        {
            // Do other stuff.
        }
    }
}

Luc Pattyn wrote:

If your inputs and outputs are integers, using floats will cost conversion times; most modern
CPUs have different register sets for ints and floats, and can pass data between them only
through "memory" (i.e. the data cache), adding to latency, and probably taking away some
performance.
If you need transcendental functions, floats are the obvious choice.
If you have streaming data the CPU might be optimized more for one or the other.
The Intel processor line has a long tradition of favoring integers over floats when spending
the transistor budget.
If your CPU is general-purpose (as opposed to DSP) and your algorithm needs a lot of
address calculations and indexing, you should consider float data, so the integer ALUs
are available for sequencing and addressing, the float ALU(s) for data operations.

if (condition) {
    for(loop_control) { stuff }
} else {
    for(loop_control) { other_stuff }
}

Leslie Sanford wrote:

floating point seems faster

cyndy_northrup wrote:

I tried coding this one also, but instead of getting a rich set of chaotic values all I got were two values
that repeated exactly the same over and over again????

cyndy_northrup wrote:

For this one I tried implementing this but for some reason, when I coded this to VB, it only generated
the same values over and over again.... no chaotically generated values......

cyndy_northrup wrote:

xnew = y + 1 - 1.4 * x^2

ynew = 0.3 * x

'step 1:
xnew = y + 1 - 1.4 * x^2
ynew = 0.3 * x
'store xnew,ynew somewhere
x=xnew;
y=ynew;
'goto step 1

1111111111111110
1111111111111100
1111111111111000
...
1100000000000000
1000000000000000

0000000000000001
0000000000000011
...
0111111111111111

int fn(int x)
   {
   switch (x)
      case 0x01:
      case 0x03:
      case 0x07:
      case 0x0F:
      case 0x1F:
      case 0x3F:
      case 0x7F:
         return 1;
      case 0x80:
      case 0xC0:
      case 0xE0:
      case 0xF0:
      case 0xF8:
      case 0xFC:
      case 0xFE:
         return 1;
      default:
         return 0;
   }

const int hi1 = {0xFF, 0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 0x80, 0};

int GetWordStatus(int word, int wordlength)
   {
   ASSERT(wordLength <= 8  &&  wordLength >= 0);
   int x = word & ~hi1[wordLength]; // may not be necessary depending on what data can be sent
   switch (x)
      {
      case 0x01:
      case 0x03:
      case 0x07:
      case 0x0F:
      case 0x1F:
      case 0x3F:
      case 0x7F:
         return 1;
      }
   x = word | hi1[wordLength];
   switch (x)
      {
      case 0x80:
      case 0xC0:
      case 0xE0:
      case 0xF0:
      case 0xF8:
      case 0xFC:
      case 0xFE:
         return 2;
      }
   return 0;
   }