Provided by: libvistaio-dev_1.2.19-2_amd64 bug


       VistaIOConst - generate constants of the appropriate type


       VistaIOFloat VistaIOFloatConst (f)

       VistaIODouble VistaIODoubleConst (f)

       VistaIOBit VistaIOBitConst (i)

       VistaIOUByte VistaIOUByteConst (i)

       VistaIOSByte VistaIOSByteConst (i)

       VistaIOShort VistaIOShortConst (i)

       VistaIOLong VistaIOLongConst (i)


       f         Specifies a floating-point constant.

       i         Specifies an integer constant.


       In  expressions  that  get  executed within inner loops, you may wish to avoid unnecessary
       coercions between the C types float and double, or between int and long. By  allowing  you
       to  specify  constants of the appropriate type in a portable, platform-independent manner,
       these macros allow you to avoid unintended coercions.

       In ANSI C, one can specify that a floating point constant is of type float be appending an
       f  character  to  it.  This  can be used to avoid coercions in expressions involving other
       float values. For example, this fragment of code uses a float constant within its loop:

              int i;
              float f = 0.0;

              for (i = 0; i < 10000000; i++)
                  f += 1.0f;

       It runs about three times faster than this one, which uses a double constant:

              int i;
              float f = 0.0;

              for (i = 0; i < 10000000; i++)
                  f += 1.0;

       The VistaIOFloatConst  and  VistaIODoubleConst  macros  allow  you  to  avoid  unnecessary
       coercions in expressions involving values of type VistaIOFloat and VistaIODouble.  Whether
       or not VistaIOFloat and VistaIODouble are equivalent to float and  double  may  depend  on
       what  platform your code is being compiled for.  Regardless, you can generate constants of
       the appropriate type by using the VistaIOFloatConst and VistaIODoubleConst macros.   On  a
       platform  where  VistaIOFloat is defined as float, VistaIOFloatConst(1.0) expands to 1.0f;
       where VistaIOFloat is defined as double, it expands to 1.0.  Similarly, VistaIODoubleConst
       may  or  may  not append an f character to the constant, depending on how VistaIODouble is

       Similarly, the VistaIOBitConst, VistaIOUByteConst,  VistaIOSByteConst,  VistaIOShortConst,
       and VistaIOLongConst take an integer constant; each one, depending on the platform, may or
       may not append an l character to the constant to specify that  it  is  of  type  long.  On
       platforms  where  int  and  long  have  different  representations, using these macros may
       prevent unintended coercions between the two representations.

       So if your want your inner loops to run blindingly fast on any platform, you should  write
       them like this to avoid unnecessary coercions:

              int i;
              VistaIOFloat f = 0.0;

              for (i = 0; i < 10000000; i++)
                  f += VistaIOFloatConst (1.0);




       The  macros can be used with a C compiler that doesn't meet the ANSI standard, but in that
       case they may not eliminate all type coercions between float and double.

       If you're more concerned about your code being easy to read, you may  be  better  off  not
       using these macros.


       Art Pope <>

       Adaption to vistaio: Gert Wollny <>