| //===--- IntegerArithmetic.swift.gyb --------------------------*- swift -*-===// |
| // |
| // This source file is part of the Swift.org open source project |
| // |
| // Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors |
| // Licensed under Apache License v2.0 with Runtime Library Exception |
| // |
| // See http://swift.org/LICENSE.txt for license information |
| // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors |
| // |
| //===----------------------------------------------------------------------===// |
| %# Ignore the following admonition; it applies to the resulting .swift file only |
| |
| // Automatically Generated From IntegerArithmetic.swift.gyb. Do Not Edit |
| // Directly! |
| |
| %{ |
| integerBinaryOps = [ |
| ('add', '+', 'Adds', 'the result'), |
| ('subtract', '-', 'Subtracts', 'the result'), |
| ('multiply', '*', 'Multiplies', 'the result'), |
| ('divide', '/', 'Divides', 'the result'), |
| ('remainder', '%', 'Divides', 'the remainder') |
| ] |
| }% |
| |
| /// This protocol is an implementation detail of `IntegerArithmetic`; do |
| /// not use it directly. |
| /// |
| /// Its requirements are inherited by `IntegerArithmetic` and thus must |
| /// be satisfied by types conforming to that protocol. |
| @_show_in_interface |
| public protocol _IntegerArithmetic { |
| % for name, _, Action, result in integerBinaryOps: |
| /// ${Action} `lhs` and `rhs`, returning ${result} and a `Bool` that is |
| /// `true` iff the operation caused an arithmetic overflow. |
| static func ${name}WithOverflow(_ lhs: Self, _ rhs: Self) -> (Self, overflow: Bool) |
| % end |
| } |
| |
| /// The common requirements for types that support integer arithmetic. |
| public protocol IntegerArithmetic : _IntegerArithmetic, Comparable { |
| // Checked arithmetic functions. Specific implementations in |
| // FixedPoint.swift.gyb support static checking for integer types. |
| % for name, op, Action, result in integerBinaryOps: |
| /// ${Action} `lhs` and `rhs`, returning ${result} and trapping in case of |
| /// arithmetic overflow (except in -Ounchecked builds). |
| static func ${op} (lhs: Self, rhs: Self) -> Self |
| % end |
| |
| /// Explicitly convert to `IntMax`, trapping on overflow (except in |
| /// -Ounchecked builds). |
| func toIntMax() -> IntMax |
| } |
| |
| % for name, op, Action, result in integerBinaryOps: |
| /// ${Action} `lhs` and `rhs`, returning ${result} and trapping in case of |
| /// arithmetic overflow (except in -Ounchecked builds). |
| @_transparent |
| public func ${op} <T : _IntegerArithmetic>(lhs: T, rhs: T) -> T { |
| return _overflowChecked(T.${name}WithOverflow(lhs, rhs)) |
| } |
| |
| % if (op != '/') and (op != '%'): |
| /// ${Action} `lhs` and `rhs`, silently discarding any overflow. |
| @_transparent |
| public func &${op} <T : _IntegerArithmetic>(lhs: T, rhs: T) -> T { |
| return T.${name}WithOverflow(lhs, rhs).0 |
| } |
| % end |
| |
| /// ${Action} `lhs` and `rhs` and stores ${result} in `lhs`, trapping in |
| /// case of arithmetic overflow (except in -Ounchecked builds). |
| @_transparent |
| public func ${op}= <T : _IntegerArithmetic>(lhs: inout T, rhs: T) { |
| lhs = lhs ${op} rhs |
| } |
| % end |
| |
| //===--- SignedNumber -----------------------------------------------------===// |
| // A numeric type that supports abs(x), +x and -x |
| //===----------------------------------------------------------------------===// |
| |
| // SignedNumber itself contains only operator requirements having |
| // default implementations on the base protocol. |
| /// Instances of conforming types can be subtracted, arithmetically |
| /// negated, and initialized from `0`. |
| /// |
| /// Axioms: |
| /// |
| /// - `x - 0 == x` |
| /// - `-x == 0 - x` |
| /// - `-(-x) == x` |
| public protocol SignedNumber : Comparable, ExpressibleByIntegerLiteral { |
| /// Returns the result of negating `x`. |
| static prefix func - (x: Self) -> Self |
| |
| /// Returns the difference between `lhs` and `rhs`. |
| static func - (lhs: Self, rhs: Self) -> Self |
| |
| // Do not use this operator directly; call abs(x) instead |
| static func ~> (_:Self,_:(_Abs, ())) -> Self |
| } |
| |
| // Unary negation in terms of subtraction. This is a default |
| // implementation; models of SignedNumber can provide their own |
| // implementations. |
| @_transparent |
| public prefix func - <T : SignedNumber>(x: T) -> T { |
| return 0 - x |
| } |
| |
| // Unary + |
| @_transparent |
| public prefix func + <T : SignedNumber>(x: T) -> T { |
| return x |
| } |
| |
| //===--- abs(x) -----------------------------------------------------------===// |
| public struct _Abs {} |
| |
| @_versioned |
| internal func _abs<Args>(_ args: Args) -> (_Abs, Args) { |
| return (_Abs(), args) |
| } |
| |
| // Do not use this operator directly; call abs(x) instead |
| @_transparent |
| public func ~> <T : SignedNumber>(x:T,_:(_Abs, ())) -> T { |
| return x < 0 ? -x : x |
| } |
| |
| // FIXME: should this be folded into SignedNumber? |
| /// A type that supports an "absolute value" function. |
| public protocol AbsoluteValuable : SignedNumber { |
| /// Returns the absolute value of `x`. |
| static func abs(_ x: Self) -> Self |
| } |
| |
| // Do not use this operator directly; call abs(x) instead |
| @_transparent |
| public func ~> <T : AbsoluteValuable>(x:T,_:(_Abs, ())) -> T { |
| return T.abs(x) |
| } |
| |
| /// Returns the absolute value of `x`. |
| /// |
| /// Concrete instances of `SignedNumber` can specialize this |
| /// function by conforming to `AbsoluteValuable`. |
| @_transparent |
| public func abs<T : SignedNumber>(_ x: T) -> T { |
| return x~>_abs() |
| } |
| |
| @available(*, unavailable, renamed: "IntegerArithmetic") |
| public typealias IntegerArithmeticType = IntegerArithmetic |
| |
| @available(*, unavailable, renamed: "SignedNumber") |
| public typealias SignedNumberType = SignedNumber |
| |
| // ${'Local Variables'}: |
| // eval: (read-only-mode 1) |
| // End: |