Mac OS 9
Math64.h
Go to the documentation of this file.
1 
19 #ifndef __MATH64__
20 #define __MATH64__
21 
22 #ifndef __CONDITIONALMACROS__
23 #include <ConditionalMacros.h>
24 #endif
25 
26 #ifndef __MACTYPES__
27 #include <MacTypes.h>
28 #endif
29 
30 #if PRAGMA_ONCE
31 #pragma once
32 #endif
33 
34 #ifdef __cplusplus
35 extern "C"
36 {
37 #endif
38 
39 #if PRAGMA_IMPORT
40 #pragma import on
41 #endif
42 
43 #if PRAGMA_STRUCT_ALIGN
44 #pragma options align = mac68k
45 #elif PRAGMA_STRUCT_PACKPUSH
46 #pragma pack(push, 2)
47 #elif PRAGMA_STRUCT_PACK
48 #pragma pack(2)
49 #endif
50 
62  SInt64
63  S64Max(void);
64 #if TYPE_LONGLONG
65 #ifdef __cplusplus
66  inline SInt64 S64Max(void) { return 9223372036854775807LL; }
67 #else
68 #define S64Max() (9223372036854775807LL)
69 #endif
70 #endif
71 
72 #if defined(__MWERKS__) && (__MWERKS__ < 0x1800) && defined(S64Max)
74 #undef S64Max
75 #define S64Max() 9223372036854775807
76 #endif
88  SInt64
89  S64Min(void);
90 #if TYPE_LONGLONG
91 #ifdef __cplusplus
92  inline SInt64 S64Min(void) { return -S64Max() - 1; }
93 #else
94 #define S64Min() (-S64Max() - 1)
95 #endif
96 #endif
97 
111  SInt64
112  S64Add(SInt64 left, SInt64 right);
113 #if TYPE_LONGLONG
114 #ifdef __cplusplus
115  inline SInt64 S64Add(SInt64 left, SInt64 right)
116  {
117  return (SInt64)(left) + (SInt64)(right);
118  }
119 #else
120 #define S64Add(left, right) ((SInt64)(left) + (SInt64)(right))
121 #endif
122 #endif
123 
137  SInt64
138  S64Subtract(SInt64 left, SInt64 right);
139 #if TYPE_LONGLONG
140 #ifdef __cplusplus
141  inline SInt64 S64Subtract(SInt64 left, SInt64 right)
142  {
143  return (SInt64)(left) - (SInt64)(right);
144  }
145 #else
146 #define S64Subtract(left, right) ((SInt64)(left) - (SInt64)(right))
147 #endif
148 #endif
149 
163  SInt64
164  S64Negate(SInt64 value);
165 #if TYPE_LONGLONG
166 #ifdef __cplusplus
167  inline SInt64 S64Negate(SInt64 value) { return -(SInt64)(value); }
168 #else
169 #define S64Negate(value) (-(SInt64)(value))
170 #endif
171 #endif
172 
173 #if !TYPE_LONGLONG
188  SInt64
189  S64Absolute(SInt64 value);
190 #if TYPE_LONGLONG
191 #ifdef __cplusplus
192  inline SInt64 S64Absolute(SInt64 value) { return llabs((SInt64)value); }
193 #else
194 #define S64Absolute(value) (llabs((SInt64)value))
195 #endif
196 #endif
197 
198 #endif
214  SInt64
215  S64Multiply(SInt64 left, SInt64 right);
216 #if TYPE_LONGLONG
217 #ifdef __cplusplus
218  inline SInt64 S64Multiply(SInt64 left, SInt64 right)
219  {
220  return (SInt64)(left) * (SInt64)(right);
221  }
222 #else
223 #define S64Multiply(left, right) ((SInt64)(left) * (SInt64)(right))
224 #endif
225 #endif
226 
227 #if CALL_NOT_IN_CARBON
242  SInt64
243  S64Mod(SInt64 dividend, SInt64 divisor);
244 #if TYPE_LONGLONG
245 #ifdef __cplusplus
246  inline SInt64 S64Mod(SInt64 dividend, SInt64 divisor)
247  {
248  return (SInt64)(dividend) % (SInt64)(divisor);
249  }
250 #else
251 #define S64Mod(dividend, divisor) ((SInt64)(dividend) % (SInt64)(divisor))
252 #endif
253 #endif
254 
255 #endif
275  SInt64
276  S64Divide(SInt64 dividend, SInt64 divisor,
277  SInt64 *remainder);
278 #if TYPE_LONGLONG
279 #ifdef __cplusplus
280  inline SInt64 S64Divide(SInt64 dividend, SInt64 divisor, SInt64 *remainder)
281  {
282  return ((remainder) ? (*((SInt64 *)(remainder)) =
283  ((SInt64)(dividend) % (SInt64)(divisor)))
284  : 0),
285  ((SInt64)(dividend) / (SInt64)(divisor));
286  }
287 #else
288 #define S64Divide(dividend, divisor, remainder) \
289  (((remainder) ? (*((SInt64 *)(remainder)) = \
290  ((SInt64)(dividend) % (SInt64)(divisor))) \
291  : 0), \
292  ((SInt64)(dividend) / (SInt64)(divisor)))
293 #endif
294 #endif
295 
296 #ifdef __cplusplus
297  inline SInt64 S64Div(SInt64 dividend, SInt64 divisor)
298  {
299  return S64Divide((dividend), (divisor), NULL);
300  }
301 #else
302 #define S64Div(dividend, divisor) (S64Divide((dividend), (divisor), NULL))
303 #endif
304 
318  SInt64
319  S64Set(SInt32 value);
320 #if TYPE_LONGLONG
321 #ifdef __cplusplus
322  inline SInt64 S64Set(SInt32 value) { return (SInt64)(value); }
323 #else
324 #define S64Set(value) ((SInt64)(value))
325 #endif
326 #endif
327 
339  SInt64
340  S64SetU(UInt32 value);
341 #if TYPE_LONGLONG
342 #ifdef __cplusplus
343  inline SInt64 S64SetU(UInt32 value) { return (SInt64)(value); }
344 #else
345 #define S64SetU(value) ((SInt64)(value))
346 #endif
347 #endif
348 
361  SInt32
362  S32Set(SInt64 value);
363 #if TYPE_LONGLONG
364 #ifdef __cplusplus
365  inline SInt32 S32Set(SInt64 value) { return (SInt32)(value); }
366 #else
367 #define S32Set(value) ((SInt32)(value))
368 #endif
369 #endif
370 
382  Boolean
383  S64And(SInt64 left, SInt64 right);
384 #if TYPE_LONGLONG
385 #ifdef __cplusplus
386  inline Boolean S64And(SInt64 left, SInt64 right)
387  {
388  return (SInt64)(left) && (SInt64)(right);
389  }
390 #else
391 #define S64And(left, right) ((SInt64)(left) && (SInt64)(right))
392 #endif
393 #endif
394 
406  Boolean
407  S64Or(SInt64 left, SInt64 right);
408 #if TYPE_LONGLONG
409 #ifdef __cplusplus
410  inline Boolean S64Or(SInt64 left, SInt64 right)
411  {
412  return (SInt64)(left) || (SInt64)(right);
413  }
414 #else
415 #define S64Or(left, right) ((SInt64)(left) || (SInt64)(right))
416 #endif
417 #endif
418 
430  Boolean
431  S64Eor(SInt64 left, SInt64 right);
432 #if TYPE_LONGLONG
433 #ifdef __cplusplus
434  inline Boolean S64Eor(SInt64 left, SInt64 right)
435  {
436  return (Boolean)(((SInt64)(left) ? 1 : 0) ^ ((SInt64)(right) ? 1 : 0));
437  }
438 #else
439 #define S64Eor(left, right) \
440  ((Boolean)(((SInt64)(left) ? 1 : 0) ^ ((SInt64)(right) ? 1 : 0)))
441 #endif
442 #endif
443 
455  Boolean
456  S64Not(SInt64 value);
457 #if TYPE_LONGLONG
458 #ifdef __cplusplus
459  inline Boolean S64Not(SInt64 value) { return !((SInt64)(value)); }
460 #else
461 #define S64Not(value) (!((SInt64)(value)))
462 #endif
463 #endif
464 
485  SInt32
486  S64Compare(SInt64 left, SInt64 right);
487 
499  SInt64
500  S64BitwiseAnd(SInt64 left, SInt64 right);
501 #if TYPE_LONGLONG
502 #ifdef __cplusplus
503  inline SInt64 S64BitwiseAnd(SInt64 left, SInt64 right)
504  {
505  return (SInt64)(left) & (SInt64)(right);
506  }
507 #else
508 #define S64BitwiseAnd(left, right) ((SInt64)(left) & (SInt64)(right))
509 #endif
510 #endif
511 
523  SInt64
524  S64BitwiseOr(SInt64 left, SInt64 right);
525 #if TYPE_LONGLONG
526 #ifdef __cplusplus
527  inline SInt64 S64BitwiseOr(SInt64 left, SInt64 right)
528  {
529  return (SInt64)(left) | (SInt64)(right);
530  }
531 #else
532 #define S64BitwiseOr(left, right) ((SInt64)(left) | (SInt64)(right))
533 #endif
534 #endif
535 
547  SInt64
548  S64BitwiseEor(SInt64 left, SInt64 right);
549 #if TYPE_LONGLONG
550 #ifdef __cplusplus
551  inline SInt64 S64BitwiseEor(SInt64 left, SInt64 right)
552  {
553  return (SInt64)(left) ^ (SInt64)(right);
554  }
555 #else
556 #define S64BitwiseEor(left, right) ((SInt64)(left) ^ (SInt64)(right))
557 #endif
558 #endif
559 
571  SInt64
572  S64BitwiseNot(SInt64 value);
573 #if TYPE_LONGLONG
574 #ifdef __cplusplus
575  inline SInt64 S64BitwiseNot(SInt64 value) { return ~((SInt64)(value)); }
576 #else
577 #define S64BitwiseNot(value) (~((SInt64)(value)))
578 #endif
579 #endif
580 
592  SInt64
593  S64ShiftRight(SInt64 value, UInt32 shift);
594 #if TYPE_LONGLONG
595 #ifdef __cplusplus
596  inline SInt64 S64ShiftRight(SInt64 value, UInt32 shift)
597  {
598  return (SInt64)(value) >> ((shift) & 0x7F);
599  }
600 #else
601 #define S64ShiftRight(value, shift) ((SInt64)(value) >> ((shift) & 0x7F))
602 #endif
603 #endif
604 
616  SInt64
617  S64ShiftLeft(SInt64 value, UInt32 shift);
618 #if TYPE_LONGLONG
619 #ifdef __cplusplus
620  inline SInt64 S64ShiftLeft(SInt64 value, UInt32 shift)
621  {
622  return (SInt64)(value) << ((shift) & 0x7F);
623  }
624 #else
625 #define S64ShiftLeft(value, shift) ((SInt64)(value) << ((shift) & 0x7F))
626 #endif
627 #endif
628 
629 #if TYPE_LONGLONG || !TYPE_LONGDOUBLE_IS_DOUBLE
646  long double
647  SInt64ToLongDouble(SInt64 value);
648 #if TYPE_LONGLONG
649 #ifdef __cplusplus
650  inline long double SInt64ToLongDouble(SInt64 value)
651  {
652  return (long double)(value);
653  }
654 #else
655 #define SInt64ToLongDouble(value) ((long double)(value))
656 #endif
657 #endif
658 
675  SInt64
676  LongDoubleToSInt64(long double value);
677 #if TYPE_LONGLONG
678 #ifdef __cplusplus
679  inline SInt64 LongDoubleToSInt64(long double value) { return (SInt64)(value); }
680 #else
681 #define LongDoubleToSInt64(value) ((SInt64)(value))
682 #endif
683 #endif
684 
685 #endif
698  UInt64
699  U64Max(void);
700 #if TYPE_LONGLONG
701 #ifdef __cplusplus
702  inline UInt64 U64Max(void) { return 0xffffffffffffffffULL; }
703 #else
704 #define U64Max() (0xffffffffffffffffULL)
705 #endif
706 #endif
707 
708 #if defined(__MWERKS__) && (__MWERKS__ < 0x1800) && defined(U64Max)
710 #undef U64Max
711 #define U64Max() 0xffffffffffffffff
712 #endif
726  UInt64
727  U64Add(UInt64 left, UInt64 right);
728 #if TYPE_LONGLONG
729 #ifdef __cplusplus
730  inline UInt64 U64Add(UInt64 left, UInt64 right)
731  {
732  return (UInt64)(left) + (UInt64)(right);
733  }
734 #else
735 #define U64Add(left, right) ((UInt64)(left) + (UInt64)(right))
736 #endif
737 #endif
738 
752  UInt64
753  U64Subtract(UInt64 left, UInt64 right);
754 #if TYPE_LONGLONG
755 #ifdef __cplusplus
756  inline UInt64 U64Subtract(UInt64 left, UInt64 right)
757  {
758  return (UInt64)(left) - (UInt64)(right);
759  }
760 #else
761 #define U64Subtract(left, right) ((UInt64)(left) - (UInt64)(right))
762 #endif
763 #endif
764 
779  UInt64
780  U64Multiply(UInt64 left, UInt64 right);
781 #if TYPE_LONGLONG
782 #ifdef __cplusplus
783  inline UInt64 U64Multiply(UInt64 left, UInt64 right)
784  {
785  return (UInt64)(left) * (UInt64)(right);
786  }
787 #else
788 #define U64Multiply(left, right) ((UInt64)(left) * (UInt64)(right))
789 #endif
790 #endif
791 
792 #if CALL_NOT_IN_CARBON
807  UInt64
808  U64Mod(UInt64 dividend, UInt64 divisor);
809 #if TYPE_LONGLONG
810 #ifdef __cplusplus
811  inline UInt64 U64Mod(UInt64 dividend, UInt64 divisor)
812  {
813  return (UInt64)(dividend) % (UInt64)(divisor);
814  }
815 #else
816 #define U64Mod(dividend, divisor) ((UInt64)(dividend) % (UInt64)(divisor))
817 #endif
818 #endif
819 
820 #endif
840  UInt64
841  U64Divide(UInt64 dividend, UInt64 divisor,
842  UInt64 *remainder);
843 #if TYPE_LONGLONG
844 #ifdef __cplusplus
845  inline UInt64 U64Divide(UInt64 dividend, UInt64 divisor, UInt64 *remainder)
846  {
847  return ((remainder) ? (*((UInt64 *)(remainder)) =
848  ((UInt64)(dividend) % (UInt64)(divisor)))
849  : 0),
850  ((UInt64)(dividend) / (UInt64)(divisor));
851  }
852 #else
853 #define U64Divide(dividend, divisor, remainder) \
854  (((remainder) ? (*((UInt64 *)(remainder)) = \
855  ((UInt64)(dividend) % (UInt64)(divisor))) \
856  : 0), \
857  ((UInt64)(dividend) / (UInt64)(divisor)))
858 #endif
859 #endif
860 
861 #ifdef __cplusplus
862  inline UInt64 U64Div(UInt64 dividend, UInt64 divisor)
863  {
864  return U64Divide((dividend), (divisor), NULL);
865  }
866 #else
867 #define U64Div(dividend, divisor) (U64Divide((dividend), (divisor), NULL))
868 #endif
869 
883  UInt64
884  U64Set(SInt32 value);
885 #if TYPE_LONGLONG
886 #ifdef __cplusplus
887  inline UInt64 U64Set(SInt32 value) { return (UInt64)(value); }
888 #else
889 #define U64Set(value) ((UInt64)(value))
890 #endif
891 #endif
892 
904  UInt64
905  U64SetU(UInt32 value);
906 #if TYPE_LONGLONG
907 #ifdef __cplusplus
908  inline UInt64 U64SetU(UInt32 value) { return (UInt64)(value); }
909 #else
910 #define U64SetU(value) ((UInt64)(value))
911 #endif
912 #endif
913 
926  UInt32
927  U32SetU(UInt64 value);
928 #if TYPE_LONGLONG
929 #ifdef __cplusplus
930  inline UInt32 U32SetU(UInt64 value) { return (UInt32)(value); }
931 #else
932 #define U32SetU(value) ((UInt32)(value))
933 #endif
934 #endif
935 
947  Boolean
948  U64And(UInt64 left, UInt64 right);
949 #if TYPE_LONGLONG
950 #ifdef __cplusplus
951  inline Boolean U64And(UInt64 left, UInt64 right)
952  {
953  return (UInt64)(left) && (UInt64)(right);
954  }
955 #else
956 #define U64And(left, right) ((UInt64)(left) && (UInt64)(right))
957 #endif
958 #endif
959 
971  Boolean
972  U64Or(UInt64 left, UInt64 right);
973 #if TYPE_LONGLONG
974 #ifdef __cplusplus
975  inline Boolean U64Or(UInt64 left, UInt64 right)
976  {
977  return (UInt64)(left) || (UInt64)(right);
978  }
979 #else
980 #define U64Or(left, right) ((UInt64)(left) || (UInt64)(right))
981 #endif
982 #endif
983 
995  Boolean
996  U64Eor(UInt64 left, UInt64 right);
997 #if TYPE_LONGLONG
998 #ifdef __cplusplus
999  inline Boolean U64Eor(UInt64 left, UInt64 right)
1000  {
1001  return (Boolean)(((UInt64)(left) ? 1 : 0) ^ ((UInt64)(right) ? 1 : 0));
1002  }
1003 #else
1004 #define U64Eor(left, right) \
1005  ((Boolean)(((UInt64)(left) ? 1 : 0) ^ ((UInt64)(right) ? 1 : 0)))
1006 #endif
1007 #endif
1008 
1020  Boolean
1021  U64Not(UInt64 value);
1022 #if TYPE_LONGLONG
1023 #ifdef __cplusplus
1024  inline Boolean U64Not(UInt64 value) { return !((UInt64)(value)); }
1025 #else
1026 #define U64Not(value) (!((UInt64)(value)))
1027 #endif
1028 #endif
1029 
1050  SInt32
1051  U64Compare(UInt64 left, UInt64 right);
1052 
1064  UInt64
1065  U64BitwiseAnd(UInt64 left, UInt64 right);
1066 #if TYPE_LONGLONG
1067 #ifdef __cplusplus
1068  inline UInt64 U64BitwiseAnd(UInt64 left, UInt64 right)
1069  {
1070  return (UInt64)(left) & (UInt64)(right);
1071  }
1072 #else
1073 #define U64BitwiseAnd(left, right) ((UInt64)(left) & (UInt64)(right))
1074 #endif
1075 #endif
1076 
1088  UInt64
1089  U64BitwiseOr(UInt64 left, UInt64 right);
1090 #if TYPE_LONGLONG
1091 #ifdef __cplusplus
1092  inline UInt64 U64BitwiseOr(UInt64 left, UInt64 right)
1093  {
1094  return (UInt64)(left) | (UInt64)(right);
1095  }
1096 #else
1097 #define U64BitwiseOr(left, right) ((UInt64)(left) | (UInt64)(right))
1098 #endif
1099 #endif
1100 
1112  UInt64
1113  U64BitwiseEor(UInt64 left, UInt64 right);
1114 #if TYPE_LONGLONG
1115 #ifdef __cplusplus
1116  inline UInt64 U64BitwiseEor(UInt64 left, UInt64 right)
1117  {
1118  return (UInt64)(left) ^ (UInt64)(right);
1119  }
1120 #else
1121 #define U64BitwiseEor(left, right) ((UInt64)(left) ^ (UInt64)(right))
1122 #endif
1123 #endif
1124 
1136  UInt64
1137  U64BitwiseNot(UInt64 value);
1138 #if TYPE_LONGLONG
1139 #ifdef __cplusplus
1140  inline UInt64 U64BitwiseNot(UInt64 value) { return ~((UInt64)(value)); }
1141 #else
1142 #define U64BitwiseNot(value) (~((UInt64)(value)))
1143 #endif
1144 #endif
1145 
1157  UInt64
1158  U64ShiftRight(UInt64 value, UInt32 shift);
1159 #if TYPE_LONGLONG
1160 #ifdef __cplusplus
1161  inline UInt64 U64ShiftRight(UInt64 value, UInt32 shift)
1162  {
1163  return (UInt64)(value) >> ((shift) & 0x7F);
1164  }
1165 #else
1166 #define U64ShiftRight(value, shift) ((UInt64)(value) >> ((shift) & 0x7F))
1167 #endif
1168 #endif
1169 
1181  UInt64
1182  U64ShiftLeft(UInt64 value, UInt32 shift);
1183 #if TYPE_LONGLONG
1184 #ifdef __cplusplus
1185  inline UInt64 U64ShiftLeft(UInt64 value, UInt32 shift)
1186  {
1187  return (UInt64)(value) << ((shift) & 0x7F);
1188  }
1189 #else
1190 #define U64ShiftLeft(value, shift) ((UInt64)(value) << ((shift) & 0x7F))
1191 #endif
1192 #endif
1193 
1194 #if TYPE_LONGLONG || !TYPE_LONGDOUBLE_IS_DOUBLE
1207  long double
1208  UInt64ToLongDouble(UInt64 value);
1209 #if TYPE_LONGLONG
1210 #ifdef __cplusplus
1211  inline long double UInt64ToLongDouble(UInt64 value)
1212  {
1213  return (long double)(value);
1214  }
1215 #else
1216 #define UInt64ToLongDouble(value) ((long double)(value))
1217 #endif
1218 #endif
1219 
1232  UInt64
1233  LongDoubleToUInt64(long double value);
1234 #if TYPE_LONGLONG
1235 #ifdef __cplusplus
1236  inline UInt64 LongDoubleToUInt64(long double value) { return (UInt64)(value); }
1237 #else
1238 #define LongDoubleToUInt64(value) ((UInt64)(value))
1239 #endif
1240 #endif
1241 
1242 #endif
1255  SInt64
1256  UInt64ToSInt64(UInt64 value);
1257 #if TYPE_LONGLONG
1258 #ifdef __cplusplus
1259  inline SInt64 UInt64ToSInt64(UInt64 value) { return (SInt64)(value); }
1260 #else
1261 #define UInt64ToSInt64(value) ((SInt64)(value))
1262 #endif
1263 #endif
1264 
1276  UInt64
1277  SInt64ToUInt64(SInt64 value);
1278 #if TYPE_LONGLONG
1279 #ifdef __cplusplus
1280  inline UInt64 SInt64ToUInt64(SInt64 value) { return (UInt64)(value); }
1281 #else
1282 #define SInt64ToUInt64(value) ((UInt64)(value))
1283 #endif
1284 #endif
1285 
1307 #if TYPE_LONGLONG
1308 #define SInt64ToWide(x) (*((wide *)(&x)))
1309 #define WideToSInt64(x) (*((SInt64 *)(&x)))
1310 #define UInt64ToUnsignedWide(x) (*((UnsignedWide *)(&x)))
1311 #define UnsignedWideToUInt64(x) (*((UInt64 *)(&x)))
1312 #else
1313 #define SInt64ToWide(x) (x)
1314 #define WideToSInt64(x) (x)
1315 #define UInt64ToUnsignedWide(x) (x)
1316 #define UnsignedWideToUInt64(x) (x)
1317 #endif
1318 
1319 #if PRAGMA_STRUCT_ALIGN
1320 #pragma options align = reset
1321 #elif PRAGMA_STRUCT_PACKPUSH
1322 #pragma pack(pop)
1323 #elif PRAGMA_STRUCT_PACK
1324 #pragma pack()
1325 #endif
1326 
1327 #ifdef PRAGMA_IMPORT_OFF
1328 #pragma import off
1329 #elif PRAGMA_IMPORT
1330 #pragma import reset
1331 #endif
1332 
1333 #ifdef __cplusplus
1334 }
1335 #endif
1336 
1337 #endif
ConditionalMacros.h
Set up for compiler independent conditionals.
MacTypes.h
Basic Macintosh data types.
NULL
#define NULL
Definition: MacTypes.h:61
Boolean
unsigned char Boolean
Definition: MacTypes.h:318
SInt64
wide SInt64
Definition: MacTypes.h:139
U64BitwiseNot
UInt64 U64BitwiseNot(UInt64 value)
U64Max
UInt64 U64Max(void)
U64Compare
SInt32 U64Compare(UInt64 left, UInt64 right)
S64ShiftLeft
SInt64 S64ShiftLeft(SInt64 value, UInt32 shift)
S64BitwiseNot
SInt64 S64BitwiseNot(SInt64 value)
S64Eor
Boolean S64Eor(SInt64 left, SInt64 right)
S64Or
Boolean S64Or(SInt64 left, SInt64 right)
SInt64ToUInt64
UInt64 SInt64ToUInt64(SInt64 value)
S64And
Boolean S64And(SInt64 left, SInt64 right)
S64Mod
SInt64 S64Mod(SInt64 dividend, SInt64 divisor)
S64ShiftRight
SInt64 S64ShiftRight(SInt64 value, UInt32 shift)
S64Div
#define S64Div(dividend, divisor)
Definition: Math64.h:302
U64BitwiseOr
UInt64 U64BitwiseOr(UInt64 left, UInt64 right)
S64Compare
SInt32 S64Compare(SInt64 left, SInt64 right)
S64Negate
SInt64 S64Negate(SInt64 value)
U64Mod
UInt64 U64Mod(UInt64 dividend, UInt64 divisor)
S32Set
SInt32 S32Set(SInt64 value)
S64Add
SInt64 S64Add(SInt64 left, SInt64 right)
U64Div
#define U64Div(dividend, divisor)
Definition: Math64.h:867
U64Add
UInt64 U64Add(UInt64 left, UInt64 right)
U64Subtract
UInt64 U64Subtract(UInt64 left, UInt64 right)
S64Absolute
SInt64 S64Absolute(SInt64 value)
U32SetU
UInt32 U32SetU(UInt64 value)
U64Divide
UInt64 U64Divide(UInt64 dividend, UInt64 divisor, UInt64 *remainder)
U64Or
Boolean U64Or(UInt64 left, UInt64 right)
S64SetU
SInt64 S64SetU(UInt32 value)
U64Multiply
UInt64 U64Multiply(UInt64 left, UInt64 right)
U64BitwiseAnd
UInt64 U64BitwiseAnd(UInt64 left, UInt64 right)
U64Eor
Boolean U64Eor(UInt64 left, UInt64 right)
U64SetU
UInt64 U64SetU(UInt32 value)
S64Multiply
SInt64 S64Multiply(SInt64 left, SInt64 right)
U64Not
Boolean U64Not(UInt64 value)
U64ShiftRight
UInt64 U64ShiftRight(UInt64 value, UInt32 shift)
S64Not
Boolean S64Not(SInt64 value)
S64BitwiseEor
SInt64 S64BitwiseEor(SInt64 left, SInt64 right)
UInt64ToSInt64
SInt64 UInt64ToSInt64(UInt64 value)
U64Set
UInt64 U64Set(SInt32 value)
U64And
Boolean U64And(UInt64 left, UInt64 right)
U64BitwiseEor
UInt64 U64BitwiseEor(UInt64 left, UInt64 right)
S64Max
SInt64 S64Max(void)
S64Divide
SInt64 S64Divide(SInt64 dividend, SInt64 divisor, SInt64 *remainder)
S64BitwiseOr
SInt64 S64BitwiseOr(SInt64 left, SInt64 right)
S64Subtract
SInt64 S64Subtract(SInt64 left, SInt64 right)
S64Set
SInt64 S64Set(SInt32 value)
S64Min
SInt64 S64Min(void)
U64ShiftLeft
UInt64 U64ShiftLeft(UInt64 value, UInt32 shift)
S64BitwiseAnd
SInt64 S64BitwiseAnd(SInt64 left, SInt64 right)
UnsignedWide
Definition: MacTypes.h:110
wide
Definition: MacTypes.h:104