protocol SignedNumeric| Inheritance |
Equatable, ExpressibleByIntegerLiteral, Numeric
View Protocol Hierarchy →
|
|---|---|
| Associated Types | |
| Import | import Swift |
Initializers
Creates an instance initialized to the specified integer value.
Do not call this initializer directly. Instead, initialize a variable or constant using an integer literal. For example:
let x = 23In this example, the assignment to the x constant calls this integer
literal initializer behind the scenes.
value: The value to create.
Declaration
init(integerLiteral value: Self.IntegerLiteralType)
Declared In
ExpressibleByIntegerLiteral
Creates a new instance from the given integer, if it can be represented exactly.
If the value passed as source is not representable exactly, the result
is nil. In the following example, the constant x is successfully
created from a value of 100, while the attempt to initialize the
constant y from 1_000 fails because the Int8 type can represent
127 at maximum:
let x = Int8(exactly: 100)
// x == Optional(100)
let y = Int8(exactly: 1_000)
// y == nilsource: A value to convert to this type.
Declaration
init?<T>(exactly source: T)
Declared In
Numeric
Instance Variables
The magnitude of this value.
For any numeric value x, x.magnitude is the absolute value of x.
You can use the magnitude property in operations that are simpler to
implement in terms of unsigned values, such as printing the value of an
integer, which is just printing a '-' character in front of an absolute
value.
let x = -200
// x.magnitude == 200The global abs(_:) function provides more familiar syntax when you need
to find an absolute value. In addition, because abs(_:) always returns
a value of the same type, even in a generic context, using the function
instead of the magnitude property is encouraged.
Declaration
var magnitude: Self.Magnitude { get }
Declared In
Numeric
Instance Methods
Multiplies two values and produces their product.
The multiplication operator (*) calculates the product of its two
arguments. For example:
2 * 3 // 6
100 * 21 // 2100
-10 * 15 // -150
3.5 * 2.25 // 7.875You cannot use * with arguments of different types. To multiply values
of different types, convert one of the values to the other value's type.
let x: Int8 = 21
let y: Int = 1000000
Int(x) * y // 21000000Parameters: lhs: The first value to multiply. rhs: The second value to multiply.
Declaration
func *(lhs: Self, rhs: Self) -> Self
Declared In
Numeric
Multiplies two values and stores the result in the left-hand-side variable.
Parameters: lhs: The first value to multiply. rhs: The second value to multiply.
Declaration
func *=(lhs: inout Self, rhs: Self)
Declared In
Numeric
Adds two values and produces their sum.
The addition operator (+) calculates the sum of its two arguments. For
example:
1 + 2 // 3
-10 + 15 // 5
-15 + -5 // -20
21.5 + 3.25 // 24.75You cannot use + with arguments of different types. To add values of
different types, convert one of the values to the other value's type.
let x: Int8 = 21
let y: Int = 1000000
Int(x) + y // 1000021Parameters: lhs: The first value to add. rhs: The second value to add.
Declaration
func +(lhs: Self, rhs: Self) -> Self
Declared In
Numeric
Adds two values and stores the result in the left-hand-side variable.
Parameters: lhs: The first value to add. rhs: The second value to add.
Declaration
func +=(lhs: inout Self, rhs: Self)
Declared In
Numeric
Returns a Boolean value indicating whether two values are equal.
Equality is the inverse of inequality. For any values a and b,
a == b implies that a != b is false.
Parameters: lhs: A value to compare. rhs: Another value to compare.
Declaration
func ==(lhs: Self, rhs: Self) -> Bool
Declared In
Equatable
Returns the additive inverse of the specified value.
The negation operator (prefix -) returns the additive inverse of its
argument.
let x = 21
let y = -x
// y == -21The resulting value must be representable in the same type as the argument. In particular, negating a signed, fixed-width integer type's minimum results in a value that cannot be represented.
let z = -Int8.min
// Overflow errorReturns: The additive inverse of this value.
Declaration
prefix func -(operand: Self) -> Self
Subtracts one value from another and produces their difference.
The subtraction operator (-) calculates the difference of its two
arguments. For example:
8 - 3 // 5
-10 - 5 // -15
100 - -5 // 105
10.5 - 100.0 // -89.5You cannot use - with arguments of different types. To subtract values
of different types, convert one of the values to the other value's type.
let x: UInt8 = 21
let y: UInt = 1000000
y - UInt(x) // 999979Parameters:
lhs: A numeric value.
rhs: The value to subtract from lhs.
Declaration
func -(lhs: Self, rhs: Self) -> Self
Declared In
Numeric
Subtracts the second value from the first and stores the difference in the left-hand-side variable.
Parameters:
lhs: A numeric value.
rhs: The value to subtract from lhs.
Declaration
func -=(lhs: inout Self, rhs: Self)
Declared In
Numeric
Replaces this value with its additive inverse.
The following example uses the negate() method to negate the value of
an integer x:
var x = 21
x.negate()
// x == -21Declaration
mutating func negate()
Default Implementations
Creates an instance initialized to the specified integer value.
Do not call this initializer directly. Instead, initialize a variable or constant using an integer literal. For example:
let x = 23In this example, the assignment to the x constant calls this integer
literal initializer behind the scenes.
value: The value to create.
Declaration
init(integerLiteral value: Self)
Declared In
Numeric
, ExpressibleByIntegerLiteral
Returns a Boolean value indicating whether two values are not equal.
Inequality is the inverse of equality. For any values a and b, a != b
implies that a == b is false.
This is the default implementation of the not-equal-to operator (!=)
for any type that conforms to Equatable.
Parameters: lhs: A value to compare. rhs: Another value to compare.
Declaration
func !=(lhs: Self, rhs: Self) -> Bool
Declared In
Numeric, Equatable
Returns the given number unchanged.
You can use the unary plus operator (+) to provide symmetry in your
code for positive numbers when also using the unary minus operator.
let x = -21
let y = +21
// x == -21
// y == 21Returns: The given argument without any changes.
Declaration
prefix func +(x: Self) -> Self
Declared In
Numeric
Returns the additive inverse of the specified value.
The negation operator (prefix -) returns the additive inverse of its
argument.
let x = 21
let y = -x
// y == -21The resulting value must be representable in the same type as the argument. In particular, negating a signed, fixed-width integer type's minimum results in a value that cannot be represented.
let z = -Int8.min
// Overflow errorReturns: The additive inverse of the argument.
Declaration
prefix func -(operand: Self) -> Self
Replaces this value with its additive inverse.
The following example uses the negate() method to negate the value of
an integer x:
var x = 21
x.negate()
// x == -21Declaration
mutating func negate()
A type that can represent both positive and negative values.
The
SignedNumericprotocol extends the operations defined by theNumericprotocol to include a value's additive inverse.Conforming to the SignedNumeric Protocol
Because the
SignedNumericprotocol provides default implementations of both of its required methods, you don't need to do anything beyond declaring conformance to the protocol and ensuring that the values of your type support negation. To customize your type's implementation, provide your own mutatingnegate()method.