Quaternion type: Difference between revisions

 

A complex number has a real and complex part, &nbsp; sometimes written as &nbsp; <big> <code> a + bi, </code> </big>

 

An example of a complex number might be &nbsp; <big> <code> -3 + 2i, </code> </big> &nbsp;

A quaternion might be written as &nbsp; <big> <code> a + bi + cj + dk. </code> </big>

 

:::* &nbsp; <big> <code> i∙i = j∙j = k∙k = i∙j∙k = -1, </code> </big> &nbsp; &nbsp; &nbsp; or more simply,

:::* &nbsp; <big> <code> ii &nbsp;= jj &nbsp;= kk &nbsp;= ijk &nbsp; = -1. </code> </big>

 

Create functions &nbsp; (or classes) &nbsp; to perform simple maths with quaternions including computing:

# The negative of a quaternion: <br> <big> <code> = (-a, -b, -c, -d)</code> </big>

# The conjugate of a quaternion: <br> <big> <code> = ( a, -b, -c, -d)</code> </big>

# Addition of two quaternions: <br> <big> <code> q₁ + q₂ = (a₁+a₂, b₁+b₂, c₁+c₂, d₁+d₂) </code> </big>

# Multiplication of a real number and a quaternion: <br> <big> <code> qr = rq = (ar, br, cr, dr) </code> </big>

* &nbsp; [http://www.maths.tcd.ie/pub/HistMath/People/Hamilton/QLetter/QLetter.pdf On Quaternions]; &nbsp; or on a new System of Imaginaries in Algebra. &nbsp; By Sir William Rowan Hamilton LL.D, P.R.I.A., F.R.A.S., Hon. M. R. Soc. Ed. and Dub., Hon. or Corr. M. of the Royal or Imperial Academies of St. Petersburgh, Berlin, Turin and Paris, Member of the American Academy of Arts and Sciences, and of other Scientific Societies at Home and Abroad, Andrews' Prof. of Astronomy in the University of Dublin, and Royal Astronomer of Ireland.

<br><br>

 

=={{header|Ada}}==

The package specification (works with any floating-point type):

type Real is digits <>;

package Quaternions is

function "*" (Left, Right : Quaternion) return Quaternion;

function Image (Left : Quaternion) return String;

The package implementation:

package body Quaternions is

package Elementary_Functions is

Real'Image (Left.D) & "k";

end Image;

Test program:

with Quaternions;

procedure Test_Quaternion is

Put_Line ("q1 * q2 = " & Image (q1 * q2));

Put_Line ("q2 * q1 = " & Image (q2 * q1));

{{out}}

<pre>

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.6 algol68g-2.6].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

 

COMMENT REQUIRES:

PROC quat exp = (QUAT q)QUAT: (exp OF class quat)(LOC QUAT := q);

 

# -*- coding: utf-8 -*- #

 

));

print((REPR(-q1*q2), ", ", REPR(-q2*q1), new line))

{{out}}

<pre>

 

=={{header|ALGOL W}}==

% Quaternion record type %

record Quaternion ( real a, b, c, d );

 

end.

{{out}}

<pre>

q2q1:(-56.0, 18.0, 20.0, 28.0)

</pre>

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}} (AutoHotkey1.1+)

q1 := [2, 3, 4, 5]

q2 := [3, 4, 5, 6]

b .= v (A_Index = q.MaxIndex() ? ")" : ", ")

return b

{{out}}

<pre>q = (1, 2, 3, 4)

=={{header|Axiom}}==

Axiom has built-in support for quaternions.

 

Type: ((Integer,Integer,Integer,Integer) -> Quaternion(Integer))

 

(13) true

Although BBC BASIC doesn't have native support for quaternions its array arithmetic provides all of the required operations either directly or very straightforwardly.

q() = 1, 2, 3, 4

q1() = 2, 3, 4, 5

DEF FNq_show(q()) : LOCAL i%, a$ : a$ = "("

FOR i% = 0 TO 3 : a$ += STR$(q(i%)) + ", " : NEXT

{{out}}

<pre>

 

=={{header|C}}==

#include <stdlib.h>

#include <stdbool.h>

printf("(%lf, %lf, %lf, %lf)\n",

q->q[0], q->q[1], q->q[2], q->q[3]);

 

