complex.c.sh

复数运算库

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of shell archive."
# Contents:  Makefile complex.3 complex.h cx_test.c cxadd.c cxampl.c
#   cxconj.c cxcons.c cxcopy.c cxdiv.c cxmul.c cxphas.c cxphsr.c
#   cxscal.c cxsqrt.c cxsub.c
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f Makefile -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"Makefile\"
else
echo shar: Extracting \"Makefile\" \(395 characters\)
sed "s/^X//" >Makefile <<'END_OF_Makefile'
XALL=complex.3 complex.h libcomplex.a
XOBJS=\
X    cxadd.o cxampl.o cxconj.o cxcons.o cxcopy.o cxdiv.o cxmul.o \
X    cxphas.o cxphsr.o cxscal.o cxsqrt.o cxsub.o
X
Xall:	$(ALL)
X
Xinstall:	$(ALL)
X	@echo install $(ALL) according to local convention.
X
Xcx_test:	cx_test.c libcomplex.a
X	$(CC) $(CFLAGS) -o cx_test cx_test.c libcomplex.a
X
Xlibcomplex.a:	$(OBJS)
X	ar r libcomplex.a $(OBJS)
X
X$(OBJS):	complex.h
END_OF_Makefile
if test 395 -ne `wc -c <Makefile`; then
    echo shar: \"Makefile\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f complex.3 -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"complex.3\"
