| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #ifndef _IGNITE_COMMON_BITS |
| #define _IGNITE_COMMON_BITS |
| |
| #include <stdint.h> |
| |
| #include <ignite/common/common.h> |
| #include <ignite/common/fixed_size_array.h> |
| |
| namespace ignite |
| { |
| namespace common |
| { |
| namespace bits |
| { |
| /** |
| * Maximum number of digits in uint64_t number. |
| */ |
| const int32_t UINT64_MAX_PRECISION = 20; |
| |
| /** |
| * Get number of trailing zero bits in the two's complement binary |
| * representation of the specified 32-bit int value. |
| * |
| * @param i The value whose bits are to be counted. |
| * @return The number of trailing zero bits in the two's complement |
| * binary representation of the specified 32-bit int value. |
| */ |
| IGNITE_IMPORT_EXPORT int32_t NumberOfTrailingZerosI32(int32_t i); |
| |
| /** |
| * Get number of trailing zero bits in the binary representation of the specified |
| * 32-bit unsigned int value. |
| * |
| * @param i The value whose bits are to be counted. |
| * @return The number of trailing zero bits in the binary representation |
| * of the specified 32-bit unsigned int value. |
| */ |
| IGNITE_IMPORT_EXPORT int32_t NumberOfTrailingZerosU32(uint32_t i); |
| |
| /** |
| * Get number of leading zero bits in the two's complement binary |
| * representation of the specified 32-bit int value. |
| * |
| * @param i The value whose bits are to be counted. |
| * @return The number of leading zero bits in the two's complement |
| * binary representation of the specified 32-bit int value. |
| */ |
| IGNITE_IMPORT_EXPORT int32_t NumberOfLeadingZerosI32(int32_t i); |
| |
| /** |
| * Get number of leading zero bits in the binary representation |
| * of the specified unsigned 32-bit int value. |
| * |
| * @param i The value whose bits are to be counted. |
| * @return The number of leading zero bits in the binary representation |
| * of the specified unsigned 32-bit int value. |
| */ |
| IGNITE_IMPORT_EXPORT int32_t NumberOfLeadingZerosU32(uint32_t i); |
| |
| /** |
| * Get number of leading zero bits in the two's complement binary |
| * representation of the specified 64-bit int value. |
| * |
| * @param i The value whose bits are to be counted. |
| * @return The number of leading zero bits in the two's complement |
| * binary representation of the specified 64-bit int value. |
| */ |
| IGNITE_IMPORT_EXPORT int32_t NumberOfLeadingZerosI64(int64_t i); |
| |
| /** |
| * Get number of leading zero bits in the two's complement binary |
| * representation of the specified 64-bit int value. |
| * |
| * @param i The value whose bits are to be counted. |
| * @return The number of leading zero bits in the two's complement |
| * binary representation of the specified 64-bit int value. |
| */ |
| IGNITE_IMPORT_EXPORT int32_t NumberOfLeadingZerosU64(uint64_t i); |
| |
| /** |
| * Get the number of one-bits in the two's complement binary |
| * representation of the specified 32-bit int value. |
| * |
| * @param i The value whose bits are to be counted. |
| * @return The number of one-bits in the two's complement binary |
| * representation of the specified 32-bit int value. |
| */ |
| IGNITE_IMPORT_EXPORT int32_t BitCountI32(int32_t i); |
| |
| /** |
| * Get bit length for the specified signed 32-bit int value. |
| * |
| * @param i The value to get bit length for. |
| * @return The number of significant bits in the two's complement binary |
| * representation of the specified 32-bit int value. |
| */ |
| IGNITE_IMPORT_EXPORT int32_t BitLengthI32(int32_t i); |
| |
| /** |
| * Get bit length for the specified unsigned 32-bit int value. |
| * |
| * @param i The value to get bit length for. |
| * @return The number of significant bits in the two's complement binary |
| * representation of the specified 32-bit int value. |
| */ |
| IGNITE_IMPORT_EXPORT int32_t BitLengthU32(uint32_t i); |
| |
| /** |
| * Calcutale capasity for required size. |
| * Rounds up to the nearest power of two. |
| * |
| * @param size Needed capasity. |
| * @return Recomended capasity to allocate. |
| */ |
| IGNITE_IMPORT_EXPORT int32_t GetCapasityForSize(int32_t size); |
| |
| /** |
| * Get the number of decimal digits of the integer value. |
| * |
| * @param x The value. |
| * @return The number of decimal digits of the integer value. |
| */ |
| IGNITE_IMPORT_EXPORT int32_t DigitLength(uint64_t x); |
| |
| /** |
| * Get n-th power of ten. |
| * |
| * @param n Power. Should be in range [0, UINT64_MAX_PRECISION] |
| * @return 10 pow n, if n is in range [0, UINT64_MAX_PRECISION]. |
| * Otherwise, behaviour is undefined. |
| */ |
| IGNITE_IMPORT_EXPORT uint64_t TenPowerU64(int32_t n); |
| |
| /** |
| * Get the signum function of the specified 64-bit integer value. |
| * The return value is -1 if the specified value is negative; 0 if the |
| * specified value is zero; and 1 if the specified value is positive. |
| * |
| * @param i the value whose signum is to be computed |
| * @return The signum function of the specified value. |
| */ |
| inline int32_t Signum64(int64_t i) |
| { |
| return (static_cast<uint64_t>(-i) >> 63) | (i >> 63); |
| } |
| |
| /** |
| * Makes single 64-bit integer number out of two 32-bit numbers. |
| * |
| * @param higher Higher bits part. |
| * @param lower Lower bits part. |
| * @return New 64-bit integer. |
| */ |
| inline uint64_t MakeU64(uint32_t higher, uint32_t lower) |
| { |
| return (static_cast<uint64_t>(higher) << 32) | lower; |
| } |
| |
| /** |
| * Makes single 64-bit integer number out of two 32-bit numbers. |
| * |
| * @param higher Higher bits part. |
| * @param lower Lower bits part. |
| * @return New 64-bit integer. |
| */ |
| inline int64_t MakeI64(uint32_t higher, uint32_t lower) |
| { |
| return static_cast<int64_t>(MakeU64(higher, lower)); |
| } |
| |
| /** |
| * Makes single 32-bit integer number out of two 32-bit numbers, |
| * shifted by specified number of bits. First number x is shifted |
| * to the left. |
| * x y |
| * [........][........] |
| * ^[........] |
| * n res |
| * |
| * @param x First part. |
| * @param y Second part. |
| * @param n Number of bits to shift. |
| * @return New 32-bit integer. |
| */ |
| inline uint32_t MakeU32(uint32_t x, uint32_t y, int32_t n) |
| { |
| return (x << n) | (y >> (32 - n)); |
| } |
| |
| /** |
| * Makes single 32-bit integer number out of two 32-bit numbers, |
| * shifted by specified number of bits. First number x is shifted |
| * to the left. |
| * x y |
| * [........][........] |
| * ^[........] |
| * n res |
| * |
| * @param x First part. |
| * @param y Second part. |
| * @param n Number of bits to shift. |
| * @return New 32-bit integer. |
| */ |
| inline int32_t MakeI32(uint32_t x, uint32_t y, int32_t n) |
| { |
| return static_cast<int32_t>(MakeU32(x, y, n)); |
| } |
| } |
| } |
| } |
| |
| #endif //_IGNITE_COMMON_BITS |
