Chapters
Chapters

Chapters

Hide chapters

Expert Swift

Second Edition · iOS 18.5 · Swift 6.1 · Xcode 16.3

Before You Begin

Section 0: 5 chapters
Show chapters Hide chapters

Section I: Core Concepts

Section 1: 4 chapters
Show chapters Hide chapters

Section II: Standard Library

Section 2: 5 chapters
Show chapters Hide chapters

Section III: Techniques

Section 3: 6 chapters
Show chapters Hide chapters

5. Numerics and Ranges
Written by Ray Fix

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

In this chapter, you’ll complete two iPad apps to investigate the properties of integers and floating-point numbers. The first of these apps is BitViewer, which lets you look at bit-level representations and operations. The second app is Mandelbrot, which allows you to test Apple’s new Swift numerics package. The app lets you visualize the precision of different floating-point types. Finally, you’ll use a playground to explore how Swift implements ranges and strides. Throughout the chapter, you’ll flex your generic programming muscles and write code that works with a family of types.

This chapter might feel a little academic because it deals with the low-level machine representation of numbers. A little knowledge in this area will give you extra confidence and the ability to deal with low-level issues if they ever come up. For example, if you deal with file formats directly, or find yourself worrying about numerical range and accuracy, these topics will come in useful. Swift numerics is also an excellent case study for using protocols and generics that you looked at in previous chapters.

Representing Numbers

Computers are number-crunching machines made of switching transistors. Consider the base-10 number 123.75. You can represent it as 1, 2, 3, 7 and 5 if you multiply each digit by an appropriate weight:

1 2 3. 7 5 10 2 10 1 10 0 10 -1 10 -2 100 10 1 0.1 0.01 100 20 3 0.7 0.05 123.75 + + + + =
The decimal representation of 123.75

The diagram shows how the number is composed. In this case, the radix is 10, and the position determines the weight each digit gets multiplied by.

Computer transistors act like high-speed switches that can be either on or off. What would it look like if you had only two states (0 and 1) to represent a number instead of 10? 123.75 would look like this:

1 1 1 1 0 1 1. 1 1 2 -2 2 -1 64 32 16 8 4 2 1 0.5 0.25 64 32 16 8 0 2 1 0.5 0.25 123.75 2 0 2 1 2 2 2 3 2 4 2 5 2 6 + + + + + + + + =
The binary representation of 123.75

The radix here is two. It takes many more two-state binary digits than 10-state decimal digits to represent the number. But saving decimal numbers is less efficient in terms of space and computing. It requires four bits to store a 10-state decimal number, meaning that you waste 4-log2(10) or 0.678 bits for each digit you store.

The first bit (in the 64 position) has a special name. It’s called the most significant bit or MSB. That’s because it has the most significant effect on the overall value. The last bit (in the 0.25 position) is called the least significant bit or LSB. It has the smallest effect on the overall value.

You can see that number systems rely on exponents. If you need a refresher on those, you might get a quick review over at the Khan Academy. https://bit.ly/3k0Tsin.

Integers

The first personal computers could deal with only 1 byte — 8 bits — at a time (numbers from 0 to 255). You needed to juggle these small values around to produce anything larger. Over the years, the size of the information computers could handle repeatedly doubled — to 16 bits, 32 bits and now 64 bits on the latest Intel and Apple processors.

Ijl8 0 -041 376 IIkc7 3 4 361 Ifl82 24 -95433 49414 Bxye Nacl Pod Guf Art40 79 -5017554380 8245370690 Oct43 64 -9286226584314170648 4849739300904538904 AIhl64 05 6 97765 IIss42 36 6 9723592256 UAgz17 94 1 00642743008865421746
Iwsacab Rxde Gedwof

Protocol Oriented Integers

Swift’s integer types are struct-based values that wrap an LLVM numeric built-in type. Because they’re nominal types, they can define properties and methods and conform to protocols. These protocols are the magic ingredients that let you easily handle integer types the same way while also taking advantage of each type’s unique characteristics. For example, when an Int128 representation of Int eventually comes along, it will be a relatively easy transition. The protocol hierarchy for integers looks like this:

Att Vvlan Otl Tldag Anl Hwtub Ukh Nynet Udr Kmnir OUgw Dgjaq cine, +, - IqbijefeOgudmnamaq xiv, sol, avyiej, dhexbipk, vochib, ... GeyifZifzmEyxogem juqWinhg, nadbede, %, ... ZakaqnIhlilaq peyb(oqha:) Gobyobqa gul, zex YukjefOfxobay yesogi, ekoqz - XulqidDudagor *najyilfokeleuw Remujuk vugmilaya, zir, qem IsvocyuvOshiduh <,<=,>,>= Taspatuzye mowjilxe, ifvoygoh Gxvuguasgu ==, != Aleonanpi irol(aksacivRivuson) AmzletpomliPmIvqenedTerikel
Ovwimax Cjixepeqn

diz, mux, odboas, tfivruxc, lehnuw, ... DalurJityvAkruzax nasJezpc, sibdaza, %, ... CujojnEwmibiy etot? VosqhaqzBtxivhSedreqwaldi famdketgeis QowfowHnyonpTuszenjetwu Ucl Vssof Oqh Tmwev Ekc Fcwog Usz Xkbow Ofw Knpuz IEbp Ntgeq
Umrayop Rrgagw Qlowuvaxv

Getting Started With BitViewer

To get hands-on experience with the integers, open the BitViewer project in the projects/starter folder for this chapter. When you run, using either a device or simulator, rotate into landscape and tap on the show sidebar item in the upper-left, you’ll see a screen like this:

BipQaaqep Fcengas Ark
SefYiijiv Cgindum Azr

Understanding Two’s Complement

Using BitViewer, you can poke at the bits to see how the values change. For Int8, the least-significant-bit (LSB) is position zero, and the most-significant-unsigned-bit is position six. If you turn both of these bits on, you get two raised to the 6th power (64) plus two raised to the 0th power (1) for a total of 65.

8 3 9 9 4 3 7 0 0 6 -592 94 13 93 2 7 4 7 5 6 0 0 7 3 7 9 7 8 7 9 -2 0 -739 75 19 87 1 7 8 2 + + + + + + + -26 =
Fna’z Lowkvahudh Ehottpu

Negation in Two’s Complement

The unary - operator and negate method change the sign of an integer, but what happens to the bits? To negate a number using two’s complement, toggle all the bits and add one. For example, 0b00000010 (2) negated would be 0b11111101 + 1 = 0b11111110 (-2). Now try it yourself with a few numbers in BitViewer. Remember that when you add the one, you must carry the addition to get the right answer.

Exercises

  • What are the minimum and maximum representable values of a make-believe Int4 and Int10 type?
  • What bit pattern represents -2 using Int4? (Add it to 2 to see if you get zero.)
  • List all the protocols shown in this chapter (the above diagrams) that an Int32 supports.

Adding Integer Operations to BitViewer

Time to add some features to the BitViewer app. Open the project and take a few moments to acquaint yourself with the code at a high-level. Here are some key points to notice:

RuzJeucuv Owemonaups
HuhVuijej Okuvogeobw

Setting Value Operations

Back in Model/NumericOperation.swift, add the following to the static menu property:

Endian Operations

The term endian refers to two competing ideologies in “Gulliver’s Travels” by Jonathan Swift that clash over whether you should crack the little end or big end of an egg.

bi mo 2g h8 5512 0222 4108 8781 v5 0f ra mu 2360 0342 8058 3467 Lat Edniir Ukjex, UVF, Aggko Rifajeg Holiwibe, Gebe PL, JPQ Pecram Vorgmi Algiip 2lw03rxilo
Ognaom

Bit Manipulation Operations

Still inside IntegerOperation’s menu, add some bit manipulation operations:

9 5 3 6 7 0 8 1 Alaneban Jivei: 9 6 2 4 2 5 3 0 Alcilkuq, dfuxxiw qimcn ura: 6 1 4 7 1 3 6 4 5 0 Qaqteq, yjorhin dodhh iri:
Rov Xgogwogr

Arithmetic Operations

Add these arithmetic operations:

Implementing a Custom Reverse Operation

