Class: Code::Object::Decimal

Inherits:
Number show all
Defined in:
lib/code/object/decimal.rb

Constant Summary

Constants inherited from Code::Object

NUMBER_CLASSES

Instance Attribute Summary

Attributes included from Concerns::Shared

#methods, #raw

Instance Method Summary collapse

Methods inherited from Code::Object

code_new, #code_new, maybe, #name, repeat, |

Methods included from Concerns::Shared

#<=>, #==, #as_json, #code_and, #code_as_json, #code_compare, #code_deep_duplicate, #code_different, #code_duplicate, #code_equal, #code_exclamation_mark, #code_exclusive_range, #code_falsy?, code_fetch, #code_fetch, code_get, #code_get, #code_greater, #code_greater_or_equal, #code_inclusive_range, #code_inspect, #code_less, #code_less_or_equal, #code_methods, #code_name, #code_nothing?, #code_or, #code_self, #code_set, code_set, #code_something?, #code_strict_different, #code_strict_equal, #code_to_boolean, #code_to_class, #code_to_date, #code_to_decimal, #code_to_dictionary, #code_to_duration, #code_to_integer, #code_to_json, #code_to_list, #code_to_nothing, #code_to_parameter, #code_to_range, #code_to_time, #code_truthy?, #eql?, #falsy?, #hash, #inspect, #multi_fetch, #nothing?, #sig, #something?, #succ, #to_code, #to_i, #to_json, #to_s, #truthy?

Constructor Details

#initialize(*args, **_kargs, &_block) ⇒ Decimal

Returns a new instance of Decimal.



6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
# File 'lib/code/object/decimal.rb', line 6

def initialize(*args, **_kargs, &_block)
  self.raw =
    if args.first.class.in?(NUMBER_CLASSES)
      if args.second.class.in?(NUMBER_CLASSES)
        args.first.to_s.to_d * (10**args.second.to_s.to_d)
      else
        args.first.to_s.to_d
      end
    else
      0.to_d
    end
rescue FloatDomainError
  self.raw = 0.to_d
end

Instance Method Details

#call(**args) ⇒ Object 



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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
 
# File 'lib/code/object/decimal.rb', line 21

