File: NSDecimal.swift

package info (click to toggle)
swiftlang 6.0.3-2
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 2,519,992 kB
  • sloc: cpp: 9,107,863; ansic: 2,040,022; asm: 1,135,751; python: 296,500; objc: 82,456; f90: 60,502; lisp: 34,951; pascal: 19,946; sh: 18,133; perl: 7,482; ml: 4,937; javascript: 4,117; makefile: 3,840; awk: 3,535; xml: 914; fortran: 619; cs: 573; ruby: 573
file content (125 lines) | stat: -rw-r--r-- 2,955 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
// RUN: %target-run-simple-swift | %FileCheck %s
// REQUIRES: executable_test

// REQUIRES: objc_interop

import Foundation

enum NSDecimalResult: ExpressibleByStringLiteral, Equatable, CustomStringConvertible {
  case Some(Decimal)
  case Error(Decimal.CalculationError)
  
  init() {
    self = .Some(Decimal())
  }
  
  init(stringLiteral: String) {
    if let value = Decimal(string: stringLiteral) {
      self = .Some(value)
    } else {
      self = .Error(.lossOfPrecision)
    }
  }

  init(unicodeScalarLiteral: String) {
    self.init(stringLiteral: unicodeScalarLiteral)
  }
  init(extendedGraphemeClusterLiteral: String) {
    self.init(stringLiteral: extendedGraphemeClusterLiteral)
  }

  var description: String {
    switch self {
    case .Some(var decimal):
      return NSDecimalString(&decimal, nil)
    case .Error:
      return "NaN"
    }
  }

  func pow10(_ power: Int) -> NSDecimalResult {
    switch self {
    case .Some(var decimal):
      var result = Decimal()
      let error = NSDecimalMultiplyByPowerOf10(&result, &decimal, Int16(power),
                                               .plain)
      if error != .noError {
        return .Error(error)
      } else {
        return .Some(result)
      }
    case .Error:
      return self
    }
  }

}

func ==(x: NSDecimalResult, y: NSDecimalResult) -> Bool {
  switch (x, y) {
  case var (.Some(x1), .Some(x2)):
    return NSDecimalCompare(&x1, &x2) == .orderedSame
  default:
    return false
  }
}

func +(x: NSDecimalResult, y: NSDecimalResult) -> NSDecimalResult {
  switch (x, y) {
  case var (.Some(x1), .Some(y1)):
    var result = Decimal()
    let error = NSDecimalAdd(&result, &x1, &y1, .plain)
    if error != .noError {
      return .Error(error)
    } else {
      return .Some(result)
    }
    
  case let (.Error(error), _):
    return .Error(error)
    
  case let (_, .Error(error)):
    return .Error(error)

  // FIXME rdar://problem/19165412
  default:
    fatalError("impossible")
  }
}

let zero = NSDecimalResult()
print(zero) // CHECK: 0

let two: NSDecimalResult = "1" + "1"
print(two) // CHECK: 2

let point95: NSDecimalResult = "0.8" + "0.1" + "0.05"
print(point95) // CHECK: 0.95

let twoAgain = point95 + "1.05"
print(twoAgain) // CHECK: 2
print(two == twoAgain) // CHECK: true

print(two + "not a number") // CHECK: NaN
print(two + "not a number" == "still not a number") // CHECK: false
print(two + "not a number" == two) // CHECK: false

let one: NSDecimalResult = "1"
print(one.pow10(2)) // CHECK: 100
print(one.pow10(-2)) // CHECK: 0.01

var twenty = Decimal(20)
var ten = Decimal(10)
twenty *= ten
print(twenty) // CHECK: 200

twenty = Decimal(20)
ten = Decimal(10)
twenty /= ten
print(twenty) // CHECK: 2

twenty = NSDecimalNumber(mantissa: 2, exponent: 1, isNegative: false) as Decimal
print(twenty.significand) // CHECK: 2
print(twenty.exponent) // CHECK: 1

print(Decimal(sign: .plus, exponent: -2, significand: 100)) // CHECK: 1