Conjugate

From APL Wiki
Revision as of 01:19, 18 March 2024 by Marshall (talk | contribs) (History)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to navigation Jump to search
+

Conjugate (+) is a monadic scalar function which negates the imaginary component of a complex argument. Because many APLs do not have a dedicated Identity function, but also do not support complex numbers, Conjugate is often used to return the argument unchanged. This usage is discouraged in modern APLs in favor of the Identity function (usually ⊢). Conjugate shares the glyph + with Add.

Examples

Conjugate leaves real numbers unchanged but negates the imaginary part of complex numbers. 

      + 0 2 ¯1.1 1E300 ¯200
0 2 ¯1.1 1E300 ¯200
      + 2J3 ¯4J¯3 ¯12 1.5J1.5
2J¯3 ¯4J3 ¯12 1.5J¯1.5

As identity function

In early APLs Conjugate was frequently used to return the argument unchanged, for example to display a shy result or break up stranding: 

      +a←2 3
2 3
      *∘2⍣3 +a
256 6561

Sometimes the name "Identity" was even used for +. Although this usage is becoming rare among new APLers, it may still affect the behavior of Conjugate. For instance, in Dyalog APL, Conjugate will allow a non-numeric argument and return it unchanged even though other monadic scalar functions give a DOMAIN ERROR: 

      + ⎕NULL
[Null]
      - ⎕NULL
DOMAIN ERROR
      -⎕NULL
      ∧

Note that other APLs, e.g. APLX (which does not support complex numbers) and APL2 do not allow applying Conjugate to non-numeric data.

Properties

Like Negate, Conjugate is its own Inverse.

The conjugate of a number is proportional to (that is, a real multiple of) its Reciprocal. Specifically, since for any complex number z, z×+z (+z)×z is a real number (the square of the Magnitude of z), we have z×((+z)÷z×+z) 1, so by definition (+z)÷z×+z is ÷z. If z is a unit complex number (for instance the result of Signum), then +z ÷z.

Hypercomplex numbers

The conjugate of a hypercomplex number (a quaternion or octonion) negates all imaginary components, that is, every component but the real part. Somewhat surprisingly, this maintains the property that z×+z (+z)×z is a real number. Therefore the conjugate can be used to define the reciprocal of a complex number using only real division (dividing a hypercomplex number by a real number divides each component by that numer).

Numerical precision

Like Negate, Conjugate almost never suffers issues with numerical precision. This is because negating a component of a complex number is exact in all common number systems.

History

In early APLs, which did not support complex numbers, monadic + returned its argument unchanged; however, this was not initially considered as a restriction of the complex conjugate to real numbers. In fact, Phil Abrams' report on IVSYS/7090 defined +A to be 0+A, implying that the function should extend to the identity on complex numbers as well. The extension to complex conjugate was included in a 1977 proposal by Paul Penfield,[1] who noted that it had already appeared in a 1975 IBM publication documenting APL.[2] Penfield's work became the basis for the first APL complex number implementation, in SHARP APL.[3] Conjugate was supported in SHARP and all later APLs to implement complex numbers.

See also

External links

Mathematics

Documentation

References

  1. ↑ Paul Penfield. Notation for complex "part" functions. APL Quote Quad Volume 8, Issue 1. 1977-09.
  2. ↑ IBM. APL Language. GC26-3847-0. 1975-03.
  3. ↑ Eugene McDonnell. SATN-40: Complex Numbers. 1981-06-20.
APL built-ins [edit]
Primitives (Timeline) Functions
Scalar
Monadic Conjugate ∙ Negate ∙ Signum ∙ Reciprocal ∙ Magnitude ∙ Exponential ∙ Natural Logarithm ∙ Floor ∙ Ceiling ∙ Factorial ∙ Not ∙ Pi Times ∙ Roll ∙ Type ∙ Imaginary ∙ Square Root ∙ Round
Dyadic Add ∙ Subtract ∙ Times ∙ Divide ∙ Residue ∙ Power ∙ Logarithm ∙ Minimum ∙ Maximum ∙ Binomial ∙ Comparison functions ∙ Boolean functions (And, Or, Nand, Nor) ∙ GCD ∙ LCM ∙ Circular ∙ Complex ∙ Root
Non-Scalar
Structural Shape ∙ Reshape ∙ Tally ∙ Depth ∙ Ravel ∙ Enlist ∙ Table ∙ Catenate ∙ Reverse ∙ Rotate ∙ Transpose ∙ Raze ∙ Mix ∙ Split ∙ Enclose ∙ Nest ∙ Cut (K) ∙ Pair ∙ Link ∙ Partitioned Enclose ∙ Partition
Selection First ∙ Pick ∙ Take ∙ Drop ∙ Unique ∙ Identity ∙ Stop ∙ Select ∙ Replicate ∙ Expand ∙ Set functions (Intersection ∙ Union ∙ Without) ∙ Bracket indexing ∙ Index ∙ Cartesian Product ∙ Sort
Selector Index generator ∙ Grade ∙ Index Of ∙ Interval Index ∙ Indices ∙ Deal ∙ Prefix and suffix vectors
Computational Match ∙ Not Match ∙ Membership ∙ Find ∙ Nub Sieve ∙ Encode ∙ Decode ∙ Matrix Inverse ∙ Matrix Divide ∙ Format ∙ Execute ∙ Materialise ∙ Range
Operators Monadic Each ∙ Commute ∙ Constant ∙ Replicate ∙ Expand ∙ Reduce ∙ Windowed Reduce ∙ Scan ∙ Outer Product ∙ Key ∙ I-Beam ∙ Spawn ∙ Function axis ∙ Identity (Null, Ident)
Dyadic Bind ∙ Compositions (Compose, Reverse Compose, Beside, Withe, Atop, Over) ∙ Inner Product ∙ Determinant ∙ Power ∙ At ∙ Under ∙ Rank ∙ Depth ∙ Variant ∙ Stencil ∙ Cut ∙ Direct definition (operator) ∙ Identity (Lev, Dex)
Quad names Index origin ∙ Comparison tolerance ∙ Migration level ∙ Atomic vector
Retrieved from ‘https://aplwiki.com/index.php?title=Conjugate&oldid=11354’