else
echo shar: Extracting \"complex.3\" \(5830 characters\)
sed "s/^X//" >complex.3 <<'END_OF_complex.3'
X'\" e
X.TH COMPLEX 3V LOCAL
X'\"	last edit:	86/02/03	D A Gwyn
X'\"	SCCS ID:	@(#)complex.3	1.2 (modified for public version)
X.EQ
Xdelim @@
X.EN
X.SH NAME
Xcomplex \- complex arithmetic operations
X.SH SYNOPSIS
X.B
X#include <complex.h>	/* assuming appropriate cc \-I option */
X.br
X/* All the following functions are declared in this header file. */
X.P
X.B complex *CxAdd(ap,bp);
X.br
X.B complex *ap, *bp;
X.P
X.B complex *CxSub(ap,bp);
X.br
X.B complex *ap, *bp;
X.P
X.B complex *CxMul(ap,bp);
X.br
X.B complex *ap, *bp;
X.P
X.B complex *CxDiv(ap,bp);
X.br
X.B complex *ap, *bp;
X.P
X.B complex *CxSqrt(cp);
X.br
X.B complex *cp;
X.P
X.B complex *CxScal(cp,\^s);
X.br
X.B complex *cp;
X.br
X.B double s;
X.P
X.B complex *CxNeg(cp);
X.br
X.B complex *cp;
X.P
X.B complex *CxConj(cp);
X.br
X.B complex *cp;
X.P
X.B complex *CxCopy(ap,bp);
X.br
X.B complex *ap, *bp;
X.P
X.B complex *CxCons(cp,\^r,\^i);
X.br
X.B complex *cp;
X.br
X.B double r, i;
X.P
X.B complex *CxPhsr(cp,m,p);
X.br
X.B complex *cp;
X.br
X.B double m, p;
X.P
X.B double CxReal(cp);
X.br
X.B complex *cp;
X.P
X.B double CxImag(cp);
X.br
X.B complex *cp;
X.P
X.B double CxAmpl(cp);
X.br
X.B complex *cp;
X.P
X.B double CxPhas(cp);
X.br
X.B complex *cp;
X.P
X.B complex *CxAllo(\ );
X.P
X.B void CxFree(cp);
X.br
X.B complex *cp;
X.SH DESCRIPTION
XThese routines perform arithmetic
Xand other useful operations on complex numbers.
XAn appropriate data structure
X.B complex
Xis defined in the header file;
Xall access to
X.B complex
Xdata should be
X.I via
Xthese predefined functions.
X(See
X.SM HINTS
Xfor further information.)
X.P
XIn the following descriptions,
Xthe names
X.IR a ,
X.IR b ,
Xand
X.I c
Xrepresent the
X.B complex
Xdata addressed by the corresponding pointers
X.IR ap ,
X.IR bp ,
Xand
X.IR cp .
X.P
X.I CxAdd\^
Xadds
X.I b
Xto
X.I a
Xand returns a pointer to the result.
X.P
X.I CxSub
Xsubtracts
X.I b
Xfrom
X.I a
Xand returns a pointer to the result.
X.P
X.I CxMul\^
Xmultiplies
X.I a
Xby
X.I b
Xand returns a pointer to the result.
X.P
X.I CxDiv
Xdivides
X.I a
Xby
X.I b
Xand returns a pointer to the result.
XThe divisor must not be precisely zero.
X.P
X.I CxSqrt
Xreplaces
X.I c
Xby the ``principal value'' of its square root
X(one having a non-negative imaginary part)
Xand returns a pointer to the result.
X.P
X.I CxScal\^
Xmultiplies
X.I c
Xby the scalar
X.I s
Xand returns a pointer to the result.
X.P
X.I CxNeg
Xnegates
X.I c
Xand returns a pointer to the result.
X.P
X.I CxConj
Xconjugates
X.I c
Xand returns a pointer to the result.
X.P
X.I CxCopy
Xassigns the value of
X.I b
Xto
X.I a
Xand returns a pointer to the result.
X.P
X.I CxCons
Xconstructs the complex number
X.I c
Xfrom its real and imaginary parts
X.I r
Xand
X.IR i ,
Xrespectively,
Xand returns a pointer to the result.
X.P
X.I CxPhsr
Xconstructs the complex number
X.I c
Xfrom its ``phasor'' amplitude and phase (given in radians)
X.I m
Xand
X.IR p ,
Xrespectively,
Xand returns a pointer to the result.
X.P
X.I CxReal\^
Xreturns the real part of the complex number
X.IR c .
X.P
X.I CxImag
Xreturns the imaginary part of the complex number
X.IR c .
X.P
X.I CxAmpl\^
Xreturns the amplitude of the complex number
X.IR c .
X.P
X.I CxPhas
Xreturns the phase of the complex number
X.IR c ,
Xas radians in the range @(- pi , pi ]@.
X.P
X.I CxAllo
Xallocates storage for a
X.B complex
Xdatum; it returns
X.SM
X.B NULL
X(defined as 0 in
X.BR <stdio.h> )
Xif not enough storage is available.
X.P
X.I CxFree
Xreleases storage previously allocated by
X.IR CxAllo .
XThe contents of such storage must not be used afterward.
X.SH HINTS
XThe
X.B complex
Xdata type consists of real and imaginary components;
X.I CxReal\^
Xand
X.I CxImag
Xare actually macros that access these components directly.
XThis allows addresses of the components to be taken,
Xas in the following \s-1EXAMPLE\s0.
X.P
XThe complex functions are designed to be nested;
Xsee the following \s-1EXAMPLE\s0.
XFor this reason,
Xmany of them modify the contents of their first parameter.
X.I CxCopy
Xcan be used to create a ``working copy'' of
X.B complex
Xdata that would otherwise be modified.
X.P
XThe square-root function is inherently double-valued;
Xin most applications, both roots should receive equal consideration.
XThe second root is the negative of the ``principal value''.
X.bp
X.SH EXAMPLE
XThe following program is compiled by the command
X.br
X	$ \fIcc \|\-I/usr/local/include \|example.c \|/usr/local/lib/libcomplex.a \|\-lm\fP
X.br
XIt reads in two complex vectors,
Xthen computes and prints their inner product.
X.sp
X.P
X	#include	<stdio.h>
X.br
X	#include	<complex.h>
X.sp
X	main( argc, argv )
X.br
X		int		argc;
X.br
X		char		*argv[\|];
X.br
X		{
X.br
X		int		n;		/* # elements in each array */
X.br
X		int		i;		/* indexes arrays */
X.br
X		complex		a[10], b[10];	/* input vectors */
X.br
X		complex		s;		/* accumulates scalar product */
X.br
X		complex		*c = CxAllo(\|);	/* holds cross-term */
X.sp
X		if ( c == NULL )
X.br
X			{
X.br
X			(void)fprintf( stderr, ``not enough memory\en'' );
X.br
X			return 1;
X.br
X			}
X.br
X		(void)printf( ``\enenter number of elements: '' );
X.br
X		(void)scanf( `` %d'', &n );
X.br
X		/* (There really should be some input validation here.) */
X.br
X		(void) printf( ``\enenter real, imaginary pairs for first array:\en'' );
X.br
X		for ( i = 0; i < n; ++i )
X.br
X			(void)scanf( `` %lg %lg'', &CxReal( &a[i] ), &CxImag( &a[i] ) );
X.br
X		(void)printf( ``\enenter real, imaginary pairs for second array:\en'' );
X.br
X		for ( i = 0; i < n; ++i )
X.br
X			(void)scanf( `` %lg %lg'', &CxReal( &b[i] ), &CxImag( &b[i] ) );
X.br
X		(void)CxCons( &s, 0.0, 0.0 );	/* initialize accumulator */
X.br
X		for ( i = 0; i < n; ++i )
X.br
X			(void)CxAdd( &s, CxMul( &a[i], CxConj( CxCopy( c, &b[i] ) ) ) );
X.br
X		(void)printf( ``\enproduct is (%g,%g)\en'', CxReal( &s ), CxImag( &s ) );
X.br
X		CxFree( c );
X.br
X		return 0;
X.br
X		}
X.SH FILES
X/usr/local/include/complex.h		header file containing definitions
X.br
X/usr/local/lib/libcomplex.a		complex run-time support library
X.SH AUTHORS
XDouglas A. Gwyn, BRL/VLD-VMB
X.br
XJeff Hanes, BRL/VLD-VMB (original version of
X.IR CxSqrt\^ )
END_OF_complex.3
if test 5830 -ne `wc -c <complex.3`; then
    echo shar: \"complex.3\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f complex.h -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"complex.h\"
