Complex numbers and printf

[jacob navia]

The C99 standard forgot to define the printf equivalent for complex numbers
Since I am revising the lcc-win implementation of complex numbers
I decided to fill this hole with
"Z"

for instance
double _Complex m = 2+3*I;
printf("%Zg\n", m);
will print
2+3*I

The alternative flag makes this look like:

printf("%#Zg\n" ,m);
2.00000+3.00000 i

--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32

[Keith Thompson]

jacob navia <ja***@nospam.c omwrites:

The C99 standard forgot to define the printf equivalent for complex numbers

I doubt that they forgot; they probably just didn't feel it was
necessary. In my opinion, they were right.

Since I am revising the lcc-win implementation of complex numbers
I decided to fill this hole with
"Z"

Do you have a similar extension for scanf?

for instance
double _Complex m = 2+3*I;
printf("%Zg\n", m);
will print
2+3*I

The alternative flag makes this look like:

printf("%#Zg\n" ,m);
2.00000+3.00000 i

I see no problem with this extension in terms of conformance to the
standard. Though I don't see any particular need for a special format
for complex numbers, I wouldn't object if such a format were added to
a future version of the standard.

However, if I were a user of lcc-win, I probably wouldn't use it in my
own code, for several reasons.

First, it is of course an extension. Unless my code already depends
on other lcc-win extensions, I'd rather not limit its portability for
the sake of a minor convenience.

Second, it's inflexible; it imposes one of two output representations
for complex numbers. If I want to print "2+3*I", I can write:

printf("%g+%g*I \n", creal(m), cimag(m));

If I want to print "2 + 3i", of course, I can write:

printf("%g + %gi\n", creal(m), cimag(m));

which your extension doesn't support, but the standard already does.

In effect, I tend to think of a complex number as a number (usually)
for purposes of arithmetic, but as a composite structure for purposes
of I/O. Perhaps that's just me.

