HDTenEightyP/NetNews huggingface dataset:
From: mjs@hubcap.clemson.edu (M. J. Saltzman)
Subject: Re: pointer to multi D array. How?
Organization: Clemson University, Clemson SC
Date: Fri, 28 Aug 1992 16:44:52 GMT

In article <28AUG199208202210@envmsa.eas.asu.edu> ptran@envmsa.eas.asu.edu (Phi-Long Tran) writes:
>In article <RICHARD.92Aug27181915@CLYDE.ttt.kth.se>, 
>RICHARD@CLYDE.ttt.kth.se writes...
>>In article <1992Aug26.050053.114348@zeus.calpoly.edu> 
>clin@zeus.calpoly.edu (Chihtsung Jeffrey Lin) writes:
>
>>> ...  How do you declare a pointer to a multi-dimensional array?  [H]ere
>>> is what I did.
>>> int A[5][5]:={1,2,3,......}, **x;
>
>> Make that:
>> int A[5][5]={1,2,3,.....}, *x;
>
>     Why not make an actual pointer to an array?  It may make references
>easier to code.  For example, a pointer to the array A declared above would
>be, "int (*ptrA)[5][5]".  Then we could reference array A with ptrA as:
>
>     ptrA = &A;		 /* Assign ptrA the address of array A. */
>     (*ptrA)[5][0] = 1;	 /* (*ptrA) is the array A. */
>
>The pointer to the array, as in the above, is useful for dynamically
>allocating multi-dimensional arrays or changes the starting address of any
>array.

Actually, I think you want

	int A[5][5] = {...}, (*x)[5];

That makes x a pointer to the same type as an element of A, namely,
an array of 5 ints.  Then 

	x = A;     /* equivalent to x = &A[0] */

	x[1][3] = 4;  /* equivalent to *(*(x + 1) + 3) = 4 */

are legal, and behave the way you would expect.

In response to another thread, I thought this was one of the hardest
aspects of C to learn--not so much pointers, but the relationship between
pointers and arrays (also the relationship between pointers and array
parameters in function calls).


-- 
		Matthew Saltzman
		Clemson University Math Sciences
		mjs@clemson.edu
Newsgroups: comp.lang.c,comp.lang.c++
From: mjn@pseudo.uucp (Murray Nesbitt)
Subject: Re: Difference between malloc and calloc
Organization: Private system in Toronto, ON
Date: Wed, 2 Sep 1992 08:45:04 GMT


sdarbha@ha17.eng.ua.edu (Subrahmanyam Darbha) writes:

>The only difference between malloc() and calloc() is that calloc() 
>initializes the memory pointed to by NULLs.

No, it does not.  calloc() stores zeros in the allocated array.

-- 
Murray
Newsgroups: comp.lang.c
From: blume@atomic.Princeton.EDU (Matthias Blume)
Subject: Re: Freedom of Speech (was: Mister Ed Nilges)
Reply-To: blume@atomic.Princeton.EDU (Matthias Blume)
Organization: Dept. of Computer Science, Princeton University
Distribution: usa
Date: Sun, 30 Aug 1992 18:38:26 GMT

In article <92243.054650IP25179@portland.caps.maine.edu>,
IP25179@portland.caps.maine.edu writes:
|> 
|>   [Text of extremely nasty put down of someone who used more parens
than were
|>   strictly speaking necessary deleted.  Suffice to say it was way out-of-
|>   line.]
|> 
|>   Keep in mind also that there are many versions of C (and C++) out there.
|>   Some of us have to program in several of them, and NOT ALL OF THEM
HAVE THE
|>   SAME OPERATOR PRECEDENCE.

Are you serious?  I would not call any compiler a ``C-compiler'' if it
employs a
operator-precedence different from the Ritchie-C-Compiler or nowadays different
from ANSI!

[stuff deleted]
|> 
|>   -Iain Odlin


--Matthias
Newsgroups: comp.lang.c
From: gjlai@csie.nctu.edu.tw (Guan-Joe)
Subject: How to convert FORTRAN to C?
Organization: Computer Science & Information Engin., Chiao-Tung U, Taiwan, ROC
X-Newsreader: Tin 1.1 PL5
Date: Mon, 31 Aug 1992 16:52:32 GMT

