Fastest way to check variable against two values

[wswilson]

In python, I could write:

a = 1

if a in [1, 2]:
do something...
In c (and many other languages):

int a = 1;

if (a == 1 || a == 2) {
do something...
}

Is there a shorter, cleaner syntax?

[fred.l.kleinschmidt]

On May 2, 8:06*am, wswilson <[e-mail]:

In python, I could write:

a = 1

if a in [1, 2]:
* *do something...

In c (and many other languages):

int a = 1;

if (a == 1 || a == 2) {
* *do something...

}

Is there a shorter, cleaner syntax?

It depends on many things, such as what types of variables
you are using (int, double, strings, etc.)

In some cases, using a switch statement is useful here:

switch(a) {
case 1: case2:
/*do something */
break;
case 3: case 4:
/* do something else */
break;
default:
/* etc. */
break;
}
The above is likely to be implemented using a jump table,
which is probably faster than the nested if's. But it
only works if the comparisons are to constants.
--
Fred Kleinschmidt

[Bartc]

"wswilson" <ws******@gmail.comwrote in message
news:06**********************************@e39g2000 hsf.googlegroups.com...

In python, I could write:

a = 1

if a in [1, 2]:
do something...

Is this supposed to be an example of a /fast/ method? I think Python creates
an array containing 1 and 2, then searches it for a.

Being neat and short isn't necessarily fast. However you do it in C, it will
be faster.

-- Bartc

[Eligiusz Narutowicz]

"Bartc" <[e-mail]:

"wswilson" <ws******@gmail.comwrote in message
news:06**********************************@e39g2000 hsf.googlegroups.com...

>In python, I could write:

a = 1

if a in [1, 2]:
do something...

Is this supposed to be an example of a /fast/ method? I think Python creates
an array containing 1 and 2, then searches it for a.

Nowhere did he mention "fast". He mentioned shorter cleaner syntax. And
it is.

>
Being neat and short isn't necessarily fast. However you do it in C, it will
be faster.

[Robert Gamble]

On May 2, 11:43 am, Eligiusz Narutowicz<[e-mail]>
wrote:

"Bartc" <[e-mail]:

"wswilson" <[e-mail] in message
news:06**********************************@e39g2000 hsf.googlegroups.com...

In python, I could write:

a = 1

if a in [1, 2]:
do something...

Is this supposed to be an example of a /fast/ method? I think Python creates
an array containing 1 and 2, then searches it for a.

Nowhere did he mention "fast". He mentioned shorter cleaner syntax. And
it is.

The subject of the message was "Fastest way to check variable against
two values".

--
Robert Gamble

[Eligiusz Narutowicz]

Robert Gamble <rg*******@gmail.comwrites:

On May 2, 11:43 am, Eligiusz Narutowicz<[e-mail]>
wrote:

>"Bartc" <[e-mail]:

"wswilson" <[e-mail] in message
news:06**********************************@e39g200 0hsf.googlegroups.com...
In python, I could write:

>a = 1

>if a in [1, 2]:
do something...

Is this supposed to be an example of a /fast/ method? I think Python creates
an array containing 1 and 2, then searches it for a.

Nowhere did he mention "fast". He mentioned shorter cleaner syntax. And
it is.

The subject of the message was "Fastest way to check variable against
two values".

It did indeed . I am sorry - I really only listened to the body of the
message which made it pretty clear. I can think that he is meaning
"fastest to type" in the subject as was clear from the body.

[wswilson]

On May 2, 11:45*am, Robert Gamble <[e-mail]:

On May 2, 11:43 am, Eligiusz Narutowicz<[e-mail]>
wrote:

"Bartc" <[e-mail]:

"wswilson" <[e-mail] in message
>news:06**********************************@e39g200 0hsf.googlegroups.com....
>In python, I could write:

>a = 1

>if a in [1, 2]:
>* do something...

Is this supposed to be an example of a /fast/ method? I think Python creates
an array containing 1 and 2, then searches it for a.

Nowhere did he mention "fast". He mentioned shorter cleaner syntax. And
it is.

The subject of the message was "Fastest way to check variable against
two values".