def call(**args)
  code_operator = args.fetch(:operator, nil).to_code
  code_arguments = args.fetch(:arguments, []).to_code
  code_value = code_arguments.code_first

  case code_operator.to_s
  when "%", "modulo"
    sig(args) { Integer | Decimal }
    code_modulo(code_value)
  when "&", "bitwise_and"
    sig(args) { Integer | Decimal }
    code_bitwise_and(code_value)
  when "*", "multiplication"
    sig(args) { Integer | Decimal }
    code_multiplication(code_value)
  when "**", "power"
    sig(args) { Integer | Decimal }
    code_power(code_value)
  when "+", "plus"
    sig(args) { Object.maybe }
    code_arguments.any? ? code_plus(code_value) : self
  when "-", "minus"
    sig(args) { (Integer | Decimal).maybe }
    code_arguments.any? ? code_minus(code_value) : code_unary_minus
  when "/", "division"
    sig(args) { Integer | Decimal }
    code_division(code_value)
  when "<<", "left_shift"
    sig(args) { Integer | Decimal }
    code_left_shift(code_value)
  when ">>", "right_shift"
    sig(args) { Integer | Decimal }
    code_right_shift(code_value)
  when "^", "bitwise_xor"
    sig(args) { Integer | Decimal }
    code_bitwise_xor(code_value)
  when "abs"
    sig(args)
    code_abs
  when "ceil"
    sig(args) { Integer.maybe }
    code_ceil(code_value)
  when "floor"
    sig(args) { Integer.maybe }
    code_floor(code_value)
  when "round"
    sig(args) { Integer.maybe }
    code_round(code_value)
  when "sqrt"
    sig(args)
    code_sqrt
  when "truncate"
    sig(args) { Integer.maybe }
    code_truncate(code_value)
  when "|", "bitwise_or"
    sig(args) { Integer | Decimal }
    code_bitwise_or(code_value)
  when "many?"
    sig(args)
    code_many?
  when "any?"
    sig(args)
    code_any?
  when "positive?"
    sig(args)
    code_positive?
  when "negative?"
    sig(args)
    code_negative?
  when "zero?"
    sig(args)
    code_zero?
  when "one?"
    sig(args)
    code_one?
  when "two?"
    sig(args)
    code_two?
  when "three?"
    sig(args)
    code_three?
  when "four?"
    sig(args)
    code_four?
  when "five?"
    sig(args)
    code_five?
  when "six?"
    sig(args)
    code_six?
  when "seven?"
    sig(args)
    code_seven?
  when "eight?"
    sig(args)
    code_eight?
  when "nine?"
    sig(args)
    code_nine?
  when "ten?"
    sig(args)
    code_ten?
  when "eleven?"
    sig(args)
    code_eleven?
  when "twelve?"
    sig(args)
    code_twelve?
  when "thirteen?"
    sig(args)
    code_thirteen?
  when "fourteen?"
    sig(args)
    code_fourteen?
  when "fifteen?"
    sig(args)
    code_fifteen?
  when "sixteen?"
    sig(args)
    code_sixteen?
  when "seventeen?"
    sig(args)
    code_seventeen?
  when "eighteen?"
    sig(args)
    code_eighteen?
  when "nineteen?"
    sig(args)
    code_nineteen?
  when "twenty?"
    sig(args)
    code_twenty?
  when "twenty_one?"
    sig(args)
    code_twenty_one?
  when "twenty_two?"
    sig(args)
    code_twenty_two?
  when "twenty_three?"
    sig(args)
    code_twenty_three?
  when "twenty_four?"
    sig(args)
    code_twenty_four?
  when "twenty_five?"
    sig(args)
    code_twenty_five?
  when "twenty_six?"
    sig(args)
    code_twenty_six?
  when "twenty_seven?"
    sig(args)
    code_twenty_seven?
  when "twenty_eight?"
    sig(args)
    code_twenty_eight?
  when "twenty_nine?"
    sig(args)
    code_twenty_nine?
  when "thirty?"
    sig(args)
    code_thirty?
  when "thirty_one?"
    sig(args)
    code_thirty_one?
  when "thirty_two?"
    sig(args)
    code_thirty_two?
  when "thirty_three?"
    sig(args)
    code_thirty_three?
  when "thirty_four?"
    sig(args)
    code_thirty_four?
  when "thirty_five?"
    sig(args)
    code_thirty_five?
  when "thirty_six?"
    sig(args)
    code_thirty_six?
  when "thirty_seven?"
    sig(args)
    code_thirty_seven?
  when "thirty_eight?"
    sig(args)
    code_thirty_eight?
  when "thirty_nine?"
    sig(args)
    code_thirty_nine?
  when "forty?"
    sig(args)
    code_forty?
  when "forty_one?"
    sig(args)
    code_forty_one?
  when "forty_two?"
    sig(args)
    code_forty_two?
  when "forty_three?"
    sig(args)
    code_forty_three?
  when "forty_four?"
    sig(args)
    code_forty_four?
  when "forty_five?"
    sig(args)
    code_forty_five?
  when "forty_six?"
    sig(args)
    code_forty_six?
  when "forty_seven?"
    sig(args)
    code_forty_seven?
  when "forty_eight?"
    sig(args)
    code_forty_eight?
  when "forty_nine?"
    sig(args)
    code_forty_nine?
  when "fifty?"
    sig(args)
    code_fifty?
  when "fifty_one?"
    sig(args)
    code_fifty_one?
  when "fifty_two?"
    sig(args)
    code_fifty_two?
  when "fifty_three?"
    sig(args)
    code_fifty_three?
  when "fifty_four?"
    sig(args)
    code_fifty_four?
  when "fifty_five?"
    sig(args)
    code_fifty_five?
  when "fifty_six?"
    sig(args)
    code_fifty_six?
  when "fifty_seven?"
    sig(args)
    code_fifty_seven?
  when "fifty_eight?"
    sig(args)
    code_fifty_eight?
  when "fifty_nine?"
    sig(args)
    code_fifty_nine?
  when "sixty?"
    sig(args)
    code_sixty?
  when "sixty_one?"
    sig(args)
    code_sixty_one?
  when "sixty_two?"
    sig(args)
    code_sixty_two?
  when "sixty_three?"
    sig(args)
    code_sixty_three?
  when "sixty_four?"
    sig(args)
    code_sixty_four?
  when "sixty_five?"
    sig(args)
    code_sixty_five?
  when "sixty_six?"
    sig(args)
    code_sixty_six?
  when "sixty_seven?"
    sig(args)
    code_sixty_seven?
  when "sixty_eight?"
    sig(args)
    code_sixty_eight?
  when "sixty_nine?"
    sig(args)
    code_sixty_nine?
  when "seventy?"
    sig(args)
    code_seventy?
  when "seventy_one?"
    sig(args)
    code_seventy_one?
  when "seventy_two?"
    sig(args)
    code_seventy_two?
  when "seventy_three?"
    sig(args)
    code_seventy_three?
  when "seventy_four?"
    sig(args)
    code_seventy_four?
  when "seventy_five?"
    sig(args)
    code_seventy_five?
  when "seventy_six?"
    sig(args)
    code_seventy_six?
  when "seventy_seven?"
    sig(args)
    code_seventy_seven?
  when "seventy_eight?"
    sig(args)
    code_seventy_eight?
  when "seventy_nine?"
    sig(args)
    code_seventy_nine?
  when "eighty?"
    sig(args)
    code_eighty?
  when "eighty_one?"
    sig(args)
    code_eighty_one?
  when "eighty_two?"
    sig(args)
    code_eighty_two?
  when "eighty_three?"
    sig(args)
    code_eighty_three?
  when "eighty_four?"
    sig(args)
    code_eighty_four?
  when "eighty_five?"
    sig(args)
    code_eighty_five?
  when "eighty_six?"
    sig(args)
    code_eighty_six?
  when "eighty_seven?"
    sig(args)
    code_eighty_seven?
  when "eighty_eight?"
    sig(args)
    code_eighty_eight?
  when "eighty_nine?"
    sig(args)
    code_eighty_nine?
  when "ninety?"
    sig(args)
    code_ninety?
  when "ninety_one?"
    sig(args)
    code_ninety_one?
  when "ninety_two?"
    sig(args)
    code_ninety_two?
  when "ninety_three?"
    sig(args)
    code_ninety_three?
  when "ninety_four?"
    sig(args)
    code_ninety_four?
  when "ninety_five?"
    sig(args)
    code_ninety_five?
  when "ninety_six?"
    sig(args)
    code_ninety_six?
  when "ninety_seven?"
    sig(args)
    code_ninety_seven?
  when "ninety_eight?"
    sig(args)
    code_ninety_eight?
  when "ninety_nine?"
    sig(args)
    code_ninety_nine?
  when "one_hundred?"
    sig(args)
    code_one_hundred?
  else
    super
  end