{

size_t i;

free(q[0]); free(q[1]); free(q[2]); free(r);

return EXIT_SUCCESS;

 

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

This example uses templates to provide the underlying data-type, and includes several extra functions and constructors that often come up when using quaternions.

 

using namespace std;

 

(q.z < T()) ? (io << " - " << (-q.z) << "k") : (io << " + " << q.z << "k");

return io;

 

Test program:

{

Quaternion<> q0(1, 2, 3, 4);

Quaternion<int> q5(2), q6(3);

cout << endl << q5*q6 << endl;

 

{{out}}

</pre>

 

 

 

 

=={{header|Common Lisp}}==

(defclass quaternion () ((a :accessor q-a :initarg :a :type real)

(b :accessor q-b :initarg :b :type real)

(format t "q*q1*q2 = ~a~&" (reduce #'mul (list q q1 q2)))

(format t "q-q1-q2 = ~a~&" (reduce #'sub (list q q1 q2)))

 

{{out}}

q-q1-q2 = +0.0+1.0i-1.0j-1.0k

</pre>

 

=={{header|D}}==

 

 

writeln(" exp(log(s)): ", exp(log(s)));

writeln(" log(exp(s)): ", log(exp(s)));

{{out}}

<pre>1. q - norm: 7.34847

exp(log(s)): [2, 0.33427, 0.445694, 0.557117]

log(exp(s)): [2, 0.33427, 0.445694, 0.557117]</pre>

 

=={{header|Delphi}}==

 

 

interface

end;

 

 

Test program

 

{$APPTYPE CONSOLE}

writeln('q1 * q2 = ', (q1 * q2).ToString);

writeln('q2 * q1 = ', (q2 * q1).ToString);

 

{{out}}

=={{header|E}}==

 

def makeQuaternion(a, b, c, d) {

return def quaternion implements QS {

to d() { return d }

}

 

# value: (2 + 3i + 4j + 5k)

 

 

? q1+(-2)

 

=={{header|Eero}}==

 

interface Quaternion : Number

Log( 'q2 * q1 = %@', q2 * q1 )

 

 

{{out}}

2013-09-04 16:40:29.822 a.out[2170:507] q1 * q2 = (-56.0, 16.0, 24.0, 26.0)

2013-09-04 16:40:29.822 a.out[2170:507] q2 * q1 = (-56.0, 18.0, 20.0, 28.0)</pre>

 

=={{header|ERRE}}==

PROGRAM QUATERNION

 

PRINTQ(R.)

END PROGRAM

 

=={{header|Euphoria}}==

return sqrt(power(q[1],2)+power(q[2],2)+power(q[3],2)+power(q[4],2))

end function

printf(1, "q1 + q2 = %s\n", {quats(add(q1,q2))})

printf(1, "q1 * q2 = %s\n", {quats(mul(q1,q2))})

 

{{out}}

Mainly a {{trans|C#}} On the minus side we have no way to define a conversion to Quaternion from any suitable (numeric) type.

On the plus side we can avoid the stuff to make the equality structual (from the referential equality default) by just declaring it as an attribute to the type and let the compiler handle the details.

 

[<Struct; StructuralEquality; NoComparison>]

printfn "q1*q2 %s q2*q1" (if (q1 * q2) = (q2 * q1) then "=" else "<>")

printfn "q %s Q(1.,2.,3.,4.)" (if q = Quaternion(1., 2., 3., 4.) then "=" else "<>")

{{out}}

<pre>q = Q(1.000000, 2.000000, 3.000000, 4.000000)

q1*q2 <> q2*q1

q = Q(1.,2.,3.,4.)</pre>

 

=={{header|Forth}}==

 

: qvariable create 1 quaternions allot ;

m1 q1 q2 q* m1 q. \ ( -56. 16. 24. 26. )

m2 q2 q1 q* m2 q. \ ( -56. 18. 20. 28. )

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

 

write(*, "(a, 4f8.3)") " q2 * q1 = ", q2 * q1

 

{{out}}

<pre> q = 1.000 2.000 3.000 4.000

q1 * q2 = -56.000 16.000 24.000 26.000

q2 * q1 = -56.000 18.000 20.000 28.000</pre>

=={{header|GAP}}==

 

A := QuaternionAlgebra(Rationals);

 

1/q;

 

=={{header|Go}}==

The three inputs are reused repeatedly without being modified.

The output is also reused repeatedly, being overwritten for each operation.

 

import (

q1.r*q2.k+q1.i*q2.j-q1.j*q2.i+q1.k*q2.r

return z

{{out}}

<pre>

 

=={{header|Haskell}}==

 

 

realQ (Q r _ _ _) = r

 

imagQ (Q _ i j k) = [i, j, k]

 

quaternionFromScalar s = Q s 0 0 0

 

quaternionFromList [a, b, c, d] = Q a b c d

 

 

conjQ (Q a b c d) = Q a (-b) (-c) (-d)

 

 

 

==Icon and {{header|Unicon}}==

Using Unicon's class system.

 

class Quaternion(a, b, c, d)

 

self.d := if /d then 0 else d

end

 

To test the above:

 

procedure main ()

q := Quaternion (1,2,3,4)

write ("q2*q1 = " || q2.multiply(q1).string ())

end

 

{{out}}

q2*q1 = -56+18i+20j+28k

</pre>

 

=={{header|J}}==

Derived from the [[j:System/Requests/Quaternions|j wiki]]:

 

ip=: +/ .* NB. inner product

T=. (_1^#:0 10 9 12)*0 7 16 23 A.=i.4

conj=: 1 _1 _1 _1 * toQ NB. + y

add=: +&toQ NB. x + y

 

T is a rank 3 tensor which allows us to express quaternion product ab as the inner product ATB if A and B are 4 element vectors representing the quaternions a and b. (Note also that once we have defined <code>mul</code> we no longer need to retain the definition of T, so we define T using =. instead of =:). The value of T is probably more interesting than its definition, so:

 

1 0 0 0

0 1 0 0

0 0 _1 0

0 1 0 0

 

In other words, the last dimension of T corresponds to the structure of the right argument (columns, in the display of T), the first dimension of T corresponds to the structure of the left argument (tables, in the display of T) and the middle dimension of T corresponds to the structure of the result (rows, in the display of T).

Example use:

 

q1=: 2 3 4 5

q2=: 3 4 5 6

_56 16 24 26

q2 mul q1

 

Finally, note that when quaternions are used to represent [[wp:Quaternions_and_spatial_rotation|orientation or rotation]], we are typically only interested in unit length quaternions. As this is the typical application for quaternions, you will sometimes see quaternion multiplication expressed using "simplifications" which are only valid for unit length quaternions. But note also that in many of those contexts you also need to normalize the quaternion length after multiplication.

 

=={{header|Java}}==

private final double a, b, c, d;

 

System.out.format("q1 \u00d7 q2 %s q2 \u00d7 q1%n", (q1q2.equals(q2q1) ? "=" : "\u2260"));

}

 

{{out}}

Runs on Firefox 3+, limited support in other JS engines. More compatible JavaScript deserves its own entry.

 

// The Q() function takes an array argument and changes it

// prototype so that it becomes a Quaternion instance. This is

Quaternion.prototype = proto;

return Quaternion;

 

Task/Example Usage:

 

var q1 = Quaternion(2,3,4,5);

var q2 = Quaternion(3,4,5,6);

console.log("7.a. q1.mul(q2) = "+q1.mul(q2));

console.log("7.b. q2.mul(q1) = "+q2.mul(q1));

 

{{out}}

=={{header|jq}}==

 

 

# promotion of a real number to a quaternion

) ;

 

Example usage and output:

Quaternion(1;0;0;0) => 1 + 0i + 0j + 0k

abs($q) => 5.477225575051661

times($q1;$q2) => -56 + 16i + 24j + 26k

times($q2; $q1) => -56 + 18i + 20j + 28k

 

=={{header|Julia}}==

https://github.com/andrioni/Quaternions.jl/blob/master/src/Quaternions.jl has a more complete implementation.

This is derived from the [https://github.com/JuliaLang/julia/blob/release-0.2/examples/quaternion.jl quaternion example file] included with Julia 0.2, which implements a quaternion type complete with arithmetic, type conversions / promotion rules, polymorphism over arbitrary real numeric types, and pretty-printing.

 

immutable Quaternion{T<:Real} <: Number

z.q0*w.q2 - z.q1*w.q3 + z.q2*w.q0 + z.q3*w.q1,

z.q0*w.q3 + z.q1*w.q2 - z.q2*w.q1 + z.q3*w.q0)

 

Example usage and output:

julia> q = Quaternion (1, 2, 3, 4)

q1 = Quaternion(2, 3, 4, 5)

 

julia> q1*q2, q2*q1, q1*q2 != q2*q1

 

=={{header|Liberty BASIC}}==

Quaternions saved as a space-separated string of four numbers.

 

q$ = q$( 1 , 2 , 3 , 4 )

add2$ =q$( ar +br, ai +bi, aj +bj, ak +bk)

end function

 

=={{header|Lua}}==

 

function Quaternion.new( a, b, c, d )

function Quaternion.print( p )

print( string.format( "%f + %fi + %fj + %fk\n", p.a, p.b, p.c, p.d ) )

Examples:

q2 = Quaternion.new( 5, 6, 7, 8 )

r = 12

io.write( "q1*r = " ); Quaternion.print( q1*r )

io.write( "q1*q2 = " ); Quaternion.print( q1*q2 )

{{out}}

-q1 = -1.000000 -2.000000i -3.000000j -4.000000k

conj(q1) = 1.000000 -2.000000i -3.000000j -4.000000k

q1*r = 12.000000 + 24.000000i + 36.000000j + 48.000000k

q1*q2 = -60.000000 + 12.000000i + 30.000000j + 24.000000k

 

q=Quaternion[1,2,3,4]

q1=Quaternion[2,3,4,5]

q2**q1

->Quaternion[-56,18,20,28]

 

=={{header|Mercury}}==

A possible implementation of quaternions in Mercury (the simplest representation) would look like this. Note that this is a full module implementation, complete with boilerplate, and that it works by giving an explicit conversion function for floats, converting a float into a quaternion representation of that float. Thus the float value <code>7.0</code> gets turned into the quaternion representation <code>q(7.0, 0.0, 0.0, 0.0)</code> through the function call <code>r(7.0)</code>.

 

 

:- interface.

W0*I1 + I0*W1 + J0*K1 - K0*J1,

W0*J1 - I0*K1 + J0*W1 + K0*I1,

 

The following test module puts the module through its paces.

 

 

:- interface.

to_string(q(I, J, K, W)) = string.format("q(%f, %f, %f, %f)",

[f(I), f(J), f(K), f(W)]).

 

The output of the above code follows:

Q1 * Q2 = q(-56.000000, 16.000000, 24.000000, 26.000000)

Q2 * Q1 = q(-56.000000, 18.000000, 20.000000, 28.000000)

 

=={{header|OCaml}}==

 

This implementation was build strictly to the specs without looking (too much) at other implementations. The implementation as a record type with only floats is said (on the ocaml mailing list) to be especially efficient. Put this into a file quaternion.ml:

type quaternion = {a: float; b: float; c: float; d: float}

 

pf "8. instead q2 * q1 = %s \n" (qstring (multq q2 q1));

pf "\n";

 

using this file on the command line will produce:

</pre>

For completeness, and since data types are of utmost importance in OCaml, here the types produced by pasting the code into the toplevel (''ocaml'' is the toplevel):

type quaternion = { a : float; b : float; c : float; d : float; }

val norm : quaternion -> float = <fun>

val qmake : float -> float -> float -> float -> quaternion = <fun>

val qstring : quaternion -> string = <fun>

 

=={{header|Octave}}==

Such a package can be install with the command:

 

 

Here is a sample interactive session solving the task:

 

q = 1 + 2i + 3j + 4k

> q1 = quaternion (2, 3, 4, 5)

ans = -56 + 16i + 24j + 26k

> q1 == q2

 

=={{header|Oforth}}==

neg is defined as "0 self -" into Number class, so no need to define it (if #- is defined).

 

 

Quaternion method: _a @a ;

q _a @b * q _b @a * + q _c @d * + q _d @c * -,

q _a @c * q _b @d * - q _c @a * + q _d @b * +,

 

Usage :

 

| q q1 q2 r |

 

System.Out "q * r = " << q r * << cr

System.Out "q1 * q2 = " << q1 q2 * << cr

 

{{out}}

q1q2 and q2q1 are different quaternions

</pre>

 

=={{header|ooRexx}}==

Note, this example uses operator overloads to perform the math operation. The operator overloads only work if the left-hand-side of the operation is a quaterion instance. Thus something like "7 + q1" would not work because this would get passed to the "+" of the string class. For those situations, the best solution would be an addition method on the .Quaternion class itself that took the appropriate action. I've chosen not to implement those to keep the example shorter.

q = .quaternion~new(1, 2, 3, 4)

q1 = .quaternion~new(2, 3, 4, 5)

::requires rxmath LIBRARY

 

<pre>

q = 1 + 2i + 3j + 4k

{{works with|PARI/GP|version 2.4.2 and above}}<!-- Needs closures -->

Here is a simple solution in GP. I think it's possible to implement this type directly in Pari by abusing t_COMPLEX, but I haven't attempted this.

if(type(q) != "t_VEC" || #q != 4, error("incorrect type"));

sqrt(q[1]^2+q[2]^2+q[3]^2+q[4]^2)

)

)

Usage:

q.norm

-q

q.mult(r) \\ or r*q or q*r

q1.mult(q2)

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

use List::Util 'reduce';

use List::MoreUtils 'pairwise';

print "a conjugate is ", $a->conjugate, "\n";

print "a * b = ", $a * $b, "\n";

 

=={{header|Phix}}==

{{out}}

<pre>

</pre>

 

=={{header|PicoLisp}}==

 

(def 'quatCopy copy)

(mapcar '((R S) (pack (format R *Scl) S))

Q

Test:

Q (1.0 2.0 3.0 4.0)

Q1 (2.0 3.0 4.0 5.0)

(prinl "Q1 * Q2 = " (quatFmt (quatMul Q1 Q2)))

(prinl "Q2 * Q1 = " (quatFmt (quatMul Q2 Q1)))

{{out}}

<pre>R = 7.000000

 

=={{header|PL/I}}==

qu: Proc Options(main);

/**********************************************************************

End;

 

{{out}}

<pre>

task C: q1=q1 --> equal

</pre>

 

=={{header|PowerShell}}==

===Implementation===

class Quaternion {

[Double]$w

"`$q1 * `$q2: $([Quaternion]::show([Quaternion]::mul($q1,$q2)))"

"`$q2 * `$q1: $([Quaternion]::show([Quaternion]::mul($q2,$q1)))"

<b>Output:</b>

<pre>

</pre>

===Library===

function show([System.Numerics.Quaternion]$c) {

function st([Double]$r) {

"`$q1 * `$q2: $(show ([System.Numerics.Quaternion]::Multiply($q1,$q2)))"

"`$q2 * `$q1: $(show ([System.Numerics.Quaternion]::Multiply($q2,$q1)))"

<b>Output:</b>

<pre>

 

=={{header|Prolog}}==

add(qx(R0,I0,J0,K0), qx(R1,I1,J1,K1), qx(R,I,J,K)) :-

!, R is R0+R1, I is I0+I1, J is J0+J1, K is K0+K1.

R is -Ri, I is -Ii, J is -Ji, K is -Ki.

conjugate(qx(R,Ii,Ji,Ki),qx(R,I,J,K)) :-

 

'''Test:'''

data(q1, qx(2,3,4,5)).

data(q2, qx(3,4,5,6)).

test :- data(q1, Q1), data(q2, Q2), mul(Q2, Q1, Qx),

writef('q2*q1 is %w\n', [Qx]), fail.

{{out}}

<pre> ?- test.

 

=={{header|PureBasic}}==

a.f

b.f

EndIf

ProcedureReturn 1 ;true

Implementation & test

ProcedureReturn "{" + StrF(*x\a, NN) + "," + StrF(*x\b, NN) + "," + StrF(*x\c, NN) + "," + StrF(*x\d, NN) + "}"

EndProcedure

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Result

<pre>Q0 = {1,2,3,4}

=={{header|Python}}==

This example extends Pythons [http://docs.python.org/library/collections.html?highlight=namedtuple#collections.namedtuple namedtuples] to add extra functionality.

import math

 

q1 = Q(2, 3, 4, 5)

q2 = Q(3, 4, 5, 6)

 

'''Continued shell session'''

Run the above with the -i flag to python on the command line, or run with idle then continue in the shell as follows:

Quaternion(real=1.0, i=2.0, j=3.0, k=4.0)

>>> q1

>>> q1 * q1.reciprocal()

Quaternion(real=0.9999999999999999, i=0.0, j=0.0, k=0.0)

 

=={{header|R}}==

Using the quaternions package.

 

library(quaternions)

 

## q1*q2 != q2*q1

 

 

=={{header|Racket}}==

(struct quaternion (a b c d)

(multiply q2 q1)

(equal? (multiply q1 q2)

 

{{out}}

#f

</pre>

 

=={{header|REXX}}==

The REXX language has no native quaternion support, but subroutines can be easily written.

qMul: procedure; parse arg x,y; call qXY y

end /*m*/

<pre>

q ──► 1+2i+3j+4k

task 8: multiplication q2*q1 ──► -56+18i+20j+28k

</pre>