Hi,
	Does anybody know how to get the translator for FORTRAN to C, under UNIX system? Thanks.

	Best Regards, G.J. Lai ,e-mail: gjlai@csie.nctu.edu.tw
Newsgroups: comp.lang.c
From: gwh@elric.cs.mcgill.ca (Gene W. Homicki)
Subject: Turbo C question
Keywords: Turbo C I/O pipe
Organization: SOCS, McGill University, Montreal, Canada
Date: Fri, 28 Aug 1992 14:00:43 GMT


Hi there,

	I have what should be a relatively simple question about 
Turbo C.... Is it possible to run another DOS program ( system() )
and get it's output into the calling program....something along
the lines of "popen()"..?  

	I'd _really_ rather not redirect the output to a file and then
read the file intot the main program....this seems rather messy. Any
help is appreciated.  Thanks. :-)

					--Gene

---
School of Computer Science		Gene W. Homicki
McGill University			gwh@elric.cs.mcgill.ca
Montreal   Canada
Xref: sparky comp.lang.c:12889 comp.sys.sun.misc:3972
From: zimerman@phoenix.Princeton.EDU (Jacob Ben-david Zimmerman)
Subject: Could someone email me a pointer to the 'bignum' package?
Originator: news@nimaster
Organization: Princeton University
Date: Mon, 31 Aug 1992 21:02:56 GMT

I remember a while back I managed to get hold of a C library called the
Bignum package - I think from DEC - that did math ops on large
(~100-200digit) integers.  I have need of that package, and of course
sinc graduating I can't remember where I got it.  If anyone out there
knows where this package could be found, I'd love a pointer to it.  I
have ftp access.  Thanks!  I am trying to write a Mac app that uses
laaarge integers, soooo.. :-) (larger than SANE will handle without
extensive mucking about. :-))

-Thanks again,
-JBZimmerman!
-- 
___________           |-Is that Scotch over there?  Hold everything.
     ||               |                -Sean Connery, The Russia House
||   ||acob Zimmerman!+> <zimerman@phoenix.Princeton.EDU> INTERNET 
 \===/                |  <zimerman@PUCC>                  BITNET
Newsgroups: comp.lang.c
From: cflatter@nrao.edu (Chris Flatters)
Subject: Re: How is NaN recognized?
Reply-To: cflatter@nrao.edu
Organization: NRAO
Date: Sun, 30 Aug 1992 22:45:24 GMT

