C#

jimwawar wrote:

Any ideas about a faster approach?

for (int probeID = 0; probeID < 1000000; probeID++)
{
    int data = GetProbeData(probeID);    // Get data from hardware.
    data = data >> 8;                    // Right shift the data to fix the value.
    if (<code>data < 70000</code> || <code>data > 90000</code>)
        Console.WriteLine("Value out of range: {0}", data);
}

for (int probeID = 0; probeID < 1000000; probeID++)
{
    int data = GetProbeData(probeID);
    if (<code>data < 17920000</code> || <code>data > 23040000</code>)
        Console.WriteLine("Value out of range: {0}", data >> 8);
}

dan neely wrote:

you've spread your weirdness all over the app instead of having it all contained in a single location at input time.

Robert.C.Cartaino wrote:

about a 5-10% improvement

fixed (byte* p = &theArray) {
   for (int i = 0; i < theArray.Length; i++) {
      p++; // skip bits 0-7
      byte lo = *(p++); // get bits 8-15
      byte mid = *(p++); // get bits 16-23
      byte hi = *(p++); // get bits 24-31
      // do something with the values?
   }
}

PIEBALDconsult wrote:

using the byte preceding the array as the first byte

Guffa wrote:

shifting the int value

Guffa wrote:

and it certainly is simpler

int masks[] = { 0xFFFFFFFF , 0x00FFFFFF , 0x0000FFFF , 0x000000FF } ;
 
int
ShiftAndSumArray
(
    int*     Array
,
    unsigned Length
,
    unsigned Shift
)
{
    int result = 0 ;
 
    int* a = (int*) ( ((char*) Array) + ( Shift %= sizeof(int) ) ) ;
 
    unsigned i ;
 
    for ( i = 0 ; i < Length-1 ; i++ )
    {
        result += a [ i ] ;
    }
 
    result += a [ i ] & masks [ Shift ] ;
 
    return ( result ) ;
}

int a[] = { 0x00000100 , 0x00000100 , 0x00000100 , 0x00000100 } ;
 
printf ( "%d\n" , ShiftAndSumArray ( a , 4 , 1 ) ) ;

private static readonly int[] masks = unchecked ( new int[] { (int) 0xFFFFFFFF , 0x00FFFFFF , 0x0000FFFF , 0x000000FF } ) ;
 
public static unsafe int
ShiftAndSumArray
(
    int[] Array
,
    uint  Shift
)
{
    int result = 0 ;
           
    fixed ( int* b = Array )
    {
        int* a = (int*) ( ((byte*) b) + ( Shift %= sizeof(int) ) ) ;
        int  i ;
                 
        for ( i = 0 ; i < Array.Length-1 ; i++ )
        {
            result += a [ i ] ;
        }
 
        result += a [ i ] & masks [ Shift ] ;
    }
             
    return ( result ) ;
}

public static int
ShiftAndSumArray2
(
    int[] Array
,
    uint  Shift
)
{
    int result = 0 ;
 
    int shift = (int) Shift % sizeof(int) * 8 ;

    // Using foreach is not much slower 
    for ( int i = 0 ; i < Array.Length ; i++ )
    {
        result += Array [ i ] >> shift ;
    }            
 
    return ( result ) ;
}