Quaternion type: Difference between revisions

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

DEFINE A_="+0"

QuatMult(q1,q2,q3) Print(" q1*q2 = ") PrintQuatE(q3)

QuatMult(q2,q1,q3) Print(" q2*q1 = ") PrintQuatE(q3)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Quaternion_type.png Screenshot from Atari 8-bit computer]

=={{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>

=={{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

=={{header|BASIC256}}==

{{works with|BASIC256|2.0.0.11}}

dim q(4)

dim q1(4)

print "q1q2 = ";printq(q_mul(q1,q2))

print "q2q1 = ";printq(q_mul(q2,q1))

{{out}}

<pre>

=={{header|BBC BASIC}}==

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 sharp}}==

struct Quaternion : IEquatable<Quaternion>

#endregion

Demonstration:

static class Program

Console.WriteLine("q1*q2 {0} q2*q1", (q1 * q2) == (q2 * q1) ? "==" : "!=");

}

{{out}}

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}}

=={{header|CLU}}==

equal, get_a, get_b, get_c, get_d, q_form

rep = struct[a,b,c,d: real]

if q1*q2 ~= q2*q1 then stream$putl(po, "q1 * q2 ~= q2 * q1") end

{{out}}

<pre> q0 = 1.000 + 2.000i + 3.000j + 4.000k

=={{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}}

=={{header|Crystal}}==

{{trans|Rust and Ruby}}

property a, b, c, d

puts

puts "q1 * q2 != q2 * q1 => #{(q1 * q2) != (q2 * q1)}"

{{out}}

<pre>q0 = (1 + 2i + 3j + 4k)

=={{header|D}}==

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

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

{{out}}

<pre>1. q - norm: 7.34847

=={{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}}

{{trans|C#}}

ELENA 5.0 :

import extensions;

import extensions'text;

console.printLineFormatted("q1*q2 {0} q2*q1", ((q1 * q2) == (q2 * q1)).iif("==","!="))

{{out}}

<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)

=={{header|Factor}}==

The <code>math.quaternions</code> vocabulary provides words for treating sequences like quaternions. <code>norm</code> and <code>vneg</code> come from the <code>math.vectors</code> vocabulary. Oddly, I wasn't able to find a word for adding a real to a quaternion, so I wrote one.

math.vectors prettyprint sequences ;

IN: rosetta-code.quaternion-type

[ q2 q1 [ q* ] ]

} 2show

{{out}}

<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

=={{header|FreeBASIC}}==

Dim Shared As Integer q(3) = {1, 2, 3, 4}

Dim Shared As Integer q1(3) = {2, 3, 4, 5}

For i = 0 To 3 : t(i) = q2(i) : Next i : q_mul(t(),q1()) : Print "q2 * q1 = "; q_show(t())

End

{{out}}

<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}}==

data Quaternion a =

print $ q2 * q1 -- prints "Q (-56.0) 18.0 20.0 28.0"

print $ q1 * q2 == q2 * q1 -- prints "False"

==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}}

With [[wp:Dependent_type|dependent types]] we can implement the more general [[wp:Cayley-Dickson_construction|Cayley-Dickson construction]]. Here the dependent type <code>CD n a</code> is implemented. It depends on a natural number <code>n</code>, which is the number of iterations carried out, and the base type <code>a</code>. So the real numbers are just <code>CD 0 Double</code>, the complex numbers <code>CD 1 Double</code> and the quaternions <code>CD 2 Double</code>

module CayleyDickson

Abs (CD n Double) where

abs {n} = fromBase n . absCD

To test it:

import CayleyDickson

printLn $ q2 * q1

printLn $ q1 * q2 == q2 * q1

=={{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|Kotlin}}==

data class Quaternion(val a: Double, val b: Double, val c: Double, val d: Double) {

println("q2 * q1 = $q4\n")

println("q1 * q2 != q2 * q1 = ${q3 != q4}")

{{out}}

=={{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}}

=={{header|M2000 Interpreter}}==

We can define Quaternions using a class, using operators for specific tasks, as negate, add, multiplication and equality with rounding to 13 decimal place (thats what doing "==" operator for doubles)

Module CheckIt {

class Quaternion {

}

CheckIt

{{out}}

<pre>

=={{header|Maple}}==

with(ArrayTools);

print("divide q1 by q2"):

q1 / q2;

{{out}}<pre>

"q, q1, q2"

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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:

For simplicity, we have limited the type of quaternion fields to floats (i.e. float64). An implementation could use a generic type in order to allow other field types such as float32.

type Quaternion* = object

echo "rq = ", r * q

echo "q1 * q2 = ", q1 * q2

{{out}}

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}}