else
echo shar: Extracting \"complex.h\" \(966 characters\)
sed "s/^X//" >complex.h <<'END_OF_complex.h'
X/*
X	<complex.h> -- definitions for complex arithmetic routines
X
X	last edit:	86/01/04	D A Gwyn
X
X	SCCS ID:	@(#)complex.h	1.1 (modified for public version)
X*/
X
X/* "complex number" data type: */
X
Xtypedef struct
X	{
X	double		re;		/* real part */
X	double		im;		/* imaginary part */
X	}	complex;
X
X/* "The future is now": */
X
X#ifdef __STDC__	/* X3J11 */
X#define	_CxGenPtr	void *		/* generic pointer type */
X#else		/* K&R */
X#define	_CxGenPtr	char *		/* generic pointer type */
X#endif
X
X/* functions that are correctly done as macros: */
X
X#define	CxAllo()		((complex *)malloc( sizeof (complex) ))
X#define	CxFree( cp )		free( (_CxGenPtr)(cp) )
X#define	CxNeg( cp )		CxScal( cp, -1.0 )
X#define	CxReal( cp )		(cp)->re
X#define	CxImag( cp )		(cp)->im
X
Xextern void		free();
Xextern _CxGenPtr	malloc();
X
X/* library functions: */
X
Xextern double	CxAmpl(), CxPhas();
Xextern complex	*CxAdd(), *CxConj(), *CxCons(), *CxCopy(), *CxDiv(),
X		*CxMul(), *CxPhsr(), *CxScal(), *CxSqrt(), *CxSub();
END_OF_complex.h
if test 966 -ne `wc -c <complex.h`; then
    echo shar: \"complex.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f cx_test.c -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"cx_test.c\"
