<div dir="ltr">On Sun, Jan 29, 2017 at 6:02 AM, Brent Royal-Gordon via swift-evolution <span dir="ltr"><<a href="mailto:swift-evolution@swift.org" target="_blank">swift-evolution@swift.org</a>></span> wrote:<br><div class="gmail_extra"><div class="gmail_quote"><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left-width:1px;border-left-style:solid;border-left-color:rgb(204,204,204);padding-left:1ex"><span class="gmail-"><br>
> On Jan 13, 2017, at 12:47 PM, Max Moiseev via swift-evolution <<a href="mailto:swift-evolution@swift.org">swift-evolution@swift.org</a>> wrote:<br>
><br>
> Protocol-oriented integers (take 2)<br>
><br>
> • Proposal: SE-NNNN<br>
> • Authors: Dave Abrahams, Maxim Moiseev<br>
> • Review Manager: TBD<br>
> • Status: Awaiting review<br>
> • Bug: SR-3196<br>
> • Previous Proposal: SE-0104<br>
<br>
</span>Definitely liking what I'm seeing here.<br>
<span class="gmail-"><br>
> public protocol Arithmetic : Equatable, ExpressibleByIntegerLiteral<br>
> {<br>
<br>
</span>Is there a reason `Arithmetic` is not `Hashable`? (I think `Comparable` isn't here because complex numbers can't be compared, but correct me if I'm wrong about that.)<br>
<span class="gmail-"><br>
> /// A type that can represent the absolute value of any possible value of the<br>
> /// conforming type.<br>
> associatedtype Magnitude : Equatable, ExpressibleByIntegerLiteral<br>
<br>
</span>Is there a reason not to have this be `Arithmetic`? Maybe just the circularity problem?<br>
<span class="gmail-"><br>
> /// Returns the n-th word, counting from the least significant to most<br>
> /// significant, of this value's binary representation.<br>
> ///<br>
> /// The `word(at:)` method returns negative values in two's complement<br>
> /// representation, regardless of a type's underlying implementation. If `n`<br>
> /// is greater than the number of words in this value's current<br>
> /// representation, the result is `0` for positive numbers and `~0` for<br>
> /// negative numbers.<br>
> ///<br>
> /// - Parameter n: The word to return, counting from the least significant to<br>
> /// most significant. `n` must be greater than or equal to zero.<br>
> /// - Returns: An word-sized, unsigned integer with the bit pattern of the<br>
> /// n-th word of this value.<br>
</span><span class="gmail-">> func word(at n: Int) -> UInt<br>
<br>
</span>How does the client know how many words there are? Are they supposed to calculate that from `bitWidth`?<br>
<br>
Oh, I see:<br>
<span class="gmail-"><br>
> good catch; countRepresentedWords is in the prototype<br>
> (<a href="https://github.com/apple/swift/blob/new-integer-protocols/stdlib/public/core/Integers.swift.gyb#L1521" rel="noreferrer" target="_blank">https://github.com/apple/<wbr>swift/blob/new-integer-<wbr>protocols/stdlib/public/core/<wbr>Integers.swift.gyb#L1521</a>),<br>
> and it should be in the proposal.<br>
<br>
</span>That looks fine to me.<br>
<br>
> /// The number of bits in the current binary representation of this value.<br>
> ///<br>
<span class="gmail-">> /// This property is a constant for instances of fixed-width integer<br>
> /// types.<br>
> var bitWidth : Int { get }<br>
<br>
</span>So, um, I'm a little confused about this one. Is this the physical number of bits in the value, or is it the number of bits you need to get from `word(at:)` in order to get all bits representing the value?<br>
<br>
For instance, when you call `UInt32.bitWidth`, does it return `32`, the physical number of bits in the value, or `33`, the number of bits including the (always zero) sign bit?<br></blockquote><div><br></div><div>Could you comment on what use cases would make `33` the relevant answer? I'd always thought that "the number of bits in the current binary representation" admits of no alternative interpretation than `32` in your example.</div><div> </div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left-width:1px;border-left-style:solid;border-left-color:rgb(204,204,204);padding-left:1ex">
> static func doubleWidthMultiply(_ lhs: Self, _ rhs: Self) -> (high: Self, low: Magnitude)<br>
> static func doubleWidthDivide(_ lhs: (high: Self, low: Magnitude), _ rhs: Self) -> (quotient: Self, remainder: Self)<br>
<br>
Could these take/return a single `DoubleWidth<Self>` value instead of two separate `Self` and `Magnitude` values? Or would that present circularity problems?</blockquote><div><br></div><div>Having mulled the idea of implementing an IEEE Decimal type, I'd be sad to see these return DoubleWidth<Self>. Double-width multiply as it is here is useful when you want to get the result and immediately discard either the high or the low bits, for instance. If you'd want a result of type `DoubleWidth<Foo>` instead, you could always just write `DoubleWidth<Foo>(a) * DoubleWidth<Foo>(b)`.</div><div><br></div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left-width:1px;border-left-style:solid;border-left-color:rgb(204,204,204);padding-left:1ex"><span class="gmail-"><br>
> /// The number of bits equal to 1 in this value's binary representation.<br>
> ///<br>
> /// For example, in a fixed-width integer type with a `bitWidth` value of 8,<br>
> /// the number 31 has five bits equal to 1.<br>
</span>> ///<br>
> /// let x: Int8 = 0b0001_1111<br>
<span class="gmail-">> /// // x == 31<br>
</span><span class="gmail-">> /// // x.popcount == 5<br>
> var popcount: Int { get }<br>
<br>
</span>I'm not super-fond of this name; I assume it's a term of art, but it's a pretty obscure one. Maybe `numberOfOnes`? `onesWithin`?</blockquote><div><br></div><div>Far less obscure than `ulp` in `FloatingPoint`!</div><div><br></div><div>I think `popcount` is by far the most appropriate name here. It uses `count`, which is rather consistent with existing Swift APIs, and it is a visually recognizable term of art (note the absence of capitalization on "count"). I think a useful barometer for the appropriateness of a term of art is three-pronged:</div><div><br></div><div><div>* People who know of this concept (the population count of a binary integer) will almost invariably know it as `popcount`. (Really, if you're working with binary integers as a collection of bits, you will likely encounter the term if you look for useful algorithms).</div><div><br></div><div>* Those who do not can immediately get all the information they need by typing this term into Google or Wikipedia, because it needs no disambiguation.</div></div><div><br></div><div>* It is hard to express the concept more accurately using an alternative name. `hammingWeight`, `populationCount` are move verbose; `hammingWeight` would be the more general term, but loses the word "count" and doesn't _specifically_ communicate the fact that property has to do with the integer's _binary_ representation. `populationCount` is needlessly wordy and still a term of art. `countOfOnes` is unfamiliar to people who know what a popcount is, and no more enlightening to someone who doesn't know what a popcount is, as it fails to communicate the binary representation-ness directly.</div><div><br></div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left-width:1px;border-left-style:solid;border-left-color:rgb(204,204,204);padding-left:1ex"><span class="gmail-"><br>
> DoubleWidth<br>
><br>
> The DoubleWidth<T> type allows to create wider fixed-width integer types from the ones available in the standard library.<br>
<br>
</span>I'm glad you're planning to include `DoubleWidth` this time.<br>
<span class="gmail-"><br>
> • Deprecation of the BitwiseOperations protocol. We find it hard to imagine a type that conforms to this protocol, but is not a binary integer type.<br>
<br>
</span>While I'm sure any such type *could* be a binary integer type, I'm not convinced they necessary *should* be. For instance, suppose I have a "bit vector"; I know I never want to perform arithmetic on it, but I *do* want to manipulate bits separately, so I make it look like a `RandomAccessCollection` of `Bool`s. It might make a great deal of sense to support bitwise operations on this type, even though I don't want to clutter it up with arithmetic.<br>
<span class="gmail-HOEnZb"><font color="#888888"><br>
--<br>
Brent Royal-Gordon<br>
Architechies<br>
</font></span><div class="gmail-HOEnZb"><div class="gmail-h5"><br>
______________________________<wbr>_________________<br>
swift-evolution mailing list<br>
<a href="mailto:swift-evolution@swift.org">swift-evolution@swift.org</a><br>
<a href="https://lists.swift.org/mailman/listinfo/swift-evolution" rel="noreferrer" target="_blank">https://lists.swift.org/<wbr>mailman/listinfo/swift-<wbr>evolution</a><br>
</div></div></blockquote></div><br></div></div>