2019-09-25 16:21:58 +08:00
|
|
|
// Copyright © 2014-2019 the Surge contributors
|
2019-08-07 01:08:53 +08:00
|
|
|
//
|
|
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
|
|
// in the Software without restriction, including without limitation the rights
|
|
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
|
|
// furnished to do so, subject to the following conditions:
|
|
|
|
//
|
|
|
|
// The above copyright notice and this permission notice shall be included in
|
|
|
|
// all copies or substantial portions of the Software.
|
|
|
|
//
|
|
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
// THE SOFTWARE.
|
|
|
|
|
|
|
|
import XCTest
|
|
|
|
|
2019-09-25 07:13:55 +08:00
|
|
|
@testable import Surge
|
|
|
|
|
2019-08-20 05:26:56 +08:00
|
|
|
// swiftlint:disable nesting type_body_length
|
2019-08-07 01:08:53 +08:00
|
|
|
|
|
|
|
class VectorTests: XCTestCase {
|
2019-09-23 20:36:08 +08:00
|
|
|
// MARK: - Initialization
|
|
|
|
|
2019-10-02 07:29:12 +08:00
|
|
|
func test_init_dimensions_repeatedValue() {
|
|
|
|
typealias Scalar = Double
|
|
|
|
|
|
|
|
let dimensions = 5
|
|
|
|
let repeatedValue: Scalar = 42
|
|
|
|
|
|
|
|
let actual: Vector<Scalar> = Vector(dimensions: dimensions, repeatedValue: repeatedValue)
|
|
|
|
|
|
|
|
let expected: Vector<Scalar> = [42, 42, 42, 42, 42]
|
|
|
|
|
|
|
|
XCTAssertEqual(actual, expected)
|
|
|
|
}
|
|
|
|
|
2019-09-23 18:37:53 +08:00
|
|
|
func test_init() {
|
2019-09-25 19:32:36 +08:00
|
|
|
typealias Scalar = Double
|
|
|
|
|
|
|
|
let values: [Scalar] = .monotonicNormalized()
|
|
|
|
let lhs: Vector<Scalar> = Vector(values)
|
|
|
|
|
|
|
|
XCTAssertEqual(lhs.scalars, values)
|
|
|
|
}
|
|
|
|
|
2019-10-02 07:29:12 +08:00
|
|
|
func test_init_dimensions_closure() {
|
|
|
|
typealias Scalar = Double
|
|
|
|
|
|
|
|
let dimensions = 5
|
|
|
|
let actual: Vector<Scalar> = Vector(dimensions: dimensions) { Scalar($0) }
|
|
|
|
let expected: Vector<Scalar> = [0, 1, 2, 3, 4]
|
|
|
|
|
|
|
|
XCTAssertEqual(actual, expected)
|
|
|
|
}
|
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
// MARK: - Subscript
|
|
|
|
|
|
|
|
func test_subscript() {
|
|
|
|
typealias Scalar = Double
|
|
|
|
|
|
|
|
let values: [Scalar] = .monotonicNormalized()
|
|
|
|
let lhs: Vector<Scalar> = Vector(values)
|
|
|
|
|
|
|
|
for (index, expected) in values.enumerated() {
|
|
|
|
XCTAssertEqual(lhs[index], expected)
|
|
|
|
}
|
2019-08-07 01:08:53 +08:00
|
|
|
}
|
|
|
|
|
2019-09-23 20:36:08 +08:00
|
|
|
// MARK: - Addition: In Place
|
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_add_in_place_vector_vector_double() {
|
|
|
|
typealias Scalar = Double
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
2019-09-23 19:10:25 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.addInPlace(&actual, rhs)
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(zip(lhs, rhs).map { $0 + $1 })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_add_in_place_vector_vector_float() {
|
|
|
|
typealias Scalar = Float
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
2019-09-23 19:10:25 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.addInPlace(&actual, rhs)
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(zip(lhs, rhs).map { $0 + $1 })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_add_in_place_vector_scalar_double() {
|
|
|
|
typealias Scalar = Double
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Scalar = .constant()
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.addInPlace(&actual, rhs)
|
2019-09-23 19:10:25 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(lhs.map { $0 + rhs })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_add_in_place_vector_scalar_float() {
|
|
|
|
typealias Scalar = Float
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Scalar = .constant()
|
2019-09-23 19:10:25 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.addInPlace(&actual, rhs)
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(lhs.map { $0 + rhs })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
2019-08-07 01:08:53 +08:00
|
|
|
|
2019-09-23 20:36:08 +08:00
|
|
|
// MARK: - Subtraction: In Place
|
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_sub_in_place_vector_vector_double() {
|
|
|
|
typealias Scalar = Double
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.subInPlace(&actual, rhs)
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(zip(lhs, rhs).map { $0 - $1 })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_sub_in_place_vector_vector_float() {
|
|
|
|
typealias Scalar = Float
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.subInPlace(&actual, rhs)
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(zip(lhs, rhs).map { $0 - $1 })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_sub_in_place_vector_scalar_double() {
|
|
|
|
typealias Scalar = Double
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Scalar = .constant()
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.subInPlace(&actual, rhs)
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(lhs.map { $0 - rhs })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_sub_in_place_vector_scalar_float() {
|
|
|
|
typealias Scalar = Float
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Scalar = .constant()
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.subInPlace(&actual, rhs)
|
2019-09-23 19:10:25 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(lhs.map { $0 - rhs })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-07 01:08:53 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
|
|
|
|
2019-09-25 05:18:05 +08:00
|
|
|
// MARK: - Multiply Addition: In Place
|
|
|
|
|
|
|
|
func test_muladd_in_place_vector_vector_double() {
|
|
|
|
typealias Scalar = Double
|
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let alpha: Scalar = .constant()
|
2019-09-25 05:18:05 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.muladdInPlace(&actual, rhs, alpha)
|
2019-09-25 05:18:05 +08:00
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(zip(lhs.scalars, rhs.scalars).map { $0 + ($1 * alpha) })
|
2019-09-25 05:18:05 +08:00
|
|
|
|
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
|
|
|
|
|
|
|
func test_muladd_in_place_vector_vector_float() {
|
|
|
|
typealias Scalar = Float
|
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let alpha: Scalar = .constant()
|
2019-09-25 05:18:05 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.muladdInPlace(&actual, rhs, alpha)
|
2019-09-25 05:18:05 +08:00
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(zip(lhs.scalars, rhs.scalars).map { $0 + ($1 * alpha) })
|
2019-09-25 05:18:05 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-6)
|
2019-09-25 05:18:05 +08:00
|
|
|
}
|
|
|
|
|
2019-09-23 20:36:08 +08:00
|
|
|
// MARK: - Multiplication: In Place
|
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_mul_in_place_vector_scalar_double() {
|
|
|
|
typealias Scalar = Double
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Scalar = .constant()
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.mulInPlace(&actual, rhs)
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(lhs.map { $0 * rhs })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_mul_in_place_vector_scalar_float() {
|
|
|
|
typealias Scalar = Float
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Scalar = .constant()
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.mulInPlace(&actual, rhs)
|
2019-09-23 19:10:25 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(lhs.map { $0 * rhs })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
|
|
|
|
|
|
|
func test_mul_vector_matrix_double() {
|
|
|
|
typealias Scalar = Double
|
|
|
|
|
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Matrix<Scalar> = .monotonicNormalized()
|
|
|
|
|
|
|
|
let actual: Vector<Scalar> = Surge.mul(lhs, rhs)
|
|
|
|
|
|
|
|
let transposed: Matrix<Scalar> = Surge.transpose(rhs)
|
|
|
|
let columns: [Vector<Scalar>] = transposed.map { Vector($0) }
|
|
|
|
let expected: Vector<Scalar> = Vector(columns.map { rhs in
|
2019-09-27 22:37:44 +08:00
|
|
|
let squares: [Scalar] = zip(lhs, rhs).map { $0 * $1 }
|
2019-09-25 19:32:36 +08:00
|
|
|
return squares.reduce(0.0, +)
|
|
|
|
})
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
2019-08-07 01:08:53 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
func test_mul_vector_matrix_float() {
|
|
|
|
typealias Scalar = Float
|
|
|
|
|
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Matrix<Scalar> = .monotonicNormalized()
|
|
|
|
|
|
|
|
let actual: Vector<Scalar> = Surge.mul(lhs, rhs)
|
|
|
|
|
|
|
|
let transposed: Matrix<Scalar> = Surge.transpose(rhs)
|
|
|
|
let columns: [Vector<Scalar>] = transposed.map { Vector($0) }
|
|
|
|
let expected: Vector<Scalar> = Vector(columns.map { rhs in
|
2019-09-27 22:37:44 +08:00
|
|
|
let squares: [Scalar] = zip(lhs, rhs).map { $0 * $1 }
|
2019-09-25 19:32:36 +08:00
|
|
|
return squares.reduce(0.0, +)
|
|
|
|
})
|
|
|
|
|
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-3)
|
|
|
|
}
|
|
|
|
|
2019-09-23 20:36:08 +08:00
|
|
|
// MARK: - Division: In Place
|
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_div_in_place_vector_scalar_double() {
|
|
|
|
typealias Scalar = Double
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Scalar = .constant()
|
2019-09-23 19:10:25 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.divInPlace(&actual, rhs)
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(lhs.map { $0 / rhs })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_div_in_place_vector_scalar_float() {
|
|
|
|
typealias Scalar = Float
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Scalar = .constant()
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.divInPlace(&actual, rhs)
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(lhs.map { $0 / rhs })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-5)
|
|
|
|
}
|
2019-08-07 01:08:53 +08:00
|
|
|
|
2019-09-23 20:36:08 +08:00
|
|
|
// MARK: - Element-wise Multiplication: In Place
|
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_elmul_in_place_double() {
|
|
|
|
typealias Scalar = Double
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
2019-09-23 19:10:25 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.elmulInPlace(&actual, rhs)
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(zip(lhs, rhs).map { $0 * $1 })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_elmul_in_place_float() {
|
|
|
|
typealias Scalar = Float
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
2019-09-23 19:10:25 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.elmulInPlace(&actual, rhs)
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(zip(lhs, rhs).map { $0 * $1 })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
2019-08-07 01:08:53 +08:00
|
|
|
|
2019-09-23 20:36:08 +08:00
|
|
|
// MARK: - Element-wise Division: In Place
|
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_eldiv_in_place_double() {
|
|
|
|
typealias Scalar = Double
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
2019-09-23 19:10:25 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.eldivInPlace(&actual, rhs)
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(zip(lhs, rhs).map { $0 / $1 })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
func test_eldiv_in_place_float() {
|
|
|
|
typealias Scalar = Float
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
2019-09-23 19:10:25 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.eldivInPlace(&actual, rhs)
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(zip(lhs, rhs).map { $0 / $1 })
|
2019-08-20 05:06:45 +08:00
|
|
|
|
2019-08-12 18:49:32 +08:00
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-6)
|
|
|
|
}
|
2019-08-07 01:08:53 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
// MARK: - Dot Product: In Place
|
2019-09-23 20:36:08 +08:00
|
|
|
|
2019-09-23 20:36:31 +08:00
|
|
|
func test_dot_vector_vector_double() {
|
|
|
|
typealias Scalar = Double
|
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
|
|
|
|
let actual: Scalar = Surge.dot(lhs, rhs)
|
2019-09-23 20:36:31 +08:00
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let squares: [Scalar] = zip(lhs, rhs).map { $0 * $1 }
|
2019-09-25 19:32:36 +08:00
|
|
|
let expected: Scalar = squares.reduce(0.0, +)
|
2019-09-23 20:36:31 +08:00
|
|
|
|
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
|
|
|
|
|
|
|
func test_dot_vector_vector_float() {
|
|
|
|
typealias Scalar = Float
|
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
2019-09-23 20:36:31 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let actual: Scalar = Surge.dot(lhs, rhs)
|
2019-09-23 20:36:31 +08:00
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let squares: [Scalar] = zip(lhs, rhs).map { $0 * $1 }
|
2019-09-25 19:32:36 +08:00
|
|
|
let expected: Scalar = squares.reduce(0.0, +)
|
|
|
|
|
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-3)
|
2019-09-23 20:36:31 +08:00
|
|
|
}
|
|
|
|
|
2019-09-23 20:36:08 +08:00
|
|
|
// MARK: - Power
|
|
|
|
|
2019-09-25 07:13:55 +08:00
|
|
|
func test_pow_in_place_vector_scalar_double() {
|
2019-08-07 01:08:53 +08:00
|
|
|
typealias Scalar = Double
|
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Scalar = .constant()
|
2019-08-07 01:08:53 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.powInPlace(&actual, rhs)
|
2019-09-25 07:13:55 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(lhs.map { pow($0, rhs) })
|
2019-08-07 01:08:53 +08:00
|
|
|
|
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-8)
|
|
|
|
}
|
|
|
|
|
2019-09-25 07:13:55 +08:00
|
|
|
func test_pow_in_place_vector_scalar_float() {
|
2019-08-07 01:08:53 +08:00
|
|
|
typealias Scalar = Float
|
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Scalar = .constant()
|
2019-08-07 01:08:53 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.powInPlace(&actual, rhs)
|
2019-09-25 07:13:55 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(lhs.map { pow($0, rhs) })
|
2019-08-07 01:08:53 +08:00
|
|
|
|
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-5)
|
|
|
|
}
|
|
|
|
|
2019-09-23 20:36:08 +08:00
|
|
|
// MARK: - Exponential
|
|
|
|
|
2019-09-25 07:13:55 +08:00
|
|
|
func test_exp_in_place_vector_double() {
|
2019-08-07 01:08:53 +08:00
|
|
|
typealias Scalar = Double
|
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
2019-08-07 01:08:53 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.expInPlace(&actual)
|
2019-09-25 07:13:55 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(lhs.map { exp($0) })
|
2019-08-07 01:08:53 +08:00
|
|
|
|
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-6)
|
|
|
|
}
|
|
|
|
|
2019-09-25 07:13:55 +08:00
|
|
|
func test_exp_in_place_vector_float() {
|
2019-08-07 01:08:53 +08:00
|
|
|
typealias Scalar = Float
|
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
2019-08-07 01:08:53 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
var actual: Vector<Scalar> = lhs
|
|
|
|
Surge.expInPlace(&actual)
|
2019-09-25 07:13:55 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let expected: Vector<Scalar> = Vector(lhs.map { exp($0) })
|
2019-08-07 01:08:53 +08:00
|
|
|
|
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-2)
|
|
|
|
}
|
2019-08-11 23:02:43 +08:00
|
|
|
|
2019-09-23 20:36:08 +08:00
|
|
|
// MARK: - Distance
|
|
|
|
|
2019-08-11 23:02:43 +08:00
|
|
|
func test_dist_vector_vector_double() {
|
|
|
|
typealias Scalar = Double
|
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
2019-08-11 23:02:43 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let actual: Scalar = Surge.dist(lhs, rhs)
|
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let partialDistances: [Scalar] = zip(lhs, rhs).map { $0 - $1 }
|
2019-09-25 19:32:36 +08:00
|
|
|
let partialDistancesSquared: [Scalar] = partialDistances.map { $0 * $0 }
|
|
|
|
let sumOfPartialDistancesSquared: Scalar = partialDistancesSquared.reduce(0.0, +)
|
|
|
|
let expected: Scalar = sqrt(sumOfPartialDistancesSquared)
|
2019-08-11 23:02:43 +08:00
|
|
|
|
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-6)
|
|
|
|
}
|
|
|
|
|
|
|
|
func test_dist_vector_vector_float() {
|
|
|
|
typealias Scalar = Float
|
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
2019-08-11 23:02:43 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let actual: Scalar = Surge.dist(lhs, rhs)
|
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let partialDistances: [Scalar] = zip(lhs, rhs).map { $0 - $1 }
|
2019-09-25 19:32:36 +08:00
|
|
|
let partialDistancesSquared: [Scalar] = partialDistances.map { $0 * $0 }
|
|
|
|
let sumOfPartialDistancesSquared: Scalar = partialDistancesSquared.reduce(0.0, +)
|
|
|
|
let expected: Scalar = sqrt(sumOfPartialDistancesSquared)
|
2019-08-11 23:02:43 +08:00
|
|
|
|
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-6)
|
|
|
|
}
|
|
|
|
|
2019-09-23 20:36:08 +08:00
|
|
|
// MARK: - Distance Squared
|
|
|
|
|
2019-08-11 23:02:43 +08:00
|
|
|
func test_distsq_vector_vector_double() {
|
|
|
|
typealias Scalar = Double
|
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
2019-08-11 23:02:43 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let actual: Scalar = Surge.dist(lhs, rhs)
|
2019-08-11 23:02:43 +08:00
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let partialDistances: [Scalar] = zip(lhs, rhs).map { $0 - $1 }
|
2019-09-25 19:32:36 +08:00
|
|
|
let partialDistancesSquared: [Scalar] = partialDistances.map { $0 * $0 }
|
|
|
|
let expected: Scalar = partialDistancesSquared.reduce(0.0, +)
|
2019-08-11 23:02:43 +08:00
|
|
|
|
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-6)
|
|
|
|
}
|
|
|
|
|
|
|
|
func test_distsq_vector_vector_float() {
|
|
|
|
typealias Scalar = Float
|
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let lhs: Vector<Scalar> = .monotonicNormalized()
|
|
|
|
let rhs: Vector<Scalar> = .monotonicNormalized()
|
2019-08-11 23:02:43 +08:00
|
|
|
|
2019-09-25 19:32:36 +08:00
|
|
|
let actual: Scalar = Surge.dist(lhs, rhs)
|
|
|
|
|
2019-09-27 22:37:44 +08:00
|
|
|
let partialDistances: [Scalar] = zip(lhs, rhs).map { $0 - $1 }
|
2019-09-25 19:32:36 +08:00
|
|
|
let partialDistancesSquared: [Scalar] = partialDistances.map { $0 * $0 }
|
|
|
|
let expected: Scalar = partialDistancesSquared.reduce(0.0, +)
|
2019-08-11 23:02:43 +08:00
|
|
|
|
|
|
|
XCTAssertEqual(actual, expected, accuracy: 1e-6)
|
|
|
|
}
|
2019-08-07 01:08:53 +08:00
|
|
|
}
|