{"id":34864,"date":"2016-05-26T14:36:49","date_gmt":"2016-05-26T09:06:49","guid":{"rendered":"http:\/\/www.tothenew.com\/blog\/?p=34864"},"modified":"2024-01-02T17:46:24","modified_gmt":"2024-01-02T12:16:24","slug":"java-bitwise-operator-using-efficiently-to-improve-performance","status":"publish","type":"post","link":"https:\/\/www.tothenew.com\/blog\/java-bitwise-operator-using-efficiently-to-improve-performance\/","title":{"rendered":"Java Bitwise Operator using efficiently to improve Performance"},"content":{"rendered":"

Many of us know the various operators available in Java. But do we really use them all efficiently. Here I am illustrating one simple example which can show the high performance gain with bitwise operatator than the standard solution.<\/p>\n

Lets calculate the mathematical expression xn\u00a0<\/sup>i.e. x’s power n.<\/p>\n

To solve this problem anyone can easily say its just one loop with n\u00a0times and adding a in that loop. Thats very simple and fast. Really? Lets analyze it, we have just used O(n) complexity to find the result which means 820<\/sup> will take 20 loop iterations to calculate it.<\/p>\n

xn<\/sup> = x * x ...... * x (n times)\r\n<\/pre>\n
Do we really need so much iterations to calculate it?<\/p>\n
Following mathematical formula can help us to reduce the O(n) complexity\u00a0to O(log n) complexity<\/p>\n
\"Blog<\/p>\n
Bitwise operator can be used to achieve this by shifting the bits of power. Following sample code is self explainatory.<\/p>\n
[java]
\npublic class PowerAofB {
\n\tpublic static void main(String[] args) {
\n\t\t\/\/ Basic way with O(n)
\n\t\tint a = 9;
\n\t\tint b = 12;
\n\t\tlong result = 1;
\n\t\tfor (int i = 1; i <= b; i++) {
\n\t\t\t\tresult *= a;
\n\t\t}
\n\t\tSystem.out.println(result);<\/p>\n
\t\t\/\/ Efficient way with O(log n)
\n\t\tSystem.out.println(ipow(a,b));
\n\t}<\/p>\n
\tprivate static long ipow(int base, int exp)
\n\t{
\n\t    long result = 1;<\/p>\n
\t    while (exp != 0)
\n\t    {
\n\t    \tif ((exp & 1) == 1){
\n\t            result *= base;
\n\t    \t}
\n\t        \/\/right shifting bytes with sign 1 position
\n\t        \/\/equivalent of division of 2
\n\t        exp >>= 1;
\n\t        base *= base;
\n\t    }<\/p>\n
\t    return result;
\n\t}
\n}
\n[\/java]<\/p>\n
Comparison between basic approach and new approach<\/p>\n\n\n\n\n\n\n\n
Approach<\/td>\nExample<\/td>\niteration count<\/td>\nExecution time (nano seconds)<\/td>\n<\/tr>\n
Basic Way<\/td>\n1215<\/sup><\/small><\/td>\n15<\/td>\n1140<\/td>\n<\/tr>\n
Using Bitwise Operator<\/td>\n1215<\/sup><\/small><\/td>\n5<\/td>\n570<\/td>\n<\/tr>\n
Basic Way<\/td>\n4122<\/small><\/sup><\/td>\n122<\/td>\n4561<\/td>\n<\/tr>\n
Using Bitwise Operator<\/td>\n4122<\/small><\/sup><\/td>\n8<\/td>\n1710<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Image\u00a0Reference:\u00a0http:\/\/www.programminglogic.com\/fast-exponentiation-algorithms\/ <\/small><\/p>\n","protected":false},"excerpt":{"rendered":"
Many of us know the various operators available in Java. But do we really use them all efficiently. Here I am illustrating one simple example which can show the high performance gain with bitwise operatator than the standard solution. Lets calculate the mathematical expression xn\u00a0i.e. x’s power n. To solve this problem anyone can easily […]<\/p>\n","protected":false},"author":922,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":12,"footnotes":""},"categories":[446,1994,1],"tags":[3397,4844,3396,2683],"class_list":["post-34864","post","type-post","status-publish","format-standard","hentry","category-java","category-software-development","category-technology","tag-complexity","tag-java","tag-operators","tag-performance"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t