end

#code_abs ⇒ Object 



398
399
400
 
# File 'lib/code/object/decimal.rb', line 398

def code_abs
  Decimal.new(raw.abs)
end

#code_any? ⇒ Boolean

Returns:



516
517
518
 
# File 'lib/code/object/decimal.rb', line 516

def code_any?
  Boolean.new(raw.positive?)
end

#code_bitwise_and(other) ⇒ Object 



402
403
404
405
406
 
# File 'lib/code/object/decimal.rb', line 402

def code_bitwise_and(other)
  code_other = other.to_code

  Integer.new(raw.to_i & code_other.raw.to_i)
end

#code_bitwise_or(other) ⇒ Object 



408
409
410
411
412
 
# File 'lib/code/object/decimal.rb', line 408

def code_bitwise_or(other)
  code_other = other.to_code

  Integer.new(raw.to_i | code_other.raw.to_i)
end

#code_bitwise_xor(other) ⇒ Object 



414
415
416
417
418
 
# File 'lib/code/object/decimal.rb', line 414

def code_bitwise_xor(other)
  code_other = other.to_code

  Integer.new(raw.to_i ^ code_other.raw.to_i)
end

#code_ceil(n = nil) ⇒ Object 



420
421
422
423
424
425
 
# File 'lib/code/object/decimal.rb', line 420

def code_ceil(n = nil)
  code_n = n.to_code
  code_n = Integer.new(0) if code_n.nothing?

  Decimal.new(raw.ceil(code_n.raw))
end

#code_division(other) ⇒ Object 



427
428
429
430
431
 
# File 'lib/code/object/decimal.rb', line 427

def code_division(other)
  code_other = other.to_code

  Decimal.new(raw / code_other.raw)
end

#code_eight? ⇒ Boolean

Returns:



560
561
562
 
# File 'lib/code/object/decimal.rb', line 560

def code_eight?
  Boolean.new(raw == 8)
end

#code_eighteen? ⇒ Boolean

Returns:



600
601
602
 
# File 'lib/code/object/decimal.rb', line 600

def code_eighteen?
  Boolean.new(raw == 18)
end

#code_eighty? ⇒ Boolean

Returns:



848
849
850
 
# File 'lib/code/object/decimal.rb', line 848

def code_eighty?
  Boolean.new(raw == 80)
end

#code_eighty_eight? ⇒ Boolean

Returns:



880
881
882
 
# File 'lib/code/object/decimal.rb', line 880

def code_eighty_eight?
  Boolean.new(raw == 88)
end

#code_eighty_five? ⇒ Boolean

Returns:



868
869
870
 
# File 'lib/code/object/decimal.rb', line 868

def code_eighty_five?
  Boolean.new(raw == 85)
end

#code_eighty_four? ⇒ Boolean

