OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | |
2 // for details. All rights reserved. Use of this source code is governed by a | |
3 // BSD-style license that can be found in the LICENSE file. | |
4 | |
5 part of fixnum; | |
6 | |
7 /** | |
8 * A fixed-precision integer. | |
9 */ | |
10 abstract class IntX implements Comparable<IntX> { | |
11 | |
12 /** Addition operator. */ | |
13 IntX operator +(other); | |
14 | |
15 /** Subtraction operator. */ | |
16 IntX operator -(other); | |
17 | |
18 /** | |
19 * Negate operator. | |
20 * | |
21 * Note that `-MIN_VALUE` is equal to `MIN_VALUE` due to overflow. | |
22 */ | |
23 IntX operator -(); | |
24 | |
25 /** Multiplication operator. */ | |
26 IntX operator *(other); | |
27 | |
28 /** | |
29 * Euclidean modulo operator. | |
30 * | |
31 * Returns the remainder of the euclidean division. The euclidean division | |
32 * of two integers `a` and `b` yields two integers `q` and `r` such that | |
33 * `a == b * q + r` and `0 <= r < a.abs()`. | |
34 */ | |
35 IntX operator %(other); | |
36 | |
37 /** Truncating division operator. */ | |
38 IntX operator ~/(other); | |
39 | |
40 /** | |
41 * Returns the remainder of the truncating division of this integer by | |
42 * [other]. | |
43 */ | |
44 IntX remainder(other); | |
45 | |
46 /** Bitwise and operator. */ | |
47 IntX operator &(other); | |
48 | |
49 /** Bitwise or operator. */ | |
50 IntX operator |(other); | |
51 | |
52 /** Bitwise xor operator. */ | |
53 IntX operator ^(other); | |
54 | |
55 /** Bitwise negate operator. */ | |
56 IntX operator ~(); | |
57 | |
58 /** | |
59 * Left bit-shift operator. | |
60 * | |
61 * Returns the result of shifting the bits of this integer by [shiftAmount] | |
62 * bits to the left. Low-order bits are filled with zeros. | |
63 */ | |
64 IntX operator <<(int shiftAmount); | |
65 | |
66 /** | |
67 * Right bit-shift operator. | |
68 * | |
69 * Returns the result of shifting the bits of this integer by [shiftAmount] | |
70 * bits to the right. High-order bits are filled with zero in the case where | |
71 * this integer is positive, or one in the case where it is negative. | |
72 */ | |
73 IntX operator >>(int shiftAmount); | |
74 | |
75 /** | |
76 * Unsigned right-shift operator. | |
77 * | |
78 * Returns the result of shifting the bits of this integer by [shiftAmount] | |
79 * bits to the right. High-order bits are filled with zeros. | |
80 */ | |
81 IntX shiftRightUnsigned(int shiftAmount); | |
82 | |
83 /** | |
84 * Returns `true` if and only if [other] is an int or IntX equal in | |
85 * value to this integer. | |
86 */ | |
87 bool operator ==(other); | |
88 | |
89 /** Relational less than operator. */ | |
90 bool operator <(other); | |
91 | |
92 /** Relational less than or equal to operator. */ | |
93 bool operator <=(other); | |
94 | |
95 /** Relational greater than operator. */ | |
96 bool operator >(other); | |
97 | |
98 /** Relational greater than or equal to operator. */ | |
99 bool operator >=(other); | |
100 | |
101 /** Returns `true` if and only if this integer is even. */ | |
102 bool get isEven; | |
103 | |
104 /** | |
105 * Returns `true` if and only if this integer is the maximum signed value | |
106 * that can be represented within its bit size. | |
107 */ | |
108 bool get isMaxValue; | |
109 | |
110 /** | |
111 * Returns `true` if and only if this integer is the minimum signed value | |
112 * that can be represented within its bit size. | |
113 */ | |
114 bool get isMinValue; | |
115 | |
116 /** Returns `true` if and only if this integer is less than zero. */ | |
117 bool get isNegative; | |
118 | |
119 /** Returns `true` if and only if this integer is odd. */ | |
120 bool get isOdd; | |
121 | |
122 /** Returns `true` if and only if this integer is zero. */ | |
123 bool get isZero; | |
124 | |
125 int get hashCode; | |
126 | |
127 /** Returns the absolute value of this integer. */ | |
128 IntX abs(); | |
129 | |
130 /** Clamps this integer to be in the range [lowerLimit] - [upperLimit]. */ | |
131 IntX clamp(lowerLimit, upperLimit); | |
132 | |
133 /** | |
134 * Returns the minimum number of bits required to store this integer. | |
135 * | |
136 * The number of bits excludes the sign bit, which gives the natural length | |
137 * for non-negative (unsigned) values. Negative values are complemented to | |
138 * return the bit position of the first bit that differs from the sign bit. | |
139 * | |
140 * To find the the number of bits needed to store the value as a signed value, | |
141 * add one, i.e. use `x.bitLength + 1`. | |
142 */ | |
143 int get bitLength; | |
144 | |
145 /** | |
146 * Returns the number of high-order zeros in this integer's bit | |
147 * representation. | |
148 */ | |
149 int numberOfLeadingZeros(); | |
150 | |
151 /** | |
152 * Returns the number of low-order zeros in this integer's bit representation. | |
153 */ | |
154 int numberOfTrailingZeros(); | |
155 | |
156 /** | |
157 * Returns the least significant [width] bits of this integer, extending the | |
158 * highest retained bit to the sign. This is the same as truncating the value | |
159 * to fit in [width] bits using an signed 2-s complement representation. The | |
160 * returned value has the same bit value in all positions higher than [width]. | |
161 * | |
162 * If the input value fits in [width] bits without truncation, the result is | |
163 * the same as the input. The minimum width needed to avoid truncation of `x` | |
164 * is `x.bitLength + 1`, i.e. | |
165 * | |
166 * x == x.toSigned(x.bitLength + 1); | |
167 */ | |
168 IntX toSigned(int width); | |
169 | |
170 /** | |
171 * Returns the least significant [width] bits of this integer as a | |
172 * non-negative number (i.e. unsigned representation). The returned value has | |
173 * zeros in all bit positions higher than [width]. | |
174 * | |
175 * If the input fits in [width] bits without truncation, the result is the | |
176 * same as the input. The minimum width needed to avoid truncation of `x` is | |
177 * given by `x.bitLength`, i.e. | |
178 * | |
179 * x == x.toUnsigned(x.bitLength); | |
180 */ | |
181 IntX toUnsigned(int width); | |
182 | |
183 /** | |
184 * Returns a byte-sequence representation of this integer. | |
185 * | |
186 * Returns a list of int, starting with the least significant byte. | |
187 */ | |
188 List<int> toBytes(); | |
189 | |
190 /** | |
191 * Returns the double representation of this integer. | |
192 * | |
193 * On some platforms, inputs with large absolute values (i.e., > 2^52) may | |
194 * lose some of their low-order bits. | |
195 */ | |
196 double toDouble(); | |
197 | |
198 /** | |
199 * Returns the int representation of this integer. | |
200 * | |
201 * On some platforms, inputs with large absolute values (i.e., > 2^52) may | |
202 * lose some of their low-order bits. | |
203 */ | |
204 int toInt(); | |
205 | |
206 /** | |
207 * Returns an Int32 representation of this integer. | |
208 * | |
209 * Narrower values are sign-extended and wider values have their high bits | |
210 * truncated. | |
211 */ | |
212 Int32 toInt32(); | |
213 | |
214 /** Returns an Int64 representation of this integer. */ | |
215 Int64 toInt64(); | |
216 | |
217 /** | |
218 * Returns a string representing the value of this integer in decimal | |
219 * notation; example: `'13'`. | |
220 */ | |
221 String toString(); | |
222 | |
223 /** | |
224 * Returns a string representing the value of this integer in hexadecimal | |
225 * notation; example: `'0xd'`. | |
226 */ | |
227 String toHexString(); | |
228 | |
229 /** | |
230 * Returns a string representing the value of this integer in the given radix. | |
231 * | |
232 * [radix] must be an integer in the range 2 .. 16, inclusive. | |
233 */ | |
234 String toRadixString(int radix); | |
235 } | |
OLD | NEW |