--
Robert Gamble

Thanks for the help guys. I did mention fast in the title but I meant
clean and short (as in the post). Sorry :-)

[Walter Roberson]

In article <06**********************************@e39g2000hsf. googlegroups.com>,
wswilson <ws******@gmail.comwrote:

>In python, I could write:

>a = 1

>if a in [1, 2]:
do something...

>In c (and many other languages):

>int a = 1;

>if (a == 1 || a == 2) {
do something...
}

>Is there a shorter, cleaner syntax?

If none of the values are 0 and none exceed the maximum char:

char ac[] = {1,2};

int a = 1;

if (strchar(ac, a)) {
do something...
}

--
Q: Why did the chicken cross the Mobius strip?

A: There were manifold reasons.

[Robert Gamble]

On May 2, 11:06 am, wswilson <[e-mail]:

In python, I could write:

a = 1

if a in [1, 2]:
do something...

In c (and many other languages):

int a = 1;

if (a == 1 || a == 2) {
do something...

}

Is there a shorter, cleaner syntax?

In your example Python creates a list of values and the in operator
compares each element of this list to "a" until it finds such a value
or the list is exhausted. The C method you propose won't likely be
any slower. As far as shorter/cleaner, it depends. There isn't a
better mechanism built into the language but if you are doing
operations like this a lot on multiple values you may want to write a
function to do what the "in" operator does in python, for example:

==cut==
int in_list (int search, int *p, size_t size)
{
for (size_t i = 0; i < size; i++)
if (search == p[i]) return 1;
return 0;
}

int main (void)
{
if (in_list(1, (int []){1, 2, 3, 4, 5}, 5))
puts("element is in list");
else
puts("element is not in list");

return 0;
}
==cut==

In this (C99) example we define a function in_list that takes an
integer to search for, an array of integers to search, and the size of
the array; it returns 1 if the searched for item was found, 0 if it
was not. We call it with a compound literal as a "shorter/cleaner"
method than creating a separate array which you would have to do if
using C89. The two major problems with this function are that it only
works for ints and it is easy to specify an incorrect size with longer
lists. You could generalize the in_list function to work with any
type by modifying it to receive a comparison function and making the
appropriate changes to the types passed on. To alleviate the second
issue you could pass in an array of pointers to values using NULL to
terminate the list, this can get messy for non-string types though. I
have used similar methods successfully in the past, whether it is
"clean" is a matter of opinion.

--
Robert Gamble

[Robert Gamble]

On May 2, 12:22 pm, [e-mail] (Walter Roberson)
wrote:

In article <[e-mail]>,

wswilson <[e-mail]:

In python, I could write:
a = 1
if a in [1, 2]:
do something...
In c (and many other languages):
int a = 1;
if (a == 1 || a == 2) {
do something...
}
Is there a shorter, cleaner syntax?

If none of the values are 0 and none exceed the maximum char:

char ac[] = {1,2};

You are going to need the terminating null character:

char ac[] = {1, 2, 0};

int a = 1;

if (strchar(ac, a)) {

It's strchr, not strchar.

do something...

}

--
Robert Gamble

[Bartc]

"wswilson" <ws******@gmail.comwrote in message
news:06**********************************@e39g2000 hsf.googlegroups.com...

In python, I could write:

a = 1

if a in [1, 2]:
do something...
In c (and many other languages):

int a = 1;

if (a == 1 || a == 2) {
do something...
}

If you want something short then, try this macro:

#define in(a,b,c) ((a)==(b) | (a)==(c))

And use it like this:

if (in(a,1,2))...

(Although, I don't use macros much and there are probably some pitfalls. You
may also like to use || instead of |)

-- Bartc

[Peter Nilsson]

wswilson wrote:

In c (and many other languages):

int a = 1;

if (a == 1 || a == 2) {
do something...
}

Is there a shorter, cleaner syntax?

Shorter, but not necessarily better...

if (a - 1u < 2)

--
Peter

[user923005]

On May 2, 8:06*am, wswilson <[e-mail]:

In python, I could write:

a = 1

if a in [1, 2]:
* *do something...

