Implementation of the Karatsuba algorithm for fast multiplication
-
Given two strings in binary notation we want to multiply them and return the value Simple approach is to multiply bits one by one which will give the time complexity of around O(n^2). To make it more efficient we will be using Karatsuba' algorithm to find the product which will solve the problem O(nlogn) of time.
- Author
- Swastika Gupta
+
Given two strings in binary notation we want to multiply them and return the value. Simple approach is to multiply bits one by one which will give the time complexity of around O(n^2). To make it more efficient we will be using Karatsuba algorithm to find the product which will solve the problem O(nlogn) of time.
- Author
- Swastika Gupta
+-
+Ameer Carlo Lubang
- | std::string divide_and_conquer::karatsuba_algorithm::addStrings |
+ std::string divide_and_conquer::karatsuba_algorithm::add_strings |
( |
std::string |
first, |
@@ -171,66 +176,64 @@ Functions
-
Helper function for the main function, that implements Karatsuba's algorithm for fast multiplication.
+
Binary addition.
- Parameters
-
- | first | the input string 1 |
- | second | the input string 2 |
+ | first,the | input string 1 |
+ | second,the | input string 2 |
-
- Returns
- the concatenated string
-
37 {
-
+
- Returns
- the sum binary string
+
37 {
+
39
-
40 int64_t len1 = first.
size();
-
41 int64_t len2 = second.
size();
-
42 int64_t length =
std::max(len1, len2);
+
40
+
41 int64_t len1 = first.
size();
+
42 int64_t len2 = second.
size();
-
44 if (len1 < len2)
-
45 {
-
46 for (int64_t i = 0; i < len2 - len1; i++) {
-
47 zero += first;
-
48 first = zero;
+
44 if (len1 < len2) {
+
45 for (int64_t i = 0; i < len2 - len1; i++) {
+
46 zero += first;
+
47 first = zero;
+
48 zero = "0";
49 }
50 } else if (len1 > len2) {
-
51 zero = "0";
-
52 for (int64_t i = 0; i < len1 - len2; i++) {
-
53 zero += second;
-
54 second = zero;
+
51 for (int64_t i = 0; i < len1 - len2; i++) {
+
52 zero += second;
+
53 second = zero;
+
54 zero = "0";
55 }
56 }
-
57 int64_t carry = 0;
-
58 for (int64_t i = length - 1; i >= 0; i--) {
-
59 int64_t firstBit = first.
at(i) -
'0';
-
60 int64_t secondBit = second.
at(i) -
'0';
-
61
-
62 int64_t
sum = (firstBit ^ secondBit ^ carry) +
'0';
-
-
-
-
-
67
-
68 carry = (firstBit & secondBit) | (secondBit & carry) |
-
69 (firstBit & carry);
-
70 }
-
71
-
72 if (carry) {
-
-
74 }
-
-
76}
+
57
+
58 int64_t length =
std::max(len1, len2);
+
59 int64_t carry = 0;
+
60 for (int64_t i = length - 1; i >= 0; i--) {
+
61 int64_t firstBit = first.
at(i) -
'0';
+
62 int64_t secondBit = second.
at(i) -
'0';
+
63
+
64 int64_t
sum = (char(firstBit ^ secondBit ^ carry)) +
'0';
+
+
66
+
67 carry = char((firstBit & secondBit) | (secondBit & carry) |
+
68 (firstBit & carry));
+
69 }
+
70
+
71 if (carry) {
+
+
73 }
+
+
75}
uint64_t result(uint64_t n)
Definition: fibonacci_sum.cpp:76
T sum(const std::vector< std::valarray< T > > &A)
Definition: vector_ops.hpp:232
-
-
@@ -270,56 +273,45 @@ Here is the call graph for this function:
-
- Returns
- the multiplicative number value
-
84 {
-
85 int64_t len1 = str1.
size();
-
86 int64_t len2 = str2.
size();
-
-
-
89 if (len1 < len2) {
-
90 for (int64_t i = 0; i < len2 - len1; i++) {
-
91 zero += str1;
-
92 str1 = zero;
-
93 }
-
94 } else if (len1 > len2) {
-
95 zero = "0";
-
96 for (int64_t i = 0; i < len1 - len2; i++) {
-
97 zero += str2;
-
98 str2 = zero;
-
99 }
-
100 }
-
101 if (n == 0) {
-
102 return 0;
-
103 }
-
104 if (n == 1) {
-
105 return (str1[0] - '0') * (str2[0] - '0');
-
106 }
-
107 int64_t fh = n / 2;
-
108 int64_t sh = (n - fh);
-
109
-
-
-
112
-
-
-
115
-
116
-
-
-
-
120 divide_and_conquer::karatsuba_algorithm::addStrings(Xl, Xr),
-
121 divide_and_conquer::karatsuba_algorithm::addStrings(Yl, Yr));
-
122
-
123 return product1 * (1 << (2 * sh)) +
-
124 (product3 - product1 - product2) * (1 << sh) +
-
125 product2;
-
126}
-
Functions for the Karatsuba algorithm for fast multiplication
-
+
- Returns
- the product number value
+
112 {
+
113 int64_t len1 = str1.
size();
+
114 int64_t len2 = str2.
size();
+
+
116
+
117 if (n == 0) {
+
118 return 0;
+
119 }
+
120 if (n == 1) {
+
121 return (str1[0] - '0') * (str2[0] - '0');
+
122 }
+
123
+
124 int64_t fh = n / 2;
+
125 int64_t sh = n - fh;
+
126
+
+
+
129
+
+
+
132
+
133
+
+
+
+
137 divide_and_conquer::karatsuba_algorithm::add_strings(Xl, Xr),
+
138 divide_and_conquer::karatsuba_algorithm::add_strings(Yl, Yr));
+
139
+
140 return product1 * (1 << (2 * sh)) +
+
141 (product3 - product1 - product2) * (1 << sh) +
+
142 product2;
+
143}
+
std::string safe_substr(const std::string &str, int64_t x1, int64_t x2, int64_t n)
Wrapper function for substr that considers leading zeros.
Definition: karatsuba_algorithm_for_fast_multiplication.cpp:86
+
Functions for the Karatsuba algorithm for fast multiplication implementation.
-
@@ -343,11 +335,11 @@ Here is the call graph for this function:
Main function.
- Returns
- 0 on exit
-
164 {
-
-
166 return 0;
-
167}
-
static void test()
Self-test implementations.
Definition: karatsuba_algorithm_for_fast_multiplication.cpp:134
+
181 {
+
+
183 return 0;
+
184}
+
static void test()
Self-test implementations.
Definition: karatsuba_algorithm_for_fast_multiplication.cpp:151
@@ -355,6 +347,85 @@ Here is the call graph for this function:
+
+
+
+
◆ safe_substr()
+
+
+
+
+
+ | std::string divide_and_conquer::karatsuba_algorithm::safe_substr |
+ ( |
+ const std::string & |
+ str, |
+
+
+ |
+ |
+ int64_t |
+ x1, |
+
+
+ |
+ |
+ int64_t |
+ x2, |
+
+
+ |
+ |
+ int64_t |
+ n |
+
+
+ |
+ ) |
+ | |
+
+
+
+
+
Wrapper function for substr that considers leading zeros.
+
- Parameters
-
+
+ | str,the | binary input string. |
+ | x1,the | substr parameter integer 1 |
+ | x2,the | substr parameter integer 2 |
+ | n,is | the length of the "whole" string: leading zeros + str |
+
+
+
+
- Returns
- the "safe" substring for the algorithm without leading zeros
+-
+"0" if substring spans to leading zeros only
+
86 {
+
87 int64_t len = str.
size();
+
88
+
89 if (len >= n) {
+
+
91 }
+
92
+
93 int64_t y1 = x1 - (n - len);
+
94 int64_t y2 = (x1 + x2 - 1) - (n - len);
+
95
+
96 if (y2 < 0) {
+
97 return "0";
+
98 } else if (y1 < 0) {
+
99 return str.
substr(0, y2 + 1);
+
100 } else {
+
101 return str.
substr(y1, x2);
+
102 }
+
103}
+
+
+
+
@@ -382,31 +453,31 @@ Here is the call graph for this function:
Self-test implementations.
134 {
-
135
-
-
-
-
139 assert(divide_and_conquer::karatsuba_algorithm::karatsuba_algorithm(
-
140 s11, s12) == 10);
-
-
142
-
143
-
-
-
-
147 assert(divide_and_conquer::karatsuba_algorithm::karatsuba_algorithm(
-
148 s21, s22) == 30);
-
-
150
-
151
-
-
-
-
155 assert(divide_and_conquer::karatsuba_algorithm::karatsuba_algorithm(
-
156 s31, s32) == 60);
-
-
158}
+
151 {
+
152
+
+
+
+
156 assert(divide_and_conquer::karatsuba_algorithm::karatsuba_algorithm(
+
157 s11, s12) == 10);
+
+
159
+
160
+
+
+
+
164 assert(divide_and_conquer::karatsuba_algorithm::karatsuba_algorithm(
+
165 s21, s22) == 30);
+
+
167
+
168
+
+
+
+
172 assert(divide_and_conquer::karatsuba_algorithm::karatsuba_algorithm(
+
173 s31, s32) == 60);
+
+
175}
diff --git a/globals_func_i.html b/globals_func_i.html
index 5adf40f08..08ae4645a 100644
--- a/globals_func_i.html
+++ b/globals_func_i.html
@@ -111,8 +111,8 @@ $(document).ready(function(){initNavTree('globals_func_i.html',''); initResizabl
is_happy() : happy_number.cpp
is_prime() : check_prime.cpp
is_square() : ordinary_least_squares_regressor.cpp
-
IsPrime() : primality_test.cpp
isPrime() : modular_inverse_fermat_little_theorem.cpp
+
IsPrime() : primality_test.cpp
it_ternary_search() : ternary_search.cpp