# How to use binary representation of floating point numbers in Swift

To store floating-point numbers in binary files or binary data buffers, they are encoded in the manner defined by IEEE 754; in Swift, the `BinaryFloatingPoint` protocol defines methods, etc., to support IEEE 754. Float, Double, and Float80 implements the `BinaryFloatingPoint` protocol.

IEEE 754 has been adopted by many modern systems, processors, and programming languages. However, there are differences between the definition in the standard and the actual implementation. In particular, the handling of `long double` in the C language deviates from the standard depending on the combination of OS, compiler, and processor.

This article explains how to encode floating-point numbers and write them to a binary file in Swift according to IEEE 754, and how to read the binaryized floating-point numbers and treat them as `Float` or `Double`. We will also read binary files created in Swift with C programs and binary files written in C programs with Swift to ensure that other programming languages are also compatible.

TOC

## Single precision floating point number

Single-precision floating-point numbers are a 32-bit wide format for representing floating-point numbers, as implemented by `Float` in Swift. The information represented by each bit is shown in the table below.

### Binaryizing Float in Swift

The `BinaryFloatingPoint` protocol has a property to retrieve each piece of information, and you can create a `32-bit` bit pattern from the retrieved value, but there is a more convenient way: using the `Float.bitPattern` property, you can retrieve the encoded `32-bit` value.

``````var bitPattern: UInt32 { get }
``````

For example, the following code writes two `Float` to the desktop in a file called `FloatValues`.

``````import Foundation

// Encode Float to IEEE 754 and convert to UInt32
let packedValues: [UInt32] = [Float(123.456).bitPattern,
Float(-456.789).bitPattern]

// Create binary data with encoded values.
let data = Data(bytes: packedValues, count: MemoryLayout<UInt32>.size * packedValues.count)

// Write to a file
do {
let url = FileManager.default.urls(for: .desktopDirectory, in: .userDomainMask)
.appendingPathComponent("FloatValues")
try data.write(to: url)
} catch let error {
print(error)
}
``````

The following code is C code that reads this written file and outputs the read value to the console; it is encoded according to IEEE 754, so the C language can treat the binary read as a `float` as is.

``````#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>
#include <stdio.h>
#include <string.h>

int main(int argc, const char * argv[]) {
struct passwd *pw = getpwuid(getuid());
char path = {};

strcpy(path, pw->pw_dir);
strcat(path, "/Desktop/FloatValues");

FILE *fp = fopen(path, "rb");

if (fp != NULL) {
float values = {};
fclose(fp);

printf("%f, %f\n", values, values);
}

return 0;
}
``````

The console outputs the following. Since this is a floating-point number, it is not an exact match to the literal value written in the code, but an approximation, but this is an event unrelated to the binaryization of this article. The same is true when a literal value is substituted.

``````123.456001, -456.789001
``````

### Read Float from Binary in Swift

When creating a `Float` from a binary, use the following initializer to specify the bit pattern.

``````init(bitPattern: UInt32)
``````

The following code reads the desktop `FloatValues` file and outputs the read values to the console.

``````import Foundation

do {
let url = FileManager.default.urls(for: .desktopDirectory, in: .userDomainMask)
.appendingPathComponent("FloatValues")

let data = try Data(contentsOf: url)

data.withUnsafeBytes() {
// Access as an array of 32-bit integers
let packedValues = \$0.bindMemory(to: UInt32.self)

// Convert to Float
let floatValues = [Float(bitPattern: packedValues),
Float(bitPattern: packedValues)]

// Output to console
print(floatValues)
print(floatValues)
}

} catch let error {
print(error)
}
``````

The console outputs the following.

``````123.456
-456.789
``````

## Double precision floating point number

Double-precision floating-point numbers are a `64-bit` wide representation of floating-point numbers, as implemented by `Double` in Swift. The information represented by each bit is shown in the table below.

### Binaryizing Double in Swift

`Double` also has a property to get the bit pattern.

``````var bitPattern: UInt64 { get }
``````

Since it is double precision, `64-bit` integers can be obtained. Let’s check it out with the following code.

``````import Foundation

// Encode Double to IEEE 754 and convert to UInt64
let packedValues: [UInt64] = [Double(123.456).bitPattern,
Double(-456.789).bitPattern]

// Create binary data with encoded values.
let data = Data(bytes: packedValues, count: MemoryLayout<UInt64>.size * packedValues.count)

// Write to a file
do {
let url = FileManager.default.urls(for: .desktopDirectory, in: .userDomainMask)
.appendingPathComponent("DoubleValues")
try data.write(to: url)
} catch let error {
print(error)
}
``````

The following is C code that reads a `DoubleValues` file and outputs the values to the console. The code assumes that `double` is read.

``````#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>
#include <stdio.h>
#include <string.h>

int main(int argc, const char * argv[]) {
struct passwd *pw = getpwuid(getuid());
char path = {};

strcpy(path, pw->pw_dir);
strcat(path, "/Desktop/DoubleValues");

FILE *fp = fopen(path, "rb");

if (fp != NULL) {
double values = {};
fclose(fp);

printf("%f, %f\n", values, values);
}

return 0;
}
``````

The console outputs the following.

``````123.456000, -456.789000
``````

### Read Double from Binary in Swift

When creating a `Double` from a binary, use an initializer that specifies a bit pattern; 64-bit integers can be specified.

``````init(bitPattern: UInt64)
``````

The following code reads the `DoubleValues` file on the desktop and outputs the read values to Console.

``````import Foundation

do {
// ファイルから読み込む
let url = FileManager.default.urls(for: .desktopDirectory, in: .userDomainMask)
.appendingPathComponent("DoubleValues")

let data = try Data(contentsOf: url)

data.withUnsafeBytes() {
// Access as an array of 64-bit integers
let packedValues = \$0.bindMemory(to: UInt64.self)

// Convert to Double
let doubleValues = [Double(bitPattern: packedValues),
Double(bitPattern: packedValues)]

// Output to console
print(doubleValues)
print(doubleValues)
}

} catch let error {
print(error)
}
``````

The console outputs the following.

``````123.456
-456.789
`````` Akira Hayashi Representative, Software Engineer