Returns:



864
865
866
 
# File 'lib/code/object/decimal.rb', line 864

def code_eighty_four?
  Boolean.new(raw == 84)
end

#code_eighty_nine? ⇒ Boolean

Returns:



884
885
886
 
# File 'lib/code/object/decimal.rb', line 884

def code_eighty_nine?
  Boolean.new(raw == 89)
end

#code_eighty_one? ⇒ Boolean

Returns:



852
853
854
 
# File 'lib/code/object/decimal.rb', line 852

def code_eighty_one?
  Boolean.new(raw == 81)
end

#code_eighty_seven? ⇒ Boolean

Returns:



876
877
878
 
# File 'lib/code/object/decimal.rb', line 876

def code_eighty_seven?
  Boolean.new(raw == 87)
end

#code_eighty_six? ⇒ Boolean

Returns:



872
873
874
 
# File 'lib/code/object/decimal.rb', line 872

def code_eighty_six?
  Boolean.new(raw == 86)
end

#code_eighty_three? ⇒ Boolean

Returns:



860
861
862
 
# File 'lib/code/object/decimal.rb', line 860

def code_eighty_three?
  Boolean.new(raw == 83)
end

#code_eighty_two? ⇒ Boolean

Returns:



856
857
858
 
# File 'lib/code/object/decimal.rb', line 856

def code_eighty_two?
  Boolean.new(raw == 82)
end

#code_eleven? ⇒ Boolean

Returns:



572
573
574
 
# File 'lib/code/object/decimal.rb', line 572

def code_eleven?
  Boolean.new(raw == 11)
end

#code_fifteen? ⇒ Boolean

Returns:



588
589
590
 
# File 'lib/code/object/decimal.rb', line 588

def code_fifteen?
  Boolean.new(raw == 15)
end

#code_fifty? ⇒ Boolean

Returns:



728
729
730
 
# File 'lib/code/object/decimal.rb', line 728

def code_fifty?
  Boolean.new(raw == 50)
end

#code_fifty_eight? ⇒ Boolean

Returns:



760
761
762
 
# File 'lib/code/object/decimal.rb', line 760

def code_fifty_eight?
  Boolean.new(raw == 58)
end

#code_fifty_five? ⇒ Boolean

Returns:



748
749
750
 
# File 'lib/code/object/decimal.rb', line 748

def code_fifty_five?
  Boolean.new(raw == 55)
end

#code_fifty_four? ⇒ Boolean

Returns:



744
745
746
 
# File 'lib/code/object/decimal.rb', line 744

def code_fifty_four?
  Boolean.new(raw == 54)
end

#code_fifty_nine? ⇒ Boolean

Returns:



764
765
766
 
# File 'lib/code/object/decimal.rb', line 764

def code_fifty_nine?
  Boolean.new(raw == 59)
end

#code_fifty_one? ⇒ Boolean

Returns:



732
733
734
 
# File 'lib/code/object/decimal.rb', line 732

def code_fifty_one?
  Boolean.new(raw == 51)
end

#code_fifty_seven? ⇒ Boolean

Returns:



756
757
758
 
# File 'lib/code/object/decimal.rb', line 756

def code_fifty_seven?
  Boolean.new(raw == 57)
end

#code_fifty_six? ⇒ Boolean

Returns:



752
753
754
 
# File 'lib/code/object/decimal.rb', line 752

def code_fifty_six?
  Boolean.new(raw == 56)
end

#code_fifty_three? ⇒ Boolean

Returns:



740
741
742
 
# File 'lib/code/object/decimal.rb', line 740

def code_fifty_three?
  Boolean.new(raw == 53)
end

#code_fifty_two? ⇒ Boolean

Returns:



736
737
738
 
# File 'lib/code/object/decimal.rb', line 736

def code_fifty_two?
  Boolean.new(raw == 52)
end

#code_five? ⇒ Boolean

Returns:



548
549
550
 
# File 'lib/code/object/decimal.rb', line 548

def code_five?
  Boolean.new(raw == 5)
end

#code_floor(n = nil) ⇒ Object 



433
434
435
436
437
438
 
# File 'lib/code/object/decimal.rb', line 433

def code_floor(n = nil)
  code_n = n.to_code
  code_n = Integer.new(0) if code_n.nothing?

  Decimal.new(raw.floor(code_n.raw))
end

#code_forty? ⇒ Boolean

Returns:



688
689
690
 
# File 'lib/code/object/decimal.rb', line 688

def code_forty?
  Boolean.new(raw == 40)
end

#code_forty_eight? ⇒ Boolean

Returns:



720
721
722
 
# File 'lib/code/object/decimal.rb', line 720

