siddharth's space

Deterministic and random are opposites but sometimes we want a way to generate and reproduce the same sequence of random numbers when a program is run. Swift language is now more than 8 years in the making but still does not provide a seedable PRNG (pseudo random number generator) out of the box. There is no way for a programmer to set the seed of the PRNG that comes with Swift. So we have to resort to other methods. One of the top results that came in my search to create a seedable random number generator was this link:

struct RandomNumberGeneratorWithSeed: RandomNumberGenerator {
    init(seed: Int) {
        // Set the random seed
        srand48(seed)
    }
    
    func next() -> UInt64 {
        // drand48() returns a Double, transform to UInt64
        return withUnsafeBytes(of: drand48()) { bytes in
            bytes.load(as: UInt64.self)
        }
    }
}

It works by using the drand48 system function to get a random number and calls srand48 to set drand48‘s seed. So far so good. We can wrap it in a class like so:

class Random {

var rnd: RandomNumberGeneratorWithSeed

init(_ seed: Int) {
    // Set the random seed
    rnd = RandomNumberGeneratorWithSeed(seed)
}    

func nextFloat() -> Float {
    return Float.random(in: 0..<1, using: &rnd)
}

func nextDouble() -> Double {
    return Double.random(in: 0..<1, using: &rnd)
}

func next(_ x: UInt) -> UInt {
    return UInt.random(in: 0..<x, using: &rnd)
}

func nextInt() -> Int {
    return Int.random(in: Int.min..<Int.max, using: &rnd)
}
}

There are at least 3 problems with this class:

1. Try following code:

let seed = Int.random(in: Int.min..<Int.max)
let random = Random(seed)
for i in 0..<10 {
    print(random.next(4))
}

You just get a sequence of 0s. Why?

2. Create instances of more than one Random in your app and see how it goes. Since both instances depend on the same drand48 they are not isolated.

3. The third problem is this:

Note

The algorithm used to create random values may change in a future version of Swift. If you’re passing a generator that results in the same sequence of integer values each time you run your program, that sequence may change when your program is compiled using a different version of Swift.

I won’t give out the solution here but this not how you should be generating deterministic random numbers in Swift.

In this post we learn how to do basic file I/O in Swift. We will create a file and write some text to it. All code here is w.r.t. Swift 5.7.2. First we need to import Foundation:

import Foundation

Then we create a URL:

let fileManager = FileManager.default
let url = URL(fileURLWithPath: filename)
let filePath = url.path        

Now we can create a file:

guard (fileManager.createFile(atPath: filePath, contents:nil)) else {
    throw Errors.fileIOException
}

Next we get a FileHandle:

let file = FileHandle(forWritingAtPath : filename)!

and now we can start writing to the file:

file.write(Data("Hello World\n".utf8))

When you are done, remember to close the file like so:

try file.close()

That’s it! Some tips:

• You will get an error if you attempt to fetch a FileHandle without creating the file first
• We see the API is different from what you would expect coming from Java or C#. You don’t create any BufferedStreamWriter.
• Some code samples write to file using the write method on the String object and passing it a TextOutputStream. Try it if you like and let me know if it works.

It’s quite hard to find any Swift examples on the web. It took me hours to write a simple program that draws a rectangle in Swift and saves it to a file. 50% of the code that comes up in search results uses old APIs and Objective C in some cases. The other 50% uses Swift UI and I am not making a GUI app. I am making a CLI app. Let’s see how to do it. All code here is w.r.t. Swift 5.7.2.

First, we have to download and install Swift. You don’t need to download Xcode to use Swift but you won’t be able to run any unit tests without Xcode.

Next cd to an empty directory and create a new executable project (i.e., a Console or command-line application):

$ swift package init --type executable

You will see a Package.swift file generated. The good thing is that you don’t need to add any dependencies to Package.swift to do 2D drawing in Swift. 2D drawing is made possible by the CoreGraphics library which is automatically loaded on MacOS for an executable app. I don’t know about other platforms. Everything here is w.r.t. Mac OS. Think of CoreGraphics as the equivalent of GDI+ if you have done 2D Drawing or Graphics on .NET platform.

The first step we will do is to create an empty bitmap of a certain size. First we import CoreGraphics:

import CoreGraphics

and then in a function we create an object of type CGContext:

let sRGB = CGColorSpace(name: CGColorSpace.sRGB)!
let ctx = CGContext(data: nil, width: 100, height: 100, bitsPerComponent: 8, bytesPerRow: 100*4, space: sRGB, bitmapInfo: CGImageAlphaInfo.premultipliedFirst.rawValue)!