else
echo shar: Extracting \"cx_test.c\" \(4250 characters\)
sed "s/^X//" >cx_test.c <<'END_OF_cx_test.c'
X/*
X	ctest -- complex arithmetic test
X
X	last edit:	86/01/04	D A Gwyn
X
X	SCCS ID:	@(#)cx_test.c	1.1 (modified for public version)
X*/
X
X#include	<stdio.h>
X#include	<math.h>
X
X#include	<complex.h>
X
X#define DEGRAD	57.2957795130823208767981548141051703324054724665642
X					/* degrees per radian */
X#define Abs( x )	((x) < 0 ? -(x) : (x))
X#define Max( a, b )	((a) > (b) ? (a) : (b))
X
Xextern void	exit();
X
X#define	Printf	(void)printf
X
X#define	TOL	1.0e-10			/* tolerance for checks */
X
Xstatic int	errs = 0;		/* tally errors */
X
Xstatic void	CCheck(), RCheck();
Xstatic double	RelDif();
X
X
X/*ARGSUSED*/
Xmain( argc, argv )
X	int	argc;
X	char	*argv[];
X	{
X	complex a, *bp, *cp;
X
X	/* CxAllo test */
X	bp = CxAllo();
X	if ( bp == NULL )
X		{
X		Printf( "CxAllo failed\n" );
X		exit( 1 );
X		}
X
X	/* CxReal, CxImag test */
X	CxReal( bp ) = 1.0;
X	CxImag( bp ) = 2.0;
X	RCheck( "CxReal", CxReal( bp ), 1.0 );
X	RCheck( "CxImag", CxImag( bp ), 2.0 );
X
X	/* CxCons test */
X	cp = CxCons( &a, -3.0, -4.0);
X	CCheck( "CxCons 1", a, -3.0, -4.0 );
X	CCheck( "CxCons 2", *cp, -3.0, -4.0 );
X
X	/* CxNeg test */
X	cp = CxNeg( &a );
X	CCheck( "CxNeg 1", a, 3.0, 4.0 );
X	CCheck( "CxNeg 2", *cp, 3.0, 4.0 );
X
X	/* CxCopy test */
X	cp = CxCopy( bp, &a );
X	(void)CxCons( &a, 1.0, sqrt( 3.0 ) );
X	CCheck( "CxCopy 1", *bp, 3.0, 4.0 );
X	CCheck( "CxCopy 2", *cp, 3.0, 4.0 );
X
X	/* CxAmpl, CxPhas test */
X	RCheck( "CxAmpl 1", CxAmpl( &a ), 2.0 );
X	RCheck( "CxPhas 1", CxPhas( &a ) * DEGRAD, 60.0 );
X	/* try other quadrants */
X	a.re = -a.re;
X	RCheck( "CxAmpl 2", CxAmpl( &a ), 2.0 );
X	RCheck( "CxPhas 2", CxPhas( &a ) * DEGRAD, 120.0 );
X	a.im = -a.im;
X	RCheck( "CxAmpl 3", CxAmpl( &a ), 2.0 );
X	RCheck( "CxPhas 3", CxPhas( &a ) * DEGRAD, -120.0 );
X	a.re = -a.re;
X	RCheck( "CxAmpl 4", CxAmpl( &a ), 2.0 );
X	RCheck( "CxPhas 4", CxPhas( &a ) * DEGRAD, -60.0 );
X	/* one more for good measure */
X	RCheck( "CxAmpl 5", CxAmpl( bp ), 5.0 );
X
X	/* CxPhsr test */
X	cp = CxPhsr( &a, 100.0, -20.0 / DEGRAD );
X	RCheck( "CxPhsr 1", CxAmpl( &a ), 100.0 );
X	RCheck( "CxPhsr 2", CxPhas( &a ) * DEGRAD, -20.0 );
X	RCheck( "CxPhsr 3", CxAmpl( cp ), 100.0 );
X	RCheck( "CxPhsr 4", CxPhas( cp ) * DEGRAD, -20.0 );
X
X	/* CxConj test */
X	cp = CxConj( bp );
X	CCheck( "CxConj 1", *bp, 3.0, -4.0 );
X	CCheck( "CxConj 2", *cp, 3.0, -4.0 );
X
X	/* CxScal test */
X	cp = CxScal( bp, 2.0 );
X	CCheck( "CxScal 1", *bp, 6.0, -8.0 );
X	CCheck( "CxScal 2", *cp, 6.0, -8.0 );
X
X	/* CxAdd test */
X	cp = CxAdd( CxCons( &a, -4.0, 11.0 ), bp );
X	CCheck( "CxAdd 1", a, 2.0, 3.0 );