In c (and many other languages):

int a = 1;

if (a == 1 || a == 2) {
* *do something...

}

Is there a shorter, cleaner syntax?

If the list of items contains a small maximum, you can use:

/*
7.21.5.4 The strpbrk function
Synopsis
1 #include <string.h>
char *strpbrk(const char *s1, const char *s2);
Description
2 The strpbrk function locates the first occurrence in the string
pointed to by s1 of any character from the string pointed to by s2.
Returns
3 The strpbrk function returns a pointer to the character, or a
null pointer if no character from s2 occurs in s1.
*/
#include <string.h>
#include <stdio.h>

/* You can't find zero in the list, and the last entry must be 0: */
static const unsigned char list[] =
{
1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 23, 25, 'a', 'A', 'Z', 'Q', 0
};

int main(void)
{
char string[256];
char *where;

puts("Enter a string:");
fflush(stdout);
fgets(string, sizeof string, stdin);
where = strpbrk(string, list);
if (where)
printf("first match is %d.\n", (int) *where);
else
puts("No characters match.");
return 0;
}
/*
Enter a string:
zzzAn
first match is 65.
*/

[Serve L]

"wswilson" <ws******@gmail.comschreef in bericht
news:06**********************************@e39g2000 hsf.googlegroups.com...

In python, I could write:

a = 1

if a in [1, 2]:
do something...
In c (and many other languages):

int a = 1;

if (a == 1 || a == 2) {
do something...
}

Is there a shorter, cleaner syntax?

Its funny to see what you all come up with while the answer is "no there is
no cleaner way as in python"

[Paul Hsieh]

On May 2, 8:21 am, "Bartc" <[e-mail]:

"wswilson" <[e-mail] in message
news:06**********************************@e39g2000 hsf.googlegroups.com...

In python, I could write:

a = 1

if a in [1, 2]:
do something...

Is this supposed to be an example of a /fast/ method? I think Python creates
an array containing 1 and 2, then searches it for a.

I wouldn't be surprised if this was faster. In Python, or any
interpreted byte-code executed language, reducing the number of byte-
codes is usually more important than the performance of the byte-code
itself. If the vector [1,2] is created at interpretation time (I
don't know if it is or it isn't), then certainly this is probably the
fastest approach in python.

Being neat and short isn't necessarily fast. However you do it in C, it will
be faster.

Indeed. All benchmarks I have seen and written myself put C at
between 50 and 200 times faster than Python on a wide variety of
code. So its always humorous when I hear about things like "Iron
Python" which are supposed to be remarkable for making Python execute
about 3 times faster.

--
Paul Hsieh
http://www.pobox.com/~qed/
http://bstring.sf.net/

[Bartc]

"Paul Hsieh" <we******@gmail.comwrote in message
news:c4**********************************@b9g2000p rh.googlegroups.com...

On May 2, 8:21 am, "Bartc" <[e-mail]:

>"wswilson" <[e-mail] in message
news:06**********************************@e39g200 0hsf.googlegroups.com...

In python, I could write:

a = 1

if a in [1, 2]:
do something...

>Being neat and short isn't necessarily fast. However you do it in C, it
will
be faster.

Indeed. All benchmarks I have seen and written myself put C at
between 50 and 200 times faster than Python on a wide variety of
code. So its always humorous when I hear about things like "Iron
Python" which are supposed to be remarkable for making Python execute
about 3 times faster.

I'd been developing interpreted languages for years to go with my
applications.