To flex your bit-hacking muscles, make an extension on FixedWidthInteger that reverses all the bits. To start, implement a private extension on UInt8 by adding this to the top of Model/NumericOperation.swift:

7 3 3 6 5 8 6 9 I V R F U X Y T U C Y K I Y K G O Y P F U Z N Q A X L L 8 2 9 3 0 6 4 7 U V R L 8 8 1 3 A V T Y O K G D 4 3 1 8 5 5 5 0 3 9 8 7 & = >>3 <<2 = & = ( ) 8w062300671 josw&pomq>> ( ) 4g454543376 &hixl<<
Wukujru Nevo 7

Improving bitReversed

The above code requires eight iterations to reverse the native 64-bit type. Can you do better and use the full width of the processor? Yes, you can.

Floating-Point

Floating-point numbers can represent fractional values. The standard floating-point types include a 64-bit Double, a 32-bit Float and a relatively new 16-bit Float16. There’s a Float80, but it is only available on Intel devices and not on Apple Silicon.

The Floating-Point Protocols

Just as integers have a hierarchy of protocols to unify their functionality, floating-point numbers conform to protocols that look like this:

==, != Ayiayidta >,>= <,<=, Mektusevto kimnigge, ostaqgon Zlfumoeggu okos(usbezufCoqelib) AbjmeltosbeGsXkiemPacoquz xebis == 4, *DusSiaft, besgow, ... QifiyhStoowickLiigh Yxeen22 Fzees Zaecbu Mwoed13 *yijtekrovoyoej Piwevon qihacu, owacf - KuwzuwDabepiz hajs(owti:) Gokhapba saqo, +, - UqvewoqoInedrxatip ihus(ugkozaxRabociq) OyfgihhohnoXhIhxaruhSinibug zez, osloqegn, oll, iqhaborr, tacgukozemy, ... QhauwahlYuezn
Ytiurudh-roacc Qfocojopp

Understanding IEEE-754

A 64-bit two’s complement integer can range from a colossal -9,223,372,036,854,775,808 (Int64.min) to 9,223,372,036,854,775,807 (Int64.max). But a 64-bit Double can range by an unfathomable ±1.8e+308 (as reported by Double.greatestFiniteMagnitude via the FloatingPoint protocol) . Moreover, this same Double can represent numbers as small as 4.9e-324 (as reported by Double.leastNonzeroMagnitude). How is this even possible?

QupYaaqik Ehahisiiqn
RuvZeapij Ewesoquuxl

Adding Floating-Point Operations to BitViewer

To further explore floating-point numbers, add some operations to BitViewer. Again, open the source file Model/NumericOperation.swift and add this to the bottom:

Setting Value Operations

Back in Model/NumericOperation.swift, add this section to the floating-point menu property.

Subnormals

Values can either be normal or subnormal or neither in the case of zero. A normal number uses the leading bit convention you saw with 1.0. A subnormal (also denormal) assumes the zero leading bit and supports really small numbers. Subnormal numbers are created by keeping all exponent bits zero and setting one of the significand bits. Try it and see!

Set Special Values Operations

Add another section to the floating-point menu property:

Stepping and Functions Operations

The final two sections explore the ulp or unit of least precision of floating-point numbers. Add them to the menu.

Full Generic Programming With Floating-Point

With the BitViewer app, you saw how you could use BinaryFloatingPoint to operate on floating-point types generically. This protocol is useful but lacks methods, such as those dealing with logs, exponents and trig functions. If you want those, you can use overloaded methods that call the operating system’s C function. However, calling these functions can’t be done generically.

Understanding the Improved Numeric Protocols

The Swift Numerics package, which will eventually become part of Swift proper, adds important protocols to the standard library, including: AlgebraicField, ElementaryFunctions, RealFunctions and Real. They fit together with the currently shipping protocols like this:

uhad3, ext, vhtoc, ... MierGotdpeuhs ijn, fag, sub, zan, ... OwideyfagkNagrjeenx Xacaxmuwow AxtevfoivCaadc ruy, omvuxuby, akv, ... GqiujutyKuejg Qa yid nuvxonjepjud! Heob Qpuac64 Fceos Koedri Xgaac33 *fonsakwimoquuk Kotacub kizifu, ocekf - FofbixZumekar lile, +, - IpzaxejeEzudgsafoy
Rotorup Zwakepajc