=={{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

{{out}}

<pre>

{{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}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">norm</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">q</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">" .c 6.a === 6.b: %t\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #7060A8;">equal</span><span style="color: #0000FF;">(</span><span style="color: #000000;">mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">q</span><span style="color: #0000FF;">,</span><span style="color: #000000;">49</span><span style="color: #0000FF;">),</span><span style="color: #000000;">mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">49</span><span style="color: #0000FF;">,</span><span style="color: #000000;">q</span><span style="color: #0000FF;">))})</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">" .d 7.a === 7.b: %t\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #7060A8;">equal</span><span style="color: #0000FF;">(</span><span style="color: #000000;">mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">q1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">q2</span><span style="color: #0000FF;">),</span><span style="color: #000000;">mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">q2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">q1</span><span style="color: #0000FF;">))})</span>

{{out}}

<pre>

{{trans|Prolog}}

A quaternion is represented as a complex term <code>qx/4</code>.

test,

nl.

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

printf("q2*q1 is %w\n", Qx), fail.

{{out}}

=={{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>

=={{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}}

=={{header|Raku}}==

(formerly Perl 6)

has Real ( $.r, $.i, $.j, $.k );

say "6) q * r = {$q * $r}";

say "7) q1 * q2 = {$q1 * $q2}";

{{out}}

<pre>1) q norm = 5.47722557505166

=={{header|Red}}==

quaternion: context [

quaternion!: make typeset! [block! hash! vector!]

`equal? quaternion/multiply q1 q2 mold quaternion/multiply q2 q1` =>}

equal? quaternion/multiply q1 q2 quaternion/multiply q2 q1]

Output:

=={{header|REXX}}==

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

q = 1 2 3 4 ; q1 = 2 3 4 5

r = 7 ; q2 = 3 4 5 6

do j=0 while h>9; m.j=h; h= h % 2 + 1; end /*j*/

do k=j+5 to 0 by -1; numeric digits m.k; g= (g + x/g)* .5; end /*k*/

{{out|output|text=&nbsp; when using the internal default inputs:}}

<pre>

{{works with|Ruby|1.9}}

def initialize(*parts)

raise ArgumentError, "wrong number of arguments (#{parts.size} for 4)" unless parts.size == 4

puts "%20s = %s" % [exp, eval(exp)]

end

{{out}}

<pre>

=={{header|Rust}}==

use std::ops::{Add, Mul, Neg};

println!();

println!("normal of q0 = {}", q0.norm());

{{out}}

<pre>

=={{header|Scala}}==

lazy val im = (i, j, k)

private lazy val norm2 = re*re + i*i + j*j + k*k

implicit def number2Quaternion[T:Numeric](n: T) = Quaternion(n.toDouble)

Demonstration:

val q1=Quaternion(2.0, 3.0, 4.0, 5.0);

val q2=Quaternion(3.0, 4.0, 5.0, 6.0);

println("q2/q1 = "+ q2/q1)

println("q1/r = "+ q1/r)

{{out}}

<pre>q0 = Q(1.00, 2.00i, 3.00j, 4.00k)

=={{header|Seed7}}==

include "float.s7i";

include "math.s7i";

writeln("q1 * q2 = " <& q1 * q2);

writeln("q2 * q1 = " <& q2 * q1);

{{out}}

<pre>

=={{header|Sidef}}==

{{trans|Raku}}

func qu(*r) { Quaternion(r...) }

say "6) q * r = #{q * r}"

say "7) q1 * q2 = #{q1 * q2}"

{{out}}

<pre>

=={{header|Swift}}==

struct Quaternion {

q₂q₁ = \(q2 * q1)

q₁q₂ ≠ q₂q₁ is \(q1*q2 != q2*q1)

{{out}}

=={{header|Tcl}}==

{{works with|Tcl|8.6}} or {{libheader|TclOO}}

# Support class that provides C++-like RAII lifetimes

export - + * ==

Demonstration code:

set q1 [Q new 2 3 4 5]

set q2 [Q new 3 4 5 6]

puts "q1 * q2 = [[$q1 * $q2] p]"

puts "q2 * q1 = [[$q2 * $q1] p]"

{{out}}

<pre>

=={{header|VBA}}==

Private Function norm(q As Variant) As Double

norm = Sqr(WorksheetFunction.SumSq(q))

Debug.Print "q1 * q2 = ";: quats mult(q1, q2)

Debug.Print "q2 * q1 = ";: quats mult(q2, q1)

<pre>q = 1 + 2i + 3j + 4k

q1 = 2 + 3i + 4j + 5k

{{works with|.NET Core|2.1}}

Option Explicit On

Option Infer On

End Operator

#End Region

Demonstration:

Sub Main()

Dim q As New Quaternion(1, 2, 3, 4),

Console.WriteLine($"q1*q2 {If((q1 * q2) = (q2 * q1), "=", "!=")} q2*q1")

End Sub

{{out}}

=={{header|Wren}}==

construct new(a, b, c, d ) {

_a = a

System.print("q1q2 = %(q3)")

System.print("q2q1 = %(q4)")

{{out}}

=={{header|XPL0}}==

real Q;

[RlOut(0, Q(0)); Text(0, " + "); RlOut(0, Q(1)); Text(0, "i + ");

Text(0, "q1 * q2 = "); QPrint(QMul (Q0, Q1, Q2));

Text(0, "q2 * q1 = "); QPrint(QMul (Q0, Q2, Q1));

{{out}}

=={{header|zkl}}==

{{trans|D}}

fcn init(real=0,i1=0,i2=0,i3=0){

var [const] vector= // Quat(r,i,j,k) or Quat( (r,i,j,k) )

(iversor*inorm.sin() + inorm.cos()) * r.exp();

}

r:=7;

q:=Quat(2,3,4,5); q1:=Quat(2,3,4,5); q2:=Quat(3,4,5,6);

println(" s.log(): ", s.log());

println(" s.log().exp(): ", s.log().exp());

{{out}}

<pre>