operator * { associativity left precedence } Declarations func *(_: Double, rhs: Double) Multiplies two values and produces their product, rounding to a representable value. The multiplication operator (*) calculates the product of its two arguments. For example: let x = 7.5 let y = x * 2.25 // y == 16.875 The * operator implements the multiplication operation defined by the IEEE 754 specification. Parameters: lhs: The first value to multiply. rhs: The second value to multiply. Declaration func *(lhs: Double, rhs: Double) -> Double func *(_: Float, rhs: Float) Multiplies two values and produces their product, rounding to a representable value. The multiplication operator (*) calculates the product of its two arguments. For example: let x = 7.5 let y = x * 2.25 // y == 16.875 The * operator implements the multiplication operation defined by the IEEE 754 specification. Parameters: lhs: The first value to multiply. rhs: The second value to multiply. Declaration func *(lhs: Float, rhs: Float) -> Float func *(_: Float80, rhs: Float80) Multiplies two values and produces their product, rounding to a representable value. The multiplication operator (*) calculates the product of its two arguments. For example: let x = 7.5 let y = x * 2.25 // y == 16.875 The * operator implements the multiplication operation defined by the IEEE 754 specification. Parameters: lhs: The first value to multiply. rhs: The second value to multiply. Declaration func *(lhs: Float80, rhs: Float80) -> Float80 func *(_: Int, rhs: Int) 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.875 You 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 // 21000000 The product of the two arguments must be representable in the arguments' type. In the following example, the result of 21 * 21 is greater than the maximum representable Int8 value: x * 21 // Overflow error Note: Overflow checking is not performed in -Ounchecked builds. If you want to opt out of overflow checking and ignore any overflow, use the overflow multiplication operator (&*). x &* 21 // -115 Parameters: lhs: The first value to multiply. rhs: The second value to multiply. Declaration func *(lhs: Int, rhs: Int) -> Int func *(_: Int8, rhs: Int8) 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.875 You 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 // 21000000 The product of the two arguments must be representable in the arguments' type. In the following example, the result of 21 * 21 is greater than the maximum representable Int8 value: x * 21 // Overflow error Note: Overflow checking is not performed in -Ounchecked builds. If you want to opt out of overflow checking and ignore any overflow, use the overflow multiplication operator (&*). x &* 21 // -115 Parameters: lhs: The first value to multiply. rhs: The second value to multiply. Declaration func *(lhs: Int8, rhs: Int8) -> Int8 func *(_: Int16, rhs: Int16) 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.875 You 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 // 21000000 The product of the two arguments must be representable in the arguments' type. In the following example, the result of 21 * 21 is greater than the maximum representable Int8 value: x * 21 // Overflow error Note: Overflow checking is not performed in -Ounchecked builds. If you want to opt out of overflow checking and ignore any overflow, use the overflow multiplication operator (&*). x &* 21 // -115 Parameters: lhs: The first value to multiply. rhs: The second value to multiply. Declaration func *(lhs: Int16, rhs: Int16) -> Int16 func *(_: Int32, rhs: Int32) 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.875 You 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 // 21000000 The product of the two arguments must be representable in the arguments' type. In the following example, the result of 21 * 21 is greater than the maximum representable Int8 value: x * 21 // Overflow error Note: Overflow checking is not performed in -Ounchecked builds. If you want to opt out of overflow checking and ignore any overflow, use the overflow multiplication operator (&*). x &* 21 // -115 Parameters: lhs: The first value to multiply. rhs: The second value to multiply. Declaration func *(lhs: Int32, rhs: Int32) -> Int32 func *(_: Int64, rhs: Int64) 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.875 You 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 // 21000000 The product of the two arguments must be representable in the arguments' type. In the following example, the result of 21 * 21 is greater than the maximum representable Int8 value: x * 21 // Overflow error Note: Overflow checking is not performed in -Ounchecked builds. If you want to opt out of overflow checking and ignore any overflow, use the overflow multiplication operator (&*). x &* 21 // -115 Parameters: lhs: The first value to multiply. rhs: The second value to multiply. Declaration func *(lhs: Int64, rhs: Int64) -> Int64 func *(_: UInt, rhs: UInt) 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.875 You 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 // 21000000 The product of the two arguments must be representable in the arguments' type. In the following example, the result of 21 * 21 is greater than the maximum representable Int8 value: x * 21 // Overflow error Note: Overflow checking is not performed in -Ounchecked builds. If you want to opt out of overflow checking and ignore any overflow, use the overflow multiplication operator (&*). x &* 21 // -115 Parameters: lhs: The first value to multiply. rhs: The second value to multiply. Declaration func *(lhs: UInt, rhs: UInt) -> UInt func *(_: UInt8, rhs: UInt8) 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.875 You 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 // 21000000 The product of the two arguments must be representable in the arguments' type. In the following example, the result of 21 * 21 is greater than the maximum representable Int8 value: x * 21 // Overflow error Note: Overflow checking is not performed in -Ounchecked builds. If you want to opt out of overflow checking and ignore any overflow, use the overflow multiplication operator (&*). x &* 21 // -115 Parameters: lhs: The first value to multiply. rhs: The second value to multiply. Declaration func *(lhs: UInt8, rhs: UInt8) -> UInt8 func *(_: UInt16, rhs: UInt16) 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.875 You 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 // 21000000 The product of the two arguments must be representable in the arguments' type. In the following example, the result of 21 * 21 is greater than the maximum representable Int8 value: x * 21 // Overflow error Note: Overflow checking is not performed in -Ounchecked builds. If you want to opt out of overflow checking and ignore any overflow, use the overflow multiplication operator (&*). x &* 21 // -115 Parameters: lhs: The first value to multiply. rhs: The second value to multiply. Declaration func *(lhs: UInt16, rhs: UInt16) -> UInt16 func *(_: UInt32, rhs: UInt32) 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.875 You 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 // 21000000 The product of the two arguments must be representable in the arguments' type. In the following example, the result of 21 * 21 is greater than the maximum representable Int8 value: x * 21 // Overflow error Note: Overflow checking is not performed in -Ounchecked builds. If you want to opt out of overflow checking and ignore any overflow, use the overflow multiplication operator (&*). x &* 21 // -115 Parameters: lhs: The first value to multiply. rhs: The second value to multiply. Declaration func *(lhs: UInt32, rhs: UInt32) -> UInt32 func *(_: UInt64, rhs: UInt64) 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.875 You 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 // 21000000 The product of the two arguments must be representable in the arguments' type. In the following example, the result of 21 * 21 is greater than the maximum representable Int8 value: x * 21 // Overflow error Note: Overflow checking is not performed in -Ounchecked builds. If you want to opt out of overflow checking and ignore any overflow, use the overflow multiplication operator (&*). x &* 21 // -115 Parameters: lhs: The first value to multiply. rhs: The second value to multiply. Declaration func *(lhs: UInt64, rhs: UInt64) -> UInt64