Words
A type that represents the words of this integer.
@frozen struct Words
A type that represents the words of this integer.
@frozen struct Words
import Swift
@frozen struct UInt16
A 16-bit unsigned integer value type.
init(_ source: Double)
Creates an integer from the given floating-point value, rounding toward zero.
init(_ source: Float)
Creates an integer from the given floating-point value, rounding toward zero.
init(_ source: Float16)
Creates an integer from the given floating-point value, rounding toward zero.
init(bitPattern x: Int16)
Creates a new instance with the same memory representation as the given value.
init?(exactly source: Double)
Creates an integer from the given floating-point value, if it can be represented exactly.
init?(exactly source: Float)
Creates an integer from the given floating-point value, if it can be represented exactly.
init?(exactly source: Float16)
Creates an integer from the given floating-point value, if it can be represented exactly.
init(from decoder: any Decoder) throws
static var bitWidth: Int { get }
The number of bits used for the underlying binary representation of values of this type.
var byteSwapped: UInt16 { get }
var customMirror: Mirror { get }
A mirror that reflects the UInt16
instance.
var leadingZeroBitCount: Int { get }
The number of leading zeros in this value’s binary representation.
var nonzeroBitCount: Int { get }
var trailingZeroBitCount: Int { get }
The number of trailing zeros in this value’s binary representation.
var words: UInt16.Words { get }
A collection containing the words of this value’s binary representation, in order from the least significant to most significant.
static func != (lhs: UInt16, rhs: UInt16) -> Bool
static func % (lhs: UInt16, rhs: UInt16) -> UInt16
static func %= (lhs: inout UInt16, rhs: UInt16)
static func & (lhs: UInt16, rhs: UInt16) -> UInt16
static func &<< (lhs: UInt16, rhs: UInt16) -> UInt16
static func &<<= (lhs: inout UInt16, rhs: UInt16)
static func &= (lhs: inout UInt16, rhs: UInt16)
static func &>> (lhs: UInt16, rhs: UInt16) -> UInt16
static func &>>= (lhs: inout UInt16, rhs: UInt16)
static func * (lhs: UInt16, rhs: UInt16) -> UInt16
Multiplies two values and produces their product.
static func *= (lhs: inout UInt16, rhs: UInt16)
Multiplies two values and stores the result in the left-hand-side variable.
static func + (lhs: UInt16, rhs: UInt16) -> UInt16
Adds two values and produces their sum.
static func += (lhs: inout UInt16, rhs: UInt16)
Adds two values and stores the result in the left-hand-side variable.
static func - (lhs: UInt16, rhs: UInt16) -> UInt16
Subtracts one value from another and produces their difference.
static func -= (lhs: inout UInt16, rhs: UInt16)
Subtracts the second value from the first and stores the difference in the left-hand-side variable.
static func / (lhs: UInt16, rhs: UInt16) -> UInt16
static func /= (lhs: inout UInt16, rhs: UInt16)
static func < (lhs: UInt16, rhs: UInt16) -> Bool
static func <= (lhs: UInt16, rhs: UInt16) -> Bool
static func == (lhs: UInt16, rhs: UInt16) -> Bool
static func > (lhs: UInt16, rhs: UInt16) -> Bool
static func >= (lhs: UInt16, rhs: UInt16) -> Bool
static func ^ (lhs: UInt16, rhs: UInt16) -> UInt16
static func ^= (lhs: inout UInt16, rhs: UInt16)
static func | (lhs: UInt16, rhs: UInt16) -> UInt16
static func |= (lhs: inout UInt16, rhs: UInt16)
func addingReportingOverflow(_ other: UInt16) -> (partialValue: UInt16, overflow: Bool)
func dividedReportingOverflow(by other: UInt16) -> (partialValue: UInt16, overflow: Bool)
func dividingFullWidth(_ dividend: (high: UInt16, low: UInt16.Magnitude)) -> (quotient: UInt16, remainder: UInt16)
Returns a tuple containing the quotient and remainder of dividing the given value by this value.
func encode(to encoder: any Encoder) throws
Encodes this value into the given encoder.
func hash(into hasher: inout Hasher)
Hashes the essential components of this value by feeding them into the given hasher.
func multipliedFullWidth(by other: UInt16) -> (high: UInt16, low: UInt16.Magnitude)
Returns a tuple containing the high and low parts of the result of multiplying this value by the given value.
func multipliedReportingOverflow(by other: UInt16) -> (partialValue: UInt16, overflow: Bool)
func remainderReportingOverflow(dividingBy other: UInt16) -> (partialValue: UInt16, overflow: Bool)
func signum() -> UInt16
func subtractingReportingOverflow(_ other: UInt16) -> (partialValue: UInt16, overflow: Bool)
@frozen struct SIMD16Storage
Storage for a vector of 16 integers.
@frozen struct SIMD2Storage
Storage for a vector of two integers.
@frozen struct SIMD32Storage
Storage for a vector of 32 integers.
@frozen struct SIMD4Storage
Storage for a vector of four integers.
@frozen struct SIMD64Storage
Storage for a vector of 64 integers.
@frozen struct SIMD8Storage
Storage for a vector of eight integers.
typealias IntegerLiteralType = UInt16
A type that represents an integer literal.
typealias Magnitude = UInt16
A type that can represent the absolute value of any possible value of this type.
typealias SIMDMaskScalar = Int16
var customPlaygroundQuickLook: _PlaygroundQuickLook { get }
A custom playground Quick Look for the UInt16
instance.
protocol BidirectionalCollection<Element> : Collection where Self.Indices : BidirectionalCollection, Self.SubSequence : BidirectionalCollection
A collection that supports backward as well as forward traversal.
protocol BitwiseCopyable
protocol Collection<Element> : Sequence
A sequence whose elements can be traversed multiple times, nondestructively, and accessed by an indexed subscript.
protocol RandomAccessCollection<Element> : BidirectionalCollection where Self.Indices : RandomAccessCollection, Self.SubSequence : RandomAccessCollection
A collection that supports efficient random-access index traversal.
protocol Sendable
protocol Sequence<Element>
A type that provides sequential, iterated access to its elements.
init(_ value: UInt16)
var count: Int { get }
var endIndex: Int { get }
var indices: UInt16.Words.Indices { get }
var startIndex: Int { get }
subscript(position: Int) -> UInt { get }
func index(after i: Int) -> Int
func index(before i: Int) -> Int
typealias Indices = Range<Int>
typealias SubSequence = Slice<UInt16.Words>
var first: Self.Element? { get }
The first element of the collection.
var isEmpty: Bool { get }
A Boolean value indicating whether the collection is empty.
var last: Self.Element? { get }
The last element of the collection.
var lazy: LazySequence<Self> { get }
A sequence containing the same elements as this sequence, but on which some operations, such as map
and filter
, are implemented lazily.
var underestimatedCount: Int { get }
A value less than or equal to the number of elements in the collection.
func allSatisfy(_ predicate: (Self.Element) throws -> Bool) rethrows -> Bool
Returns a Boolean value indicating whether every element of a sequence satisfies a given predicate.
func compactMap<ElementOfResult>(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
Returns an array containing the non-nil
results of calling the given transformation with each element of this sequence.
func contains(_ element: Self.Element) -> Bool
Returns a Boolean value indicating whether the sequence contains the given element.
func contains(where predicate: (Self.Element) throws -> Bool) rethrows -> Bool
Returns a Boolean value indicating whether the sequence contains an element that satisfies the given predicate.
func count<E>(where predicate: (Self.Element) throws(E) -> Bool) throws(E) -> Int where E : Error
Returns the number of elements in the sequence that satisfy the given predicate.
func difference<C>(from other: C) -> CollectionDifference<Self.Element> where C : BidirectionalCollection, Self.Element == C.Element
Returns the difference needed to produce this collection’s ordered elements from the given collection.
func difference<C>(from other: C, by areEquivalent: (C.Element, Self.Element) -> Bool) -> CollectionDifference<Self.Element> where C : BidirectionalCollection, Self.Element == C.Element
Returns the difference needed to produce this collection’s ordered elements from the given collection, using the given predicate as an equivalence test.
func drop(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence
Returns a subsequence by skipping elements while predicate
returns true
and returning the remaining elements.
func dropFirst(_ k: Int = 1) -> Self.SubSequence
Returns a subsequence containing all but the given number of initial elements.
func dropLast(_ k: Int) -> Self.SubSequence
Returns a subsequence containing all but the specified number of final elements.
func elementsEqual<OtherSequence>(_ other: OtherSequence) -> Bool where OtherSequence : Sequence, Self.Element == OtherSequence.Element
Returns a Boolean value indicating whether this sequence and another sequence contain the same elements in the same order.
func elementsEqual<OtherSequence>(_ other: OtherSequence, by areEquivalent: (Self.Element, OtherSequence.Element) throws -> Bool) rethrows -> Bool where OtherSequence : Sequence
Returns a Boolean value indicating whether this sequence and another sequence contain equivalent elements in the same order, using the given predicate as the equivalence test.
func enumerated() -> EnumeratedSequence<Self>
Returns a sequence of pairs (n, x), where n represents a consecutive integer starting at zero and x represents an element of the sequence.
func filter(_ isIncluded: (Self.Element) throws -> Bool) rethrows -> [Self.Element]
Returns an array containing, in order, the elements of the sequence that satisfy the given predicate.
func first(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Element?
Returns the first element of the sequence that satisfies the given predicate.
func firstIndex(of element: Self.Element) -> Self.Index?
Returns the first index where the specified value appears in the collection.
func firstIndex(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Index?
Returns the first index in which an element of the collection satisfies the given predicate.
func flatMap<SegmentOfResult>(_ transform: (Self.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element] where SegmentOfResult : Sequence
Returns an array containing the concatenated results of calling the given transformation with each element of this sequence.
func forEach(_ body: (Self.Element) throws -> Void) rethrows
Calls the given closure on each element in the sequence in the same order as a for
-in
loop.
func formIndex(_ i: inout Self.Index, offsetBy distance: Int)
Offsets the given index by the specified distance.
func formIndex(_ i: inout Self.Index, offsetBy distance: Int, limitedBy limit: Self.Index) -> Bool
Offsets the given index by the specified distance, or so that it equals the given limiting index.
func formIndex(after i: inout Self.Index)
Replaces the given index with its successor.
func formIndex(before i: inout Self.Index)
func index(_ i: Self.Index, offsetBy distance: Int, limitedBy limit: Self.Index) -> Self.Index?
Returns an index that is the specified distance from the given index, unless that distance is beyond a given limiting index.
func indices(of element: Self.Element) -> RangeSet<Self.Index>
Returns the indices of all the elements that are equal to the given element.
func indices(where predicate: (Self.Element) throws -> Bool) rethrows -> RangeSet<Self.Index>
Returns the indices of all the elements that match the given predicate.
func last(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Element?
Returns the last element of the sequence that satisfies the given predicate.
func lastIndex(of element: Self.Element) -> Self.Index?
Returns the last index where the specified value appears in the collection.
func lastIndex(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Index?
Returns the index of the last element in the collection that matches the given predicate.
func lexicographicallyPrecedes<OtherSequence>(_ other: OtherSequence) -> Bool where OtherSequence : Sequence, Self.Element == OtherSequence.Element
Returns a Boolean value indicating whether the sequence precedes another sequence in a lexicographical (dictionary) ordering, using the less-than operator (<
) to compare elements.
func lexicographicallyPrecedes<OtherSequence>(_ other: OtherSequence, by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> Bool where OtherSequence : Sequence, Self.Element == OtherSequence.Element
Returns a Boolean value indicating whether the sequence precedes another sequence in a lexicographical (dictionary) ordering, using the given predicate to compare elements.
func makeIterator() -> IndexingIterator<Self>
Returns an iterator over the elements of the collection.
func map<T, E>(_ transform: (Self.Element) throws(E) -> T) throws(E) -> [T] where E : Error
Returns an array containing the results of mapping the given closure over the sequence’s elements.
func map<T, E>(_ transform: (Self.Element) throws(E) -> T) throws(E) -> [T] where E : Error
Returns an array containing the results of mapping the given closure over the sequence’s elements.
@warn_unqualified_access func max() -> Self.Element?
Returns the maximum element in the sequence.
@warn_unqualified_access func max(by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> Self.Element?
Returns the maximum element in the sequence, using the given predicate as the comparison between elements.
@warn_unqualified_access func min() -> Self.Element?
Returns the minimum element in the sequence.
@warn_unqualified_access func min(by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> Self.Element?
Returns the minimum element in the sequence, using the given predicate as the comparison between elements.
func prefix(_ maxLength: Int) -> Self.SubSequence
Returns a subsequence, up to the specified maximum length, containing the initial elements of the collection.
func prefix(through position: Self.Index) -> Self.SubSequence
Returns a subsequence from the start of the collection through the specified position.
func prefix(upTo end: Self.Index) -> Self.SubSequence
Returns a subsequence from the start of the collection up to, but not including, the specified position.
func prefix(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence
Returns a subsequence containing the initial elements until predicate
returns false
and skipping the remaining elements.
func randomElement() -> Self.Element?
Returns a random element of the collection.
func randomElement<T>(using generator: inout T) -> Self.Element? where T : RandomNumberGenerator
Returns a random element of the collection, using the given generator as a source for randomness.
func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Self.Element) throws -> Result) rethrows -> Result
Returns the result of combining the elements of the sequence using the given closure.
func reduce<Result>(into initialResult: Result, _ updateAccumulatingResult: (inout Result, Self.Element) throws -> ()) rethrows -> Result
Returns the result of combining the elements of the sequence using the given closure.
func removingSubranges(_ subranges: RangeSet<Self.Index>) -> DiscontiguousSlice<Self>
Returns a collection of the elements in this collection that are not represented by the given range set.
func reversed() -> ReversedCollection<Self>
Returns a view presenting the elements of the collection in reverse order.
func shuffled() -> [Self.Element]
Returns the elements of the sequence, shuffled.
func shuffled<T>(using generator: inout T) -> [Self.Element] where T : RandomNumberGenerator
Returns the elements of the sequence, shuffled using the given generator as a source for randomness.
func sorted() -> [Self.Element]
Returns the elements of the sequence, sorted.
func sorted(by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> [Self.Element]
Returns the elements of the sequence, sorted using the given predicate as the comparison between elements.
func split(maxSplits: Int = Int.max, omittingEmptySubsequences: Bool = true, whereSeparator isSeparator: (Self.Element) throws -> Bool) rethrows -> [Self.SubSequence]
Returns the longest possible subsequences of the collection, in order, that don’t contain elements satisfying the given predicate.
func split(separator: Self.Element, maxSplits: Int = Int.max, omittingEmptySubsequences: Bool = true) -> [Self.SubSequence]
Returns the longest possible subsequences of the collection, in order, around elements equal to the given element.
func starts<PossiblePrefix>(with possiblePrefix: PossiblePrefix) -> Bool where PossiblePrefix : Sequence, Self.Element == PossiblePrefix.Element
Returns a Boolean value indicating whether the initial elements of the sequence are the same as the elements in another sequence.
func starts<PossiblePrefix>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Self.Element, PossiblePrefix.Element) throws -> Bool) rethrows -> Bool where PossiblePrefix : Sequence
Returns a Boolean value indicating whether the initial elements of the sequence are equivalent to the elements in another sequence, using the given predicate as the equivalence test.
func suffix(_ maxLength: Int) -> Self.SubSequence
Returns a subsequence, up to the given maximum length, containing the final elements of the collection.
func suffix(from start: Self.Index) -> Self.SubSequence
Returns a subsequence from the specified position to the end of the collection.
func withContiguousStorageIfAvailable<R>(_ body: (UnsafeBufferPointer<Self.Element>) throws -> R) rethrows -> R?
func flatMap<ElementOfResult>(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
func index(of element: Self.Element) -> Self.Index?
Returns the first index where the specified value appears in the collection.