def code_forty_eight?
  Boolean.new(raw == 48)
end

#code_forty_five? ⇒ Boolean

Returns:



708
709
710
 
# File 'lib/code/object/decimal.rb', line 708

def code_forty_five?
  Boolean.new(raw == 45)
end

#code_forty_four? ⇒ Boolean

Returns:



704
705
706
 
# File 'lib/code/object/decimal.rb', line 704

def code_forty_four?
  Boolean.new(raw == 44)
end

#code_forty_nine? ⇒ Boolean

Returns:



724
725
726
 
# File 'lib/code/object/decimal.rb', line 724

def code_forty_nine?
  Boolean.new(raw == 49)
end

#code_forty_one? ⇒ Boolean

Returns:



692
693
694
 
# File 'lib/code/object/decimal.rb', line 692

def code_forty_one?
  Boolean.new(raw == 41)
end

#code_forty_seven? ⇒ Boolean

Returns:



716
717
718
 
# File 'lib/code/object/decimal.rb', line 716

def code_forty_seven?
  Boolean.new(raw == 47)
end

#code_forty_six? ⇒ Boolean

Returns:



712
713
714
 
# File 'lib/code/object/decimal.rb', line 712

def code_forty_six?
  Boolean.new(raw == 46)
end

#code_forty_three? ⇒ Boolean

Returns:



700
701
702
 
# File 'lib/code/object/decimal.rb', line 700

def code_forty_three?
  Boolean.new(raw == 43)
end

#code_forty_two? ⇒ Boolean

Returns:



696
697
698
 
# File 'lib/code/object/decimal.rb', line 696

def code_forty_two?
  Boolean.new(raw == 42)
end

#code_four? ⇒ Boolean

Returns:



544
545
546
 
# File 'lib/code/object/decimal.rb', line 544

def code_four?
  Boolean.new(raw == 4)
end

#code_fourteen? ⇒ Boolean

Returns:



584
585
586
 
# File 'lib/code/object/decimal.rb', line 584

def code_fourteen?
  Boolean.new(raw == 14)
end

#code_left_shift(other) ⇒ Object 



440
441
442
443
444
 
# File 'lib/code/object/decimal.rb', line 440

def code_left_shift(other)
  code_other = other.to_code

  Integer.new(raw.to_i << code_other.raw.to_i)
end

#code_many? ⇒ Boolean

Returns:



512
513
514
 
# File 'lib/code/object/decimal.rb', line 512

def code_many?
  Boolean.new(raw > 1)
end

#code_minus(other) ⇒ Object 



446
447
448
449
450
 
# File 'lib/code/object/decimal.rb', line 446

def code_minus(other)
  code_other = other.to_code

  Decimal.new(raw - code_other.raw)
end

#code_modulo(other) ⇒ Object 



452
453
454
455
456
 
# File 'lib/code/object/decimal.rb', line 452

def code_modulo(other)
  code_other = other.to_code

  Decimal.new(raw % code_other.raw)
end

#code_multiplication(other) ⇒ Object 



458
459
460
461
462
 
# File 'lib/code/object/decimal.rb', line 458

def code_multiplication(other)
  code_other = other.to_code

  Decimal.new(raw * code_other.raw)
end

#code_negative? ⇒ Boolean

Returns:



524
525
526
 
# File 'lib/code/object/decimal.rb', line 524

def code_negative?
  Boolean.new(raw.negative?)
end

#code_nine? ⇒ Boolean

Returns:



564
565
566
 
# File 'lib/code/object/decimal.rb', line 564

def code_nine?
  Boolean.new(raw == 9)
end

#code_nineteen? ⇒ Boolean

Returns:



604
605
606
 
# File 'lib/code/object/decimal.rb', line 604

def code_nineteen?
  Boolean.new(raw == 19)
end

#code_ninety? ⇒ Boolean

Returns:



888
889
890
 
# File 'lib/code/object/decimal.rb', line 888

def code_ninety?
  Boolean.new(raw == 90)
end

#code_ninety_eight? ⇒ Boolean

Returns:



920
921
922
 
# File 'lib/code/object/decimal.rb', line 920

def code_ninety_eight?
  Boolean.new(raw == 98)
end

#code_ninety_five? ⇒ Boolean

Returns:



908
909
910
 
# File 'lib/code/object/decimal.rb', line 908

def code_ninety_five?
  Boolean.new(raw == 95)
end

#code_ninety_four? ⇒ Boolean

Returns:



904
905
906
 
# File 'lib/code/object/decimal.rb', line 904

def code_ninety_four?
  Boolean.new(raw == 94)
end

#code_ninety_nine? ⇒ Boolean