In article 5569@ucsbcsl.ucsb.edu, 6500mack@ucsbuxa.ucsb.edu (Michael P. Mack) writes:
>I am using scanf() to read in a float that is entered by the user.  If
>an invalid string is typed such as "-" or "." then the variable is
>assigned -0.NaN(DFD5480000000000... or -0.NaN(DFD9400000000000000...
>
>How do I detect when the float is a NaN so that I can set it to 0.0?
>

If your C compiler vendor was doing a good job you should have an isnan()
function or macro available to you.  If not you can make your own as follows
(assuming your fp implementation comforms to IEEE-754)

#define isnan(x) (x) != (x)

A NaN is equal to nothing --- not even itself.

	Chris Flatters
	cflatter@nrao.edu


Newsgroups: comp.lang.c
From: chans@marsh.cs.curtin.edu.au (Sean Chan)
Subject: Passing 2D dynamic array to function
Organization: Curtin University of Technology
Date: Sun, 30 Aug 1992 17:27:27 GMT

Yup its me again...(apologies for not posting all my questions
together).

I have a 2D array declared as int **array. How do I pass that to a
function?? I've tried :-

   int func (int **ar, int ...etc.)

however, I have a feeling that I'm not passing the pointer to the array
to the function.

Sean
From: dave@cs.arizona.edu (Dave Schaumann)
Newsgroups: comp.lang.c
Subject: Re: Order of execution...
Keywords: Umm, Uhh, Well, Daa, Gee
Date: 30 Aug 92 23:42:10 GMT
Reply-To: dave@cs.arizona.edu (Dave Schaumann)
Distribution: usa
Organization: University of Arizona

In article <behrenss.715196434@hphalle6>, behrenss@Informatik (Soenke Behrens) writes:
>linley@seas.ucla.edu (Bruce Linley) writes:
>
>>This subroutine is supposed to convert a string to all lower case:
>>int StripCase(textLine)
>>char textLine[];
>>{
>>  register int index = 0;
>>  
>>  while ((textline[index++] = tolower(textLine[index])) != '\0');
>>}
>>The question is will it always work?
>
>No. 
>
>Better would be: 
>
>for(;(textline[index] = tolower(textline[index])) != '\0';index++);
>                                    ^
>				    I assume you made a typo here and
>				    there is no textLine.
>
>BTW, this will only work for "printable" ASCII characters, so you are in
>the dark if the text uses Umlaute or similar.

There is also another problem with the code, if you are concerned with
porting the code to a non-ANSI compiler:

	When using non-ANSI implementations, you should be wary of the value
	returned by tolower when its argument is not an uppercase letter, and 
	of the value returned by toupper when its argument is not a lowercase
	letter.  Many non-ANSI implementations work correctly only when the
	argument is a letter of the proper case.

				H&S, section 12.9

-- 
Caught an internal error--.brainrc restored
Newsgroups: comp.lang.c,comp.unix.programmer,comp.sys.sun.misc
From: fitzgb@mml0.meche.rpi.edu (Brian Fitzgerald)
Subject: Re: SunOS 4.1.2: Increasing per process file pointers
Organization: Rensselaer Polytechnic Institute, Troy, NY
Date: Wed, 2 Sep 1992 00:35:24 GMT

Hugh Warren writes:
>How can you increase the number of open file pointers allowable
>per process under SunOS 4.1.2?  I'm hitting a limit of 60 using
>fopen() right now.  Thanks for any help...

To increase your descriptor limit to 256:

csh:	limit descriptors 256
bash:	ulimit -n 256
sh:	sorry :-(
C:	

#include <sys/time.h>
#include <sys/resource.h>

static struct rlimit rl = { 256, 256 };
...
    if(setrlimit(RLIMIT_NOFILE, &rl) == -1) {
        perror("setrlimit");
        exit(1);
    }

If you want > 256, then maybe adjust NOFILE in /sys/sys/param.h,
rebuild the kernel, and reboot.  With luck, this works without sun
sources.  Haven't tried.

Brian
Newsgroups: comp.lang.c
From: henders@infonode.ingr.com (Greg Henderson)
Subject: Re: Why should POINTERS be so damn hard to understand ?
Organization: Intergraph Corporation, Huntsville, AL.
Date: Fri, 4 Sep 1992 14:08:51 GMT

rot@multisys.com (Republic of Taiwan) writes:
  *** code you've no doubt seen before deleted for brevity ***
>==These two pieces of code do the exact same thing, but if you are 
>==worried about low-level efficiency the second version is a little
>==tighter, as each reference to the array value in the pointer version
>==requires less work to come up w/ that address.

I should probably have put the qualification here that this generalization
may not hold true for every compiler, just the stupid ones... ;)

>The presumption here is that the length of int is same as
>the length of the address space.

>If the int is 4 byte long and the address space is 2(or 8 or 3) byte long,
>the this fell miserably. The second one is not portable.

Wrongo, buddy.  The whole point of the example code was that C knows
how many bytes to increment the pointer such that it will point to the
next item in the array, because the pointer has a type ... (Wasn't
that the whole point of this initial thread, a question about why
pointers need to be typed?)

The examples could be written using some structure, char, double,
whatever instead of int and they still would work.  That was my point,
which maybe got lost in the jumble somewhere I guess...

>=Isn't that a function of the compiler? In fact, let me ask why don't we
>=have compilers that produce the most efficient code even when array
>=notation is used? Is it that they would be too slow? I recall a FORTRAN

Well we do have compilers that do this, but unfortunately, not all do.
This is more of a concern if you are working on an older platform,
that might not have all the latest advances than if you are working
with a compiler that you just got yesterday (figuratively speaking...)

-- 

Greg Henderson   henders@infonode.ingr.com   ...uunet!ingr!infonode!henders


Xref: sparky comp.lang.c:13192 comp.sys.sun.misc:4080
Newsgroups: comp.lang.c,comp.sys.sun.misc
Subject: Re: sun cc optimization failure
From: selig@sysjj.mdcbbs.com
Date: 3 Sep 92 12:34:28 GMT
Organization: McDonnell Douglas M&E, Cypress CA
Nntp-Posting-User: selig

> consider the following program:
> 
> main() {
> 	int i,j,ax;
> 	ax = 0;
> 	for(i=0;i<3;i++){
> 		j = ax * i;
> 		puts("in for loop");
> 	}
> }
> when compiled with cc (sun os 4.1 on sparc 1+), the 
> code runs thru the loop three times. when comiled with 
> the -O flag it only runs once. how come the optimization 
> screws up the loop?
> --
          If you're entertaining wild guesses, mine is that the
          compiler picked up that since ax is zero, j will always be
          zero.

          Try initializing ax to a non-zero number.


          Dan
From: karl@ima.isc.com (Karl Heuer)
Newsgroups: comp.lang.c
Subject: Re: How do I portably code a function to be vararg?
Date: 1 Sep 92 22:55:52 GMT
Article-I.D.: ima.1992Sep01.225552.7726
Organization: Interactive Systems, Cambridge, MA 02138-5302

In article <1992Sep1.193206.13672@cas.org> lvirden@cas.org (Larry W. Virden) writes:
>I have a function which will need to compile under ANSI and pre-ANSI compilers.
>In all environments, there are varargs.h - in at least one there is no 
>stdarg.h
>
>What would be the Politically Correct method of coding this?

Solution 1:
	#include <stdio.h>
	#if defined(__STDC__)
	#include <stdarg.h>
	void error(char *fmt, ...)
	#else
	#include <varargs.h>
	void error(va_alist) va_dcl
	#endif
	{
	    va_list argp;
	#ifdef __STDC__
	    va_start(argp, fmt);
	#else
	    char *fmt;
	    va_start(argp);
	    fmt = va_arg(argp, char *);
	#endif
	    fprintf(stderr, "fatal error: ");
	    vfprintf(stderr, fmt, argp);
	    va_end(argp);
	    exit(1);
	}

Solution 2: (My personal preference)
	/*
	 * If your compiler doesn't accept prototypes, use `deproto' in your
	 * Makefile.  If you don't have <stdarg.h>, create one based on the
	 * existing <varargs.h>, or use the one supplied with this package;
	 * and compile with the `-I.' flag.
	 */
	#include <stdio.h>
	#include <stdarg.h>
	void error(char *fmt, ...) {
	    va_list argp;
	    va_start(argp, fmt);
	    fprintf(stderr, "fatal error: ");
	    vfprintf(stderr, fmt, argp);
	    va_end(argp);
	    exit(1);
	}

Karl W. Z. Heuer (karl@ima.isc.com or uunet!ima!karl), The Walking Lint
________
/* Sample implementation of <stdarg.h> (public domain) */
#if !defined(_H_STDARG)
#define _H_STDARG
typedef char *va_list;
#define va_start(ap, parmN) (ap = (char *)&parmN + sizeof(parmN))
#define va_end(ap)
#define va_arg(ap, type) (ap += sizeof(type), *((type *)ap - 1))
#endif /* include guard */
Newsgroups: comp.lang.c
From: henders@infonode.ingr.com (Greg Henderson)
Subject: Re: help me get started in C
Organization: Intergraph Corporation, Huntsville, AL.
Date: Thu, 27 Aug 1992 14:22:13 GMT

jwarner@mrcnext.cso.uiuc.edu (Jack E. Warner) writes:

>Thanks in advance to anyone answering my queries. I have received guidance
>from other newsgroups when learning a new language and it helps tremendously.
>The C class is full so I'm going to read the books and try to keep up with
>it anyway. I would like to learn how to do ``simple'' tasks in C like: 
.
.
.
>   2.  inspired by a recent database programming contract job, a C utility
>       to print the number of characters per paragraph (\015) and the number
>       of paragraphs, such that the output looks something like:
>       
>            	line number 001 contains 192 characters

My guess is that these little tasks were recently inspired by your 
programming class...  ;)   But seriously, you shortchange yourself if
you let someone else do your work for you and you don't even take a
whack at it.   Take a look at the examples in your book, read it as
you said you would above, and take you should be able to handle these
little utilities yourself.  OK, 'nuff preaching...
-- 

Greg Henderson   henders@infonode.ingr.com   ...uunet!ingr!infonode!henders


Xref: sparky comp.lang.c:13000 comp.lang.c++:13075 comp.sys.ibm.pc.hardware:22999 comp.sys.intel:1612
From: kjb@cgl.citri.edu.au (Kendall Bennett)
Newsgroups: comp.lang.c,comp.lang.c++,comp.sys.ibm.pc.hardware,comp.sys.intel
Subject: CoProcessor detection and emulation libraries...
Date: 31 Aug 92 01:36:20 GMT
Organization: RMIT Advanced Computer Graphics Centre, CITRI, Melbourne

I have an interesting question. One of the routines in a library that I am
developing detects the type of CPU and co-processor installed in am IBM PC
type machine. It works correctly on all the machines that I have tried it
on. One of my beta testers mentions that on his machine it said he has
an 80387 installed when he had none.

Since the co-processor is detected by checking the status of the processor's
control and status words, is it possible that 387 emulation libraries 
(such as FRANKIE.387) would show up as a co-processor in this type of
check? Is there any way to check that such a library is installed, rather
than a co-processor (in the docs for FRANKIE.387 is says that programs will
not be able to tell the difference between a real co-pro and the emulation
library)?

Thanks in advance,

+------------------------------------------+-------------------------------+
| Kendall Bennett,                         | Internet:                     |
| Advanced Computer Graphics Centre,       | kjb@citri.edu.au              |
| Royal Melbourne Institute of Technology, | rcskb@minyos.xx.rmit.oz.au    |
| Victoria, AUSTRALIA.                     |                               | 
+------------------------------------------+-------------------------------+
| CoSysop (Bossman), PC Connection Australia:               +61 3 688 0909 |
+--------------------------------------------------------------------------+
Newsgroups: comp.lang.c
From: jlg@cochiti.lanl.gov (Jim Giles)
Subject: Re: Giles' Manual Mania (Was - Re: About the 'F' in RTFM)
Organization: Los Alamos National Laboratory
Date: Thu, 3 Sep 1992 16:20:38 GMT

In article <QUANSTRO.92Sep2095812@lars.StOlaf.edu>, quanstro@lars.StOlaf.edu (goon) writes:
|> [...]
|> You are great at speaking in generalities. Which systems _have_ you
|> used? 

CDC's Scope was *much* easier to use.  Being a `vintage' system, it had
about the same capabilities as UNIX.  Cray CTSS is much easier to use
and is more powerful.  Given the TCP/IP implementation from the
University of Illinois and the tree structured file system from MFE,
the system has a superset of the capabilities of UNIX.

*MOST* systems are easier to use than UNIX.  Most are more powerful
for restricted domains of work that UNIX.  A few, like CTSS are
more powerful for *all* work domains and yet simpler to learn and use.

|> [....]
|> Please tell us what you mean by ``power.'' This is so vague as to border
|> on contentless. And of which ``better system designs'' are you speaking?

Power is an inherently vague term.  Technically, all Turing-equivalent
environments have the same theoretical capabilities.  I define *power*
as the inverse of the amount of effort to learn and/or use the environment.

|> [...]
|> This is just true in general. A pro x bias (calling it a ``propaganda
|> machine'' goes a bit far), where x is just about anything, is hard to
|> overcome. There are things to be said for standards. Even if you are
|> right that  Unix is difficult to learn and relatively unpowerful, it's
|> unfortunately the case that there is good motivation (perhaps not
|> sufficient) for keeping the old: learning a new system is always
|> somewhat painful and porting old software is often next to impossible.

Yes, but I have no opposition to learning new systems if they offer a better
capability.  Also, porting software to most alternative systems is relatively
easy compared to porting to UNIX.  We have codes which work - with the same
source code - on Cray CTSS, CDC NOS, DEC VMS, IBM MVS, MS/DOS, even MACs
but which have to be extensively modified to run on UNIX.  I would tag
all of these systems as easier to use - many are more powerful - than UNIX, 
if only because of ease of portability.  I've yet to discover a non-trivial
code which even ports from one UNIX to another without modification.

-- 
J. Giles
From: wirzeniu@klaava.Helsinki.FI (Lars Wirzenius)
Newsgroups: comp.lang.c
Subject: Re: Too many open files
Date: 27 Aug 92 06:58:03 GMT
Organization: University of Helsinki

michel@vedge.UUCP (Michel Trudeau) writes:
> [* fopen fails, some compilers set errno, some don't *]

Yes.  There is no guarantee that fopen set errno to anything at all.

--
Lars.Wirzenius@helsinki.fi
From: rehak@breeze.rap.ucar.edu (Nancy Rehak)
Newsgroups: comp.lang.c
Subject: Re: GNU gcc Compiler Question
Date: 25 Aug 92 17:59:42 GMT
Distribution: usa
Organization: NCAR / RAP

In article <1992Aug25.145142.5039@mksol.dseg.ti.com> katzn@mksol.dseg.ti.com (Neil M Katz) writes:
>I have a few questions about the GNU gcc compiler.
>
>More specifically, I have found that when I compile a program
>that refers to math functions such as pow or log10, I 
>get the following message from gcc:
>ld: Undefined symbol:
>	_cos
>	_asin
>	_tan
>collect: /usr/bin/ld returned 2 exit status
>
>I have included math.h, but still get these errors.  Note that this
>same file compiled successfully with Sun's acc compiler on
>a SparcStation IPC.
>
>What am I doing wrong?
>
>Please post responses to this newsgroup or email me directly at
>katzn@lobby.ti.com.       
>
>Thanks,
>Neil Katz


You may want to include the math library (-lm) when you link.

Nancy Rehak
From: cbarber@bbn.com (Chris Barber)
Newsgroups: comp.lang.c
Subject: Operator precedence (was: Freedom of Speech...)
Date: 1 Sep 92 12:21:14 GMT
Distribution: usa
Organization: BBN Systems and Technology, Inc.

In article <92243.054650IP25179@portland.caps.maine.edu> 
IP25179@portland.caps.maine.edu (Iain Odlin) writes:
>  Keep in mind also that there are many versions of C (and C++) out there.
>  Some of us have to program in several of them, and NOT ALL OF THEM HAVE THE
>  SAME OPERATOR PRECEDENCE.

I have not actually come across any instances of compilers with differing 
operator precedence. Anyone have any examples? 



-- 
Christopher Barber
(cbarber@bbn.com)
From: michel@vedge.UUCP (Michel Trudeau)
Newsgroups: comp.lang.c
Subject: Too many open files
Date: 26 Aug 92 21:11:39 GMT
Organization: Visual Edge Software, St. Laurent, Quebec

If I try to open to many files using BCC 3.0 or MSC 7.0, I get a NULL
ptr from fopen and errno = 0 (no error).

In UNIX, the variable errno is set properly to 24 (EMFILE).

Is there something I don't understand or this is the way it works ???

Thanks.

Michel Trudeau (Visual Edge Software Ltd.)
Xref: sparky comp.lang.c:13183 comp.sys.sun.misc:4073
From: torek@horse.ee.lbl.gov (Chris Torek)
Newsgroups: comp.lang.c,comp.sys.sun.misc
Subject: Re: sun cc optimization failure
Supersedes: <26042@dog.ee.lbl.gov>
Date: 3 Sep 1992 18:22:15 GMT
Organization: Lawrence Berkeley Laboratory, Berkeley
Reply-To: torek@horse.ee.lbl.gov (Chris Torek)
NNTP-Posting-Host: 128.3.112.15

[N.B.: this article is a replacement for a previous one in which I made
an unwarranted dig at the people at Sun who work on the compilers.  Current
news systems should have deleted the other article, but some of you may
have already seen it or have older or incompatible news systems.  I
hereby apologize to the compiler group at Sun.]

In article <1992Sep3.040401.16902@mr.med.ge.com> carl@aslmr-serv.med.ge.com
(Carl Crawford) writes:
>consider the following program:
>
>main() {
>	int i,j,ax;
>	ax = 0;
>	for(i=0;i<3;i++){
>		j = ax * i;
>		puts("in for loop");
>	}
>}

This program fails strict conformance by:

	A: not including <stdio.h>;
	B: reaching the end of an int-valued function (main()) wihtout
	   returning a value.

>when compiled with cc (sun os 4.1 on sparc 1+), the code runs thru the
>loop three times. when compiled with the -O flag it only runs once. ...

After fixing the two errors above, the program still produces only
one copy of "in for loop" when compiled with the SunOS 4.1 `cc' compiler
using `-O'.

>how come the optimization screws up the loop?

The only possible answer is now ``because the compiler is broken''.
-- 
In-Real-Life: Chris Torek, Lawrence Berkeley Lab CSE/EE (+1 510 486 5427)
Berkeley, CA		Domain:	torek@ee.lbl.gov