mirror of
https://github.com/apple/swift-numerics
synced 2026-11-22 04:30:45 +00:00
56 lines
2.5 KiB
Swift
56 lines
2.5 KiB
Swift
//===--- Scale.swift ------------------------------------------*- swift -*-===//
|
|
//
|
|
// This source file is part of the Swift Numerics open source project
|
|
//
|
|
// Copyright (c) 2019-2021 Apple Inc. and the Swift Numerics project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Policy: deliberately not using the * and / operators for these at the
|
|
// moment, because then there's an ambiguity in expressions like 2*z; is
|
|
// that Complex(2) * z or is it RealType(2) * z? This is especially
|
|
// problematic in type inference: suppose we have:
|
|
//
|
|
// let a: RealType = 1
|
|
// let b = 2*a
|
|
//
|
|
// what is the type of b? If we don't have a type context, it's ambiguous.
|
|
// If we have a Complex type context, then b will be inferred to have type
|
|
// Complex! Obviously, that doesn't help anyone.
|
|
//
|
|
// TODO: figure out if there's some way to avoid these surprising results
|
|
// and turn these into operators if/when we have it.
|
|
// (https://github.com/apple/swift-numerics/issues/12)
|
|
extension Complex {
|
|
/// `self` scaled by `a`.
|
|
@usableFromInline @_transparent
|
|
internal func multiplied(by a: RealType) -> Complex {
|
|
// This can be viewed in two different ways, which are mathematically
|
|
// equivalent: either we are computing `self * Complex(a)` (i.e.
|
|
// converting `a` to be a complex value, and then using the complex
|
|
// multiplication) or we are using the scalar product of the vector
|
|
// space structure: `Complex(a*real, a*imaginary)`.
|
|
//
|
|
// Although these two interpretations are _mathematically_ equivalent,
|
|
// they will generate different representations of the point at
|
|
// infinity in general. For example, suppose `self` is represented by
|
|
// `(infinity, 0)`. Then `self * Complex(1)` would evaluate as
|
|
// `(1*infinity - 0*0, 0*infinity + 1*0) = (infinity, nan)`, but
|
|
// the vector space interpretation produces `(infinity, 0)`. This does
|
|
// not matter much, because these are two representations of the same
|
|
// semantic value, but note that one requires four multiplies and two
|
|
// additions, while the one we use requires only two real multiplications.
|
|
Complex(x*a, y*a)
|
|
}
|
|
|
|
/// `self` unscaled by `a`.
|
|
@usableFromInline @_transparent
|
|
internal func divided(by a: RealType) -> Complex {
|
|
// See implementation notes for `multiplied` above.
|
|
Complex(x/a, y/a)
|
|
}
|
|
}
|