For pure integer code, I always found it difficult to break the 10x slower
barrier compared with, say, C (although I'm currently working on that!).

But, I had decided originally that when the interpreted language was used
properly, it should only be between 1x to 2x as slow as a compiled
equivalent, and in most cases this was achieved, while making development a
delight because it was so easy.

Even forgetting library calls, an interpreted language doing high level
things (working with strings, entire arrays, etc) can compare well with pure
C.

--
Bartc

[Dann Corbit]

"Bartc" <[e-mail] in message
news:0T******************@text.news.virginmedia.co m...

>
"Paul Hsieh" <we******@gmail.comwrote in message
news:c4**********************************@b9g2000p rh.googlegroups.com...

>On May 2, 8:21 am, "Bartc" <[e-mail]:

>>"wswilson" <[e-mail] in message
news:06**********************************@e39g20 00hsf.googlegroups.com...
In python, I could write:

a = 1

if a in [1, 2]:
do something...

>>Being neat and short isn't necessarily fast. However you do it in C, it
will
be faster.

Indeed. All benchmarks I have seen and written myself put C at
between 50 and 200 times faster than Python on a wide variety of
code. So its always humorous when I hear about things like "Iron
Python" which are supposed to be remarkable for making Python execute
about 3 times faster.

I'd been developing interpreted languages for years to go with my
applications.

For pure integer code, I always found it difficult to break the 10x slower
barrier compared with, say, C (although I'm currently working on that!).

But, I had decided originally that when the interpreted language was used
properly, it should only be between 1x to 2x as slow as a compiled
equivalent, and in most cases this was achieved, while making development
a delight because it was so easy.

Even forgetting library calls, an interpreted language doing high level
things (working with strings, entire arrays, etc) can compare well with
pure C.

Most of the time, scripting languages are used as drivers for compiled
programs. For this purpose, they really excel. I don't know why people
want to pan languages like Python or Perl because they make life so much
easier.

There are definitely projects where I would choose to write the major
portion in (for instance) Java. Nothing wrong with that. If it cuts
development cost and maintenance effort and is still fast enough, then it is
foolish to choose another method that might be a tiny bit faster but cost a
lot more.

Computer languages all have their strengths and weaknesses. There is no
"one size fits all" language that I know of. Each one has its own area
where it is the better choice.

IMO-YMMV
** Posted from http://www.teranews.com **

[dj3vande]

In article <0T******************@text.news.virginmedia.com> ,
Bartc <[e-mail]:

>For pure integer code, I always found it difficult to break the 10x slower
barrier compared with, say, C (although I'm currently working on that!).

But, I had decided originally that when the interpreted language was used
properly, it should only be between 1x to 2x as slow as a compiled
equivalent, and in most cases this was achieved, while making development a
delight because it was so easy.

Even forgetting library calls, an interpreted language doing high level
things (working with strings, entire arrays, etc) can compare well with pure
C.

Interpreted languages doing high level things are most likely
translating one or two language primitives into "call a big chunk of
compiled code", and when you're doing that the return on investment for
spending extra time optimizing the compiled code goes way up, so it
usually ends up faster than writing the code directly in C. (Unless
you do something dumb like using an expensive language primitive to do
an operation that can be done cheaply without it.)
Compiling to native code wins easily when you can't reduce code that
does nontrivial things to a short sequence of language primitives,
though, since the interpreter has to stop and look up what to do again
after every interpreted-language instruction, and compiled code can
skip that part.

I work with people who like to write everything in Matlab.
For what it's good at (pretty much any easy-to-describe numerical
computation), I won't even bother trying to make my C run as fast as
the Matlab runtime. I occasionally convert Matlab code to something we
can call from a C program without having to ship with the Matlab
runtime, but if it's performance-critical I'll tell them to just ship
the Matlab code.
But occasionally they'll come to me with code that loops over a big
array doing something that there aren't Matlab primitives to do
array-at-a-time and that's way too slow, and when that happens I can
easily get a factor of five or ten speedup even before I ask the
compiler to optimize it (i.e. working with one hand tied behind my
back), just by writing C code to do the same thing.
Good interpreted languages[1] make it easy to write compiled-to-native
code and call it from the interpreted scripts, which essentially lets
the user-programmer write their own primitives. Though making it as
easy to optimize as aggressively as they do for the builtin ones is a
little bit harder, and well beyond the scope of what the people who
sell the interpreted languages are trying to do.
dave

[1] Matlab meets this criterion for "good" (it's the only one I've had
reason to find out about).

--
Dave Vandervies dj3vande at eskimo dot com

Have you checked under your desk for stray sixes?

So *that's* where the beast is!
--Normal L. DeForest and Stuart Lamble in the scary devil monastery