fix: support multiplication of arrays with units (#3456)

Author: Delaney

src/function/complex/conj.js

@@ -25,14 +25,15 @@ export const createConj = /* #__PURE__ */ factory(name, dependencies, ({ typed }
    *
    *    re, im, arg, abs
    *
-   * @param {number | BigNumber | Complex | Array | Matrix} x
+   * @param {number | BigNumber | Complex | Array | Matrix | Unit} x
    *            A complex number or array with complex numbers
-   * @return {number | BigNumber | Complex | Array | Matrix}
+   * @return {number | BigNumber | Complex | Array | Matrix | Unit}
    *            The complex conjugate of x
    */
   return typed(name, {
     'number | BigNumber | Fraction': x => x,
     Complex: x => x.conjugate(),
+    Unit: typed.referToSelf(self => x => new x.constructor(self(x.toNumeric()), x.formatUnits())),
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   })
 })

test/unit-tests/function/arithmetic/multiply.test.js

@@ -318,6 +318,19 @@ describe('multiply', function () {
       approxDeepEqual(multiply(matrix(a), matrix(b)), 32)
     })
 
+    it('should multiply vectors with units correctly (dot product)', function () {
+      const a = [1, 2, 3]
+      const b = [unit('4cm'), unit('5cm'), unit('6cm')]
+
+      approxDeepEqual(multiply(a, b), unit('32cm'))
+      approxDeepEqual(multiply(matrix(a), matrix(b)), unit('32cm'))
+
+      const e = [unit('1cm'), unit('2cm'), unit('3cm')]
+
+      assert.strictEqual(multiply(e, b).format(5), '32 cm^2')
+      assert.strictEqual(multiply(matrix(e), matrix(b)).format(5), '32 cm^2')
+    })
+
     it('should conjugate the first argument in dot product', function () {
       const a = [complex(1, 2), complex(3, 4)]
       const b = [complex(5, 6), complex(7, 8)]

test/unit-tests/function/complex/conj.test.js

@@ -26,6 +26,14 @@ describe('conj', function () {
     assert.strictEqual(conj(math.complex('2')).toString(), '2')
     assert.strictEqual(conj(math.complex('-4i')).toString(), '4i')
     assert.strictEqual(conj(math.i).toString(), '-i')
+    assert.strictEqual(conj(math.unit('5cm')).toString(), '5 cm')
+  })
+
+  it('should calculate the conjugate of a units with complex, Fraction and BigNumber values', function () {
+    assert.strictEqual(conj(math.unit(math.complex('300+250i'), 'ohm')).toString(), '(300 - 250i) ohm')
+    assert.strictEqual(conj(math.unit(math.bignumber('0.3'), 'm/s')).toString(), '0.3 m / s')
+    assert.strictEqual(conj(math.unit(math.fraction('0.(285714)'), 'fahrenheit')).toString(), '2/7 fahrenheit')
+    assert.strictEqual(conj(math.unit(math.fraction(0.125), 'hp')).toString(), '1/8 hp')
   })
 
   it('should calculate the conjugate for each element in a matrix', function () {
@@ -37,7 +45,6 @@ describe('conj', function () {
 
   it('should throw an error when called with an unsupported type of argument', function () {
     assert.throws(function () { conj(new Date()) }, /TypeError: Unexpected type of argument/)
-    assert.throws(function () { conj(math.unit('5cm')) }, /TypeError: Unexpected type of argument/)
   })
 
   it('should throw an error in case of invalid number of arguments', function () {

test/unit-tests/function/matrix/dot.test.js

@@ -5,6 +5,9 @@ const dot = math.dot
 const matrix = math.matrix
 const sparse = math.sparse
 const complex = math.complex
+const unit = math.unit
+const bignumber = math.bignumber
+const fraction = math.fraction
 
 describe('dot', function () {
   it('should calculate dot product for two 1-dim arrays', function () {
@@ -57,6 +60,40 @@ describe('dot', function () {
     assert.strictEqual(dot(matrix([[7], [3]]), matrix([2, 4])), 26)
   })
 
+  it('should calculate dot product for two 1-dim unit arrays', function () {
+    assert.strictEqual(dot([unit('2m'), unit('4m'), unit('1m')], [2, 2, 3]).toString(), '15 m')
+    assert.strictEqual(dot([7, 3], [unit('2m'), unit('4m')]).toString(), '26 m')
+    assert.strictEqual(dot([unit('2m'), unit('4m'), unit('1m')], [unit('2m'), unit('2m'), unit('3m')]).toString(), '15 m^2')
+  })
+
+  it('should calculate dot product for two column unit arrays', function () {
+    assert.strictEqual(dot([[unit('2g')], [unit('4g')], [unit('1g')]], [[2], [2], [3]]).toString(), '15 g')
+    assert.strictEqual(dot([[unit('7g')], [unit('3g')]], [[2], [4]]).toString(), '26 g')
+  })
+
+  it('should calculate dot product for two 1-dim unit vectors', function () {
+    assert.strictEqual(dot(matrix([2, 4, 1]), matrix([unit('2g'), unit('2g'), unit('3g')])).toString(), '15 g')
+    assert.strictEqual(dot(matrix([unit('7m'), unit('3m')]), matrix([unit('2m'), unit('4m')])).toString(), '26 m^2')
+  })
+
+  it('should calculate dot product for two column unit vectors', function () {
+    assert.strictEqual(dot(matrix([[unit('2m')], [unit('4m')], [unit('1m')]]), matrix([[unit('2m')], [unit('2m')], [unit('3m')]])).toString(), '15 m^2')
+    assert.strictEqual(dot(matrix([[7], [3]]), matrix([[unit('2g')], [unit('4g')]])).toString(), '26 g')
+  })
+
+  it('should calculate dot product for two 1-dim unit with complex value vectors', function () {
+    assert.deepEqual(dot(matrix([unit(complex(2, 3), 'm'), unit(complex(4, 5), 'm')]), matrix([unit(complex(1, 1), 'm'), unit(complex(2, 4), 'm')])).toNumeric(), complex(33, 5))
+    assert.strictEqual(dot(matrix([unit(complex(2, 3), 'm'), unit(complex(4, 5), 'm')]), matrix([unit(complex(1, 1), 'm'), unit(complex(2, 4), 'm')])).toString(), '(33 + 5i) m^2')
+  })
+
+  it('should calculate dot product for two 1-dim unit with BigNumber value vectors', function () {
+    assert.strictEqual(dot(matrix([[unit(bignumber(7), 'g')], [unit(bignumber(3), 'g')]]), matrix([[unit(bignumber(2), 'g')], [unit(bignumber(4), 'g')]])).toString(), '26 g^2')
+  })
+
+  it('should calculate dot product for two 1-dim unit with Fraction value vectors', function () {
+    assert.strictEqual(dot(matrix([[unit(fraction(0.4), 'm')], [unit(fraction('0.5'), 'm')]]), matrix([[unit(fraction(1, 4), 'm')], [unit(fraction('3/4'), 'm')]])).toString(), '19/40 m^2')
+  })
+
   it('should calculate dot product for sparse vectors', function () {
     assert.strictEqual(dot(sparse([0, 0, 2, 4, 4, 1]), sparse([1, 0, 2, 2, 0, 3])), 15)
     assert.strictEqual(dot(sparse([7, 1, 2, 3]), sparse([2, 0, 0, 4])), 26)