For those familiar with GDI+, think of CGContext as the equivalent of System.Drawing.Graphics. The CG stands for CoreGraphics. It took me hours to figure out the two line code above and was the hardest part. After this we will draw the rectangle and fill it with a color. It can be done like this:

let origin = CGPoint(x: 20, y: 40)
let size = CGSize(width: 30, height: 15)
let rect = CGRect(origin: origin, size: size)
ctx.setFillColor(red: 1.0, green: 0, blue: 0, alpha: 0.5)
ctx.fill(rect)

Compared to GDI+ we don’t create any Brush. To draw a rectangle without filling it with a color you would call:

ctx.setStrokeColor(cgColor)
ctx.stroke(cgRect, width: strokeWidth)

Again if you compare to GDI+, we don’t create any Pen object.

Next, all that remains is to save the image to a file. But before we do that, hold on. Where is the image? We don’t have any image yet. We can get it from CGContext as follows:

let img = ctx.makeImage()!

Again, if you compare to GDI+, you will notice its backwards. In GDI+, we first create a Bitmap or Image and then get a Graphics object from it. In Swift we first create CGContext and then get CGImage from it. Now to save this image in a file we use following function:

import Foundation
import ImageIO
import CoreGraphics
import UniformTypeIdentifiers

// https://gist.github.com/KrisYu/abf3d03a76b781ffc2a26848d713b11e
@discardableResult static func writeCGImage(_ image: CGImage, to destinationURL: URL) throws -> Bool {
    guard let destination = CGImageDestinationCreateWithURL(destinationURL as CFURL, UTType.jpeg.identifier as CFString, 1, nil) else {
        throw Errors.fileIOException
    }
    CGImageDestinationAddImage(destination, image, nil)
    return CGImageDestinationFinalize(destination)
}

This function can be called like:

writeCGImage(img, to: URL(fileURLWithPath: "test.jpg"))

And now we have a complete program that draws a rectangle and saves it to a file.

Compared to GDI+, I feel GDI+ API is slightly better as it uses intuitive objects like Brush and Pen for drawing.

Trivia: Swift language is very annoying and you have to prefix arguments with their labels. E.g., if you write:

let origin = CGPoint(20, 40)

You will get a compile time error. To be able to write:

let origin = CGPoint(20, 40)

The CGPoint function has to be declared like:

func CGPoint(_ x: Float, _ y: Float)

I decided to use some holidays I had to learn the Swift programming language. Below are the steps I followed to get started (and some gotchas I ran into) which is often the hardest part. I did not want to install Xcode so I only downloaded the Universal .pkg file from this link. I installed it without any issues but when I tried to run a sample program, I immediately got this error:

`PackageDescription` could not be found

After lot of debugging and searching online (answers to Swift problems are very hard to find because compared to Java, Python etc. it has much smaller user base), it seems this problem happens when you had a version of Swift that you unwittingly installed previously when you installed Xcode command line tools. E.g., in my case before installing Swift I had installed git which required me to install the Xcode c.l.t. Now I had two versions of Swift on my system.

Binary downloaded from Swift website:

% /Library/Developer/Toolchains/swift-5.7.2-RELEASE.xctoolchain/usr/bin/swift --version
Apple Swift version 5.7.2 (swift-5.7.2-RELEASE)
Target: arm64-apple-macosx13.0

Binary that got installed with Xcode Command Line Tools:

% /usr/bin/swift --version
Apple Swift version 5.7.2 (swiftlang-5.7.2.135.5 clang-1400.0.29.51)
Target: arm64-apple-darwin22.2.0

By default I was running /usr/bin/swift which I think came with Xcode c.l.t. When I changed to /Library/Developer/Toolchains/swift-5.7.2-RELEASE.xctoolchain/usr/bin/swift the problem went away. Its going to be tedious to have to type that long string every time you want to run Swift so you can add following line to your ~/.zshrc to use a shortcut:

alias swift=/Library/Developer/Toolchains/swift-5.7.2-RELEASE.xctoolchain/usr/bin/swift

The nasty problem I found out later is that if you do NOT download Xcode, you won’t be able to run any tests using the xctest command. See this. I was actually trying to download Xcode initially but before I could do so Apple wanted to know my address and other information. In all their setup screens they say they take your privacy very seriously and then force you to disclose your private information to them for no reason. Why should I have to tell Apple my address when all I wanted to do was download Xcode?

It doesn’t end here. To run the REPL swift repl, I had to use the Swift that comes with Xcode c.l.t. Using the other Swift gave me error. Hope it helps someone else who ends up with a setup like mine.