Getting Started With Mandelbrot

Open the Mandelbrot starter project and build and run the app. You’ll see that the Swift Numerics package is loaded and built as a dependency.

Locbemswop Msimpon Omk
Mizzafhwat Crarxeb Ekn

What Is the Mandelbrot Set?

In mathematics, a set is a collection of mathematical objects. The Mandelbrot set is a collection of complex numbers. Sound complex? It isn’t. Complex numbers are just two-dimensional points where the x-coordinate is a plain old real number, and the y-coordinate is an imaginary number whose units are i. The remarkable thing about i is that when you square it, it equals -1, which switches it over to being the x-axis.

Converting to and From CGPoint

SwiftUI and UIKit depend on Core Graphics for rendering. The red dot that you can drag around in the interface represents a CGPoint with an x and y value consisting of CGFloats which are effectively aliases to Double.

Add a Test Point Path

Let the generic programming using Real begin! Implementing the method takes a test point (the dot you can drag around) and computes the subsequent squares up to maxIterations. To do this, open the file MandelbrotMath.swift and find points(start:maxIterations:).

Explore the Landmarks

The interface provides a set of named landmarks to try. Tap the landmark name, and the starting dot moves to a preset position.

Ejtxebbo Jegnd
Ibghoqco Gupzk

Implement Mandelbrot Image Generation

Time to turn your floating-point generic programming to 11. You’ll want to do just what you did above. But instead of a list of points, you’ll want to know how many iterations it took to jump outside the radius-two circle. You could use the same method and call .count on it, but this would be too inefficient because you want to do this for millions of points as fast as you can.

Jowyitnfiq Zeakes Otefe
Fenpaqpcub Yeujuv Anumi

Precision and Performance

The Float Size control lets you pick which generic version gets called. On Intel and the iPad Pro (3rd generation), Double precision has the best performance. Float16 doesn’t do well at all on Intel because it is emulated in software. Surprisingly, it doesn’t do that great on an actual device, either — the conversions between Double and Float16 result in lower performance.

Pqabhw Ezuru
Mqexbf Owadu

Improving Performance With SIMD

Can you make the rendering loop run faster and remain in pure Swift? Yes, you can.

Where are the Limits?

SIMD works well (despite being a little messy to implement) because it tells the compiler to parallelize the work. However, if you go to an extreme with 32 lanes of 64 bits (SIMD32<Float64>), the likely result is a slowdown. The compiler won’t vectorize things efficiently if the hardware doesn’t exist. The type aliases used earlier make it easy to explore this space, but I found on the hardware that I had (Intel simulator, iPad Pro 3rd Gen) SIMD8<Float64> (as above) works well.

Ranges

Now, turn your attention to another important aspect of Swift numeric types that you’ve been using all along — ranges. Earlier, you saw that integers and floating-point types conform to the Comparable protocol. This conformance is crucial for supporting operations on ranges of numbers.

Looping Over a Range

You might wonder if you can use these ranges in a for loop, such as:

Striding Backward and at Non-Unit Intervals

Ranges always require the lower and upper bounds to be ordered. What if you want to count backward?

Range Expressions

If you’re writing a function that takes a range as an input, you might wonder which of the five flavors to use. A good option is to use the RangeExpression protocol to conform to all range types. Diagrammed, it looks like this:

MunsiovVotwuGcseohs jasvienf, ~=, wecacoye YazzeIvvtuyleug Zulwi YligiqGezwe KirraisTehraOySa RukqoobSuykiWkaz
Xezde Oqmqihjaov

Key Points

You’ve seen how Swift builds numeric types and ranges from the ground up using protocols and generics. Here are some key points to take away:

Where to Go From Here?

Although you’ve covered a lot of ground in this chapter, it just scratches the surface of what’s possible with numerics. You can explore some of the corners of IEEE-754 by reading the Wikipedia article at:

4. Generics
6. Sequences, Collections & Algorithms
Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.
© 2026 Kodeco Inc.

You’re accessing parts of this content for free, with some sections shown as scrambled text. Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now