[Question]
  [
The [cross product](https://en.wikipedia.org/wiki/Cross_product) of two three-dimensional vectors \$\vec a\$ and \$\vec b\$ is the unique vector \$\vec c\$ such that:
* ﻿\$\vec c\$ is orthogonal to both \$\vec a\$ and \$\vec b\$
* The magnitude of \$\vec c\$ is equal to the area of the parallelogram formed by \$\vec a\$ and \$\vec b\$
* The directions of \$\vec a\$, \$\vec b\$, and \$\vec c\$, in that order, follow the [right-hand rule](https://en.wikipedia.org/wiki/Right-hand_rule).
There are a few equivalent formulas for cross product, but one is as follows:
$$\vec a\times\vec b=\det\begin{bmatrix}\vec i&\vec j&\vec k\\a\_1&a\_2&a\_3\\b\_1&b\_2&b\_3\end{bmatrix}$$
where \$\vec i\$, \$\vec j\$, and \$\vec k\$ are the unit vectors in the first, second, and third dimensions.
### Challenge
Given two 3D vectors, write a full program or function to find their cross product. Builtins that specifically calculate the cross product are disallowed.
### Input
Two arrays of three real numbers each. If your language doesn't have arrays, the numbers still must be grouped into threes. Both vectors will have magnitude \$<2^{16}\$. Note that the cross product is noncommutative (\$\vec a\times\vec b=-\bigl(\vec b\times\vec a\bigr)\$), so you should have a way to specify order.
### Output
Their cross product, in a reasonable format, with each component accurate to four significant figures or \$10^{-4}\$, whichever is looser. Scientific notation is optional.
### Test cases
```
[3, 1, 4], [1, 5, 9]
[-11, -23, 14]
[5, 0, -3], [-3, -2, -8]
[-6, 49, -10]
[0.95972, 0.25833, 0.22140],[0.93507, -0.80917, -0.99177]
[-0.077054, 1.158846, -1.018133]
[1024.28, -2316.39, 2567.14], [-2290.77, 1941.87, 712.09]
[-6.6345e+06, -6.6101e+06, -3.3173e+06]
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest solution in bytes wins.
Maltysen posted a [similar challenge](https://codegolf.stackexchange.com/q/70269/39328), but the response was poor and the question wasn't edited.
  
[Answer]
# Jelly, ~~14~~ ~~13~~ 12 bytes
```
;"s€2U×¥/ḅ-U
```
[Try it online!](http://jelly.tryitonline.net/#code=OyJz4oKsMlXDl8KlL-G4hS1V&input=&args=WzMsIDEsIDRdLCBbMSwgNSwgOV0)
### How it works
```
;"s€2U×¥/ḅ-U Main link. Input: [a1, a2, a3], [b1, b2, b3]
;"           Concatenate each [x1, x2, x3] with itself.
             Yields [a1, a2, a3, a1, a2, a3], [b1, b2, b3, b1, b2, b3].
  s€2        Split each array into pairs.
             Yields [[a1, a2], [a3, a1], [a2, a3]], [[b1, b2], [b3, b1], [b2, b3]].
       ¥     Define a dyadic chain:
     U         Reverse the order of all arrays in the left argument.
      ×        Multiply both arguments, element by element.
        /    Reduce the 2D array of pairs by this chain.
             Reversing yields [a2, a1], [a1, a3], [a3, a2].
             Reducing yields [a2b1, a1b2], [a1b3, a3b1], [a3b2, a2b3].
         ḅ-  Convert each pair from base -1 to integer.
             This yields [a1b2 - a2b1, a3b1 - a1b3, a2b3 - a3b2]
           U Reverse the array.
             This yields [a2b3 - a3b2, a3b1 - a1b3, a1b2 - a2b1] (cross product).
```
## Non-competing version (10 bytes)
OK, this is embarrassing, but the array manipulation language Jelly did not have a built-in for array rotation until just now. With this new built-in, we can save two additional bytes.
```
ṙ-×
ç_ç@ṙ-
```
This uses the approach from [@AlexA.'s J answer](https://codegolf.stackexchange.com/a/70517). [Try it online!](http://jelly.tryitonline.net/#code=4bmZLcOXCsOnX8OnQOG5mS0&input=&args=WzMsIDEsIDRd+WzEsIDUsIDld)
### How it works
```
ṙ-×     Helper link. Left input: x = [x1, x2, x3]. Right input: y = [y1, y2, y3].
ṙ-      Rotate x 1 unit to the right (actually, -1 units to the left).
        This yields [x3, x1, x2].
  ×     Multiply the result with y.
        This yields [x3y1, x1y2, x2y3].
ç_ç@ṙ-  Main link. Left input: a = [a1, a2, a3]. Right input: b = [b1, b2, b3].
ç       Call the helper link with arguments a and b.
        This yields [a3b1, a1b2, a2b3].
  ç@    Call the helper link with arguments b and a.
        This yields [b3a1, b1a2, b2a3].
_       Subtract the result to the right from the result to the left.
        This yields [a3b1 - a1b3, a1b2 - a2b1, a2b3 - a3b2].
    ṙ-  Rotate the result 1 unit to the right.
        This yields [a2b3 - a3b2, a3b1 - a1b3, a1b2 - a2b1] (cross product).
```
[Answer]
## **LISP, 128 122 bytes**
Hi! This is my code:
```
(defmacro D(x y)`(list(*(cadr,x)(caddr,y))(*(caddr,x)(car,y))(*(car,x)(cadr,y))))(defun c(a b)(mapcar #'- (D a b)(D b a)))
```
I know that it isn't the shortest solution, but nobody has provided one in Lisp, until now :)
Copy and paste the following code [here](http://www.tutorialspoint.com/lisp/try_lisp.php) to try it!
```
(defmacro D(x y)`(list(*(cadr,x)(caddr,y))(*(caddr,x)(car,y))(*(car,x)(cadr,y))))(defun c(a b)(mapcar #'- (D a b)(D b a)))
(format T "Inputs: (3 1 4), (1 5 9)~%")
(format T "Result ~S~%~%" (c '(3 1 4) '(1 5 9)))
(format T "Inputs: (5 0 -3), (-3 -2 -8)~%")
(format T "Result ~S~%~%" (c '(5 0 -3) '(-3 -2 -8)))
(format T "Inputs: (0.95972 0.25833 0.22140), (0.93507 -0.80917 -0.99177)~%")
(format T "Result ~S~%" (c '(0.95972 0.25833 0.22140) '(0.93507 -0.80917 -0.99177)))
(format T "Inputs: (1024.28 -2316.39 2567.14), (-2290.77 1941.87 712.09)~%")
(format T "Result ~S~%" (c '(1024.28 -2316.39 2567.14) '(-2290.77 1941.87 712.09)))
```
[Answer]
# J, ~~27~~ 14 bytes
```
2|.v~-v=.*2&|.
```
This is a dyadic verb that accepts arrays on the left and right and returns their cross product.
Explanation:
```
         *2&|.     NB. Dyadic verb: Left input * twice-rotated right input
      v=.          NB. Locally assign to v
   v~-             NB. Commute arguments, negate left
2|.                NB. Left rotate twice
```
Example:
```
    f =: 2|.v~-v=.*2&|.
    3 1 4 f 1 5 9
_11 _23 14
```
[Try it here](https://a296a8f7c5110b2ece73921ddc2abbaaa3c90d10.googledrive.com/host/0B3cbLoy-_9Dbb0NaSk9MRGE5UEU/index.html#code=f%20%3D%3A%202%7C.v~-v%3D.*2%26%7C.)
Saved 13 bytes thanks to randomra!
[Answer]
# Dyalog APL, 12 bytes
```
2⌽p⍨-p←⊣×2⌽⊢
```
Based on [@AlexA.'s J answer](https://codegolf.stackexchange.com/a/70517) and (coincidentally) equivalent to @randomra's improvement in that answer's comment section.
Try it online on [TryAPL](http://tryapl.org/?a=3%201%204%20%28%202%u233Dp%u2368-p%u2190%u22A3%D72%u233D%u22A2%20%29%201%205%209&run).
### How it works
```
2⌽p⍨-p←⊣×2⌽⊢  Dyadic function.
              Left argument: a = [a1, a2, a3]. Right argument: b = [b1, b2, b3].
         2⌽⊢  Rotate b 2 units to the left. Yields [b3, b1, b2].
       ⊣×     Multiply the result by a. Yields [a1b3, a2b1, a3b2].
     p←       Save the tacit function to the right (NOT the result) in p.
  p⍨          Apply p to b and a (reversed). Yields [b1a3, b2a1, b3a2].
    -         Subtract the right result (p) from the left one (p⍨).
              This yields [a3b1 - a1b3, a1b2 - a2b1, a2b3 - a3b2].
2⌽            Rotate the result 2 units to the left.
              This yields [a2b3 - a3b2, a3b1 - a1b3, a1b2 - a2b1].
```
[Answer]
# C, 156 154 150 148 144 bytes
```
#include <stdio.h>
main(){float v[6];int i=7,j,k;for(;--i;)scanf("%f",v+6-i);for(i=1;i<4;)j=i%3,k=++i%3,printf("%f ",v[j]*v[k+3]-v[k]*v[j+3]);}
```
Not going to be winning any prizes for length, but thought I'd have a go anyway.
* Input is a newline- or space-delimited list of components (i.e. a1 a2 a3 b1 b2 b3), output is space-delimited (i.e. c1 c2 c3).
* Cyclically permutes the indices of the two input vectors to calculate the product - takes fewer characters than writing out the determinants!
[Demo](http://cpp.sh/5acf)
Ungolfed:
```
#include <cstdio>
int main()
{
    float v[6];
    int i = 7, j, k;
    for (; --i; ) scanf("%f", v + 6 - 1);
    for (i = 1; i < 4; )
        j = i % 3,
        k = ++i % 3,
        printf("%f ", v[j] * v[k + 3] - v[k] * v[j + 3]);
}
```
[Answer]
## Haskell, 41 bytes
```
x(a,b,c)(d,e,f)=(b*f-c*e,c*d-a*f,a*e-b*d)
```
A straightforward solution.
[Answer]
# Bash + coreutils, 51
```
eval set {$1}*{$2}
bc<<<"scale=4;$6-$8;$7-$3;$2-$4"
```
* Line 1 constructs a brace expansion that gives the cartesian product of the two vectors and sets them into the positional parameters.
* Line 2 subtracts the appropriate terms; `bc` does the arithmetic evaluation to the required precision.
Input is as two comma-separated lists on the command-line. Output as newline-separated lines:
```
$ ./crossprod.sh 0.95972,0.25833,0.22140 0.93507,-0.80917,-0.99177
-.07705
1.15884
-1.01812
$
```
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 17 bytes
```
!*[6,7,2;8,3,4])d
```
First input is **a**, second is **b**.
[**Try it online!**](http://matl.tryitonline.net/#code=ISpbNiw3LDI7OCwzLDRdKWQ&input=WzAuOTU5NzIsIDAuMjU4MzMsIDAuMjIxNDBdClswLjkzNTA3LCAtMC44MDkxNywgLTAuOTkxNzddCg)
### Explanation
```
!              % input b as a row array and transpose into a column array
*              % input a as a row array. Compute 3x3 matrix of pairwise products
[6,7,2;8,3,4]  % 2x3 matrix that picks elements from the former in column-major order
)              % apply index
d              % difference within each column
```
[Answer]
# Pyth, 16 bytes
```
-VF*VM.<VLQ_BMS2
```
Try it online: [Demonstration](http://pyth.herokuapp.com/?code=-VF*VM.%3CVLQ_BMS2&input=[3%2C+1%2C+4]%2C+[1%2C+5%2C+9]&debug=0)
### Explanation:
```
-VF*VM.<VLQ_BMS2   Q = input, pair of vectors [u, v]
              S2   creates the list [1, 2]
           _BM     transforms it to [[1, -1], [2, -2]]
      .<VLQ        rotate of the input vectors accordingly to the left:
                   [[u by 1, v by -1], [u by 2, v by -2]]
   *VM             vectorized multiplication for each of the vector-pairs
-VF                vectorized subtraction of the resulting two vectors
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
Takes input in the form \$[[x\_1,x\_2],[y\_1,y\_2],[z\_1,z\_2]]\$. If you want them to be two lists of x-y-z coordinates, just prepend `Z` to the beginning of the program.
```
ṁ4ÆḊƝ
```
[Try it online!](https://tio.run/##y0rNyan8///hzkaTw20Pd3Qdm/v/cPujpjXu//9HR0frGuooGMbqKEQDaSMQrWuso6BrGQtigsRMQAwjqBqglGlsbCwA "Jelly – Try It Online")
Here is a PDF [explanation](https://mr-xcoder.github.io/data/Cross_Product_Calculation.pdf) in case SE markdown can't handle it.
---
### The cross-product in analytic form
Let \$(x\_1,y\_1,z\_1)\$ be the coordinates of \$\vec{v\_1}\$ and \$(x\_2,y\_2,z\_2)\$ be the coordinates of \$\vec{v\_2}\$. Their analytic expressions are as follows:
$$\boldsymbol{\vec{v\_1}}=x\_1\cdot \boldsymbol{\vec{i}}+y\_1\cdot \boldsymbol{\vec{j}}+z\_1\cdot\boldsymbol{\vec{k}}$$
$$\boldsymbol{\vec{v\_2}}=x\_2\cdot \boldsymbol{\vec{i}}+y\_2\cdot \boldsymbol{\vec{j}}+z\_2\cdot\boldsymbol{\vec{k}}$$
The only thing left to do now is to also write their cross-product in terms of its coordinates in the \$Oxyz\$ space.
$$\boldsymbol{\vec{v\_1}}\times \boldsymbol{\vec{v\_2}}=\left(x\_1\cdot \boldsymbol{\vec{i}}+y\_1\cdot \boldsymbol{\vec{j}}+z\_1\cdot\boldsymbol{\vec{k}}\right)\times\left(x\_2\cdot \boldsymbol{\vec{i}}+y\_2\cdot \boldsymbol{\vec{j}}+z\_2\cdot\boldsymbol{\vec{k}}\right)$$
Keeping in mind that: $$\boldsymbol{\vec{i}}\times \boldsymbol{\vec{j}}=\boldsymbol{\vec{k}}, \:\: \boldsymbol{\vec{i}}\times \boldsymbol{\vec{k}}=-\boldsymbol{\vec{j}}, \:\: \boldsymbol{\vec{j}}\times \boldsymbol{\vec{i}}=-\boldsymbol{\vec{k}}, \:\: \boldsymbol{\vec{j}}\times \boldsymbol{\vec{k}}=\boldsymbol{\vec{i}}, \:\: \boldsymbol{\vec{k}}\times \boldsymbol{\vec{i}}=\boldsymbol{\vec{j}}, \:\: \boldsymbol{\vec{k}}\times \boldsymbol{\vec{j}}=-\boldsymbol{\vec{i}}$$
After the necessary rearrangements and calculations:
$$\boldsymbol{\vec{v\_1}}\times \boldsymbol{\vec{v\_2}}=(y\_1z\_2-z\_1y\_2)\cdot \boldsymbol{\vec{i}}+(z\_1x\_2-x\_1z\_2)\cdot \boldsymbol{\vec{j}}+(x\_1y\_2-y\_1x\_2)\cdot \boldsymbol{\vec{k}}$$
### The close relationship with matrix determinants
There's an interesting thing to note here:
$$x\_1y\_2-y\_1x\_2=\left|\begin{matrix}x\_1 & y\_1 \\\ x\_2 & y\_2\end{matrix}\right|$$
$$z\_1x\_2-x\_1z\_2=\left|\begin{matrix}z\_1 & x\_1 \\\ z\_2 & x\_2\end{matrix}\right|$$
$$y\_1z\_2-z\_1y\_2=\left|\begin{matrix}y\_1 & z\_1 \\\ y\_2 & z\_2\end{matrix}\right|$$
Where we use the notation \$\left|\cdot\right|\$ for matrix determinant. Notice the *beautiful* rotational symmetry?
### Jelly code explanation
Well... not much to explain here. It just generates the matrix:
$$\left(\begin{matrix}x\_1 & y\_1 & z\_1 & x\_1 \\\ x\_2 & y\_2 & z\_2 & x\_2\end{matrix}\right)$$
And for each pair of neighbouring matrices, it computes the determinant of the matrix formed by joining the two.
```
ṁ4ÆḊƝ – Monadic Link. Takes input as [[x1,x2],[y1,y2],[z1,z2]].
ṁ4    – Mold 4. Cycle the list up to length 4, reusing the elements if necessary.
        Generates [[x1,x2],[y1,y2],[z1,z2],[x1,x2]].
    Ɲ – For each pair of neighbours: [[x1,x2],[y1,y2]], [[y1,y2],[z1,z2]], [[z1,z2],[x1,x2]].
  ÆḊ  – Compute the determinant of those 2 paired together into a single matrix.
```
[Answer]
# K5, ~~44~~ ~~40~~ ~~37~~ 32 bytes
Wrote this one quite a while ago and [dusted it off again recently](https://github.com/JohnEarnest/ok/blob/gh-pages/ike/examples/vector.k#L16).
```
{{x[y]-x[|y]}[*/x@']'3 3\'5 6 1}
```
In action:
```
 cross: {{x[y]-x[|y]}[*/x@']'3 3\'5 6 1};
 cross (3 1 4;1 5 9)
-11 -23 14
 cross (0.95972 0.25833 0.22140;0.93507 -0.80917 -0.99177)
-7.705371e-2 1.158846 -1.018133
```
## Edit 1:
Saved 4 bytes by taking input as a list of lists instead of two separate arguments:
```
old: {m:{*/x@'y}(x;y);{m[x]-m[|x]}'(1 2;2 0;0 1)}
new: {m:{*/x@'y}x    ;{m[x]-m[|x]}'(1 2;2 0;0 1)}
```
## Edit 2:
Saved 3 bytes by computing a lookup table with base-decode:
```
old: {m:{*/x@'y}x;{m[x]-m[|x]}'(1 2;2 0;0 1)}
new: {m:{*/x@'y}x;{m[x]-m[|x]}'3 3\'5 6 1}
```
## Edit 3:
Save 5 bytes by rearranging application to permit using a tacit definition instead of a local lambda. Unfortunately, this solution no longer works in oK, and requires the official k5 interpreter. Gonna have to take my word for this one until I fix the bug in oK:
```
old: {m:{*/x@'y}x;{m[x]-m[|x]}'3 3\'5 6 1}
new: {{x[y]-x[|y]}[*/x@']     '3 3\'5 6 1}
```
[Answer]
# Python, ~~73~~ 48 bytes
Thanks @FryAmTheEggman
```
lambda (a,b,c),(d,e,f):[b*f-c*e,c*d-a*f,a*e-b*d]
```
This is based on the component definition of the vector cross product.
[Try it here](http://ideone.com/Pt0NpE)
[Answer]
# [Ruby](https://www.ruby-lang.org/), 49 bytes
```
->u,v{(0..2).map{|a|u[a-2]*v[a-1]-u[a-1]*v[a-2]}}
```
[Try it online!](https://tio.run/##PU4xCsMwDNzzCo9tsYUk27U9tB8xHtIhWyEUHChJ3u4qLmQQd6fTifvU17dNj2aeVS/rBQH4Cu9xXrdxq3k0XG6LABVTO3TFZd/brKacrVaklStaZUGvVSplGLolArUy9vCM3BmWiaeNkHwKskNgH63thMlh0YdnPQa5R4iY6M@SkHDmCdkBx@OvpTvYpBX7ewDqZQxzQggSpOQIopBADCj12g8 "Ruby – Try It Online")
Returning after 2 years, I shaved off 12 bytes by using how Ruby treats negative array indices. `-1` is the last element of the array, `-2` the second last etc.
# Ruby, 57
```
->u,v{(0..2).map{|a|u[b=(a+1)%3]*v[c=(a+2)%3]-u[c]*v[b]}}
```
**In test program**
```
f=->u,v{(0..2).map{|a|u[b=(a+1)%3]*v[c=(a+2)%3]-u[c]*v[b]}}
p f[[3, 1, 4], [1, 5, 9]]
p f[[5, 0, -3], [-3, -2, -8]]
p f[[0.95972, 0.25833, 0.22140],[0.93507, -0.80917, -0.99177]]
p f[[1024.28, -2316.39, 2567.14], [-2290.77, 1941.87, 712.09]]
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~38 33 25~~ 24 bytes
-1 byte thanks to [@att](https://codegolf.stackexchange.com/users/81203/att).
```
Det@{a={i,j,},##}~D~{a}&
```
[Try it online!](https://tio.run/##JY6xisMwDIZfRRDoJAtJjmt76JGhD9C9dDCl5XLQG45swn31nNIMQp/@XxL/qy3fj1db5ntbn3CC9fxYJmsnm/EHOw5Df5/f1vphvfzNv8vVXIHwBc/rMNxucIBpmsDMIoIgjB3BvCeE2jc2J0YIcRuCLwX1KrvHVFPNLjBpKjF@QGXkjpsXE2dfZipcZafqkPdjYR1Jy/YxypFiRdB0zCSfDEG1MmW/kjoKFYcsSuyp@voP "Wolfram Language (Mathematica) – Try It Online")
[Answer]
## ES6, 40 bytes
```
(a,b,c,d,e,f)=>[b*f-c*e,c*d-a*f,a*e-b*d]
```
44 bytes if the input needs to be two arrays:
```
([a,b,c],[d,e,f])=>[b*f-c*e,c*d-a*f,a*e-b*d]
```
52 bytes for a more interesting version:
```
(a,b)=>a.map((_,i)=>a[x=++i%3]*b[y=++i%3]-a[y]*b[x])
```
[Answer]
# [Julia 0.7](http://julialang.org/), ~~45~~ 39 bytes
```
f(a,b)=1:3 .|>i->det([eye(3)[i,:] a b])
```
[Try it online!](https://tio.run/##XY5NagMxDIX3OYWWNshCP@PYDjQXGbyY0AlMCCGEdFHo3aeadFOyEPrQe5Le5eu6TGVdz2HCU/yQgwH9HJd0/JyfYZy/52BxXPDQYYJTj@v9sdye11s4h9EQBGHoCKP3jNB6jLt/Bh8xQrLNkdyd1Ku@mZhabsUVJs3V7AUqA3fcNMtcfIupcpM/ag7l7YqwDqR1@2GyJ2sImveF5BUvqTam4uvSBqHqUESJt8DrLw "Julia 0.7 – Try It Online")
Uses the determinant-based formula given in the task description.
Thanks to H.PWiz for -6 bytes.
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 41 bytes
```
(a,b)->Vec(matdet(Mat([[x^2,x,1],a,b]~)))
```
[Try it online!](https://tio.run/##JY5BagMxDEWvIrKyQTaSPI7tRXODbrsxU3DTpASmxYRZpJtefSpnFkJP@v8L9Xa/ua@@XeEFNtPww7rT2@Vsvtv6eVnNa1tNrY93wQfyjKrPf9barfW@/JoG7gT9fvtZFQ9jOMC5LYu5IjRrsdYaEBhhmhGq9ohQ5sFViRBcGINTkxOtvGvkSyxJF@Ql5hCeIDzRUFUMkZK6yWcqvFNRSHuaSSYveZwMfPShIEg8Js/PJ5xIIZ80xWVinxUSiyd9a7bbPw "Pari/GP – Try It Online")
[Answer]
# [CSASM v2.5.0.2](https://github.com/absoluteAquarian/CSASM/releases/tag/v2.5.0.2), 306 bytes
```
func a:
dup
dup
ldelem 0
pop $3
ldelem 1
pop $4
ldelem 2
pop $5
dup
dup
ldelem 0
pop $a
ldelem 1
pop $1
ldelem 2
pop $2
push $1
push $5
mul
push $2
push $4
mul
sub
push $2
push $3
mul
push $a
push $5
mul
sub
push $a
push $4
mul
push $1
push $3
mul
sub
push 3
newarr f32
pop $a
push $a
swap
stelem 2
push $a
swap
stelem 1
push $a
swap
stelem 0
push $a
ret
end
```
The function `a` expects two `~arr:f32` arrays representing the two 3D vectors on the stack before calling it.  
\$\vec a\$ should be pushed to the stack first, then \$\vec b\$ should be pushed.  
This function leaves an `~arr:f32` array on the stack which corresponds to \$\vec c\$.
**Explanation:**
```
; Input: two ~arr:f32 representing the two vectors
func a:
    ; stack: [ a, b, c ], [ d, e, f ]
    ; These numbers represent the coordinates of the two vectors for an easier explanation
    ; Duplicate the second vector twice
    dup
    dup
    ; stack: [ a, b, c ], [ d, e, f ], [ d, e, f ], [ d, e, f ]
    ; Store the elements in the array to the pre-defined registers $3, $4 and $5
    ldelem 0
    pop $3
    ldelem 1
    pop $4
    ldelem 2
    pop $5
    ; Duplicate the first vector twice
    dup
    dup
    ; stack: [ a, b, c ], [ a, b, c ], [ a, b, c ]
    ; Store the elements in the array to the pre-defined registers $a, $1 and $2
    ldelem 0
    pop $a
    ldelem 1
    pop $1
    ldelem 2
    pop $2
    ; Perform the algorithm: [ bf - ce, cd - af, ae - bd ]
    ; $a = a, $1 = b, $2 = c
    ; $3 = d, $4 = e, $5 = f
    ; bf - ce
    push $1
    push $5
    mul
    push $2
    push $4
    mul
    sub
    ; cd - af
    push $2
    push $3
    mul
    push $a
    push $5
    mul
    sub
    ; ae - bd
    push $a
    push $4
    mul
    push $1
    push $3
    mul
    sub
    ; Create the result array and store it in $a
    push 3
    newarr f32
    pop $a
    ; Store the resulting values from earlier into this new array
    ; "swap" swaps the top two values on the stack
    push $a
    swap
    stelem 2
    push $a
    swap
    stelem 1
    
    push $a
    swap
    stelem 0
    push $a
    ret
end
```
[Answer]
## TI-BASIC, ~~75~~ ~~73~~ ~~71~~ 62 bytes
-4 bytes thanks to [@MarcMush](https://codegolf.stackexchange.com/users/98541/marcmush)  
-9 bytes using `Ans` instead of `Prompt`  and `Disp` 
Not 62 characters -- TI-BASIC is tokenized.
```
:Prompt A
:{Ans(2)ʟA(3)-Ans(3)ʟA(2),Ans(3)ʟA(1)-Ans(1)ʟA(3),Ans(1)ʟA(2)-Ans(2)ʟA(1
```
Usage example, computing \$\langle 1,2,3\rangle\times\langle 0,1,0\rangle\$:
```
{1,2,3}:pgrmXPROD
A=?{0,1,0}
                  {⁻3 0 1}
```
[Answer]
# MATLAB/Octave, 61 bytes.
[Try it online!](https://tio.run/##XY/NasMwEITvfQodbVgv@yNFEiKQ9zA@SE0CPbWQ0Nd3VwoB04NgdjTzSfv9@ay/t32/ny9ThTav19tzWhkIqNTSthmGQcD/DbNexlb2yu7sVgXH4PxWXBuzDQFctvn69fiZ7lM1p/E8l48qPWC3BG7R3hjGYohF7KRDyeYmo6Q9Q5hDjmYSSkiqQwh76pR3QgNFwxAmyvxS2UQ8YK3YdGD9@CyJR0n9feUTagYn4RSRxz4jsohkwmg4zp4xmYgsSMcNvVG9Ufc/)
```
f=@(a,b)[det([1,0,0;a;b]),det([0,1,0;a;b]),det([0,0,1;a;b])];
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~24~~ 21 bytes
```
D/@HodgeDual[1##]&
```
[Try it online!](https://tio.run/##JY4/zsIwDMWvYqkSU2JspyHJAOrAwMheMVT8@5A@QEJlinIGDsAhOUJx6WD55/ds6127/u947frLvhtOsIRhPW8298P5uH52/y1/Xu@q2s2G7eNy69tcVQXsCk6tijuYQdM0kHN2BthAXQxk7d5AKiNnJTJg3ThYXbKiFSePMPkUVCAUH537gXBNxYye8xR0mTBS4omSQpiOmaRGieNHxwt0yYD4RUD@ZbAiiTDoFaeaMSoEFiRNVYYv "Wolfram Language (Mathematica) – Try It Online")
`` is `\[TensorWedge]` (U+F3DB).
[Answer]
# APL(NARS), 23 chars, 46 bytes
```
{((1⌽⍺)×5⌽⍵)-(5⌽⍺)×1⌽⍵}
```
test:
```
  f←{((1⌽⍺)×5⌽⍵)-(5⌽⍺)×1⌽⍵}
  (3 1 4) f (1 5 9)
¯11 ¯23 14 
  (5 0 ¯3) f (¯3 ¯2 ¯8)
¯6 49 ¯10 
  (0.95972 0.25833 0.22140) f (0.93507 ¯0.80917 ¯0.99177)
¯0.0770537061 1.158846002 ¯1.018133265 
  (1024.28 ¯2316.39 2567.14) f (¯2290.77 1941.87 712.09)
¯6634530.307 ¯6610106.843 ¯3317298.117 
```
]