[Swift]数値型

# 数値型

## 数値リテラル

- 数値を表すリテラル
  - 整数リテラル
     - デフォルトは``Int``型

    ```Swift:整数リテラル
    let a = 123 // Int型
    ```

  - 浮動小数点リテラル
     - デフォルトは``Double``型

    ```Swift:浮動小数点リテラル
    let a = 1.0 // Double型
    ```

## 数値型の種類

  - 整数型
  - 浮動小数点型

### 整数型

#### ``Int``型

- 32bitプラットフォームでは32bit
- 64bitプラットフォームでは64bit

#### 固定ビット数の整数型

- ``Int8``型
- ``Int16``型
- ``Int32``型
- ``Int64``型

#### 符号なしの整数型

- ``UInt``型
- ``UInt8``型
- ``UInt16``型
- ``UInt32``型
- ``UInt64``型

#### 整数型の最大値と最小値

- スタティックプロパティ``min``, ``max``からアクセス可能

    ```Swift:Int8型の最大値・最小値
    let a = Int8.min    // -128
    let b = Int8.max    // 128
    ```

### 浮動小数点型

- ``Float``型
  - 32bit
- ``Double``型
  - 64bit


#### 浮動小数点型の最大値と最小値

- 浮動小数点型には最小値や最大値を表すスタティックプロパティは用意されていない
  - ``Float``型
      - およそ10の38乗の正負の値まで表すことができる
  - ``Double``型
      - およそ10の308乗の正負の値まで表すことができる

#### 浮動小数点型の精度

- ``Float``型
  - 最小で6桁の精度
- ``Double``型
  - 最小で15桁の精度

    ```Swift:浮動小数点型の精度
    let a: Double = 12345678.9  // 12345678.9
    let b: Float = 12345678.9   // 1.2345678e+07
    ```

- 精度の違いによる使い分け
  - ``CGFloat``型
      - 画面上の座標
          - 32bitプラットフォーム上では``Float``型
          - 64bitプラットフォーム上では``Double``型
  - ``CLLocationDegrees``型
        - 地球上の座標
          - プラットフォームによらず``Double``型

##### 型エイリアス

- 型の別名
- ``typealias``キーワードを用いる

```Swift:typealiasの書式
typealias 新しい型名 = 型名
```

```Swift:CLLocationDegreesの定義
typealias CLLocationDegrees = Double
```

#### 浮動小数点型のスタティックプロパティ

- ``infinity``
  - 無限大を表す
  - 浮動小数点型に対する演算結果が無限大となった場合、その値は``infinity``
      - ``isInfinite``プロパティが``true``を返す

    ```Swift:infinity
    let a: Double = 1.0 / 0.0
    a.isInfinite    // true

    let b: Double = Double.infinity
    b.isInfinite    // true
    ```

- ``nan``
  - Nan(Not a Number、非数)を表す
    - 演算として不正な値が渡されてしまい、演算できなかったことを表す
      - ``isNaN``プロパティが``true``を返す

    ```Swift:nan
    let a: Double = 0.0 / 0.0
    a.isNaN     // true

    let b: Double = Double.nan
    b.isNaN    // true
    ```

## 数値型どうしの相互変換

- **整数型どうしや浮動小数点型どうしでも型が異なれば代入できない**
- 数値型をほかの数値型に変換するにはイニシャライザを使用する

### イニシャライザ

- 型の値を生成して初期化
- 数値型には他の数値型の値から自分の型の値を生成するイニシャライザがある
- 生成したい型よりも精度の高い型から初期化すると、生成した型の制度に合わせて端数処理が行われる

```Swift:イニシャライザの書式
型名()
```

```Swift:イニシャライザによる変換
let a: Int = 123
let b: Int64 = Int64(a)

let c: Float = 1.0
let d: Double = Double(c)
```

```Swift:精度の高い型からの変換
let c: Float = 1.99
let d: Int = Int(c)     // 1

let e: Double = 1.23456789
let f: Float = Float(e)     // 1.234568
```

### 数値型の操作

#### 比較

- 比較演算子(中置演算子)
  - ``==`` : 左辺と右辺が一致
  - ``!=`` : 左辺と右辺が一致しない
  - ``>``  : 左辺が右辺より大きい
  - ``>=`` : 左辺が右辺以上
  - ``<``  : 左辺が右辺より小さい
  - ``<=`` : 左辺が右辺以下

    ```Swift:比較演算
    123 == 456      // false
    123 != 456      // true
    123 > 456       // false
    123 >= 456      // false
    123 < 456       // true
    123 <= 456      // true
    ```

- 比較演算の注意点
  - 比較対象となる2つの数値の型が一致していなければならない
     - 型が一致しない場合はコンパイルエラー
     - 異なる型の数値どうしを比較するには明示的な型変換が必要
 
    ```Swift:比較演算と型変換
    let a: Int = 123
    let b: Int64 = 123

    a == Int(b)  // true
    ```

#### 算術

- 算術演算子(中置演算子)
  - ``+`` : 加算
  - ``-`` : 減算
  - ``*`` : 乗算
  - ``/`` : 除算
  - ``%`` : 剰余

    ```Swift:算術演算
    // 加算
    1 + 1   // 2

    // 減算
    5 - 2   // 3

    // 乗算
    2 * 4   // 8

    // 除算
    9 / 3   // 3

    // 剰余
    7 % 3   // 1
    ```

- 算術演算の注意点
  - 対象となる2つの数値の型が一致していなければならない
      - 型が一致しない場合はコンパイルエラー
      - 異なる型の数値どうしに対して算術演算を行うには明示的な型変換が必要

    ```Swift:算術演算と型変換
    let a: Int = 123
    let b: Float = 123.0

    a + Int(b)  // 246
    ```

- 複合代入演算子(中置演算子)
  - ``+=`` : 加算
  - ``-=`` : 減算
  - ``*=`` : 乗算
  - ``/=`` : 除算
  - ``%=`` : 剰余

    ```Swift:算術演算
    // 加算
    var a = 1
    a += 6      // 7

    // 減算
    var b = 1
    b -= 4      // -3

    // 乗算
    var c = 1
    c *= 2      // 2

    // 除算
    var d = 6
    d /= 2      // 3

    // 剰余
    var e = 5
    e %= 2      // 1
    ```