Finally Fortran has supported complex numbers, and I/O on them, since
dinosaurs walked the Earth. The result of printing 2+3*I in Fortran
would be "(2.,3.)" (at least by default using g77; I don't know
Fortran well enough to know whether that's standard). That form is
also valid in Fortran source as a complex literal (insert previous
disclaimer here).

Note that a parenthesized format might make things easier for a
corresponding scanf extension.

This is not to say that your extension is a bad idea, merely that I
personally don't find it to be a sufficiently good idea to pique my
interest. (And yet here I am writing about it at some length.)

Or, as "Gerry Ford" might put it, "Bertha termite prefecture
psychopomp inhabit dovetail statuette virus superlative deposition."

--
Keith Thompson (The_Other_Keit h) <ks***@mib.or g>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[CBFalconer]

jacob navia wrote:

>
The C99 standard forgot to define the printf equivalent for
complex numbers

I don't believe so. Formatting of such dumps is easily done by
selecting the real and imaginary portions, and using the existing
printf operations to format them. Why standardize something that
will not be used and is unnecessary?

--
[mail]: Chuck F (cbfalconer at maineline dot net)
[page]: <http://cbfalconer.home .att.net>
Try the download section.

--
Posted via a free Usenet account from http://www.teranews.com

[Walter Roberson]

In article <87************ @kvetch.smov.or g>,
Keith Thompson <ks***@mib.orgw rote:

>Second, it's inflexible; it imposes one of two output representations
for complex numbers. If I want to print "2+3*I", I can write:

printf("%g+%g*I \n", creal(m), cimag(m));

>If I want to print "2 + 3i", of course, I can write:

printf("%g + %gi\n", creal(m), cimag(m));

>which your extension doesn't support, but the standard already does.

Then there is engineering, in which the imaginary constant is
usually represented as 'j' instead of 'i' or 'I'.
--
"Style is instinctive and few achieve it in a notable degree. Its
development is not hastened by instruction. It comes or it doesn't.
It will take care of itself." -- Walter J. Phillips

[Nelu]

On Fri, 29 Feb 2008 16:08:59 +0000, Nelu wrote:
<snip>

printf ("%f+%f*I\n",re al(m),imag(m)) is not that big of an effort, is

That's probably creal and cimag. I think the real/imag forms are only
available in C++.
--
Ioan - Ciprian Tandau
tandau _at_ freeshell _dot_ org (hope it's not too late)
(... and that it still works...)

[Walter Roberson]

In article <47************ ***@yahoo.com>,
CBFalconer <cb********@mai neline.netwrote :

>jacob navia wrote:

>The C99 standard forgot to define the printf equivalent for
complex numbers

>I don't believe so. Formatting of such dumps is easily done by
selecting the real and imaginary portions, and using the existing
printf operations to format them. Why standardize something that
will not be used and is unnecessary?

Because it gives an opportunity to demonstrate the incomparible
beauty of operator overloading??
--
"To all, to each! a fair good-night,
And pleasing dreams, and slumbers light" -- Sir Walter Scott

[jacob navia]

Walter Roberson wrote:

In article <47************ ***@yahoo.com>,
CBFalconer <cb********@mai neline.netwrote :

>jacob navia wrote:

>>The C99 standard forgot to define the printf equivalent for
complex numbers

>I don't believe so. Formatting of such dumps is easily done by
selecting the real and imaginary portions, and using the existing
printf operations to format them. Why standardize something that
will not be used and is unnecessary?

Because it gives an opportunity to demonstrate the incomparible
beauty of operator overloading??

Operator overloading in printf?

Funny how much nonsense you can say. Are you paid by the nonsense line?

Or you do it for free as a hobby?
--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32

[Bartc]

"jacob navia" <ja***@nospam.c omwrote in message
news:fq******** **@aioe.org...

The C99 standard forgot to define the printf equivalent for complex
numbers
Since I am revising the lcc-win implementation of complex numbers
I decided to fill this hole with

printf("%Zg\n", m);

2+3*I

printf("%#Zg\n" ,m);
2.00000+3.00000 i

As has been mentioned, it may not be flexible enough for all situations, but
may be convenient sometimes.

But inventing new printf formats is fun; how about the following for
printing arrays and blocks of data:

int a[] = {10,20,30,40,50 ,60};

printf(" (%A,%d)\n",a,6) ;

will print: (10,20,30,40,50 ,60)

%A means array print, the parameter should point to the data. An extra
int/size_t parameter is how many values to print. The format of each element
follows (%d). The text between %A and %d is separator chars. Maybe %10A for
10 elems per line.

Might get more use than %Z anyway.

--
Bart

[Morris Dovey]

Bartc wrote:

But inventing new printf formats is fun; how about the following for
printing arrays and blocks of data:

int a[] = {10,20,30,40,50 ,60};

printf(" (%A,%d)\n",a,6) ;

will print: (10,20,30,40,50 ,60)

%A means array print, the parameter should point to the data. An extra
int/size_t parameter is how many values to print. The format of each element
follows (%d). The text between %A and %d is separator chars. Maybe %10A for
10 elems per line.

Might get more use than %Z anyway.

Cool! How about:

printf("%f",a[i=0; i<6; i++]);

--
Morris Dovey
DeSoto Solar
DeSoto, Iowa USA
http://www.iedu.com/DeSoto/Stirling/

[Martin Ambuhl]

Bartc wrote:

But inventing new printf formats is fun; how about the following for
printing arrays and blocks of data:

int a[] = {10,20,30,40,50 ,60};

printf(" (%A,%d)\n",a,6) ;

will print: (10,20,30,40,50 ,60)

%A means array print,

You'll need to choose some other specifier. "%A" already is defined for
signed hexadecimal floating-point conversion.

[burton.samogradNOSP]

Morris Dovey <mr*****@iedu.c omwrites:

Bartc wrote:

Cool! How about:

printf("%f",a[i=0; i<6; i++]);

Heh, I just had to try that thinking I missed a new feature of C99 ;-)

--
burton