generic data range monitor

[LordHog]

Hello all,

My lead wants to implement a data range monitor for a project that we
are coding. Basically it performs a boundry checking that will take
three parameters. I am/was trying to implement a generic data range
monitor, but it doesn't quite work. I am trying to create one method
that will accept any type of parameter and use those values whether
they be int, unsigned int, float, double etc.... I am not sure if this
can be done within the c language, but I was hoping someone might point
me in the correct direction. Thanks.

Mark

int drm( void*, void*, void*);

main( ) {
int data = 2,
lower = 5,
upper = 15;

unsigned int data2 = 1;

float data1 = 2.7f;

if ( drm( (void*)data, (void*)lower, (void*)upper ) ) {
printf( "Within bounds\n" );
} else {
printf( "Out of bounds\n" );
}
return 0;
}

bool drm( void* data, void* lowerLimit, void* upperLimit) {
if( data < lowerLimit || data > upperLimit )
return 0;
else
return 1;
}

[Jens.Toerring]

Lo*****@hotmail.com wrote:

My lead wants to implement a data range monitor for a project that we
are coding. Basically it performs a boundry checking that will take
three parameters. I am/was trying to implement a generic data range
monitor, but it doesn't quite work. I am trying to create one method
that will accept any type of parameter and use those values whether
they be int, unsigned int, float, double etc.... I am not sure if this
can be done within the c language, but I was hoping someone might point
me in the correct direction. Thanks.

What about

int drm ( double data, double ll, double ul ) {
return data < ul || data > ul;
}

I guess that's as far as "type-agnostic" you can get, since data must
have a type to be compared (using void isn't an option since you then
don't know what type the data have). As long as 'double' is the type
with the largest range (unless your system has 'long double', then you
should use that) it could be used - on invocation of the function
(given that the declaration of the function is in scope) the arguments
all get converted to double. If your limits are always ints, you could
of course also use

int drm ( double data, int ll, int ul ) {
return data < ul || data > ul;
}
Regards, Jens
--
\ Jens Thoms Toerring ___ Je***********@physik.fu-berlin.de
\__________________________ http://www.toerring.de

[David Resnick]

Lo*****@hotmail.com wrote:

Hello all,

My lead wants to implement a data range monitor for a project that we
are coding. Basically it performs a boundry checking that will take
three parameters. I am/was trying to implement a generic data range
monitor, but it doesn't quite work. I am trying to create one method
that will accept any type of parameter and use those values whether
they be int, unsigned int, float, double etc.... I am not sure if this
can be done within the c language, but I was hoping someone might point
me in the correct direction. Thanks.

Mark

int drm( void*, void*, void*);

main( ) {
int data = 2,
lower = 5,
upper = 15;

unsigned int data2 = 1;

float data1 = 2.7f;

if ( drm( (void*)data, (void*)lower, (void*)upper ) ) {
printf( "Within bounds\n" );
} else {
printf( "Out of bounds\n" );
}
return 0;
}

bool drm( void* data, void* lowerLimit, void* upperLimit) {
if( data < lowerLimit || data > upperLimit )
return 0;
else
return 1;
}

A void* is a generic pointer, not a generic holder of arbitrary data.
Forgetting other issues (trap representations, etc, that I know little
about), a void* may well not have enough bits to hold all types, for
example long double or long long int. IMHO as soon as you are adding
casts to code you have a clue that you've made a bad choice (yes, there
are exceptions...).

You could have the arguments be 3 unions of all types you want supported
and a 4th argument that is an enumeration that says what the type is.
Or you could take 3 void* arguments which are pointers to the things
to be compared and a 4th argument that is again an enum explaining
the type.

Or you could use a macro along the lines of:
#define DRM(value, lower, upper) (((value) < lower) ? 0 : ((value) >
(upper)) ? 0 : 1)
With the usual caveat that DRM(value++, lower, upper) is a problem.

