Arithmetic/Complex: Difference between revisions

-- Conjugation

C := Conjugate (C);

 

=={{header|ALGOL 68}}==

Output:

=={{header|AutoHotkey}}==

contributed by Laszlo on the ahk [http://www.autohotkey.com/forum/post-276431.html#276431 forum]

MsgBox % Cstr(C) ; 1 + i*1

Cneg(C,C)

{{works with|C99}}

The more recent [[C99]] standard has built-in complex number primitive types, which can be declared with float, double, or long double precision. To use these types and their associated library functions, you must include the <complex.h> header. (Note: this is a ''different'' header than the <complex> templates that are defined by [[C++]].) [http://www.opengroup.org/onlinepubs/009695399/basedefs/complex.h.html] [http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.vacpp7a.doc/language/ref/clrc03complex_types.htm]

 

void cprint(double complex c)

c = -a;

printf("\n-a="); cprint(c); printf("\n");

 

{{works with|C89}}

printf("\n1/a="); put(inv(a));

printf("\n-a="); put(neg(a)); printf("\n");

 

=={{header|C++}}==

#include <complex>

using std::complex;

// negation

std::cout << -a << std::endl;

 

=={{header|C sharp|C#}}==

Complex numbers are a built-in numeric type in Common Lisp. The literal syntax for a complex number is <tt>#C(<var>real</var> <var>imaginary</var>)</tt>. The components of a complex number may be integers, ratios, or floating-point. Arithmetic operations automatically return complex (or real) numbers when appropriate:

 

 

 

Here are some arithmetic operations on complex numbers:

 

 

Complex numbers can be constructed from real and imaginary parts using the <tt>complex</tt> function, and taken apart using the <tt>realpart</tt> and <tt>imagpart</tt> functions.

 

 

 

 

=={{header|D}}==

There is no standard syntax or mechanism for complex numbers. The FSL provides several implementations suitable for different uses. This example uses the existing floating point stack, but other libraries define a separate complex stack and/or a fixed-point implementation suitable for microcontrollers and DSPs.

 

 

=={{header|Fortran}}==

In ANSI FORTRAN 66 or later, COMPLEX is a built-in data type with full access to intrinsic arithmetic operations. Putting each native operation in a function is horribly inefficient, so I will simply demonstrate the operations. This example shows usage for Fortran 90 or later:

 

And, although you did not ask, here are demonstrations of some other common complex number operations

 

=={{header|Groovy}}==

have ''Complex Integer'' for the Gaussian Integers, ''Complex Float'', ''Complex Double'', etc. The operations are just the usual overloaded numeric operations.

 

 

Output:

 

 

=={{header|IDL}}==

<tt>complex</tt> (and <tt>dcomplex</tt> for double-precision) is a built-in data type in IDL:

 

y=complex(!pi,1.2)

print,x+y

( -1.00000, -1.00000)

print,1/x

 

=={{header|J}}==

0.5j_0.5

-x

 

=={{header|Java}}==

=={{header|JavaScript}}==

 

this.r = r;

this.i = i;

Complex.prototype.getMod = function ( ){

return Math.sqrt( Math.pow(this.r,2) , Math.pow(this.i,2) )

 

=={{header|Maple}}==

Maple has "I" (the square root of -1) built-in. Thus:

 

 

By itself, it will perform mathematical operations symbolically, i.e. it will not try to perform computational evaluation unless specifically asked to do so. Thus:

 

 

Other than that, the task merely asks for

 

 

=={{header|Mathematica}}==

Mathematica has fully implemented support for complex numbers throughout the software. Addition, subtraction, division, multiplications and powering need no further syntax than for real numbers:

 

Powering to a complex power can in general not be written shorter, so Mathematica leaves it unevaluated if the numbers are exact. An approximation can be acquired using the function N.

However Mathematica goes much further, basically all functions can handle complex numbers to arbitrary precision, including (but not limited to!):

Sin Cos Tan Csc Sec Cot

ArcSin ArcCos ArcTan ArcCsc ArcSec ArcCot

Haversine InverseHaversine

Factorial Gamma PolyGamma LogGamma

and many many more. The documentation states:

 

 

=={{header|Pascal}}==

 

type

print(zr); { prints (-9,38) }

writeln

 

=={{header|Perl}}==

'1 -: 3' is '1 - 3i' in mathematical notation.

 

a+b =>

a*b =>

a-a =>

a/b =>

 

=={{header|Python}}==

=={{header|Slate}}==

 

a: 1 + 1 i.

b: Pi + 1.2 i.

print: a abs.

print: a negated.

 

=={{header|Smalltalk}}==

The choice of examples here is {{trans|Common Lisp}}.

 

■ ^2 —1

■  + 1 1 + 

■ 1/(2) —1 - 

■ real(1 + 2) 1

 

Complex numbers can also be entered and displayed in polar form. (This example shows input in polar form while the complex display mode is rectangular and the angle mode is radians).

 

 

Note that the parentheses around ∠ notation are required. It has a related use in vectors: (1∠π/4) is a complex number, [1,∠π/4] is a vector in two dimensions in polar notation, and [(1∠π/4)] is a complex number in a vector.