Returns:



924
925
926
 
# File 'lib/code/object/decimal.rb', line 924

def code_ninety_nine?
  Boolean.new(raw == 99)
end

#code_ninety_one? ⇒ Boolean

Returns:



892
893
894
 
# File 'lib/code/object/decimal.rb', line 892

def code_ninety_one?
  Boolean.new(raw == 91)
end

#code_ninety_seven? ⇒ Boolean

Returns:



916
917
918
 
# File 'lib/code/object/decimal.rb', line 916

def code_ninety_seven?
  Boolean.new(raw == 97)
end

#code_ninety_six? ⇒ Boolean

Returns:



912
913
914
 
# File 'lib/code/object/decimal.rb', line 912

def code_ninety_six?
  Boolean.new(raw == 96)
end

#code_ninety_three? ⇒ Boolean

Returns:



900
901
902
 
# File 'lib/code/object/decimal.rb', line 900

def code_ninety_three?
  Boolean.new(raw == 93)
end

#code_ninety_two? ⇒ Boolean

Returns:



896
897
898
 
# File 'lib/code/object/decimal.rb', line 896

def code_ninety_two?
  Boolean.new(raw == 92)
end

#code_one? ⇒ Boolean

Returns:



532
533
534
 
# File 'lib/code/object/decimal.rb', line 532

def code_one?
  Boolean.new(raw == 1)
end

#code_one_hundred? ⇒ Boolean

Returns:



928
929
930
 
# File 'lib/code/object/decimal.rb', line 928

def code_one_hundred?
  Boolean.new(raw == 100)
end

#code_plus(other) ⇒ Object 



464
465
466
467
468
469
470
471
472
 
# File 'lib/code/object/decimal.rb', line 464

def code_plus(other)
  code_other = other.to_code

  if code_other.is_an?(Integer) || other.is_a?(Decimal)
    Decimal.new(raw + code_other.raw)
  else
    String.new(to_s + code_other.to_s)
  end
end

#code_positive? ⇒ Boolean

Returns:



520
521
522
 
# File 'lib/code/object/decimal.rb', line 520

def code_positive?
  Boolean.new(raw.positive?)
end

#code_power(other) ⇒ Object 



474
475
476
477
478
 
# File 'lib/code/object/decimal.rb', line 474

def code_power(other)
  code_other = other.to_code

  Decimal.new(raw**code_other.raw)
end

#code_right_shift(other) ⇒ Object 



480
481
482
483
484
 
# File 'lib/code/object/decimal.rb', line 480

def code_right_shift(other)
  code_other = other.to_code

  Integer.new(raw.to_i >> code_other.raw.to_i)
end

#code_round(n = nil) ⇒ Object 



486
487
488
489
490
491
 
# File 'lib/code/object/decimal.rb', line 486

def code_round(n = nil)
  code_n = n.to_code
  code_n = Integer.new(0) if code_n.nothing?

  Decimal.new(raw.round(code_n.raw))
end

#code_seven? ⇒ Boolean

Returns:



556
557
558
 
# File 'lib/code/object/decimal.rb', line 556

def code_seven?
  Boolean.new(raw == 7)
end

#code_seventeen? ⇒ Boolean

Returns:



596
597
598
 
# File 'lib/code/object/decimal.rb', line 596

def code_seventeen?
  Boolean.new(raw == 17)
end

#code_seventy? ⇒ Boolean

Returns:



808
809
810
 
# File 'lib/code/object/decimal.rb', line 808

def code_seventy?
  Boolean.new(raw == 70)
end

#code_seventy_eight? ⇒ Boolean

Returns:



840
841
842
 
# File 'lib/code/object/decimal.rb', line 840

def code_seventy_eight?
  Boolean.new(raw == 78)
end

#code_seventy_five? ⇒ Boolean

Returns:



828
829
830
 
# File 'lib/code/object/decimal.rb', line 828

def code_seventy_five?
  Boolean.new(raw == 75)
end

#code_seventy_four? ⇒ Boolean

Returns:



824
825
826
 
# File 'lib/code/object/decimal.rb', line 824

def code_seventy_four?
  Boolean.new(raw == 74)
end

#code_seventy_nine? ⇒ Boolean

Returns:



844
845
846
 
# File 'lib/code/object/decimal.rb', line 844

def code_seventy_nine?
  Boolean.new(raw == 79)
end

#code_seventy_one? ⇒ Boolean

Returns:



812
813
814
 
# File 'lib/code/object/decimal.rb', line 812

def code_seventy_one?
  Boolean.new(raw == 71)
end

#code_seventy_seven? ⇒ Boolean

Returns:



836
837
838
 
# File 'lib/code/object/decimal.rb', line 836

def code_seventy_seven?
  Boolean.new(raw == 77)
end

#code_seventy_six? ⇒ Boolean

Returns:



832
833
834
 
# File 'lib/code/object/decimal.rb', line 832

def code_seventy_six?
  Boolean.new(raw == 76)
end

#code_seventy_three? ⇒ Boolean

Returns:



820
821
822
 
# File 'lib/code/object/decimal.rb', line 820

def code_seventy_three?
  Boolean.new(raw == 73)
end

#code_seventy_two? ⇒ Boolean

Returns:



816
817
818
 
# File 'lib/code/object/decimal.rb', line 816

def code_seventy_two?
  Boolean.new(raw == 72)
end

#code_six? ⇒ Boolean

Returns:



552
553
554
 
# File 'lib/code/object/decimal.rb', line 552

def code_six?
  Boolean.new(raw == 6)
end

#code_sixteen? ⇒ Boolean

Returns:



592
593
594
 
# File 'lib/code/object/decimal.rb', line 592

def code_sixteen?
  Boolean.new(raw == 16)
end

#code_sixty? ⇒ Boolean

Returns:



768
769
770
 
# File 'lib/code/object/decimal.rb', line 768

def code_sixty?
  Boolean.new(raw == 60)
end

#code_sixty_eight? ⇒ Boolean

Returns:



800
801
802
 
# File 'lib/code/object/decimal.rb', line 800

def code_sixty_eight?
  Boolean.new(raw == 68)
end

#code_sixty_five? ⇒ Boolean

Returns:



788
789
790
 
# File 'lib/code/object/decimal.rb', line 788

def code_sixty_five?
  Boolean.new(raw == 65)
end

#code_sixty_four? ⇒ Boolean

Returns:



784
785
786
 
# File 'lib/code/object/decimal.rb', line 784

def code_sixty_four?
  Boolean.new(raw == 64)
end

#code_sixty_nine? ⇒ Boolean

Returns:



804
805
806
 
# File 'lib/code/object/decimal.rb', line 804

def code_sixty_nine?
  Boolean.new(raw == 69)
end

#code_sixty_one? ⇒ Boolean

Returns:



772
773
774
 
# File 'lib/code/object/decimal.rb', line 772

def code_sixty_one?
  Boolean.new(raw == 61)
end

#code_sixty_seven? ⇒ Boolean

Returns:



796
797
798
 
# File 'lib/code/object/decimal.rb', line 796

def code_sixty_seven?
  Boolean.new(raw == 67)
end

#code_sixty_six? ⇒ Boolean

Returns:



792
793
794
 
# File 'lib/code/object/decimal.rb', line 792

def code_sixty_six?
  Boolean.new(raw == 66)
end

#code_sixty_three? ⇒ Boolean

Returns:



780
781
782
 
# File 'lib/code/object/decimal.rb', line 780

def code_sixty_three?
  Boolean.new(raw == 63)
end

#code_sixty_two? ⇒ Boolean

Returns:



776
777
778
 
# File 'lib/code/object/decimal.rb', line 776

def code_sixty_two?
  Boolean.new(raw == 62)
end

#code_sqrt ⇒ Object 



493
494
495
 
# File 'lib/code/object/decimal.rb', line 493

def code_sqrt
  Decimal.new(Math.sqrt(raw).to_s)
end

#code_ten? ⇒ Boolean

Returns:



568
569
570
 
# File 'lib/code/object/decimal.rb', line 568

def code_ten?
  Boolean.new(raw == 10)
end

#code_thirteen? ⇒ Boolean

Returns:



580
581
582
 
# File 'lib/code/object/decimal.rb', line 580

def code_thirteen?
  Boolean.new(raw == 13)
end

#code_thirty? ⇒ Boolean

Returns:



648
649
650
 
# File 'lib/code/object/decimal.rb', line 648

def code_thirty?
  Boolean.new(raw == 30)
end

#code_thirty_eight? ⇒ Boolean

Returns:



680
681
682
 
# File 'lib/code/object/decimal.rb', line 680

def code_thirty_eight?
  Boolean.new(raw == 38)
end

#code_thirty_five? ⇒ Boolean

Returns:



668
669
670
 
# File 'lib/code/object/decimal.rb', line 668

def code_thirty_five?
  Boolean.new(raw == 35)
end

#code_thirty_four? ⇒ Boolean

Returns:



664
665
666
 
# File 'lib/code/object/decimal.rb', line 664

def code_thirty_four?
  Boolean.new(raw == 34)
end

#code_thirty_nine? ⇒ Boolean

Returns:



