arrays - una - Cómo multiplicar dos matrices por elementos

suma elementos de una matriz

Question

Necesito multiplicar una matriz por otra matriz en cuanto a elementos, al igual que el producto Hadamard de vectores en matemáticas. Por ejemplo:

A = [1,2,3,4]
B = [2,3,4,5]
C = A*B = [2,6,12,20]

Ni siquiera puedo descifrar el código, he intentado hacerlo elemento por elemento, pero esto me parece una solución demasiado desordenada, ¿alguna idea?

Answer 1

Acelerar el marco

Para el tema de la multiplicación de vectores, otra alternativa (además del simd cubierto por la respuesta de @ appzYourLife ) está haciendo uso del marco Acelerar . En este caso, específicamente los métodos vDSP_vmul y vDSP_vmuld ,

func vDSP_vmul(UnsafePointer<Float>, vDSP_Stride,
UnsafePointer<Float>, vDSP_Stride,
UnsafeMutablePointer<Float>, vDSP_Stride, vDSP_Length)
func vDSP_vmulD(UnsafePointer<Double>, vDSP_Stride,
UnsafePointer<Double>, vDSP_Stride,
UnsafeMutablePointer<Double>, vDSP_Stride, vDSP_Length)

Por ejemplo, este último utilizado para la multiplicación elemento por elemento de dos vectores de valores Double :

import Accelerate
let a = [1.5, 2.5, 16.5, 7.5, 3.0]
let b = [3.0, 4.5, 0.25, 3.5, 6.25]
var result = [Double](repeating: 0.0, count: a.count)
if a.count == b.count {
vDSP_vmulD(a, 1, b, 1, &result, 1, vDSP_Length(a.count))
print(result) // [4.5, 11.25, 4.125, 26.25, 18.75]
}

Tenga en cuenta que usar Accelerate no es tan fácil de usar y seguro como los métodos alternativos, ya que los argumentos vectoriales para vDSP_vmulD se capturan como punteros inseguros ( UnsafePointer<Double> ), y es nuestra responsabilidad asegurarnos de que los vectores de entrada sean de la misma longitud , así como que el vector resultante se asigne correctamente antes de la multiplicación del vector por vDSP_vmulD .

Answer 2

Instrucción única Datos múltiples

Si sus vectores tienen exactamente 4 componentes, puede usar las instrucciones simd ( Single Instruction Multiple Data ) proporcionadas por iOS.

Utiliza la CPU para realizar cálculos paralelos.

Dados 2 vectores de 4 componentes de Int32

import simd
let a = int4(1, 2, 3, 4)
let b = int4(2, 3, 4, 5)

puedes multiplicar cada componente

let res = a &* b // int4(2, 6, 12, 20)

Como señaló Martin R , el módulo simd también proporciona una matriz de float(s) o de double(s) .

Answer 3

Al "comprimir" las dos matrices se obtiene una secuencia de tuplas (a_i, b_i) que luego se pueden multiplicar por elementos:

let A = [1,2,3,4]
let B = [2,3,4,5]
let C = zip(A, B).map { $0 * $1 }
print(C) // [2, 6, 12, 20]

(Si las matrices tienen una longitud diferente, zip ignora silenciosamente los elementos adicionales de la matriz más larga).

Como @appzYourLife dijo correctamente, también puede pasar el operador de multiplicación directamente como un argumento para map lugar de una expresión de cierre:

let C = zip(A, B).map(*)

Answer 4

Con Swift 5, puede usar una de las siguientes formas para resolver su problema.

# 1 Usando tipos de vectores SIMD

El siguiente código de muestra de Playground muestra una multiplicación por elementos usando SIMD4 :

let vector1 = SIMD4(1, 2, 3, 4)
let vector2 = SIMD4(2, 3, 4, 5)
let vector3 = vector1 &* vector2
print(vector3) // prints: SIMD4<Int>(2, 6, 12, 20)

Tenga en cuenta que el protocolo SIMD ajusta a ExpressibleByArrayLiteral . Por lo tanto, puede inicializar su vector usando una matriz literal:

var vector1: SIMD4 = [1, 2, 3, 4]
let vector2: SIMD4 = [2, 3, 4, 5]
vector1 &*= vector2
print(vector1) // prints: SIMD4<Int>(2, 6, 12, 20)

# 2 Usar un tipo personalizado que se ajuste a los protocolos Numeric y ExpressibleByArrayLiteral

Puede crear su propio tipo personalizado que se ajuste a Numeric y ExpressibleByArrayLiteral . El siguiente código de muestra de Playground muestra cómo implementarlo y usarlo:

struct Vector {
let x, y: Int
init(_ x: Int, _ y: Int) {
self.x = x
self.y = y
}
}

extension Vector: AdditiveArithmetic {
static var zero: Vector {
return Vector(0, 0)
}
static func +(lhs: Vector, rhs: Vector) -> Vector {
return Vector(lhs.x + rhs.x, lhs.y + rhs.y)
}
static func +=(lhs: inout Vector, rhs: Vector) {
lhs = lhs + rhs
}
static func -(lhs: Vector, rhs: Vector) -> Vector {
return Vector(lhs.x - rhs.x, lhs.y - rhs.y)
}
static func -=(lhs: inout Vector, rhs: Vector) {
lhs = lhs - rhs
}
}

extension Vector: ExpressibleByIntegerLiteral {
init(integerLiteral value: Int) {
x = value
y = value
}
}

import Darwin
extension Vector: Numeric {
var magnitude: Int {
// Implement according to your needs
return Int(Darwin.sqrt(Double(x * x + y * y)))
}
init?<T>(exactly source: T) where T : BinaryInteger {
guard let source = source as? Int else {
return nil
}
x = source
y = source
}
static func *(lhs: Vector, rhs: Vector) -> Vector {
return Vector(lhs.x * rhs.y, lhs.y * rhs.x)
}
static func *=(lhs: inout Vector, rhs: Vector) {
lhs = lhs * rhs
}
}

extension Vector: ExpressibleByArrayLiteral {
init(arrayLiteral elements: Int...) {
assert(elements.count == 2, "arrayLiteral should have exactly 2 elements")
self.x = elements[0]
self.y = elements[1]
}
}

Uso:

let vector1 = Vector(1, 2)
let vector2 = Vector(2, 3)
let vector3 = vector1 * vector2
print(vector3) // prints: Vector(x: 3, y: 4)

let vector1: Vector = [1, 2]
let vector2: Vector = [2, 3]
let vector3 = vector1 * vector2
print(vector3) // prints: Vector(x: 3, y: 4)

Answer 5

 let A = [1,2,3,4]
let B = [2,3,4,5]
var C = [Int]()
A.enumerated().forEach{ index, value in
return C.append(value * B[index])
}