Or you could head over to C++ land which handles this with templates.

BTW, int main(void) is better (required in C99), and the bool return of
drm is C99 specific.

-David

[CBFalconer]

Lo*****@hotmail.com wrote:

My lead wants to implement a data range monitor for a project that
we are coding. Basically it performs a boundry checking that will
take three parameters. I am/was trying to implement a generic data
range monitor, but it doesn't quite work. I am trying to create
one method that will accept any type of parameter and use those
values whether they be int, unsigned int, float, double etc.... I
am not sure if this can be done within the c language, but I was
hoping someone might point me in the correct direction. Thanks.

C doesn't have methods, it has functions. At any rate ...

You will have to write separate routines to deal with floating
point and integral arguments, and probably another for unsigned
arguments. Use the largest range available to you to pass the
arguments, and let the compiler generate the conversions on the
calls. i.e. never cast anything.

int drmi(long value, long min, long max)
{
return (value <= max) && (value >= min);
}

You can probably improve the efficiency by declaring it as static
inline. In any case the usage can be:

if (!drmi(v, bottom, top)) takecorrectiveaction(whatever);
else {
/* known suitable values */
}

For example, you could check for hex lower case chars with:

if (!drmi(ch, 'a', 'f')) ....

You can't use void*, since to dereference anything you have to know
its type.

--
"If you want to post a followup via groups.google.com, don't use
the broken "Reply" link at the bottom of the article. Click on
"show options" at the top of the article, then click on the
"Reply" at the bottom of the article headers." - Keith Thompson

[Christian Kandeler]

Je***********@physik.fu-berlin.de wrote:

As long as 'double' is the type
with the largest range (unless your system has 'long double', then you
should use that)

If he is using a conforming implementation, there _must_ be a long double
data type.
Christian

[Jesse Meyer]

Je***********@physik.fu-berlin.de <Je***********@physik.fu-berlin.de> wrote:

Lo*****@hotmail.com wrote:

My lead wants to implement a data range monitor for a project that we
are coding. Basically it performs a boundry checking that will take
three parameters. I am/was trying to implement a generic data range
monitor, but it doesn't quite work. I am trying to create one method
that will accept any type of parameter and use those values whether
they be int, unsigned int, float, double etc.... I am not sure if this
can be done within the c language, but I was hoping someone might point
me in the correct direction. Thanks.

What about

int drm ( double data, double ll, double ul ) {
return data < ul || data > ul;

Perhaps its the high amount of blood in my caffiene stream today, but
why are you checking that data != ul?

ITYM
return data < ul && data > ll;

Or perhaps I need coffee.

--
With sufficient thrust, pigs fly just fine. However, this is
not necessarily a good idea. It is hard to be sure where they
are going to land, and it could be dangerous sitting under them
as they fly overhead. -- RFC 1925

[Jens.Toerring]

Jesse Meyer <me**************@ideaone.net> wrote:

Je***********@physik.fu-berlin.de <Je***********@physik.fu-berlin.de> wrote:

Lo*****@hotmail.com wrote:

My lead wants to implement a data range monitor for a project that we
are coding. Basically it performs a boundry checking that will take
three parameters. I am/was trying to implement a generic data range
monitor, but it doesn't quite work. I am trying to create one method
that will accept any type of parameter and use those values whether
they be int, unsigned int, float, double etc.... I am not sure if this
can be done within the c language, but I was hoping someone might point
me in the correct direction. Thanks.
What about

int drm ( double data, double ll, double ul ) {
return data < ul || data > ul;

Perhaps its the high amount of blood in my caffiene stream today, but
why are you checking that data != ul? ITYM
return data < ul && data > ll; Or perhaps I need coffee.

Obviously it was me that needed more coffee when I wrote that;-)

Regards, Jens
--
\ Jens Thoms Toerring ___ Je***********@physik.fu-berlin.de
\__________________________ http://www.toerring.de