684
685
686
 
# File 'lib/code/object/decimal.rb', line 684

def code_thirty_nine?
  Boolean.new(raw == 39)
end

#code_thirty_one? ⇒ Boolean

Returns:



652
653
654
 
# File 'lib/code/object/decimal.rb', line 652

def code_thirty_one?
  Boolean.new(raw == 31)
end

#code_thirty_seven? ⇒ Boolean

Returns:



676
677
678
 
# File 'lib/code/object/decimal.rb', line 676

def code_thirty_seven?
  Boolean.new(raw == 37)
end

#code_thirty_six? ⇒ Boolean

Returns:



672
673
674
 
# File 'lib/code/object/decimal.rb', line 672

def code_thirty_six?
  Boolean.new(raw == 36)
end

#code_thirty_three? ⇒ Boolean

Returns:



660
661
662
 
# File 'lib/code/object/decimal.rb', line 660

def code_thirty_three?
  Boolean.new(raw == 33)
end

#code_thirty_two? ⇒ Boolean

Returns:



656
657
658
 
# File 'lib/code/object/decimal.rb', line 656

def code_thirty_two?
  Boolean.new(raw == 32)
end

#code_three? ⇒ Boolean

Returns:



540
541
542
 
# File 'lib/code/object/decimal.rb', line 540

def code_three?
  Boolean.new(raw == 3)
end

#code_to_string ⇒ Object 



497
498
499
 
# File 'lib/code/object/decimal.rb', line 497

def code_to_string
  String.new(raw.to_s("F"))
end

#code_truncate(n = nil) ⇒ Object 



501
502
503
504
505
506
 
# File 'lib/code/object/decimal.rb', line 501

def code_truncate(n = nil)
  code_n = n.to_code
  code_n = Integer.new(0) if code_n.nothing?

  Decimal.new(raw.truncate(code_n.raw))
end

#code_twelve? ⇒ Boolean

Returns:



576
577
578
 
# File 'lib/code/object/decimal.rb', line 576

def code_twelve?
  Boolean.new(raw == 12)
end

#code_twenty? ⇒ Boolean

Returns:



608
609
610
 
# File 'lib/code/object/decimal.rb', line 608

def code_twenty?
  Boolean.new(raw == 20)
end

#code_twenty_eight? ⇒ Boolean

Returns:



640
641
642
 
# File 'lib/code/object/decimal.rb', line 640

def code_twenty_eight?
  Boolean.new(raw == 28)
end

#code_twenty_five? ⇒ Boolean

Returns:



628
629
630
 
# File 'lib/code/object/decimal.rb', line 628

def code_twenty_five?
  Boolean.new(raw == 25)
end

#code_twenty_four? ⇒ Boolean

Returns:



624
625
626
 
# File 'lib/code/object/decimal.rb', line 624

def code_twenty_four?
  Boolean.new(raw == 24)
end

#code_twenty_nine? ⇒ Boolean

Returns:



644
645
646
 
# File 'lib/code/object/decimal.rb', line 644

def code_twenty_nine?
  Boolean.new(raw == 29)
end

#code_twenty_one? ⇒ Boolean

Returns:



612
613
614
 
# File 'lib/code/object/decimal.rb', line 612

def code_twenty_one?
  Boolean.new(raw == 21)
end

#code_twenty_seven? ⇒ Boolean

Returns:



636
637
638
 
# File 'lib/code/object/decimal.rb', line 636

def code_twenty_seven?
  Boolean.new(raw == 27)
end

#code_twenty_six? ⇒ Boolean

Returns:



632
633
634
 
# File 'lib/code/object/decimal.rb', line 632

def code_twenty_six?
  Boolean.new(raw == 26)
end

#code_twenty_three? ⇒ Boolean

Returns:



620
621
622
 
# File 'lib/code/object/decimal.rb', line 620

def code_twenty_three?
  Boolean.new(raw == 23)
end

#code_twenty_two? ⇒ Boolean

Returns:



616
617
618
 
# File 'lib/code/object/decimal.rb', line 616

def code_twenty_two?
  Boolean.new(raw == 22)
end

#code_two? ⇒ Boolean

Returns:



536
537
538
 
# File 'lib/code/object/decimal.rb', line 536

def code_two?
  Boolean.new(raw == 2)
end

#code_unary_minus ⇒ Object 



508
509
510
 
# File 'lib/code/object/decimal.rb', line 508

def code_unary_minus
  Decimal.new(-raw)
end

#code_zero? ⇒ Boolean

Returns:



528
529
530
 
# File 'lib/code/object/decimal.rb', line 528

def code_zero?
  Boolean.new(raw.zero?)
end