K
Keith Thompson
[...]Fred Kleinschmidt said:
Why do you presume that? The OP specifically referred to the "input
integer".
Why do you presume that? The OP specifically referred to the "input
integer".
K
Keith Thompson
Malcolm McLean said:
<OT>
It's on my bookshelf, preceded by Eli Maor's book about e, Paul
J. Jahin's book about i (sqrt(-1)), petr beckmann's book about pi, and
the Beatles' album "1".
</OT>
R
Richard Tobin
[/QUOTE]
Lisp of course has always had the option of returning a list or nil
(which is the same as the empty list in most Lisps), but that's not
what I was referring to.
Common Lisp has a mechanism specifically for returning multiple
values. If a function uses (values 1 2 3) to return, it returns three
values, 1, 2, and 3. A caller that does not care about this just sees
the single value 1, but a caller that wants all the values can see
them using constructs such as multiple-value-bind. If a function uses
(values) to return, it returns no values. A caller that doesn't care
about this will instead see the value nil returned.
For example, the floor function returns two values: the rounded-down
value of its argument and the remainder. Callers that only want the
rounded-down value (probably the usual case) just treat it as an
ordinary function, and don't see the second return value.
Sufficiently Clever [tm] Compilers can detect this and avoid
calculating the unnecessary value.
-- Richard
M
Malcolm McLean
One would have thought that the Beatles would write an album on the roots ofKeith Thompson said:
unity.
Anyway, there's an obvious gap in the market for a title, phi.
A
Army1987
Which is *exactly* what I suggested in the post he was replying
to. He's still in my killfile, but I see he isn't showing any sign
of getting even ever-so-slightly closer to posting anything
useful...
7
7atim.Ld
well you have one issue.in stead of returnig nothing,the fonction will
return a value like 0 or -1.
then in the main programme you can add a test so you can be sure if
it's a prime number or not.
#incldue<stdio.h>
int n;
int prime(int x)
{int r;
if(x%2!=0) r=x;
else r=0;
return r;
}
void main()
{
printf("give your number");scanf("%d",&n);
if(prim(n)!=0)
printf("%d",n);
}
getch();
7aT!M
R
Richard Tobin
Michal Nazarewicz said:Well... i is not really sqrt(-1) since there are two complex numbers
which are not equal to one another which power of two is equal -1 and
i cannot be equal to both numbers.
Would you also say that 2 is not really sqrt(4), since there are
two real numbers whose square is 4 and 2 cannot be equal to both
of them?
(You do have a point though: there is no way to distinguish between
i and -i.)
-- Richard
M
Michal Nazarewicz
Keith Thompson said:
Well... i is not really sqrt(-1) since there are two complex numbers
which are not equal to one another which power of two is equal -1 and
i cannot be equal to both numbers.
A
Alexei A. Frounze
Another (perverse) alternative is to not return at all... in a
conventional way. Use longjump() for the "emergency return" from the
function.
Alex
K
Keith Thompson
Um, -i is the one with the minus sign in front of it.
Seriously, I'm not sure what you mean by "no way to distinguish". For
positive operands, only the positive square root is considered to be
*the* square root (e.g., sqrt(4.0) is 2.0, not -2.0). Similar rules
apply for negative and even complex operands.
C99 supports a complex square root function, csqrt (plus csqrtf and
csqrtl for float complex and long double complex, respectively).
C99 7.3.8.3 says:
The csqrt functions compute the complex square root of z, with a
branch cut along the negative real axis.
The csqrt functions return the complex square root value, in the
range of the right halfplane (including the imaginary axis).
Both in C and in mathematics, sqrt(-1) is i, not -i (or I as C's
<complex.h> calls it).
(See, we're topical again!.)
C
C. Benson Manica
That's a bit fractured, but at least it's feasible. The code you
posted, however...
....contains two obvious typos, an invalid declaration for main, and a
misplaced invocation of a nonstandard function. (It also has some
problems at runtime, assuming it were fixed to a point where it could
be compiled.)
J
jaysome
Good advice. And name the function something like "is_prime".
/*prototype*/
int is_prime(int i);
/* code that calls is_prime()*/
if ( is_prime(i) )
{
/*i is a prime number*/
}
Regards
C
Coos Haak
Op 20 Sep 2007 09:57:05 GMT schreef Richard Tobin:
Right, but which square root of -1 is the positive one?
Imagine you're talking to an alien, and you want to describe the
square roots of 4. There are two of them, and one of them happens to
have the property that when you add it to itself, you get four again.
So you can easily specify which one you're talking about (and of
course you can do it in lots of other ways).
Now you want to describe the square roots of -1. There are two of
them, but which is the one you call i? Suppose he calls the square
root of -1 j: is j the same as i or is it -i? There's no way to tell.
[/QUOTE]
i nor -i is the square root of -1.
i squared and -i squared both equal -1.
Not the other way round.
Um, -i is the one with the minus sign in front of it.
Seriously, I'm not sure what you mean by "no way to distinguish". For
positive operands, only the positive square root is considered to be
*the* square root (e.g., sqrt(4.0) is 2.0, not -2.0). Similar rules
apply for negative and even complex operands.
Right, but which square root of -1 is the positive one?
Imagine you're talking to an alien, and you want to describe the
square roots of 4. There are two of them, and one of them happens to
have the property that when you add it to itself, you get four again.
So you can easily specify which one you're talking about (and of
course you can do it in lots of other ways).
Now you want to describe the square roots of -1. There are two of
them, but which is the one you call i? Suppose he calls the square
root of -1 j: is j the same as i or is it -i? There's no way to tell.
[/QUOTE]
i nor -i is the square root of -1.
i squared and -i squared both equal -1.
Not the other way round.
R
Richard Tobin
[/QUOTE]
Um, -i is the one with the minus sign in front of it.
Seriously, I'm not sure what you mean by "no way to distinguish". For
positive operands, only the positive square root is considered to be
*the* square root (e.g., sqrt(4.0) is 2.0, not -2.0). Similar rules
apply for negative and even complex operands.
Right, but which square root of -1 is the positive one?
Imagine you're talking to an alien, and you want to describe the
square roots of 4. There are two of them, and one of them happens to
have the property that when you add it to itself, you get four again.
So you can easily specify which one you're talking about (and of
course you can do it in lots of other ways).
Now you want to describe the square roots of -1. There are two of
them, but which is the one you call i? Suppose he calls the square
root of -1 j: is j the same as i or is it -i? There's no way to tell.
-- Richard
R
Ralf Damaschke
Not exactly, but if the interface really cannot be changed,
here you are:
int checkprime (int i)
{
int isprime = 1;
/* code to set isprime to 0 if i is not prime */
if (isprime)
return i;
}
Of course the caller of this function must take special care.
The following would not yet cross the frontier to the land
of undefined behavior:
#include <stdio.h>
int main (void)
{
if (checkprime(32323))
puts("32323 is prime");
checkprime(31313);
puts("31313 is not prime");
return 0;
}
Ralf
R
Richard Bos
C. Benson Manica said:
It's a perfectly good and perfectly normal way to handle such functions
in dynamically typed languages. You could do something like
list_print(object)
if typeof object = string
print "'" trim(object) "'"
elseif typeof object = number
print format(object, "*.##", false)
elseif typeof object = logical
print (if object: "yes" else: "no")
elseif typeof object = null
print "(nothing)"
else
print "(something odd)"
end
C, however, is statically typed, so this doesn't work, at least not
without using a struct or something similar.
Richard
R
Richard Tobin
Coos Haak said:
What makes you think that?
-- Richard
M
Michal Nazarewicz
The same thing I've pointed. In real number domain a square root of
x is defined to be _nonnegative_ number which squared gives x. You
cannot apply analogical definitions to complex numbers since there is no
such think as nonnegative complex number (or nonpositive for that
matter).
R
Richard Heathfield
Michal Nazarewicz said:
Sorry, but I must disagree. I can accept that there is no such thing as a
positive imaginary number, and no such thing as a negative imaginary
number, but I cannot accept that there is no such thing as a non-negative
*complex* number. A complex number has a (possibly zero but usually not)
real number element which is sufficient to displace it off the zero line
in the complex plane. Most numbers in the complex plane are either to the
right of the zero line (positive) or to its left (negative), regardless of
the value of their imaginary co-ordinate.
Sorry, but I must disagree. I can accept that there is no such thing as a
positive imaginary number, and no such thing as a negative imaginary
number, but I cannot accept that there is no such thing as a non-negative
*complex* number. A complex number has a (possibly zero but usually not)
real number element which is sufficient to displace it off the zero line
in the complex plane. Most numbers in the complex plane are either to the
right of the zero line (positive) or to its left (negative), regardless of
the value of their imaginary co-ordinate.
R
Richard Tobin
[/QUOTE]
No, this is not true. The sqrt() function is defined to return the
non-negative square root, and the square root symbol has the same
convention, but a number (other than zero) has two square roots. Of
course you might be able to find someone who uses a different
convention, but it's not usual. Search for square root with Google,
and look at the first few references such as Wolfram and Wikipedia.
The same applies to other uses of "root" in maths: consider nth roots
of unity, roots of equations, and so on.
-- Richard