Explore all topics

Quantum Computing

Explore all libraries in Quantum Computing

Explore Kits

Explore all topics

Quantum Computing

Explore all libraries in Quantum Computing

Explore Kits

Explore all topics

Quantum Computing

Explore all libraries in Quantum Computing

Explore Kits

Explore all topics

Quantum Computing

Explore all libraries in Quantum Computing

Explore all Quantum Computing open source software, libraries, packages, source code, cloud functions and APIs.

Popular New Releases in Quantum Computing

No Popular Releases are available at this moment for Quantum Computing

Popular Libraries in Quantum Computing

No Trending Libraries are available at this moment for Quantum Computing

Explore all libraries in Quantum Computing

Trending New libraries in Quantum Computing

No Trending Libraries are available at this moment for Quantum Computing

Top Authors in Quantum Computing

No Top Authors are available at this moment for Quantum Computing.

Trending Kits in Quantum Computing

No Trending Kits are available at this moment for Quantum Computing

Trending Discussions on Quantum Computing

I am trying to build a website according to the "Holy Grail Layout" and I cannot get it to look good on my phone

How does Elasticsearch aggregate or weight scores from two sub queries ("bool query" and "decay function")

Cannot create Q# projects

Quantum computing vs traditional base10 systems

Distance Estimation Using Quantum Computer

In quantum computing is there a preference to usage of little endian or big endian?

how to only replace \n which has some char after that

Curated WebAssembly CDN

Polynomial Equations in Q# E=MC^2

Fastest way for boolean matrix computations

QUESTION

I am trying to build a website according to the "Holy Grail Layout" and I cannot get it to look good on my phone

Asked 2022-Mar-12 at 22:30

I am building a website using the Holy Grail Layout and while it looks fine currently on my laptop and desktop computers, it looks terrible on my phone and does not resize correctly at all. I cannot even see half of the page despite having a media query to try and address this as well as using dynamically sized HTML elements in the rest of my CSS. Here is my code, I am not sure what my issue is currently as my media query doesn't seem to do anything.

1&lt;!DOCTYPE html&gt;
2&lt;html&gt;
3&lt;head&gt;
4&lt;meta charset=&quot;UTF-8&quot;&gt;
5&lt;meta http-equiv=&quot;X-UA-Compatible&quot; content=&quot;IE=edge&quot;&gt;
6&lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1.0&quot;&gt;
7&lt;script&gt;
8const originalAlpha = &quot;abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;;
9// rot13
10var rot13 = function() {
11    var the_text = document.getElementById(&quot;main_text&quot;).value;
12    the_text = the_text.replace(/[a-z]/gi, letter =&gt; String.fromCharCode(letter.charCodeAt(0) + (letter.toLowerCase() &lt;= 'm' ? 13 : -13)));
13    document.getElementById(&quot;output_text&quot;).innerHTML=the_text;
14};
15&lt;/script&gt;
16&lt;style&gt;
17@import url('https://fonts.googleapis.com/css2?family=Libre+Baskerville&amp;family=ZCOOL+QingKe+HuangYou&amp;display=swap');
18
19html {
20    width: 100%;
21    height: 100%;
22    overflow: hidden;
23}
24
25/* Use a media query to add a breakpoint at 800px: */
26@media screen and (max-width: 800px) {
27    html, body {
28        aspect-ratio: 1024/768;
29        width: 100%;
30        height: 100%;
31        overflow: hidden;
32    }
33}
34
35.item1 { grid-area: header; }
36.item2 { grid-area: menu; }
37.item3 { grid-area: main; }
38.item4 { grid-area: right; }
39.item5 { grid-area: footer; }
40
41.grid-container {
42  display: grid;
43  grid-template-areas:
44    'header header header header header header'
45    'menu main main main right right'
46    'menu footer footer footer footer footer';
47  gap: 10px;
48  background-color:seashell;
49  padding: 10px;
50}
51
52.grid-container &gt; div {
53  background-color: rgb(57, 61, 66, 0.4);
54  text-align: center;
55  padding: 20px 0;
56}
57
58.plaintext-form {
59    flex-flow:row wrap;
60    align-content:center;
61    text-align: justify;
62    justify-content: center;
63    margin: 2%;
64    padding: 2%;
65    width: 80%;
66    height: 80%;
67    font-family: 'Libre Baskerville', sans-serif;
68}
69
70ul {
71    padding-top: 5px;
72    padding-right: 30px;
73    position: relative;
74    justify-self: center;
75    text-align: center;
76    align-self: center;
77    flex-flow: column wrap;
78    align-content: center;
79    width: auto;
80    margin:0 auto;
81}
82
83li {
84    display: block;
85    margin: 20px;
86    padding: 15px;
87    height: 100%;
88    font-size: 21px;
89}
90
91a {
92    color:slateblue;
93}
94
95p {
96    background-color: rgb(57, 61, 66, 0.4);
97    height: 200px;
98    width: auto;
99    margin: 0 auto;
100    padding: 20px;
101    text-align:justify;
102    color:gainsboro;
103    font-family: 'Libre Baskerville', sans-serif;
104}
105
106footer {
107    flex-flow:row wrap;
108    align-content:center;
109    text-align: center;
110    justify-content: center;
111    margin: 2%;
112    padding: 2%;
113}
114&lt;/style&gt;
115&lt;title&gt;ROT13 Cipher Machine&lt;/title&gt;
116&lt;/head&gt;
117&lt;body&gt;
118&lt;div class=&quot;grid-container&quot;&gt;
119  &lt;div class=&quot;item1&quot;&gt;
120    &lt;h1 class=&quot;page_title&quot;&gt;ROT13 Cipher Machine&lt;/h1&gt;
121  &lt;/div&gt;
122  &lt;div class=&quot;item2&quot;&gt;
123    &lt;div class=&quot;navbar&quot;&gt;
124        &lt;header role=&quot;navigation&quot;&gt;
125            &lt;nav class=&quot;site-nav&quot;&gt;
126                &lt;ul id=&quot;site-links&quot;&gt;
127                    &lt;li id=&quot;homework&quot;&gt;&lt;a href=&quot;./cs212/homework/&quot;&gt;Homework&lt;/a&gt;&lt;/li&gt;
128                    &lt;li id=&quot;crypto&quot;&gt;&lt;a href=&quot;./docs/Cryptography/index.html&quot;&gt;Cryptography&lt;/a&gt;&lt;/li&gt;
129                    &lt;!-- &lt;li id=&quot;networking&quot;&gt;&lt;a href=&quot;./docs/network-programming.html&quot;&gt;Network Programming&lt;/a&gt;&lt;/li&gt;
130                    &lt;li id=&quot;quantum-computing&quot;&gt;&lt;a href=&quot;./docs/quantum-computing.html&quot;&gt;Quantum Computing&lt;/a&gt;&lt;/li&gt; --&gt;
131                    &lt;li id=&quot;minecraft&quot;&gt;&lt;a href=&quot;./docs/minecraft.html&quot;&gt;Minecraft&lt;/a&gt;&lt;/li&gt;
132                &lt;/ul&gt;
133            &lt;/nav&gt;
134        &lt;/header&gt;
135    &lt;/div&gt;
136  &lt;/div&gt;
137  &lt;div class=&quot;item3&quot;&gt;
138        &lt;form id=&quot;input_text&quot;&gt;
139            Plaintext/Ciphertext: &lt;input class=&quot;plaintext-form&quot; type=&quot;text&quot; placeholder=&quot;Type&quot; id=&quot;main_text&quot;&gt;&lt;br&gt;&lt;br&gt;
140            &lt;input type=&quot;button&quot; onclick=&quot;rot13()&quot; value=&quot;Submit&quot;&gt;
141        &lt;/form&gt;
142  &lt;/div&gt;  
143  &lt;div class=&quot;item4&quot;&gt;
144        &lt;h4&gt;Output:&lt;/h4&gt;
145        &lt;p id=&quot;output_text&quot;&gt;&lt;/p&gt;
146  &lt;/div&gt;
147  &lt;hr&gt;
148  &lt;div class=&quot;item5&quot;&gt;
149    &lt;section class=&quot;rot13-about&quot;&gt;
150        The ROT13 Algorithm is a symmetric cipher algorithm; simply put:
151        &lt;br&gt;&lt;br&gt;
152        &lt;code&gt;
153        ROT13(plaintext) = ciphertext, rot13(ciphertext) = plaintext 
154        &lt;/code&gt;
155        &lt;br&gt;&lt;br&gt;
156        Try it out yourself for some simple text obfuscation!
157    &lt;/section&gt;
158  &lt;/div&gt;
159&lt;/div&gt;
160
161&lt;/body&gt;
162&lt;/html&gt;
163

I personally prefer flexboxes over CSS grid and find the grid to be terribly confusing. Maybe I am using it wrong, but I have to use both for my assignment.

Edit: I added a 600px breakpoint and it still cuts off over half the screen, this can be seen in the screenshot below.

phone screenshot

I am so tired of making sites that should fit with responsive design practices and then seeing them never work for me. I have media queries, I have dynamic sizing with %'s, I have a combo of a grid and flexboxes. Nothing about that should cause it to cut half my site off on mobile screens and I cannot understand what would be the cause at this point. Everything I look up indicates these are the things I should be doing to make it responsive yet it never works for me.

ANSWER

Answered 2022-Mar-12 at 21:33

Your media query only has one break point at 800px;

1&lt;!DOCTYPE html&gt;
2&lt;html&gt;
3&lt;head&gt;
4&lt;meta charset=&quot;UTF-8&quot;&gt;
5&lt;meta http-equiv=&quot;X-UA-Compatible&quot; content=&quot;IE=edge&quot;&gt;
6&lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1.0&quot;&gt;
7&lt;script&gt;
8const originalAlpha = &quot;abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;;
9// rot13
10var rot13 = function() {
11    var the_text = document.getElementById(&quot;main_text&quot;).value;
12    the_text = the_text.replace(/[a-z]/gi, letter =&gt; String.fromCharCode(letter.charCodeAt(0) + (letter.toLowerCase() &lt;= 'm' ? 13 : -13)));
13    document.getElementById(&quot;output_text&quot;).innerHTML=the_text;
14};
15&lt;/script&gt;
16&lt;style&gt;
17@import url('https://fonts.googleapis.com/css2?family=Libre+Baskerville&amp;family=ZCOOL+QingKe+HuangYou&amp;display=swap');
18
19html {
20    width: 100%;
21    height: 100%;
22    overflow: hidden;
23}
24
25/* Use a media query to add a breakpoint at 800px: */
26@media screen and (max-width: 800px) {
27    html, body {
28        aspect-ratio: 1024/768;
29        width: 100%;
30        height: 100%;
31        overflow: hidden;
32    }
33}
34
35.item1 { grid-area: header; }
36.item2 { grid-area: menu; }
37.item3 { grid-area: main; }
38.item4 { grid-area: right; }
39.item5 { grid-area: footer; }
40
41.grid-container {
42  display: grid;
43  grid-template-areas:
44    'header header header header header header'
45    'menu main main main right right'
46    'menu footer footer footer footer footer';
47  gap: 10px;
48  background-color:seashell;
49  padding: 10px;
50}
51
52.grid-container &gt; div {
53  background-color: rgb(57, 61, 66, 0.4);
54  text-align: center;
55  padding: 20px 0;
56}
57
58.plaintext-form {
59    flex-flow:row wrap;
60    align-content:center;
61    text-align: justify;
62    justify-content: center;
63    margin: 2%;
64    padding: 2%;
65    width: 80%;
66    height: 80%;
67    font-family: 'Libre Baskerville', sans-serif;
68}
69
70ul {
71    padding-top: 5px;
72    padding-right: 30px;
73    position: relative;
74    justify-self: center;
75    text-align: center;
76    align-self: center;
77    flex-flow: column wrap;
78    align-content: center;
79    width: auto;
80    margin:0 auto;
81}
82
83li {
84    display: block;
85    margin: 20px;
86    padding: 15px;
87    height: 100%;
88    font-size: 21px;
89}
90
91a {
92    color:slateblue;
93}
94
95p {
96    background-color: rgb(57, 61, 66, 0.4);
97    height: 200px;
98    width: auto;
99    margin: 0 auto;
100    padding: 20px;
101    text-align:justify;
102    color:gainsboro;
103    font-family: 'Libre Baskerville', sans-serif;
104}
105
106footer {
107    flex-flow:row wrap;
108    align-content:center;
109    text-align: center;
110    justify-content: center;
111    margin: 2%;
112    padding: 2%;
113}
114&lt;/style&gt;
115&lt;title&gt;ROT13 Cipher Machine&lt;/title&gt;
116&lt;/head&gt;
117&lt;body&gt;
118&lt;div class=&quot;grid-container&quot;&gt;
119  &lt;div class=&quot;item1&quot;&gt;
120    &lt;h1 class=&quot;page_title&quot;&gt;ROT13 Cipher Machine&lt;/h1&gt;
121  &lt;/div&gt;
122  &lt;div class=&quot;item2&quot;&gt;
123    &lt;div class=&quot;navbar&quot;&gt;
124        &lt;header role=&quot;navigation&quot;&gt;
125            &lt;nav class=&quot;site-nav&quot;&gt;
126                &lt;ul id=&quot;site-links&quot;&gt;
127                    &lt;li id=&quot;homework&quot;&gt;&lt;a href=&quot;./cs212/homework/&quot;&gt;Homework&lt;/a&gt;&lt;/li&gt;
128                    &lt;li id=&quot;crypto&quot;&gt;&lt;a href=&quot;./docs/Cryptography/index.html&quot;&gt;Cryptography&lt;/a&gt;&lt;/li&gt;
129                    &lt;!-- &lt;li id=&quot;networking&quot;&gt;&lt;a href=&quot;./docs/network-programming.html&quot;&gt;Network Programming&lt;/a&gt;&lt;/li&gt;
130                    &lt;li id=&quot;quantum-computing&quot;&gt;&lt;a href=&quot;./docs/quantum-computing.html&quot;&gt;Quantum Computing&lt;/a&gt;&lt;/li&gt; --&gt;
131                    &lt;li id=&quot;minecraft&quot;&gt;&lt;a href=&quot;./docs/minecraft.html&quot;&gt;Minecraft&lt;/a&gt;&lt;/li&gt;
132                &lt;/ul&gt;
133            &lt;/nav&gt;
134        &lt;/header&gt;
135    &lt;/div&gt;
136  &lt;/div&gt;
137  &lt;div class=&quot;item3&quot;&gt;
138        &lt;form id=&quot;input_text&quot;&gt;
139            Plaintext/Ciphertext: &lt;input class=&quot;plaintext-form&quot; type=&quot;text&quot; placeholder=&quot;Type&quot; id=&quot;main_text&quot;&gt;&lt;br&gt;&lt;br&gt;
140            &lt;input type=&quot;button&quot; onclick=&quot;rot13()&quot; value=&quot;Submit&quot;&gt;
141        &lt;/form&gt;
142  &lt;/div&gt;  
143  &lt;div class=&quot;item4&quot;&gt;
144        &lt;h4&gt;Output:&lt;/h4&gt;
145        &lt;p id=&quot;output_text&quot;&gt;&lt;/p&gt;
146  &lt;/div&gt;
147  &lt;hr&gt;
148  &lt;div class=&quot;item5&quot;&gt;
149    &lt;section class=&quot;rot13-about&quot;&gt;
150        The ROT13 Algorithm is a symmetric cipher algorithm; simply put:
151        &lt;br&gt;&lt;br&gt;
152        &lt;code&gt;
153        ROT13(plaintext) = ciphertext, rot13(ciphertext) = plaintext 
154        &lt;/code&gt;
155        &lt;br&gt;&lt;br&gt;
156        Try it out yourself for some simple text obfuscation!
157    &lt;/section&gt;
158  &lt;/div&gt;
159&lt;/div&gt;
160
161&lt;/body&gt;
162&lt;/html&gt;
163@media screen and (max-width: 800px) {
164    html, body {
165        aspect-ratio: 1024/768;
166        width: 100%;
167        height: 100%;
168        overflow: hidden;
169    }
170}
171

You would need to add another break point for cell phone screens such as

1&lt;!DOCTYPE html&gt;
2&lt;html&gt;
3&lt;head&gt;
4&lt;meta charset=&quot;UTF-8&quot;&gt;
5&lt;meta http-equiv=&quot;X-UA-Compatible&quot; content=&quot;IE=edge&quot;&gt;
6&lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1.0&quot;&gt;
7&lt;script&gt;
8const originalAlpha = &quot;abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;;
9// rot13
10var rot13 = function() {
11    var the_text = document.getElementById(&quot;main_text&quot;).value;
12    the_text = the_text.replace(/[a-z]/gi, letter =&gt; String.fromCharCode(letter.charCodeAt(0) + (letter.toLowerCase() &lt;= 'm' ? 13 : -13)));
13    document.getElementById(&quot;output_text&quot;).innerHTML=the_text;
14};
15&lt;/script&gt;
16&lt;style&gt;
17@import url('https://fonts.googleapis.com/css2?family=Libre+Baskerville&amp;family=ZCOOL+QingKe+HuangYou&amp;display=swap');
18
19html {
20    width: 100%;
21    height: 100%;
22    overflow: hidden;
23}
24
25/* Use a media query to add a breakpoint at 800px: */
26@media screen and (max-width: 800px) {
27    html, body {
28        aspect-ratio: 1024/768;
29        width: 100%;
30        height: 100%;
31        overflow: hidden;
32    }
33}
34
35.item1 { grid-area: header; }
36.item2 { grid-area: menu; }
37.item3 { grid-area: main; }
38.item4 { grid-area: right; }
39.item5 { grid-area: footer; }
40
41.grid-container {
42  display: grid;
43  grid-template-areas:
44    'header header header header header header'
45    'menu main main main right right'
46    'menu footer footer footer footer footer';
47  gap: 10px;
48  background-color:seashell;
49  padding: 10px;
50}
51
52.grid-container &gt; div {
53  background-color: rgb(57, 61, 66, 0.4);
54  text-align: center;
55  padding: 20px 0;
56}
57
58.plaintext-form {
59    flex-flow:row wrap;
60    align-content:center;
61    text-align: justify;
62    justify-content: center;
63    margin: 2%;
64    padding: 2%;
65    width: 80%;
66    height: 80%;
67    font-family: 'Libre Baskerville', sans-serif;
68}
69
70ul {
71    padding-top: 5px;
72    padding-right: 30px;
73    position: relative;
74    justify-self: center;
75    text-align: center;
76    align-self: center;
77    flex-flow: column wrap;
78    align-content: center;
79    width: auto;
80    margin:0 auto;
81}
82
83li {
84    display: block;
85    margin: 20px;
86    padding: 15px;
87    height: 100%;
88    font-size: 21px;
89}
90
91a {
92    color:slateblue;
93}
94
95p {
96    background-color: rgb(57, 61, 66, 0.4);
97    height: 200px;
98    width: auto;
99    margin: 0 auto;
100    padding: 20px;
101    text-align:justify;
102    color:gainsboro;
103    font-family: 'Libre Baskerville', sans-serif;
104}
105
106footer {
107    flex-flow:row wrap;
108    align-content:center;
109    text-align: center;
110    justify-content: center;
111    margin: 2%;
112    padding: 2%;
113}
114&lt;/style&gt;
115&lt;title&gt;ROT13 Cipher Machine&lt;/title&gt;
116&lt;/head&gt;
117&lt;body&gt;
118&lt;div class=&quot;grid-container&quot;&gt;
119  &lt;div class=&quot;item1&quot;&gt;
120    &lt;h1 class=&quot;page_title&quot;&gt;ROT13 Cipher Machine&lt;/h1&gt;
121  &lt;/div&gt;
122  &lt;div class=&quot;item2&quot;&gt;
123    &lt;div class=&quot;navbar&quot;&gt;
124        &lt;header role=&quot;navigation&quot;&gt;
125            &lt;nav class=&quot;site-nav&quot;&gt;
126                &lt;ul id=&quot;site-links&quot;&gt;
127                    &lt;li id=&quot;homework&quot;&gt;&lt;a href=&quot;./cs212/homework/&quot;&gt;Homework&lt;/a&gt;&lt;/li&gt;
128                    &lt;li id=&quot;crypto&quot;&gt;&lt;a href=&quot;./docs/Cryptography/index.html&quot;&gt;Cryptography&lt;/a&gt;&lt;/li&gt;
129                    &lt;!-- &lt;li id=&quot;networking&quot;&gt;&lt;a href=&quot;./docs/network-programming.html&quot;&gt;Network Programming&lt;/a&gt;&lt;/li&gt;
130                    &lt;li id=&quot;quantum-computing&quot;&gt;&lt;a href=&quot;./docs/quantum-computing.html&quot;&gt;Quantum Computing&lt;/a&gt;&lt;/li&gt; --&gt;
131                    &lt;li id=&quot;minecraft&quot;&gt;&lt;a href=&quot;./docs/minecraft.html&quot;&gt;Minecraft&lt;/a&gt;&lt;/li&gt;
132                &lt;/ul&gt;
133            &lt;/nav&gt;
134        &lt;/header&gt;
135    &lt;/div&gt;
136  &lt;/div&gt;
137  &lt;div class=&quot;item3&quot;&gt;
138        &lt;form id=&quot;input_text&quot;&gt;
139            Plaintext/Ciphertext: &lt;input class=&quot;plaintext-form&quot; type=&quot;text&quot; placeholder=&quot;Type&quot; id=&quot;main_text&quot;&gt;&lt;br&gt;&lt;br&gt;
140            &lt;input type=&quot;button&quot; onclick=&quot;rot13()&quot; value=&quot;Submit&quot;&gt;
141        &lt;/form&gt;
142  &lt;/div&gt;  
143  &lt;div class=&quot;item4&quot;&gt;
144        &lt;h4&gt;Output:&lt;/h4&gt;
145        &lt;p id=&quot;output_text&quot;&gt;&lt;/p&gt;
146  &lt;/div&gt;
147  &lt;hr&gt;
148  &lt;div class=&quot;item5&quot;&gt;
149    &lt;section class=&quot;rot13-about&quot;&gt;
150        The ROT13 Algorithm is a symmetric cipher algorithm; simply put:
151        &lt;br&gt;&lt;br&gt;
152        &lt;code&gt;
153        ROT13(plaintext) = ciphertext, rot13(ciphertext) = plaintext 
154        &lt;/code&gt;
155        &lt;br&gt;&lt;br&gt;
156        Try it out yourself for some simple text obfuscation!
157    &lt;/section&gt;
158  &lt;/div&gt;
159&lt;/div&gt;
160
161&lt;/body&gt;
162&lt;/html&gt;
163@media screen and (max-width: 800px) {
164    html, body {
165        aspect-ratio: 1024/768;
166        width: 100%;
167        height: 100%;
168        overflow: hidden;
169    }
170}
171@media screen and (max-width: 600px) {
172    html, body {
173        ...
174    }
175}
176

Cell phone screen size break points can be anywhere between 400 to 600.

Source https://stackoverflow.com/questions/71452947

QUESTION

How does Elasticsearch aggregate or weight scores from two sub queries ("bool query" and "decay function")

Asked 2021-Jun-13 at 15:43

I have a complicated Elasticsearch query like the following example. This query has two sub queries: a weighted bool query and a decay function. I am trying to understand how Elasticsearch aggregrates the scores from each sub queries. If I run the first sub query alone (the weighted bool query), my top score is 20. If I run the second sub query alone (the decay function), my score is 1. However, if I run both sub queries together, my top score is 15. Can someone explain this?

My second related question is how to weight the scores from the two sub queries?

1query = { &quot;function_score&quot;: {
2
3    &quot;query&quot;: {
4      &quot;bool&quot;: {
5        &quot;should&quot;: [
6          {'match': {'title': {'query': 'Quantum computing', 'boost': 1}}}, 
7          {'match': {'author': {'query': 'Richard Feynman', 'boost': 2}}}
8        ]
9      },
10    },
11
12    &quot;functions&quot;: [
13      { &quot;exp&quot;:  # a built-in exponential decay function 
14        { 
15          &quot;publication_date&quot;: {
16            &quot;origin&quot;: &quot;2000-01-01&quot;,
17            &quot;offset&quot;: &quot;7d&quot;,
18            &quot;scale&quot;:  &quot;180d&quot;,
19            &quot;decay&quot;: 0.5
20          },
21        },
22     }]
23
24}}
25

ANSWER

Answered 2021-Jun-13 at 15:43

I found the answer myself by reading the elasticsearch document on the usage of function_score. function_score has a parameter boost_mode that specifies how query score and function score are combined. By default, boost_mode is set to multiply.

Besides the default multiply method, we could also set boost_mode to avg, and add a parameter weight to the above decay function exp, then the combined score will be: ( the_bool_query_score + the_decay_function_score * weight ) / ( 1 + weight ).

Source https://stackoverflow.com/questions/67865698

QUESTION

Quantum computing vs traditional base10 systems

Asked 2021-Feb-24 at 18:40

This may show my naiveté but it is my understanding that quantum computing's obstacle is stabilizing the qbits. I also understand that standard computers use binary (on/off); but it seems like it may be easier with today's tech to read electric states between 0 and 9. Binary was the answer because it was very hard to read the varying amounts of electricity, components degrade over time, and maybe maintaining a clean electrical "signal" was challenging.

But wouldn't it be easier to try to solve the problem of reading varying levels of electricity so we can go from 2 inputs to 10 and thereby increasing the smallest unit of storage and exponentially increasing the number of paths through the logic gates? I know I am missing quite a bit (sorry the puns were painful) so I would love to hear why or why not. Thank you

ANSWER

Answered 2021-Feb-24 at 18:40

"Exponentially increasing the number of paths through the logic gates" is exactly the problem. More possible states for each n-ary digit means more transistors, larger gates and more complex CPUs. That's not to say no one is working on ternary and similar systems, but the reason binary is ubiquitous is its simplicity. For storage, more possible states also means we need more sensitive electronics for reading and writing, and a much higher error frequency during these operations. There's a lot of hype around using DNA (base-4) for storage, but this is more on account of the density and durability of the substrate.

You're correct, though that your question is missing quite a bit - qubits are entirely different from classical information, whether we use bits or digits. Classical bits and trits respectively correspond to vectors like

1Binary:  |0&gt; = [1,0];   |1&gt; = [0,1];
2Ternary: |0&gt; = [1,0,0]; |1&gt; = [0,1,0];  |2&gt; = [0,0,1];
3

A qubit, on the other hand, can be a linear combination of classical states

1Binary:  |0&gt; = [1,0];   |1&gt; = [0,1];
2Ternary: |0&gt; = [1,0,0]; |1&gt; = [0,1,0];  |2&gt; = [0,0,1];
3Qubit: |Ψ&gt; = α |0&gt; + β |1&gt;
4

where α and β are arbitrary complex numbers such that such that |α|² + |β|² = 1.

This is called a superposition, meaning even a single qubit can be in one of an infinite number of states. Moreover, unless you prepared the qubit yourself or received some classical information about α and β, there is no way to determine the values of α and β. If you want to extract information from the qubit you must perform a measurement, which collapses the superposition and returns |0> with probability |α|² and |1> with probability |β|².

We can extend the idea to qutrits (though, just like trits, these are even more difficult to effectively realize than qubits):

1Binary:  |0&gt; = [1,0];   |1&gt; = [0,1];
2Ternary: |0&gt; = [1,0,0]; |1&gt; = [0,1,0];  |2&gt; = [0,0,1];
3Qubit: |Ψ&gt; = α |0&gt; + β |1&gt;
4Qutrit: |Ψ&gt; = α |0&gt; + β |1&gt; + γ |2&gt;
5

These requirements mean that qubits are much more difficult to realize than classical bits of any base.

Source https://stackoverflow.com/questions/66148518

QUESTION

Distance Estimation Using Quantum Computer

Asked 2021-Feb-07 at 03:34

I did a small benchmarking to compare quantum version of algorithm to its classical version, and I found that quantum computing taking so much time in comparison to classical version.

I don't understand why its happening, it should be either similar to classical or better.

DataSet Explanation: 1 test data point and 3 training data points, dimension = 2. Goal: our goal is to classify the test data point in one of training data point category.

1import matplotlib.pyplot as plt
2import pandas as pd
3from numpy import pi
4from qiskit import Aer, execute
5from qiskit import QuantumCircuit
6from qiskit import QuantumRegister, ClassicalRegister
7from qiskit import IBMQ
8import os
9import time
10
11# IBMQ Configure
12# IBMQ.save_account(os.environ.get('IBM'))
13# IBMQ.load_account()
14# provider = IBMQ.get_provider('ibm-q')
15# qcomp = provider.get_backend('ibmq_16_melbourne')
16##
17
18fig, ax = plt.subplots()
19ax.set(xlabel='Data Feature 1', ylabel='Data Feature 2')
20
21# Get the data from the .csv file
22data = pd.read_csv('data.csv',
23                   usecols=['Feature 1', 'Feature 2', 'Class'])
24
25# Create binary variables to filter data
26isGreen = data['Class'] == 'Green'
27isBlue = data['Class'] == 'Blue'
28isBlack = data['Class'] == 'Black'
29
30# Filter data
31greenData = data[isGreen].drop(['Class'], axis=1)
32blueData = data[isBlue].drop(['Class'], axis=1)
33blackData = data[isBlack].drop(['Class'], axis=1)
34
35# This is the point we need to classify
36y_p = 0.141
37x_p = -0.161
38
39# Finding the x-coords of the centroids
40xgc = sum(greenData['Feature 1']) / len(greenData['Feature 1'])
41xbc = sum(blueData['Feature 1']) / len(blueData['Feature 1'])
42xkc = sum(blackData['Feature 1']) / len(blackData['Feature 1'])
43
44# Finding the y-coords of the centroids
45ygc = sum(greenData['Feature 2']) / len(greenData['Feature 2'])
46ybc = sum(blueData['Feature 2']) / len(blueData['Feature 2'])
47ykc = sum(blackData['Feature 2']) / len(blackData['Feature 2'])
48
49# Plotting the centroids
50plt.plot(xgc, ygc, 'gx')
51plt.plot(xbc, ybc, 'bx')
52plt.plot(xkc, ykc, 'kx')
53
54# Plotting the new data point
55plt.plot(x_p, y_p, 'ro')
56
57# Setting the axis ranges
58plt.axis([-1, 1, -1, 1])
59
60plt.show()
61
62# Calculating theta and phi values
63phi_list = [((x + 1) * pi / 2) for x in [x_p, xgc, xbc, xkc]]
64theta_list = [((x + 1) * pi / 2) for x in [y_p, ygc, ybc, ykc]]
65
66#----- quantum start time -------#
67st = time.time()
68# Create a 2 qubit QuantumRegister - two for the vectors, and
69# one for the ancillary qubit
70qreg = QuantumRegister(3)
71
72# Create a one bit ClassicalRegister to hold the result
73# of the measurements
74creg = ClassicalRegister(1)
75
76qc = QuantumCircuit(qreg, creg, name='qc')
77
78# Get backend using the Aer provider
79backend = Aer.get_backend('qasm_simulator')
80
81# Create list to hold the results
82results_list = []
83
84# Estimating distances from the new point to the centroids
85for i in range(1, 4):
86    # Apply a Hadamard to the ancillary
87    qc.h(qreg[2])
88
89    # Encode new point and centroid
90    qc.u(theta_list[0], phi_list[0], 0, qreg[0])
91    qc.u(theta_list[i], phi_list[i], 0, qreg[1])
92
93    # Perform controlled swap
94    qc.cswap(qreg[2], qreg[0], qreg[1])
95    # Apply second Hadamard to ancillary
96    qc.h(qreg[2])
97
98    # Measure ancillary
99    qc.measure(qreg[2], creg[0])
100
101    # run on quantum computer
102    # job = execute(qc, backend=qcomp, shots=1024)
103    # job_monitor(job)
104
105    # Reset qubits
106    qc.reset(qreg)
107
108    # Register and execute job
109    job = execute(qc, backend=backend, shots=1024)
110    result = job.result().get_counts(qc)
111    results_list.append(result['1'])
112
113et = time.time()
114# --------- end time ----------
115
116print(results_list)
117print('final circuit fig')
118print(qc.draw())
119
120# Create a list to hold the possible classes
121class_list = ['Green', 'Blue', 'Black']
122
123# Find out which class the new data point belongs to 
124# according to our distance estimation algorithm
125quantum_p_class = class_list[results_list.index(min(results_list))]
126
127# Find out which class the new data point belongs to 
128# according to classical euclidean distance calculation
129
130# classical start time
131cst = time.time()
132distances_list = [((x_p - i[0]) ** 2 + (y_p - i[1]) ** 2) ** 0.5 for i in [(xgc, ygc), (xbc, ybc), (xkc, ykc)]]
133cet = time.time()
134
135classical_p_class = class_list[distances_list.index(min(distances_list))]
136
137
138# Print time taken
139print(&quot;classical time =&gt; &quot;, cet-cst)
140print(&quot;quantum time =&gt; &quot;, et-st)
141
142# Print results
143print(&quot;&quot;&quot;According to our distance algorithm, the new data point belongs to the&quot;&quot;&quot;, quantum_p_class, 'class.\n')
144print('Euclidean distances: ', distances_list, '\n')
145print(&quot;&quot;&quot;According to euclidean distance calculations, the new data point belongs to the&quot;&quot;&quot;, classical_p_class,
146      'class.')
147
148
149

Output:

1import matplotlib.pyplot as plt
2import pandas as pd
3from numpy import pi
4from qiskit import Aer, execute
5from qiskit import QuantumCircuit
6from qiskit import QuantumRegister, ClassicalRegister
7from qiskit import IBMQ
8import os
9import time
10
11# IBMQ Configure
12# IBMQ.save_account(os.environ.get('IBM'))
13# IBMQ.load_account()
14# provider = IBMQ.get_provider('ibm-q')
15# qcomp = provider.get_backend('ibmq_16_melbourne')
16##
17
18fig, ax = plt.subplots()
19ax.set(xlabel='Data Feature 1', ylabel='Data Feature 2')
20
21# Get the data from the .csv file
22data = pd.read_csv('data.csv',
23                   usecols=['Feature 1', 'Feature 2', 'Class'])
24
25# Create binary variables to filter data
26isGreen = data['Class'] == 'Green'
27isBlue = data['Class'] == 'Blue'
28isBlack = data['Class'] == 'Black'
29
30# Filter data
31greenData = data[isGreen].drop(['Class'], axis=1)
32blueData = data[isBlue].drop(['Class'], axis=1)
33blackData = data[isBlack].drop(['Class'], axis=1)
34
35# This is the point we need to classify
36y_p = 0.141
37x_p = -0.161
38
39# Finding the x-coords of the centroids
40xgc = sum(greenData['Feature 1']) / len(greenData['Feature 1'])
41xbc = sum(blueData['Feature 1']) / len(blueData['Feature 1'])
42xkc = sum(blackData['Feature 1']) / len(blackData['Feature 1'])
43
44# Finding the y-coords of the centroids
45ygc = sum(greenData['Feature 2']) / len(greenData['Feature 2'])
46ybc = sum(blueData['Feature 2']) / len(blueData['Feature 2'])
47ykc = sum(blackData['Feature 2']) / len(blackData['Feature 2'])
48
49# Plotting the centroids
50plt.plot(xgc, ygc, 'gx')
51plt.plot(xbc, ybc, 'bx')
52plt.plot(xkc, ykc, 'kx')
53
54# Plotting the new data point
55plt.plot(x_p, y_p, 'ro')
56
57# Setting the axis ranges
58plt.axis([-1, 1, -1, 1])
59
60plt.show()
61
62# Calculating theta and phi values
63phi_list = [((x + 1) * pi / 2) for x in [x_p, xgc, xbc, xkc]]
64theta_list = [((x + 1) * pi / 2) for x in [y_p, ygc, ybc, ykc]]
65
66#----- quantum start time -------#
67st = time.time()
68# Create a 2 qubit QuantumRegister - two for the vectors, and
69# one for the ancillary qubit
70qreg = QuantumRegister(3)
71
72# Create a one bit ClassicalRegister to hold the result
73# of the measurements
74creg = ClassicalRegister(1)
75
76qc = QuantumCircuit(qreg, creg, name='qc')
77
78# Get backend using the Aer provider
79backend = Aer.get_backend('qasm_simulator')
80
81# Create list to hold the results
82results_list = []
83
84# Estimating distances from the new point to the centroids
85for i in range(1, 4):
86    # Apply a Hadamard to the ancillary
87    qc.h(qreg[2])
88
89    # Encode new point and centroid
90    qc.u(theta_list[0], phi_list[0], 0, qreg[0])
91    qc.u(theta_list[i], phi_list[i], 0, qreg[1])
92
93    # Perform controlled swap
94    qc.cswap(qreg[2], qreg[0], qreg[1])
95    # Apply second Hadamard to ancillary
96    qc.h(qreg[2])
97
98    # Measure ancillary
99    qc.measure(qreg[2], creg[0])
100
101    # run on quantum computer
102    # job = execute(qc, backend=qcomp, shots=1024)
103    # job_monitor(job)
104
105    # Reset qubits
106    qc.reset(qreg)
107
108    # Register and execute job
109    job = execute(qc, backend=backend, shots=1024)
110    result = job.result().get_counts(qc)
111    results_list.append(result['1'])
112
113et = time.time()
114# --------- end time ----------
115
116print(results_list)
117print('final circuit fig')
118print(qc.draw())
119
120# Create a list to hold the possible classes
121class_list = ['Green', 'Blue', 'Black']
122
123# Find out which class the new data point belongs to 
124# according to our distance estimation algorithm
125quantum_p_class = class_list[results_list.index(min(results_list))]
126
127# Find out which class the new data point belongs to 
128# according to classical euclidean distance calculation
129
130# classical start time
131cst = time.time()
132distances_list = [((x_p - i[0]) ** 2 + (y_p - i[1]) ** 2) ** 0.5 for i in [(xgc, ygc), (xbc, ybc), (xkc, ykc)]]
133cet = time.time()
134
135classical_p_class = class_list[distances_list.index(min(distances_list))]
136
137
138# Print time taken
139print(&quot;classical time =&gt; &quot;, cet-cst)
140print(&quot;quantum time =&gt; &quot;, et-st)
141
142# Print results
143print(&quot;&quot;&quot;According to our distance algorithm, the new data point belongs to the&quot;&quot;&quot;, quantum_p_class, 'class.\n')
144print('Euclidean distances: ', distances_list, '\n')
145print(&quot;&quot;&quot;According to euclidean distance calculations, the new data point belongs to the&quot;&quot;&quot;, classical_p_class,
146      'class.')
147
148
149classical time =&gt;  **1.0967254638671875e-05**
150quantum time =&gt;  **0.2530648708343506**  // more time
151According to our distance algorithm, the new data point belongs to the Blue class.
152
153Euclidean distances:  [0.520285324797846, 0.4905204028376393, 0.7014755294377704] 
154
155According to euclidean distance calculations, the new data point belongs to the Blue class.
156
157

I am not able to understand, why quantum computing taking so much time.

ANSWER

Answered 2021-Feb-07 at 03:34

I am a physicist and programmer who has worked extensively on Qiskit. I have limited experience with things like machine learning but if I am not mistaken figure 13 on page 22 of this paper on Nearest-Neighbor methods is precisely the circuit you are creating.

You have a dramatic performance hit because you are simulating quantum hardware using classical algorithms. This is commented out:

1import matplotlib.pyplot as plt
2import pandas as pd
3from numpy import pi
4from qiskit import Aer, execute
5from qiskit import QuantumCircuit
6from qiskit import QuantumRegister, ClassicalRegister
7from qiskit import IBMQ
8import os
9import time
10
11# IBMQ Configure
12# IBMQ.save_account(os.environ.get('IBM'))
13# IBMQ.load_account()
14# provider = IBMQ.get_provider('ibm-q')
15# qcomp = provider.get_backend('ibmq_16_melbourne')
16##
17
18fig, ax = plt.subplots()
19ax.set(xlabel='Data Feature 1', ylabel='Data Feature 2')
20
21# Get the data from the .csv file
22data = pd.read_csv('data.csv',
23                   usecols=['Feature 1', 'Feature 2', 'Class'])
24
25# Create binary variables to filter data
26isGreen = data['Class'] == 'Green'
27isBlue = data['Class'] == 'Blue'
28isBlack = data['Class'] == 'Black'
29
30# Filter data
31greenData = data[isGreen].drop(['Class'], axis=1)
32blueData = data[isBlue].drop(['Class'], axis=1)
33blackData = data[isBlack].drop(['Class'], axis=1)
34
35# This is the point we need to classify
36y_p = 0.141
37x_p = -0.161
38
39# Finding the x-coords of the centroids
40xgc = sum(greenData['Feature 1']) / len(greenData['Feature 1'])
41xbc = sum(blueData['Feature 1']) / len(blueData['Feature 1'])
42xkc = sum(blackData['Feature 1']) / len(blackData['Feature 1'])
43
44# Finding the y-coords of the centroids
45ygc = sum(greenData['Feature 2']) / len(greenData['Feature 2'])
46ybc = sum(blueData['Feature 2']) / len(blueData['Feature 2'])
47ykc = sum(blackData['Feature 2']) / len(blackData['Feature 2'])
48
49# Plotting the centroids
50plt.plot(xgc, ygc, 'gx')
51plt.plot(xbc, ybc, 'bx')
52plt.plot(xkc, ykc, 'kx')
53
54# Plotting the new data point
55plt.plot(x_p, y_p, 'ro')
56
57# Setting the axis ranges
58plt.axis([-1, 1, -1, 1])
59
60plt.show()
61
62# Calculating theta and phi values
63phi_list = [((x + 1) * pi / 2) for x in [x_p, xgc, xbc, xkc]]
64theta_list = [((x + 1) * pi / 2) for x in [y_p, ygc, ybc, ykc]]
65
66#----- quantum start time -------#
67st = time.time()
68# Create a 2 qubit QuantumRegister - two for the vectors, and
69# one for the ancillary qubit
70qreg = QuantumRegister(3)
71
72# Create a one bit ClassicalRegister to hold the result
73# of the measurements
74creg = ClassicalRegister(1)
75
76qc = QuantumCircuit(qreg, creg, name='qc')
77
78# Get backend using the Aer provider
79backend = Aer.get_backend('qasm_simulator')
80
81# Create list to hold the results
82results_list = []
83
84# Estimating distances from the new point to the centroids
85for i in range(1, 4):
86    # Apply a Hadamard to the ancillary
87    qc.h(qreg[2])
88
89    # Encode new point and centroid
90    qc.u(theta_list[0], phi_list[0], 0, qreg[0])
91    qc.u(theta_list[i], phi_list[i], 0, qreg[1])
92
93    # Perform controlled swap
94    qc.cswap(qreg[2], qreg[0], qreg[1])
95    # Apply second Hadamard to ancillary
96    qc.h(qreg[2])
97
98    # Measure ancillary
99    qc.measure(qreg[2], creg[0])
100
101    # run on quantum computer
102    # job = execute(qc, backend=qcomp, shots=1024)
103    # job_monitor(job)
104
105    # Reset qubits
106    qc.reset(qreg)
107
108    # Register and execute job
109    job = execute(qc, backend=backend, shots=1024)
110    result = job.result().get_counts(qc)
111    results_list.append(result['1'])
112
113et = time.time()
114# --------- end time ----------
115
116print(results_list)
117print('final circuit fig')
118print(qc.draw())
119
120# Create a list to hold the possible classes
121class_list = ['Green', 'Blue', 'Black']
122
123# Find out which class the new data point belongs to 
124# according to our distance estimation algorithm
125quantum_p_class = class_list[results_list.index(min(results_list))]
126
127# Find out which class the new data point belongs to 
128# according to classical euclidean distance calculation
129
130# classical start time
131cst = time.time()
132distances_list = [((x_p - i[0]) ** 2 + (y_p - i[1]) ** 2) ** 0.5 for i in [(xgc, ygc), (xbc, ybc), (xkc, ykc)]]
133cet = time.time()
134
135classical_p_class = class_list[distances_list.index(min(distances_list))]
136
137
138# Print time taken
139print(&quot;classical time =&gt; &quot;, cet-cst)
140print(&quot;quantum time =&gt; &quot;, et-st)
141
142# Print results
143print(&quot;&quot;&quot;According to our distance algorithm, the new data point belongs to the&quot;&quot;&quot;, quantum_p_class, 'class.\n')
144print('Euclidean distances: ', distances_list, '\n')
145print(&quot;&quot;&quot;According to euclidean distance calculations, the new data point belongs to the&quot;&quot;&quot;, classical_p_class,
146      'class.')
147
148
149classical time =&gt;  **1.0967254638671875e-05**
150quantum time =&gt;  **0.2530648708343506**  // more time
151According to our distance algorithm, the new data point belongs to the Blue class.
152
153Euclidean distances:  [0.520285324797846, 0.4905204028376393, 0.7014755294377704] 
154
155According to euclidean distance calculations, the new data point belongs to the Blue class.
156
157# IBMQ Configure
158# IBMQ.save_account(os.environ.get('IBM'))
159# IBMQ.load_account()
160# provider = IBMQ.get_provider('ibm-q')
161# qcomp = provider.get_backend('ibmq_16_melbourne')
162

Where the "ibmq_16_melbourne" refers to a physical quantum computer with the ibm architecture which is partially documented here. That makes total sense because IBM restricts access for most accounts. That is why later on you have this:

1import matplotlib.pyplot as plt
2import pandas as pd
3from numpy import pi
4from qiskit import Aer, execute
5from qiskit import QuantumCircuit
6from qiskit import QuantumRegister, ClassicalRegister
7from qiskit import IBMQ
8import os
9import time
10
11# IBMQ Configure
12# IBMQ.save_account(os.environ.get('IBM'))
13# IBMQ.load_account()
14# provider = IBMQ.get_provider('ibm-q')
15# qcomp = provider.get_backend('ibmq_16_melbourne')
16##
17
18fig, ax = plt.subplots()
19ax.set(xlabel='Data Feature 1', ylabel='Data Feature 2')
20
21# Get the data from the .csv file
22data = pd.read_csv('data.csv',
23                   usecols=['Feature 1', 'Feature 2', 'Class'])
24
25# Create binary variables to filter data
26isGreen = data['Class'] == 'Green'
27isBlue = data['Class'] == 'Blue'
28isBlack = data['Class'] == 'Black'
29
30# Filter data
31greenData = data[isGreen].drop(['Class'], axis=1)
32blueData = data[isBlue].drop(['Class'], axis=1)
33blackData = data[isBlack].drop(['Class'], axis=1)
34
35# This is the point we need to classify
36y_p = 0.141
37x_p = -0.161
38
39# Finding the x-coords of the centroids
40xgc = sum(greenData['Feature 1']) / len(greenData['Feature 1'])
41xbc = sum(blueData['Feature 1']) / len(blueData['Feature 1'])
42xkc = sum(blackData['Feature 1']) / len(blackData['Feature 1'])
43
44# Finding the y-coords of the centroids
45ygc = sum(greenData['Feature 2']) / len(greenData['Feature 2'])
46ybc = sum(blueData['Feature 2']) / len(blueData['Feature 2'])
47ykc = sum(blackData['Feature 2']) / len(blackData['Feature 2'])
48
49# Plotting the centroids
50plt.plot(xgc, ygc, 'gx')
51plt.plot(xbc, ybc, 'bx')
52plt.plot(xkc, ykc, 'kx')
53
54# Plotting the new data point
55plt.plot(x_p, y_p, 'ro')
56
57# Setting the axis ranges
58plt.axis([-1, 1, -1, 1])
59
60plt.show()
61
62# Calculating theta and phi values
63phi_list = [((x + 1) * pi / 2) for x in [x_p, xgc, xbc, xkc]]
64theta_list = [((x + 1) * pi / 2) for x in [y_p, ygc, ybc, ykc]]
65
66#----- quantum start time -------#
67st = time.time()
68# Create a 2 qubit QuantumRegister - two for the vectors, and
69# one for the ancillary qubit
70qreg = QuantumRegister(3)
71
72# Create a one bit ClassicalRegister to hold the result
73# of the measurements
74creg = ClassicalRegister(1)
75
76qc = QuantumCircuit(qreg, creg, name='qc')
77
78# Get backend using the Aer provider
79backend = Aer.get_backend('qasm_simulator')
80
81# Create list to hold the results
82results_list = []
83
84# Estimating distances from the new point to the centroids
85for i in range(1, 4):
86    # Apply a Hadamard to the ancillary
87    qc.h(qreg[2])
88
89    # Encode new point and centroid
90    qc.u(theta_list[0], phi_list[0], 0, qreg[0])
91    qc.u(theta_list[i], phi_list[i], 0, qreg[1])
92
93    # Perform controlled swap
94    qc.cswap(qreg[2], qreg[0], qreg[1])
95    # Apply second Hadamard to ancillary
96    qc.h(qreg[2])
97
98    # Measure ancillary
99    qc.measure(qreg[2], creg[0])
100
101    # run on quantum computer
102    # job = execute(qc, backend=qcomp, shots=1024)
103    # job_monitor(job)
104
105    # Reset qubits
106    qc.reset(qreg)
107
108    # Register and execute job
109    job = execute(qc, backend=backend, shots=1024)
110    result = job.result().get_counts(qc)
111    results_list.append(result['1'])
112
113et = time.time()
114# --------- end time ----------
115
116print(results_list)
117print('final circuit fig')
118print(qc.draw())
119
120# Create a list to hold the possible classes
121class_list = ['Green', 'Blue', 'Black']
122
123# Find out which class the new data point belongs to 
124# according to our distance estimation algorithm
125quantum_p_class = class_list[results_list.index(min(results_list))]
126
127# Find out which class the new data point belongs to 
128# according to classical euclidean distance calculation
129
130# classical start time
131cst = time.time()
132distances_list = [((x_p - i[0]) ** 2 + (y_p - i[1]) ** 2) ** 0.5 for i in [(xgc, ygc), (xbc, ybc), (xkc, ykc)]]
133cet = time.time()
134
135classical_p_class = class_list[distances_list.index(min(distances_list))]
136
137
138# Print time taken
139print(&quot;classical time =&gt; &quot;, cet-cst)
140print(&quot;quantum time =&gt; &quot;, et-st)
141
142# Print results
143print(&quot;&quot;&quot;According to our distance algorithm, the new data point belongs to the&quot;&quot;&quot;, quantum_p_class, 'class.\n')
144print('Euclidean distances: ', distances_list, '\n')
145print(&quot;&quot;&quot;According to euclidean distance calculations, the new data point belongs to the&quot;&quot;&quot;, classical_p_class,
146      'class.')
147
148
149classical time =&gt;  **1.0967254638671875e-05**
150quantum time =&gt;  **0.2530648708343506**  // more time
151According to our distance algorithm, the new data point belongs to the Blue class.
152
153Euclidean distances:  [0.520285324797846, 0.4905204028376393, 0.7014755294377704] 
154
155According to euclidean distance calculations, the new data point belongs to the Blue class.
156
157# IBMQ Configure
158# IBMQ.save_account(os.environ.get('IBM'))
159# IBMQ.load_account()
160# provider = IBMQ.get_provider('ibm-q')
161# qcomp = provider.get_backend('ibmq_16_melbourne')
162# Get backend using the Aer provider
163backend = Aer.get_backend('qasm_simulator')
164

"Aer" refers to the quantum computer simulation software which is running locally on your client-side computer. To my knowledge there is not yet something in qiskit which could simulate a specific physical quantum computer. That is what would presumably tell you what the simulated/theoretical speedup would be (despite the fact that it would take longer to simulate on a classical computer).

IMPORTANT: Many of the standards defined as part of the Qiskit ecosystem (like the OpenQASM format) are meant to be hardware agnostic. You can describe a circuit that has any two qubits interacting at any time. But the truth is a physical quantum computers of any size (in terms of 10+ qubits) will not have direct any-qubit-to-any-other-qubit connections. You have to swap things around in ways specific to that architecture (like the Melbourne 16-qubit architecture).

Source https://stackoverflow.com/questions/66071608

QUESTION

how to only replace \n which has some char after that

Asked 2020-Jun-17 at 08:39

I converted pdf to txt using pdfminer. Issue is pdfminer adds \n after line end in pdf but sentence is not ending there. you can see each line is taken as a sentence in below text which is not right. I also gave other version of text to show where are new lines chars. for example

1quan-
2tum population.
3

should be in one sentence. I so I replace \n with " and this issue is solved. But other \n are also replace which I don't want to.

1quan-
2tum population.
3Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
4
5Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
6
7Abstract
8With advancement in Quantum computing, classical algorithms are adapted and integrated
9with Quantum properties such as qubit representation and entanglement. Although these
10properties perform better however pre-mature convergence is the main issue in Quantum
11Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-
12tum population. In this paper, we introduced a new way to update the quantum population
13of QEA to avoid premature convergence
14
15'Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, 
16Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical 
17algorithms are adapted and integrated\nwith Quantum properties such as qubit representation 
18and entanglement', ' Although these\nproperties perform better however pre-mature 
19convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only 
20the best individual to update quan-\ntum population', ' In this paper, we introduced a new 
21way to update the quantum population\nof QEA to avoid premature convergence',
22

I have tried this code.

1quan-
2tum population.
3Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
4
5Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
6
7Abstract
8With advancement in Quantum computing, classical algorithms are adapted and integrated
9with Quantum properties such as qubit representation and entanglement. Although these
10properties perform better however pre-mature convergence is the main issue in Quantum
11Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-
12tum population. In this paper, we introduced a new way to update the quantum population
13of QEA to avoid premature convergence
14
15'Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, 
16Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical 
17algorithms are adapted and integrated\nwith Quantum properties such as qubit representation 
18and entanglement', ' Although these\nproperties perform better however pre-mature 
19convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only 
20the best individual to update quan-\ntum population', ' In this paper, we introduced a new 
21way to update the quantum population\nof QEA to avoid premature convergence',
22lines =tokenize.sent_tokenize(txt_str)
23for l in lines:
24    s = l.replace('\n', '')
25    print(s)
26

This results in this.

1quan-
2tum population.
3Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
4
5Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
6
7Abstract
8With advancement in Quantum computing, classical algorithms are adapted and integrated
9with Quantum properties such as qubit representation and entanglement. Although these
10properties perform better however pre-mature convergence is the main issue in Quantum
11Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-
12tum population. In this paper, we introduced a new way to update the quantum population
13of QEA to avoid premature convergence
14
15'Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, 
16Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical 
17algorithms are adapted and integrated\nwith Quantum properties such as qubit representation 
18and entanglement', ' Although these\nproperties perform better however pre-mature 
19convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only 
20the best individual to update quan-\ntum population', ' In this paper, we introduced a new 
21way to update the quantum population\nof QEA to avoid premature convergence',
22lines =tokenize.sent_tokenize(txt_str)
23for l in lines:
24    s = l.replace('\n', '')
25    print(s)
26Balanced Quantum Classical Evolutionary Algorithm(BQCEA)Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer BegAbstractWith advancement in Quantum computing, classical algorithms are adapted and integratedwith Quantum properties such as qubit representation and entanglement.
27Although theseproperties perform better however pre-mature convergence is the main issue in QuantumEvolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population.
28In this paper, we introduced a new way to update the quantum populationof QEA to avoid premature convergence.
29

but this is not wanted text. I want text in this version.

1quan-
2tum population.
3Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
4
5Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
6
7Abstract
8With advancement in Quantum computing, classical algorithms are adapted and integrated
9with Quantum properties such as qubit representation and entanglement. Although these
10properties perform better however pre-mature convergence is the main issue in Quantum
11Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-
12tum population. In this paper, we introduced a new way to update the quantum population
13of QEA to avoid premature convergence
14
15'Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, 
16Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical 
17algorithms are adapted and integrated\nwith Quantum properties such as qubit representation 
18and entanglement', ' Although these\nproperties perform better however pre-mature 
19convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only 
20the best individual to update quan-\ntum population', ' In this paper, we introduced a new 
21way to update the quantum population\nof QEA to avoid premature convergence',
22lines =tokenize.sent_tokenize(txt_str)
23for l in lines:
24    s = l.replace('\n', '')
25    print(s)
26Balanced Quantum Classical Evolutionary Algorithm(BQCEA)Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer BegAbstractWith advancement in Quantum computing, classical algorithms are adapted and integratedwith Quantum properties such as qubit representation and entanglement.
27Although theseproperties perform better however pre-mature convergence is the main issue in QuantumEvolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population.
28In this paper, we introduced a new way to update the quantum populationof QEA to avoid premature convergence.
29Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
30
31Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
32
33Abstract
34With advancement in Quantum computing, classical algorithms are adapted and integrated with Quantum properties such as qubit representation and entanglement. Although these properties perform better however pre-mature convergence is the main issue in Quantum Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population. In this paper, we introduced a new way to update the quantum population of QEA to avoid premature convergence
35

I don't want empty lines to disappear. I hope you understand.

ANSWER

Answered 2020-Jun-17 at 06:23

1quan-
2tum population.
3Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
4
5Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
6
7Abstract
8With advancement in Quantum computing, classical algorithms are adapted and integrated
9with Quantum properties such as qubit representation and entanglement. Although these
10properties perform better however pre-mature convergence is the main issue in Quantum
11Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-
12tum population. In this paper, we introduced a new way to update the quantum population
13of QEA to avoid premature convergence
14
15'Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, 
16Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical 
17algorithms are adapted and integrated\nwith Quantum properties such as qubit representation 
18and entanglement', ' Although these\nproperties perform better however pre-mature 
19convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only 
20the best individual to update quan-\ntum population', ' In this paper, we introduced a new 
21way to update the quantum population\nof QEA to avoid premature convergence',
22lines =tokenize.sent_tokenize(txt_str)
23for l in lines:
24    s = l.replace('\n', '')
25    print(s)
26Balanced Quantum Classical Evolutionary Algorithm(BQCEA)Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer BegAbstractWith advancement in Quantum computing, classical algorithms are adapted and integratedwith Quantum properties such as qubit representation and entanglement.
27Although theseproperties perform better however pre-mature convergence is the main issue in QuantumEvolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population.
28In this paper, we introduced a new way to update the quantum populationof QEA to avoid premature convergence.
29Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
30
31Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
32
33Abstract
34With advancement in Quantum computing, classical algorithms are adapted and integrated with Quantum properties such as qubit representation and entanglement. Although these properties perform better however pre-mature convergence is the main issue in Quantum Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population. In this paper, we introduced a new way to update the quantum population of QEA to avoid premature convergence
35(?&lt;=\S)(?&lt;!\bAbstract)\n(?=\S)
36

You can try this.See demo.

https://regex101.com/r/crj3aD/1

Python script:

1quan-
2tum population.
3Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
4
5Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
6
7Abstract
8With advancement in Quantum computing, classical algorithms are adapted and integrated
9with Quantum properties such as qubit representation and entanglement. Although these
10properties perform better however pre-mature convergence is the main issue in Quantum
11Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-
12tum population. In this paper, we introduced a new way to update the quantum population
13of QEA to avoid premature convergence
14
15'Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, 
16Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical 
17algorithms are adapted and integrated\nwith Quantum properties such as qubit representation 
18and entanglement', ' Although these\nproperties perform better however pre-mature 
19convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only 
20the best individual to update quan-\ntum population', ' In this paper, we introduced a new 
21way to update the quantum population\nof QEA to avoid premature convergence',
22lines =tokenize.sent_tokenize(txt_str)
23for l in lines:
24    s = l.replace('\n', '')
25    print(s)
26Balanced Quantum Classical Evolutionary Algorithm(BQCEA)Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer BegAbstractWith advancement in Quantum computing, classical algorithms are adapted and integratedwith Quantum properties such as qubit representation and entanglement.
27Although theseproperties perform better however pre-mature convergence is the main issue in QuantumEvolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population.
28In this paper, we introduced a new way to update the quantum populationof QEA to avoid premature convergence.
29Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
30
31Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
32
33Abstract
34With advancement in Quantum computing, classical algorithms are adapted and integrated with Quantum properties such as qubit representation and entanglement. Although these properties perform better however pre-mature convergence is the main issue in Quantum Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population. In this paper, we introduced a new way to update the quantum population of QEA to avoid premature convergence
35(?&lt;=\S)(?&lt;!\bAbstract)\n(?=\S)
36inp = "Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical algorithms are adapted and integrated\nwith Quantum properties such as qubit representation and entanglement', ' Although these\nproperties perform better however pre-mature convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-\ntum population', ' In this paper, we introduced a new way to update the quantum population\nof QEA to avoid premature convergence"
37
38output = re.sub(r'(?&lt;=\S)(?&lt;!\bAbstract)\n(?=\S)', ' ', inp)
39print(output)
40

There are more conditions.

1quan-
2tum population.
3Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
4
5Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
6
7Abstract
8With advancement in Quantum computing, classical algorithms are adapted and integrated
9with Quantum properties such as qubit representation and entanglement. Although these
10properties perform better however pre-mature convergence is the main issue in Quantum
11Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-
12tum population. In this paper, we introduced a new way to update the quantum population
13of QEA to avoid premature convergence
14
15'Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, 
16Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical 
17algorithms are adapted and integrated\nwith Quantum properties such as qubit representation 
18and entanglement', ' Although these\nproperties perform better however pre-mature 
19convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only 
20the best individual to update quan-\ntum population', ' In this paper, we introduced a new 
21way to update the quantum population\nof QEA to avoid premature convergence',
22lines =tokenize.sent_tokenize(txt_str)
23for l in lines:
24    s = l.replace('\n', '')
25    print(s)
26Balanced Quantum Classical Evolutionary Algorithm(BQCEA)Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer BegAbstractWith advancement in Quantum computing, classical algorithms are adapted and integratedwith Quantum properties such as qubit representation and entanglement.
27Although theseproperties perform better however pre-mature convergence is the main issue in QuantumEvolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population.
28In this paper, we introduced a new way to update the quantum populationof QEA to avoid premature convergence.
29Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
30
31Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
32
33Abstract
34With advancement in Quantum computing, classical algorithms are adapted and integrated with Quantum properties such as qubit representation and entanglement. Although these properties perform better however pre-mature convergence is the main issue in Quantum Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population. In this paper, we introduced a new way to update the quantum population of QEA to avoid premature convergence
35(?&lt;=\S)(?&lt;!\bAbstract)\n(?=\S)
36inp = "Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical algorithms are adapted and integrated\nwith Quantum properties such as qubit representation and entanglement', ' Although these\nproperties perform better however pre-mature convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-\ntum population', ' In this paper, we introduced a new way to update the quantum population\nof QEA to avoid premature convergence"
37
38output = re.sub(r'(?&lt;=\S)(?&lt;!\bAbstract)\n(?=\S)', ' ', inp)
39print(output)
40(?&lt;=\S)(?&lt;!\bAbstract)(?:\n|\\n)(?=\S)
41

Try this for your another condition.

https://regex101.com/r/crj3aD/2

Source https://stackoverflow.com/questions/62422383

QUESTION

Polynomial Equations in Q# E=MC^2

Asked 2020-Apr-16 at 10:02

I am trying to understand how to use quantum computing and have started to understand some of the basic gates and other concepts, but am not able to understand how to put it to practice in real world problems.

Let's say I want to write a function in Q# that returns the value of E in the equation

E= MC^2

Can someone help me write this operation?

ANSWER

Answered 2020-Apr-15 at 22:44

To answer the literal question: if M and C are just floating-point numbers, the calculation can be done using purely classical Q# constructs:

1// The function that carries out the computation itself
2function Energy (m : Double, c : Double) : Double {
3    return m * c ^ 2.0;
4}
5
6// The operation that you'll invoke to pass the parameters to the function and to print the results
7operation PrintEnergy () : Unit {
8    let c = 299792458.0;
9    let energy1 = Energy(1.0, c);
10    Message($"Calculated energy of 1 gram of mass = {energy1}");
11    let energy2 = Energy(2.0, c);
12    Message($"Calculated energy of 2 grams of mass = {energy2}");
13}
14

The output is:

1// The function that carries out the computation itself
2function Energy (m : Double, c : Double) : Double {
3    return m * c ^ 2.0;
4}
5
6// The operation that you'll invoke to pass the parameters to the function and to print the results
7operation PrintEnergy () : Unit {
8    let c = 299792458.0;
9    let energy1 = Energy(1.0, c);
10    Message($"Calculated energy of 1 gram of mass = {energy1}");
11    let energy2 = Energy(2.0, c);
12    Message($"Calculated energy of 2 grams of mass = {energy2}");
13}
14Calculated energy of 1 gram of mass = 89875517873681760
15Calculated energy of 2 grams of mass = 1.7975103574736352E+17
16

You will notice that this code fragment does not use any qubits or gates, so it's not really a good example of using quantum computing to solve real-world problems, even though it's implemented using a quantum programming language. This problem involved very simple mathematical computations, which can be done very efficiently using classical computers.

Quantum computers are going to use a co-processor model of computation - we'll use them to do computations that they are well suited to do (such as solving chemistry problems), and use classical computers for the rest of the computations.

To learn to apply quantum computing to solving problems with Q#, you can check out the Quantum Katas - a collection of tutorials and programming exercises. In particular, they show how to translate classical problems such as SAT or graph coloring into a form that can take advantage of quantum computing algorithms. (Disclosure: I'm the maintainer of this project)

Source https://stackoverflow.com/questions/61182919

QUESTION

Fastest way for boolean matrix computations

Asked 2020-Feb-04 at 16:38

I have a boolean matrix with 1.5E6 rows and 20E3 columns, similar to this example:

1M = [[ True,  True, False,  True, ...],
2     [False,  True,  True,  True, ...],
3     [False, False, False, False, ...],
4     [False,  True, False, False, ...],
5     ...
6     [ True,  True, False, False, ...]
7     ]
8

Also, I have another matrix N ( 1.5E6 rows, 1 column):

1M = [[ True,  True, False,  True, ...],
2     [False,  True,  True,  True, ...],
3     [False, False, False, False, ...],
4     [False,  True, False, False, ...],
5     ...
6     [ True,  True, False, False, ...]
7     ]
8 N = [[ True],
9      [False],
10      [ True],
11      [ True],
12      ...
13      [ True]
14      ]
15

What I need to do, is to go through each column pair from matrix M (1&1, 1&2, 1&3, 1&N, 2&1, 2&2 etc) combined by the AND operator, and count how many overlaps there are between the result and matrix N.

My Python/Numpy code would look like this:

1M = [[ True,  True, False,  True, ...],
2     [False,  True,  True,  True, ...],
3     [False, False, False, False, ...],
4     [False,  True, False, False, ...],
5     ...
6     [ True,  True, False, False, ...]
7     ]
8 N = [[ True],
9      [False],
10      [ True],
11      [ True],
12      ...
13      [ True]
14      ]
15for i in range(M.shape[1]):
16  for j in range(M.shape[1]):
17    result = M[:,i] &amp; M[:,j] # Combine the columns with AND operator
18    count = np.sum(result &amp; N.ravel()) # Counts the True occurrences
19    ... # Save the count for the i and j pair
20

The problem is, going through 20E3 x 20E3 combinations with two for loops is computationally expensive (takes around 5-10 days to compute). A better option I tried is comparing each column to the whole matrix M:

1M = [[ True,  True, False,  True, ...],
2     [False,  True,  True,  True, ...],
3     [False, False, False, False, ...],
4     [False,  True, False, False, ...],
5     ...
6     [ True,  True, False, False, ...]
7     ]
8 N = [[ True],
9      [False],
10      [ True],
11      [ True],
12      ...
13      [ True]
14      ]
15for i in range(M.shape[1]):
16  for j in range(M.shape[1]):
17    result = M[:,i] &amp; M[:,j] # Combine the columns with AND operator
18    count = np.sum(result &amp; N.ravel()) # Counts the True occurrences
19    ... # Save the count for the i and j pair
20for i in range(M.shape[1]):
21  result = M[:,i]*M.shape[1] &amp; M # np.tile or np.repeat is used to horizontally repeat the column
22  counts = np.sum(result &amp; N*M.shape[1], axis=0)
23  ... # Save the counts
24

This reduces overhead and calculation time to around 10%, but it's still taking 1 day or so to compute.

My question would be :
what is the fastest way (non Python maybe?) to make these calculations (basically just AND and SUM)?

I was thinking about low level languages, GPU processing, quantum computing etc.. but I don't know much about any of these so any advice regarding the direction is appreciated!

Additional thoughts: Currently thinking if there is a fast way using the dot product (as Davikar proposed) for computing triplets of combinations:

1M = [[ True,  True, False,  True, ...],
2     [False,  True,  True,  True, ...],
3     [False, False, False, False, ...],
4     [False,  True, False, False, ...],
5     ...
6     [ True,  True, False, False, ...]
7     ]
8 N = [[ True],
9      [False],
10      [ True],
11      [ True],
12      ...
13      [ True]
14      ]
15for i in range(M.shape[1]):
16  for j in range(M.shape[1]):
17    result = M[:,i] &amp; M[:,j] # Combine the columns with AND operator
18    count = np.sum(result &amp; N.ravel()) # Counts the True occurrences
19    ... # Save the count for the i and j pair
20for i in range(M.shape[1]):
21  result = M[:,i]*M.shape[1] &amp; M # np.tile or np.repeat is used to horizontally repeat the column
22  counts = np.sum(result &amp; N*M.shape[1], axis=0)
23  ... # Save the counts
24def compute(M, N):
25    out = np.zeros((M.shape[1], M.shape[1], M.shape[1]), np.int32)
26    for i in range(M.shape[1]):
27        for j in range(M.shape[1]):
28            for k in range(M.shape[1]):
29                result = M[:, i] &amp; M[:, j] &amp; M[:, k]
30                out[i, j, k] = np.sum(result &amp; N.ravel())
31    return out
32

ANSWER

Answered 2020-Feb-04 at 15:58

Simply use np.einsum to get all the counts -

1M = [[ True,  True, False,  True, ...],
2     [False,  True,  True,  True, ...],
3     [False, False, False, False, ...],
4     [False,  True, False, False, ...],
5     ...
6     [ True,  True, False, False, ...]
7     ]
8 N = [[ True],
9      [False],
10      [ True],
11      [ True],
12      ...
13      [ True]
14      ]
15for i in range(M.shape[1]):
16  for j in range(M.shape[1]):
17    result = M[:,i] &amp; M[:,j] # Combine the columns with AND operator
18    count = np.sum(result &amp; N.ravel()) # Counts the True occurrences
19    ... # Save the count for the i and j pair
20for i in range(M.shape[1]):
21  result = M[:,i]*M.shape[1] &amp; M # np.tile or np.repeat is used to horizontally repeat the column
22  counts = np.sum(result &amp; N*M.shape[1], axis=0)
23  ... # Save the counts
24def compute(M, N):
25    out = np.zeros((M.shape[1], M.shape[1], M.shape[1]), np.int32)
26    for i in range(M.shape[1]):
27        for j in range(M.shape[1]):
28            for k in range(M.shape[1]):
29                result = M[:, i] &amp; M[:, j] &amp; M[:, k]
30                out[i, j, k] = np.sum(result &amp; N.ravel())
31    return out
32np.einsum('ij,ik,i-&gt;jk',M,M.astype(int),N.ravel())
33

Feel free to play around with optimize flag with np.einsum. Also, feel free to play around with different dtypes conversion.

To leverage GPU, we can use tensorflow package that also supports einsum.

Faster alternatives with np.dot :

1M = [[ True,  True, False,  True, ...],
2     [False,  True,  True,  True, ...],
3     [False, False, False, False, ...],
4     [False,  True, False, False, ...],
5     ...
6     [ True,  True, False, False, ...]
7     ]
8 N = [[ True],
9      [False],
10      [ True],
11      [ True],
12      ...
13      [ True]
14      ]
15for i in range(M.shape[1]):
16  for j in range(M.shape[1]):
17    result = M[:,i] &amp; M[:,j] # Combine the columns with AND operator
18    count = np.sum(result &amp; N.ravel()) # Counts the True occurrences
19    ... # Save the count for the i and j pair
20for i in range(M.shape[1]):
21  result = M[:,i]*M.shape[1] &amp; M # np.tile or np.repeat is used to horizontally repeat the column
22  counts = np.sum(result &amp; N*M.shape[1], axis=0)
23  ... # Save the counts
24def compute(M, N):
25    out = np.zeros((M.shape[1], M.shape[1], M.shape[1]), np.int32)
26    for i in range(M.shape[1]):
27        for j in range(M.shape[1]):
28            for k in range(M.shape[1]):
29                result = M[:, i] &amp; M[:, j] &amp; M[:, k]
30                out[i, j, k] = np.sum(result &amp; N.ravel())
31    return out
32np.einsum('ij,ik,i-&gt;jk',M,M.astype(int),N.ravel())
33(M&amp;N).T.dot(M.astype(int))
34(M&amp;N).T.dot(M.astype(np.float32))
35

Timings -

1M = [[ True,  True, False,  True, ...],
2     [False,  True,  True,  True, ...],
3     [False, False, False, False, ...],
4     [False,  True, False, False, ...],
5     ...
6     [ True,  True, False, False, ...]
7     ]
8 N = [[ True],
9      [False],
10      [ True],
11      [ True],
12      ...
13      [ True]
14      ]
15for i in range(M.shape[1]):
16  for j in range(M.shape[1]):
17    result = M[:,i] &amp; M[:,j] # Combine the columns with AND operator
18    count = np.sum(result &amp; N.ravel()) # Counts the True occurrences
19    ... # Save the count for the i and j pair
20for i in range(M.shape[1]):
21  result = M[:,i]*M.shape[1] &amp; M # np.tile or np.repeat is used to horizontally repeat the column
22  counts = np.sum(result &amp; N*M.shape[1], axis=0)
23  ... # Save the counts
24def compute(M, N):
25    out = np.zeros((M.shape[1], M.shape[1], M.shape[1]), np.int32)
26    for i in range(M.shape[1]):
27        for j in range(M.shape[1]):
28            for k in range(M.shape[1]):
29                result = M[:, i] &amp; M[:, j] &amp; M[:, k]
30                out[i, j, k] = np.sum(result &amp; N.ravel())
31    return out
32np.einsum('ij,ik,i-&gt;jk',M,M.astype(int),N.ravel())
33(M&amp;N).T.dot(M.astype(int))
34(M&amp;N).T.dot(M.astype(np.float32))
35In [110]: np.random.seed(0)
36     ...: M = np.random.rand(500,300)&gt;0.5
37     ...: N = np.random.rand(500,1)&gt;0.5
38
39In [111]: %timeit np.einsum('ij,ik,i-&gt;jk',M,M.astype(int),N.ravel())
40     ...: %timeit (M&amp;N).T.dot(M.astype(int))
41     ...: %timeit (M&amp;N).T.dot(M.astype(np.float32))
42227 ms ± 191 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)
4366.8 ms ± 198 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
443.26 ms ± 753 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
45

And take it a bit further with float32 conversions for both of the boolean arrays -

1M = [[ True,  True, False,  True, ...],
2     [False,  True,  True,  True, ...],
3     [False, False, False, False, ...],
4     [False,  True, False, False, ...],
5     ...
6     [ True,  True, False, False, ...]
7     ]
8 N = [[ True],
9      [False],
10      [ True],
11      [ True],
12      ...
13      [ True]
14      ]
15for i in range(M.shape[1]):
16  for j in range(M.shape[1]):
17    result = M[:,i] &amp; M[:,j] # Combine the columns with AND operator
18    count = np.sum(result &amp; N.ravel()) # Counts the True occurrences
19    ... # Save the count for the i and j pair
20for i in range(M.shape[1]):
21  result = M[:,i]*M.shape[1] &amp; M # np.tile or np.repeat is used to horizontally repeat the column
22  counts = np.sum(result &amp; N*M.shape[1], axis=0)
23  ... # Save the counts
24def compute(M, N):
25    out = np.zeros((M.shape[1], M.shape[1], M.shape[1]), np.int32)
26    for i in range(M.shape[1]):
27        for j in range(M.shape[1]):
28            for k in range(M.shape[1]):
29                result = M[:, i] &amp; M[:, j] &amp; M[:, k]
30                out[i, j, k] = np.sum(result &amp; N.ravel())
31    return out
32np.einsum('ij,ik,i-&gt;jk',M,M.astype(int),N.ravel())
33(M&amp;N).T.dot(M.astype(int))
34(M&amp;N).T.dot(M.astype(np.float32))
35In [110]: np.random.seed(0)
36     ...: M = np.random.rand(500,300)&gt;0.5
37     ...: N = np.random.rand(500,1)&gt;0.5
38
39In [111]: %timeit np.einsum('ij,ik,i-&gt;jk',M,M.astype(int),N.ravel())
40     ...: %timeit (M&amp;N).T.dot(M.astype(int))
41     ...: %timeit (M&amp;N).T.dot(M.astype(np.float32))
42227 ms ± 191 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)
4366.8 ms ± 198 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
443.26 ms ± 753 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
45In [122]: %%timeit
46     ...: p1 = (M&amp;N).astype(np.float32)
47     ...: p2 = M.astype(np.float32)
48     ...: out = p1.T.dot(p2)
492.7 ms ± 34.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
50

Source https://stackoverflow.com/questions/60058762

Community Discussions contain sources that include Stack Exchange Network

I am trying to build a website according to the "Holy Grail Layout" and I cannot get it to look good on my phone

How does Elasticsearch aggregate or weight scores from two sub queries ("bool query" and "decay function")

Cannot create Q# projects

Quantum computing vs traditional base10 systems

Distance Estimation Using Quantum Computer

In quantum computing is there a preference to usage of little endian or big endian?

how to only replace \n which has some char after that

Curated WebAssembly CDN

Polynomial Equations in Q# E=MC^2

Fastest way for boolean matrix computations

QUESTION

I am trying to build a website according to the "Holy Grail Layout" and I cannot get it to look good on my phone

Asked 2022-Mar-12 at 22:30

1&lt;!DOCTYPE html&gt;
2&lt;html&gt;
3&lt;head&gt;
4&lt;meta charset=&quot;UTF-8&quot;&gt;
5&lt;meta http-equiv=&quot;X-UA-Compatible&quot; content=&quot;IE=edge&quot;&gt;
6&lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1.0&quot;&gt;
7&lt;script&gt;
8const originalAlpha = &quot;abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;;
9// rot13
10var rot13 = function() {
11    var the_text = document.getElementById(&quot;main_text&quot;).value;
12    the_text = the_text.replace(/[a-z]/gi, letter =&gt; String.fromCharCode(letter.charCodeAt(0) + (letter.toLowerCase() &lt;= 'm' ? 13 : -13)));
13    document.getElementById(&quot;output_text&quot;).innerHTML=the_text;
14};
15&lt;/script&gt;
16&lt;style&gt;
17@import url('https://fonts.googleapis.com/css2?family=Libre+Baskerville&amp;family=ZCOOL+QingKe+HuangYou&amp;display=swap');
18
19html {
20    width: 100%;
21    height: 100%;
22    overflow: hidden;
23}
24
25/* Use a media query to add a breakpoint at 800px: */
26@media screen and (max-width: 800px) {
27    html, body {
28        aspect-ratio: 1024/768;
29        width: 100%;
30        height: 100%;
31        overflow: hidden;
32    }
33}
34
35.item1 { grid-area: header; }
36.item2 { grid-area: menu; }
37.item3 { grid-area: main; }
38.item4 { grid-area: right; }
39.item5 { grid-area: footer; }
40
41.grid-container {
42  display: grid;
43  grid-template-areas:
44    'header header header header header header'
45    'menu main main main right right'
46    'menu footer footer footer footer footer';
47  gap: 10px;
48  background-color:seashell;
49  padding: 10px;
50}
51
52.grid-container &gt; div {
53  background-color: rgb(57, 61, 66, 0.4);
54  text-align: center;
55  padding: 20px 0;
56}
57
58.plaintext-form {
59    flex-flow:row wrap;
60    align-content:center;
61    text-align: justify;
62    justify-content: center;
63    margin: 2%;
64    padding: 2%;
65    width: 80%;
66    height: 80%;
67    font-family: 'Libre Baskerville', sans-serif;
68}
69
70ul {
71    padding-top: 5px;
72    padding-right: 30px;
73    position: relative;
74    justify-self: center;
75    text-align: center;
76    align-self: center;
77    flex-flow: column wrap;
78    align-content: center;
79    width: auto;
80    margin:0 auto;
81}
82
83li {
84    display: block;
85    margin: 20px;
86    padding: 15px;
87    height: 100%;
88    font-size: 21px;
89}
90
91a {
92    color:slateblue;
93}
94
95p {
96    background-color: rgb(57, 61, 66, 0.4);
97    height: 200px;
98    width: auto;
99    margin: 0 auto;
100    padding: 20px;
101    text-align:justify;
102    color:gainsboro;
103    font-family: 'Libre Baskerville', sans-serif;
104}
105
106footer {
107    flex-flow:row wrap;
108    align-content:center;
109    text-align: center;
110    justify-content: center;
111    margin: 2%;
112    padding: 2%;
113}
114&lt;/style&gt;
115&lt;title&gt;ROT13 Cipher Machine&lt;/title&gt;
116&lt;/head&gt;
117&lt;body&gt;
118&lt;div class=&quot;grid-container&quot;&gt;
119  &lt;div class=&quot;item1&quot;&gt;
120    &lt;h1 class=&quot;page_title&quot;&gt;ROT13 Cipher Machine&lt;/h1&gt;
121  &lt;/div&gt;
122  &lt;div class=&quot;item2&quot;&gt;
123    &lt;div class=&quot;navbar&quot;&gt;
124        &lt;header role=&quot;navigation&quot;&gt;
125            &lt;nav class=&quot;site-nav&quot;&gt;
126                &lt;ul id=&quot;site-links&quot;&gt;
127                    &lt;li id=&quot;homework&quot;&gt;&lt;a href=&quot;./cs212/homework/&quot;&gt;Homework&lt;/a&gt;&lt;/li&gt;
128                    &lt;li id=&quot;crypto&quot;&gt;&lt;a href=&quot;./docs/Cryptography/index.html&quot;&gt;Cryptography&lt;/a&gt;&lt;/li&gt;
129                    &lt;!-- &lt;li id=&quot;networking&quot;&gt;&lt;a href=&quot;./docs/network-programming.html&quot;&gt;Network Programming&lt;/a&gt;&lt;/li&gt;
130                    &lt;li id=&quot;quantum-computing&quot;&gt;&lt;a href=&quot;./docs/quantum-computing.html&quot;&gt;Quantum Computing&lt;/a&gt;&lt;/li&gt; --&gt;
131                    &lt;li id=&quot;minecraft&quot;&gt;&lt;a href=&quot;./docs/minecraft.html&quot;&gt;Minecraft&lt;/a&gt;&lt;/li&gt;
132                &lt;/ul&gt;
133            &lt;/nav&gt;
134        &lt;/header&gt;
135    &lt;/div&gt;
136  &lt;/div&gt;
137  &lt;div class=&quot;item3&quot;&gt;
138        &lt;form id=&quot;input_text&quot;&gt;
139            Plaintext/Ciphertext: &lt;input class=&quot;plaintext-form&quot; type=&quot;text&quot; placeholder=&quot;Type&quot; id=&quot;main_text&quot;&gt;&lt;br&gt;&lt;br&gt;
140            &lt;input type=&quot;button&quot; onclick=&quot;rot13()&quot; value=&quot;Submit&quot;&gt;
141        &lt;/form&gt;
142  &lt;/div&gt;  
143  &lt;div class=&quot;item4&quot;&gt;
144        &lt;h4&gt;Output:&lt;/h4&gt;
145        &lt;p id=&quot;output_text&quot;&gt;&lt;/p&gt;
146  &lt;/div&gt;
147  &lt;hr&gt;
148  &lt;div class=&quot;item5&quot;&gt;
149    &lt;section class=&quot;rot13-about&quot;&gt;
150        The ROT13 Algorithm is a symmetric cipher algorithm; simply put:
151        &lt;br&gt;&lt;br&gt;
152        &lt;code&gt;
153        ROT13(plaintext) = ciphertext, rot13(ciphertext) = plaintext 
154        &lt;/code&gt;
155        &lt;br&gt;&lt;br&gt;
156        Try it out yourself for some simple text obfuscation!
157    &lt;/section&gt;
158  &lt;/div&gt;
159&lt;/div&gt;
160
161&lt;/body&gt;
162&lt;/html&gt;
163

I personally prefer flexboxes over CSS grid and find the grid to be terribly confusing. Maybe I am using it wrong, but I have to use both for my assignment.

Edit: I added a 600px breakpoint and it still cuts off over half the screen, this can be seen in the screenshot below.

phone screenshot

ANSWER

Answered 2022-Mar-12 at 21:33

Your media query only has one break point at 800px;

1&lt;!DOCTYPE html&gt;
2&lt;html&gt;
3&lt;head&gt;
4&lt;meta charset=&quot;UTF-8&quot;&gt;
5&lt;meta http-equiv=&quot;X-UA-Compatible&quot; content=&quot;IE=edge&quot;&gt;
6&lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1.0&quot;&gt;
7&lt;script&gt;
8const originalAlpha = &quot;abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;;
9// rot13
10var rot13 = function() {
11    var the_text = document.getElementById(&quot;main_text&quot;).value;
12    the_text = the_text.replace(/[a-z]/gi, letter =&gt; String.fromCharCode(letter.charCodeAt(0) + (letter.toLowerCase() &lt;= 'm' ? 13 : -13)));
13    document.getElementById(&quot;output_text&quot;).innerHTML=the_text;
14};
15&lt;/script&gt;
16&lt;style&gt;
17@import url('https://fonts.googleapis.com/css2?family=Libre+Baskerville&amp;family=ZCOOL+QingKe+HuangYou&amp;display=swap');
18
19html {
20    width: 100%;
21    height: 100%;
22    overflow: hidden;
23}
24
25/* Use a media query to add a breakpoint at 800px: */
26@media screen and (max-width: 800px) {
27    html, body {
28        aspect-ratio: 1024/768;
29        width: 100%;
30        height: 100%;
31        overflow: hidden;
32    }
33}
34
35.item1 { grid-area: header; }
36.item2 { grid-area: menu; }
37.item3 { grid-area: main; }
38.item4 { grid-area: right; }
39.item5 { grid-area: footer; }
40
41.grid-container {
42  display: grid;
43  grid-template-areas:
44    'header header header header header header'
45    'menu main main main right right'
46    'menu footer footer footer footer footer';
47  gap: 10px;
48  background-color:seashell;
49  padding: 10px;
50}
51
52.grid-container &gt; div {
53  background-color: rgb(57, 61, 66, 0.4);
54  text-align: center;
55  padding: 20px 0;
56}
57
58.plaintext-form {
59    flex-flow:row wrap;
60    align-content:center;
61    text-align: justify;
62    justify-content: center;
63    margin: 2%;
64    padding: 2%;
65    width: 80%;
66    height: 80%;
67    font-family: 'Libre Baskerville', sans-serif;
68}
69
70ul {
71    padding-top: 5px;
72    padding-right: 30px;
73    position: relative;
74    justify-self: center;
75    text-align: center;
76    align-self: center;
77    flex-flow: column wrap;
78    align-content: center;
79    width: auto;
80    margin:0 auto;
81}
82
83li {
84    display: block;
85    margin: 20px;
86    padding: 15px;
87    height: 100%;
88    font-size: 21px;
89}
90
91a {
92    color:slateblue;
93}
94
95p {
96    background-color: rgb(57, 61, 66, 0.4);
97    height: 200px;
98    width: auto;
99    margin: 0 auto;
100    padding: 20px;
101    text-align:justify;
102    color:gainsboro;
103    font-family: 'Libre Baskerville', sans-serif;
104}
105
106footer {
107    flex-flow:row wrap;
108    align-content:center;
109    text-align: center;
110    justify-content: center;
111    margin: 2%;
112    padding: 2%;
113}
114&lt;/style&gt;
115&lt;title&gt;ROT13 Cipher Machine&lt;/title&gt;
116&lt;/head&gt;
117&lt;body&gt;
118&lt;div class=&quot;grid-container&quot;&gt;
119  &lt;div class=&quot;item1&quot;&gt;
120    &lt;h1 class=&quot;page_title&quot;&gt;ROT13 Cipher Machine&lt;/h1&gt;
121  &lt;/div&gt;
122  &lt;div class=&quot;item2&quot;&gt;
123    &lt;div class=&quot;navbar&quot;&gt;
124        &lt;header role=&quot;navigation&quot;&gt;
125            &lt;nav class=&quot;site-nav&quot;&gt;
126                &lt;ul id=&quot;site-links&quot;&gt;
127                    &lt;li id=&quot;homework&quot;&gt;&lt;a href=&quot;./cs212/homework/&quot;&gt;Homework&lt;/a&gt;&lt;/li&gt;
128                    &lt;li id=&quot;crypto&quot;&gt;&lt;a href=&quot;./docs/Cryptography/index.html&quot;&gt;Cryptography&lt;/a&gt;&lt;/li&gt;
129                    &lt;!-- &lt;li id=&quot;networking&quot;&gt;&lt;a href=&quot;./docs/network-programming.html&quot;&gt;Network Programming&lt;/a&gt;&lt;/li&gt;
130                    &lt;li id=&quot;quantum-computing&quot;&gt;&lt;a href=&quot;./docs/quantum-computing.html&quot;&gt;Quantum Computing&lt;/a&gt;&lt;/li&gt; --&gt;
131                    &lt;li id=&quot;minecraft&quot;&gt;&lt;a href=&quot;./docs/minecraft.html&quot;&gt;Minecraft&lt;/a&gt;&lt;/li&gt;
132                &lt;/ul&gt;
133            &lt;/nav&gt;
134        &lt;/header&gt;
135    &lt;/div&gt;
136  &lt;/div&gt;
137  &lt;div class=&quot;item3&quot;&gt;
138        &lt;form id=&quot;input_text&quot;&gt;
139            Plaintext/Ciphertext: &lt;input class=&quot;plaintext-form&quot; type=&quot;text&quot; placeholder=&quot;Type&quot; id=&quot;main_text&quot;&gt;&lt;br&gt;&lt;br&gt;
140            &lt;input type=&quot;button&quot; onclick=&quot;rot13()&quot; value=&quot;Submit&quot;&gt;
141        &lt;/form&gt;
142  &lt;/div&gt;  
143  &lt;div class=&quot;item4&quot;&gt;
144        &lt;h4&gt;Output:&lt;/h4&gt;
145        &lt;p id=&quot;output_text&quot;&gt;&lt;/p&gt;
146  &lt;/div&gt;
147  &lt;hr&gt;
148  &lt;div class=&quot;item5&quot;&gt;
149    &lt;section class=&quot;rot13-about&quot;&gt;
150        The ROT13 Algorithm is a symmetric cipher algorithm; simply put:
151        &lt;br&gt;&lt;br&gt;
152        &lt;code&gt;
153        ROT13(plaintext) = ciphertext, rot13(ciphertext) = plaintext 
154        &lt;/code&gt;
155        &lt;br&gt;&lt;br&gt;
156        Try it out yourself for some simple text obfuscation!
157    &lt;/section&gt;
158  &lt;/div&gt;
159&lt;/div&gt;
160
161&lt;/body&gt;
162&lt;/html&gt;
163@media screen and (max-width: 800px) {
164    html, body {
165        aspect-ratio: 1024/768;
166        width: 100%;
167        height: 100%;
168        overflow: hidden;
169    }
170}
171

You would need to add another break point for cell phone screens such as

1&lt;!DOCTYPE html&gt;
2&lt;html&gt;
3&lt;head&gt;
4&lt;meta charset=&quot;UTF-8&quot;&gt;
5&lt;meta http-equiv=&quot;X-UA-Compatible&quot; content=&quot;IE=edge&quot;&gt;
6&lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1.0&quot;&gt;
7&lt;script&gt;
8const originalAlpha = &quot;abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;;
9// rot13
10var rot13 = function() {
11    var the_text = document.getElementById(&quot;main_text&quot;).value;
12    the_text = the_text.replace(/[a-z]/gi, letter =&gt; String.fromCharCode(letter.charCodeAt(0) + (letter.toLowerCase() &lt;= 'm' ? 13 : -13)));
13    document.getElementById(&quot;output_text&quot;).innerHTML=the_text;
14};
15&lt;/script&gt;
16&lt;style&gt;
17@import url('https://fonts.googleapis.com/css2?family=Libre+Baskerville&amp;family=ZCOOL+QingKe+HuangYou&amp;display=swap');
18
19html {
20    width: 100%;
21    height: 100%;
22    overflow: hidden;
23}
24
25/* Use a media query to add a breakpoint at 800px: */
26@media screen and (max-width: 800px) {
27    html, body {
28        aspect-ratio: 1024/768;
29        width: 100%;
30        height: 100%;
31        overflow: hidden;
32    }
33}
34
35.item1 { grid-area: header; }
36.item2 { grid-area: menu; }
37.item3 { grid-area: main; }
38.item4 { grid-area: right; }
39.item5 { grid-area: footer; }
40
41.grid-container {
42  display: grid;
43  grid-template-areas:
44    'header header header header header header'
45    'menu main main main right right'
46    'menu footer footer footer footer footer';
47  gap: 10px;
48  background-color:seashell;
49  padding: 10px;
50}
51
52.grid-container &gt; div {
53  background-color: rgb(57, 61, 66, 0.4);
54  text-align: center;
55  padding: 20px 0;
56}
57
58.plaintext-form {
59    flex-flow:row wrap;
60    align-content:center;
61    text-align: justify;
62    justify-content: center;
63    margin: 2%;
64    padding: 2%;
65    width: 80%;
66    height: 80%;
67    font-family: 'Libre Baskerville', sans-serif;
68}
69
70ul {
71    padding-top: 5px;
72    padding-right: 30px;
73    position: relative;
74    justify-self: center;
75    text-align: center;
76    align-self: center;
77    flex-flow: column wrap;
78    align-content: center;
79    width: auto;
80    margin:0 auto;
81}
82
83li {
84    display: block;
85    margin: 20px;
86    padding: 15px;
87    height: 100%;
88    font-size: 21px;
89}
90
91a {
92    color:slateblue;
93}
94
95p {
96    background-color: rgb(57, 61, 66, 0.4);
97    height: 200px;
98    width: auto;
99    margin: 0 auto;
100    padding: 20px;
101    text-align:justify;
102    color:gainsboro;
103    font-family: 'Libre Baskerville', sans-serif;
104}
105
106footer {
107    flex-flow:row wrap;
108    align-content:center;
109    text-align: center;
110    justify-content: center;
111    margin: 2%;
112    padding: 2%;
113}
114&lt;/style&gt;
115&lt;title&gt;ROT13 Cipher Machine&lt;/title&gt;
116&lt;/head&gt;
117&lt;body&gt;
118&lt;div class=&quot;grid-container&quot;&gt;
119  &lt;div class=&quot;item1&quot;&gt;
120    &lt;h1 class=&quot;page_title&quot;&gt;ROT13 Cipher Machine&lt;/h1&gt;
121  &lt;/div&gt;
122  &lt;div class=&quot;item2&quot;&gt;
123    &lt;div class=&quot;navbar&quot;&gt;
124        &lt;header role=&quot;navigation&quot;&gt;
125            &lt;nav class=&quot;site-nav&quot;&gt;
126                &lt;ul id=&quot;site-links&quot;&gt;
127                    &lt;li id=&quot;homework&quot;&gt;&lt;a href=&quot;./cs212/homework/&quot;&gt;Homework&lt;/a&gt;&lt;/li&gt;
128                    &lt;li id=&quot;crypto&quot;&gt;&lt;a href=&quot;./docs/Cryptography/index.html&quot;&gt;Cryptography&lt;/a&gt;&lt;/li&gt;
129                    &lt;!-- &lt;li id=&quot;networking&quot;&gt;&lt;a href=&quot;./docs/network-programming.html&quot;&gt;Network Programming&lt;/a&gt;&lt;/li&gt;
130                    &lt;li id=&quot;quantum-computing&quot;&gt;&lt;a href=&quot;./docs/quantum-computing.html&quot;&gt;Quantum Computing&lt;/a&gt;&lt;/li&gt; --&gt;
131                    &lt;li id=&quot;minecraft&quot;&gt;&lt;a href=&quot;./docs/minecraft.html&quot;&gt;Minecraft&lt;/a&gt;&lt;/li&gt;
132                &lt;/ul&gt;
133            &lt;/nav&gt;
134        &lt;/header&gt;
135    &lt;/div&gt;
136  &lt;/div&gt;
137  &lt;div class=&quot;item3&quot;&gt;
138        &lt;form id=&quot;input_text&quot;&gt;
139            Plaintext/Ciphertext: &lt;input class=&quot;plaintext-form&quot; type=&quot;text&quot; placeholder=&quot;Type&quot; id=&quot;main_text&quot;&gt;&lt;br&gt;&lt;br&gt;
140            &lt;input type=&quot;button&quot; onclick=&quot;rot13()&quot; value=&quot;Submit&quot;&gt;
141        &lt;/form&gt;
142  &lt;/div&gt;  
143  &lt;div class=&quot;item4&quot;&gt;
144        &lt;h4&gt;Output:&lt;/h4&gt;
145        &lt;p id=&quot;output_text&quot;&gt;&lt;/p&gt;
146  &lt;/div&gt;
147  &lt;hr&gt;
148  &lt;div class=&quot;item5&quot;&gt;
149    &lt;section class=&quot;rot13-about&quot;&gt;
150        The ROT13 Algorithm is a symmetric cipher algorithm; simply put:
151        &lt;br&gt;&lt;br&gt;
152        &lt;code&gt;
153        ROT13(plaintext) = ciphertext, rot13(ciphertext) = plaintext 
154        &lt;/code&gt;
155        &lt;br&gt;&lt;br&gt;
156        Try it out yourself for some simple text obfuscation!
157    &lt;/section&gt;
158  &lt;/div&gt;
159&lt;/div&gt;
160
161&lt;/body&gt;
162&lt;/html&gt;
163@media screen and (max-width: 800px) {
164    html, body {
165        aspect-ratio: 1024/768;
166        width: 100%;
167        height: 100%;
168        overflow: hidden;
169    }
170}
171@media screen and (max-width: 600px) {
172    html, body {
173        ...
174    }
175}
176

Cell phone screen size break points can be anywhere between 400 to 600.

Source https://stackoverflow.com/questions/71452947

QUESTION

How does Elasticsearch aggregate or weight scores from two sub queries ("bool query" and "decay function")

Asked 2021-Jun-13 at 15:43

My second related question is how to weight the scores from the two sub queries?

1query = { &quot;function_score&quot;: {
2
3    &quot;query&quot;: {
4      &quot;bool&quot;: {
5        &quot;should&quot;: [
6          {'match': {'title': {'query': 'Quantum computing', 'boost': 1}}}, 
7          {'match': {'author': {'query': 'Richard Feynman', 'boost': 2}}}
8        ]
9      },
10    },
11
12    &quot;functions&quot;: [
13      { &quot;exp&quot;:  # a built-in exponential decay function 
14        { 
15          &quot;publication_date&quot;: {
16            &quot;origin&quot;: &quot;2000-01-01&quot;,
17            &quot;offset&quot;: &quot;7d&quot;,
18            &quot;scale&quot;:  &quot;180d&quot;,
19            &quot;decay&quot;: 0.5
20          },
21        },
22     }]
23
24}}
25

ANSWER

Answered 2021-Jun-13 at 15:43

Source https://stackoverflow.com/questions/67865698

QUESTION

Quantum computing vs traditional base10 systems

Asked 2021-Feb-24 at 18:40

ANSWER

Answered 2021-Feb-24 at 18:40

1Binary:  |0&gt; = [1,0];   |1&gt; = [0,1];
2Ternary: |0&gt; = [1,0,0]; |1&gt; = [0,1,0];  |2&gt; = [0,0,1];
3

A qubit, on the other hand, can be a linear combination of classical states

1Binary:  |0&gt; = [1,0];   |1&gt; = [0,1];
2Ternary: |0&gt; = [1,0,0]; |1&gt; = [0,1,0];  |2&gt; = [0,0,1];
3Qubit: |Ψ&gt; = α |0&gt; + β |1&gt;
4

where α and β are arbitrary complex numbers such that such that |α|² + |β|² = 1.

We can extend the idea to qutrits (though, just like trits, these are even more difficult to effectively realize than qubits):

1Binary:  |0&gt; = [1,0];   |1&gt; = [0,1];
2Ternary: |0&gt; = [1,0,0]; |1&gt; = [0,1,0];  |2&gt; = [0,0,1];
3Qubit: |Ψ&gt; = α |0&gt; + β |1&gt;
4Qutrit: |Ψ&gt; = α |0&gt; + β |1&gt; + γ |2&gt;
5

These requirements mean that qubits are much more difficult to realize than classical bits of any base.

Source https://stackoverflow.com/questions/66148518

QUESTION

Distance Estimation Using Quantum Computer

Asked 2021-Feb-07 at 03:34

I did a small benchmarking to compare quantum version of algorithm to its classical version, and I found that quantum computing taking so much time in comparison to classical version.

I don't understand why its happening, it should be either similar to classical or better.

DataSet Explanation: 1 test data point and 3 training data points, dimension = 2. Goal: our goal is to classify the test data point in one of training data point category.

1import matplotlib.pyplot as plt
2import pandas as pd
3from numpy import pi
4from qiskit import Aer, execute
5from qiskit import QuantumCircuit
6from qiskit import QuantumRegister, ClassicalRegister
7from qiskit import IBMQ
8import os
9import time
10
11# IBMQ Configure
12# IBMQ.save_account(os.environ.get('IBM'))
13# IBMQ.load_account()
14# provider = IBMQ.get_provider('ibm-q')
15# qcomp = provider.get_backend('ibmq_16_melbourne')
16##
17
18fig, ax = plt.subplots()
19ax.set(xlabel='Data Feature 1', ylabel='Data Feature 2')
20
21# Get the data from the .csv file
22data = pd.read_csv('data.csv',
23                   usecols=['Feature 1', 'Feature 2', 'Class'])
24
25# Create binary variables to filter data
26isGreen = data['Class'] == 'Green'
27isBlue = data['Class'] == 'Blue'
28isBlack = data['Class'] == 'Black'
29
30# Filter data
31greenData = data[isGreen].drop(['Class'], axis=1)
32blueData = data[isBlue].drop(['Class'], axis=1)
33blackData = data[isBlack].drop(['Class'], axis=1)
34
35# This is the point we need to classify
36y_p = 0.141
37x_p = -0.161
38
39# Finding the x-coords of the centroids
40xgc = sum(greenData['Feature 1']) / len(greenData['Feature 1'])
41xbc = sum(blueData['Feature 1']) / len(blueData['Feature 1'])
42xkc = sum(blackData['Feature 1']) / len(blackData['Feature 1'])
43
44# Finding the y-coords of the centroids
45ygc = sum(greenData['Feature 2']) / len(greenData['Feature 2'])
46ybc = sum(blueData['Feature 2']) / len(blueData['Feature 2'])
47ykc = sum(blackData['Feature 2']) / len(blackData['Feature 2'])
48
49# Plotting the centroids
50plt.plot(xgc, ygc, 'gx')
51plt.plot(xbc, ybc, 'bx')
52plt.plot(xkc, ykc, 'kx')
53
54# Plotting the new data point
55plt.plot(x_p, y_p, 'ro')
56
57# Setting the axis ranges
58plt.axis([-1, 1, -1, 1])
59
60plt.show()
61
62# Calculating theta and phi values
63phi_list = [((x + 1) * pi / 2) for x in [x_p, xgc, xbc, xkc]]
64theta_list = [((x + 1) * pi / 2) for x in [y_p, ygc, ybc, ykc]]
65
66#----- quantum start time -------#
67st = time.time()
68# Create a 2 qubit QuantumRegister - two for the vectors, and
69# one for the ancillary qubit
70qreg = QuantumRegister(3)
71
72# Create a one bit ClassicalRegister to hold the result
73# of the measurements
74creg = ClassicalRegister(1)
75
76qc = QuantumCircuit(qreg, creg, name='qc')
77
78# Get backend using the Aer provider
79backend = Aer.get_backend('qasm_simulator')
80
81# Create list to hold the results
82results_list = []
83
84# Estimating distances from the new point to the centroids
85for i in range(1, 4):
86    # Apply a Hadamard to the ancillary
87    qc.h(qreg[2])
88
89    # Encode new point and centroid
90    qc.u(theta_list[0], phi_list[0], 0, qreg[0])
91    qc.u(theta_list[i], phi_list[i], 0, qreg[1])
92
93    # Perform controlled swap
94    qc.cswap(qreg[2], qreg[0], qreg[1])
95    # Apply second Hadamard to ancillary
96    qc.h(qreg[2])
97
98    # Measure ancillary
99    qc.measure(qreg[2], creg[0])
100
101    # run on quantum computer
102    # job = execute(qc, backend=qcomp, shots=1024)
103    # job_monitor(job)
104
105    # Reset qubits
106    qc.reset(qreg)
107
108    # Register and execute job
109    job = execute(qc, backend=backend, shots=1024)
110    result = job.result().get_counts(qc)
111    results_list.append(result['1'])
112
113et = time.time()
114# --------- end time ----------
115
116print(results_list)
117print('final circuit fig')
118print(qc.draw())
119
120# Create a list to hold the possible classes
121class_list = ['Green', 'Blue', 'Black']
122
123# Find out which class the new data point belongs to 
124# according to our distance estimation algorithm
125quantum_p_class = class_list[results_list.index(min(results_list))]
126
127# Find out which class the new data point belongs to 
128# according to classical euclidean distance calculation
129
130# classical start time
131cst = time.time()
132distances_list = [((x_p - i[0]) ** 2 + (y_p - i[1]) ** 2) ** 0.5 for i in [(xgc, ygc), (xbc, ybc), (xkc, ykc)]]
133cet = time.time()
134
135classical_p_class = class_list[distances_list.index(min(distances_list))]
136
137
138# Print time taken
139print(&quot;classical time =&gt; &quot;, cet-cst)
140print(&quot;quantum time =&gt; &quot;, et-st)
141
142# Print results
143print(&quot;&quot;&quot;According to our distance algorithm, the new data point belongs to the&quot;&quot;&quot;, quantum_p_class, 'class.\n')
144print('Euclidean distances: ', distances_list, '\n')
145print(&quot;&quot;&quot;According to euclidean distance calculations, the new data point belongs to the&quot;&quot;&quot;, classical_p_class,
146      'class.')
147
148
149

Output:

1import matplotlib.pyplot as plt
2import pandas as pd
3from numpy import pi
4from qiskit import Aer, execute
5from qiskit import QuantumCircuit
6from qiskit import QuantumRegister, ClassicalRegister
7from qiskit import IBMQ
8import os
9import time
10
11# IBMQ Configure
12# IBMQ.save_account(os.environ.get('IBM'))
13# IBMQ.load_account()
14# provider = IBMQ.get_provider('ibm-q')
15# qcomp = provider.get_backend('ibmq_16_melbourne')
16##
17
18fig, ax = plt.subplots()
19ax.set(xlabel='Data Feature 1', ylabel='Data Feature 2')
20
21# Get the data from the .csv file
22data = pd.read_csv('data.csv',
23                   usecols=['Feature 1', 'Feature 2', 'Class'])
24
25# Create binary variables to filter data
26isGreen = data['Class'] == 'Green'
27isBlue = data['Class'] == 'Blue'
28isBlack = data['Class'] == 'Black'
29
30# Filter data
31greenData = data[isGreen].drop(['Class'], axis=1)
32blueData = data[isBlue].drop(['Class'], axis=1)
33blackData = data[isBlack].drop(['Class'], axis=1)
34
35# This is the point we need to classify
36y_p = 0.141
37x_p = -0.161
38
39# Finding the x-coords of the centroids
40xgc = sum(greenData['Feature 1']) / len(greenData['Feature 1'])
41xbc = sum(blueData['Feature 1']) / len(blueData['Feature 1'])
42xkc = sum(blackData['Feature 1']) / len(blackData['Feature 1'])
43
44# Finding the y-coords of the centroids
45ygc = sum(greenData['Feature 2']) / len(greenData['Feature 2'])
46ybc = sum(blueData['Feature 2']) / len(blueData['Feature 2'])
47ykc = sum(blackData['Feature 2']) / len(blackData['Feature 2'])
48
49# Plotting the centroids
50plt.plot(xgc, ygc, 'gx')
51plt.plot(xbc, ybc, 'bx')
52plt.plot(xkc, ykc, 'kx')
53
54# Plotting the new data point
55plt.plot(x_p, y_p, 'ro')
56
57# Setting the axis ranges
58plt.axis([-1, 1, -1, 1])
59
60plt.show()
61
62# Calculating theta and phi values
63phi_list = [((x + 1) * pi / 2) for x in [x_p, xgc, xbc, xkc]]
64theta_list = [((x + 1) * pi / 2) for x in [y_p, ygc, ybc, ykc]]
65
66#----- quantum start time -------#
67st = time.time()
68# Create a 2 qubit QuantumRegister - two for the vectors, and
69# one for the ancillary qubit
70qreg = QuantumRegister(3)
71
72# Create a one bit ClassicalRegister to hold the result
73# of the measurements
74creg = ClassicalRegister(1)
75
76qc = QuantumCircuit(qreg, creg, name='qc')
77
78# Get backend using the Aer provider
79backend = Aer.get_backend('qasm_simulator')
80
81# Create list to hold the results
82results_list = []
83
84# Estimating distances from the new point to the centroids
85for i in range(1, 4):
86    # Apply a Hadamard to the ancillary
87    qc.h(qreg[2])
88
89    # Encode new point and centroid
90    qc.u(theta_list[0], phi_list[0], 0, qreg[0])
91    qc.u(theta_list[i], phi_list[i], 0, qreg[1])
92
93    # Perform controlled swap
94    qc.cswap(qreg[2], qreg[0], qreg[1])
95    # Apply second Hadamard to ancillary
96    qc.h(qreg[2])
97
98    # Measure ancillary
99    qc.measure(qreg[2], creg[0])
100
101    # run on quantum computer
102    # job = execute(qc, backend=qcomp, shots=1024)
103    # job_monitor(job)
104
105    # Reset qubits
106    qc.reset(qreg)
107
108    # Register and execute job
109    job = execute(qc, backend=backend, shots=1024)
110    result = job.result().get_counts(qc)
111    results_list.append(result['1'])
112
113et = time.time()
114# --------- end time ----------
115
116print(results_list)
117print('final circuit fig')
118print(qc.draw())
119
120# Create a list to hold the possible classes
121class_list = ['Green', 'Blue', 'Black']
122
123# Find out which class the new data point belongs to 
124# according to our distance estimation algorithm
125quantum_p_class = class_list[results_list.index(min(results_list))]
126
127# Find out which class the new data point belongs to 
128# according to classical euclidean distance calculation
129
130# classical start time
131cst = time.time()
132distances_list = [((x_p - i[0]) ** 2 + (y_p - i[1]) ** 2) ** 0.5 for i in [(xgc, ygc), (xbc, ybc), (xkc, ykc)]]
133cet = time.time()
134
135classical_p_class = class_list[distances_list.index(min(distances_list))]
136
137
138# Print time taken
139print(&quot;classical time =&gt; &quot;, cet-cst)
140print(&quot;quantum time =&gt; &quot;, et-st)
141
142# Print results
143print(&quot;&quot;&quot;According to our distance algorithm, the new data point belongs to the&quot;&quot;&quot;, quantum_p_class, 'class.\n')
144print('Euclidean distances: ', distances_list, '\n')
145print(&quot;&quot;&quot;According to euclidean distance calculations, the new data point belongs to the&quot;&quot;&quot;, classical_p_class,
146      'class.')
147
148
149classical time =&gt;  **1.0967254638671875e-05**
150quantum time =&gt;  **0.2530648708343506**  // more time
151According to our distance algorithm, the new data point belongs to the Blue class.
152
153Euclidean distances:  [0.520285324797846, 0.4905204028376393, 0.7014755294377704] 
154
155According to euclidean distance calculations, the new data point belongs to the Blue class.
156
157

I am not able to understand, why quantum computing taking so much time.

ANSWER

Answered 2021-Feb-07 at 03:34

You have a dramatic performance hit because you are simulating quantum hardware using classical algorithms. This is commented out:

1import matplotlib.pyplot as plt
2import pandas as pd
3from numpy import pi
4from qiskit import Aer, execute
5from qiskit import QuantumCircuit
6from qiskit import QuantumRegister, ClassicalRegister
7from qiskit import IBMQ
8import os
9import time
10
11# IBMQ Configure
12# IBMQ.save_account(os.environ.get('IBM'))
13# IBMQ.load_account()
14# provider = IBMQ.get_provider('ibm-q')
15# qcomp = provider.get_backend('ibmq_16_melbourne')
16##
17
18fig, ax = plt.subplots()
19ax.set(xlabel='Data Feature 1', ylabel='Data Feature 2')
20
21# Get the data from the .csv file
22data = pd.read_csv('data.csv',
23                   usecols=['Feature 1', 'Feature 2', 'Class'])
24
25# Create binary variables to filter data
26isGreen = data['Class'] == 'Green'
27isBlue = data['Class'] == 'Blue'
28isBlack = data['Class'] == 'Black'
29
30# Filter data
31greenData = data[isGreen].drop(['Class'], axis=1)
32blueData = data[isBlue].drop(['Class'], axis=1)
33blackData = data[isBlack].drop(['Class'], axis=1)
34
35# This is the point we need to classify
36y_p = 0.141
37x_p = -0.161
38
39# Finding the x-coords of the centroids
40xgc = sum(greenData['Feature 1']) / len(greenData['Feature 1'])
41xbc = sum(blueData['Feature 1']) / len(blueData['Feature 1'])
42xkc = sum(blackData['Feature 1']) / len(blackData['Feature 1'])
43
44# Finding the y-coords of the centroids
45ygc = sum(greenData['Feature 2']) / len(greenData['Feature 2'])
46ybc = sum(blueData['Feature 2']) / len(blueData['Feature 2'])
47ykc = sum(blackData['Feature 2']) / len(blackData['Feature 2'])
48
49# Plotting the centroids
50plt.plot(xgc, ygc, 'gx')
51plt.plot(xbc, ybc, 'bx')
52plt.plot(xkc, ykc, 'kx')
53
54# Plotting the new data point
55plt.plot(x_p, y_p, 'ro')
56
57# Setting the axis ranges
58plt.axis([-1, 1, -1, 1])
59
60plt.show()
61
62# Calculating theta and phi values
63phi_list = [((x + 1) * pi / 2) for x in [x_p, xgc, xbc, xkc]]
64theta_list = [((x + 1) * pi / 2) for x in [y_p, ygc, ybc, ykc]]
65
66#----- quantum start time -------#
67st = time.time()
68# Create a 2 qubit QuantumRegister - two for the vectors, and
69# one for the ancillary qubit
70qreg = QuantumRegister(3)
71
72# Create a one bit ClassicalRegister to hold the result
73# of the measurements
74creg = ClassicalRegister(1)
75
76qc = QuantumCircuit(qreg, creg, name='qc')
77
78# Get backend using the Aer provider
79backend = Aer.get_backend('qasm_simulator')
80
81# Create list to hold the results
82results_list = []
83
84# Estimating distances from the new point to the centroids
85for i in range(1, 4):
86    # Apply a Hadamard to the ancillary
87    qc.h(qreg[2])
88
89    # Encode new point and centroid
90    qc.u(theta_list[0], phi_list[0], 0, qreg[0])
91    qc.u(theta_list[i], phi_list[i], 0, qreg[1])
92
93    # Perform controlled swap
94    qc.cswap(qreg[2], qreg[0], qreg[1])
95    # Apply second Hadamard to ancillary
96    qc.h(qreg[2])
97
98    # Measure ancillary
99    qc.measure(qreg[2], creg[0])
100
101    # run on quantum computer
102    # job = execute(qc, backend=qcomp, shots=1024)
103    # job_monitor(job)
104
105    # Reset qubits
106    qc.reset(qreg)
107
108    # Register and execute job
109    job = execute(qc, backend=backend, shots=1024)
110    result = job.result().get_counts(qc)
111    results_list.append(result['1'])
112
113et = time.time()
114# --------- end time ----------
115
116print(results_list)
117print('final circuit fig')
118print(qc.draw())
119
120# Create a list to hold the possible classes
121class_list = ['Green', 'Blue', 'Black']
122
123# Find out which class the new data point belongs to 
124# according to our distance estimation algorithm
125quantum_p_class = class_list[results_list.index(min(results_list))]
126
127# Find out which class the new data point belongs to 
128# according to classical euclidean distance calculation
129
130# classical start time
131cst = time.time()
132distances_list = [((x_p - i[0]) ** 2 + (y_p - i[1]) ** 2) ** 0.5 for i in [(xgc, ygc), (xbc, ybc), (xkc, ykc)]]
133cet = time.time()
134
135classical_p_class = class_list[distances_list.index(min(distances_list))]
136
137
138# Print time taken
139print(&quot;classical time =&gt; &quot;, cet-cst)
140print(&quot;quantum time =&gt; &quot;, et-st)
141
142# Print results
143print(&quot;&quot;&quot;According to our distance algorithm, the new data point belongs to the&quot;&quot;&quot;, quantum_p_class, 'class.\n')
144print('Euclidean distances: ', distances_list, '\n')
145print(&quot;&quot;&quot;According to euclidean distance calculations, the new data point belongs to the&quot;&quot;&quot;, classical_p_class,
146      'class.')
147
148
149classical time =&gt;  **1.0967254638671875e-05**
150quantum time =&gt;  **0.2530648708343506**  // more time
151According to our distance algorithm, the new data point belongs to the Blue class.
152
153Euclidean distances:  [0.520285324797846, 0.4905204028376393, 0.7014755294377704] 
154
155According to euclidean distance calculations, the new data point belongs to the Blue class.
156
157# IBMQ Configure
158# IBMQ.save_account(os.environ.get('IBM'))
159# IBMQ.load_account()
160# provider = IBMQ.get_provider('ibm-q')
161# qcomp = provider.get_backend('ibmq_16_melbourne')
162

1import matplotlib.pyplot as plt
2import pandas as pd
3from numpy import pi
4from qiskit import Aer, execute
5from qiskit import QuantumCircuit
6from qiskit import QuantumRegister, ClassicalRegister
7from qiskit import IBMQ
8import os
9import time
10
11# IBMQ Configure
12# IBMQ.save_account(os.environ.get('IBM'))
13# IBMQ.load_account()
14# provider = IBMQ.get_provider('ibm-q')
15# qcomp = provider.get_backend('ibmq_16_melbourne')
16##
17
18fig, ax = plt.subplots()
19ax.set(xlabel='Data Feature 1', ylabel='Data Feature 2')
20
21# Get the data from the .csv file
22data = pd.read_csv('data.csv',
23                   usecols=['Feature 1', 'Feature 2', 'Class'])
24
25# Create binary variables to filter data
26isGreen = data['Class'] == 'Green'
27isBlue = data['Class'] == 'Blue'
28isBlack = data['Class'] == 'Black'
29
30# Filter data
31greenData = data[isGreen].drop(['Class'], axis=1)
32blueData = data[isBlue].drop(['Class'], axis=1)
33blackData = data[isBlack].drop(['Class'], axis=1)
34
35# This is the point we need to classify
36y_p = 0.141
37x_p = -0.161
38
39# Finding the x-coords of the centroids
40xgc = sum(greenData['Feature 1']) / len(greenData['Feature 1'])
41xbc = sum(blueData['Feature 1']) / len(blueData['Feature 1'])
42xkc = sum(blackData['Feature 1']) / len(blackData['Feature 1'])
43
44# Finding the y-coords of the centroids
45ygc = sum(greenData['Feature 2']) / len(greenData['Feature 2'])
46ybc = sum(blueData['Feature 2']) / len(blueData['Feature 2'])
47ykc = sum(blackData['Feature 2']) / len(blackData['Feature 2'])
48
49# Plotting the centroids
50plt.plot(xgc, ygc, 'gx')
51plt.plot(xbc, ybc, 'bx')
52plt.plot(xkc, ykc, 'kx')
53
54# Plotting the new data point
55plt.plot(x_p, y_p, 'ro')
56
57# Setting the axis ranges
58plt.axis([-1, 1, -1, 1])
59
60plt.show()
61
62# Calculating theta and phi values
63phi_list = [((x + 1) * pi / 2) for x in [x_p, xgc, xbc, xkc]]
64theta_list = [((x + 1) * pi / 2) for x in [y_p, ygc, ybc, ykc]]
65
66#----- quantum start time -------#
67st = time.time()
68# Create a 2 qubit QuantumRegister - two for the vectors, and
69# one for the ancillary qubit
70qreg = QuantumRegister(3)
71
72# Create a one bit ClassicalRegister to hold the result
73# of the measurements
74creg = ClassicalRegister(1)
75
76qc = QuantumCircuit(qreg, creg, name='qc')
77
78# Get backend using the Aer provider
79backend = Aer.get_backend('qasm_simulator')
80
81# Create list to hold the results
82results_list = []
83
84# Estimating distances from the new point to the centroids
85for i in range(1, 4):
86    # Apply a Hadamard to the ancillary
87    qc.h(qreg[2])
88
89    # Encode new point and centroid
90    qc.u(theta_list[0], phi_list[0], 0, qreg[0])
91    qc.u(theta_list[i], phi_list[i], 0, qreg[1])
92
93    # Perform controlled swap
94    qc.cswap(qreg[2], qreg[0], qreg[1])
95    # Apply second Hadamard to ancillary
96    qc.h(qreg[2])
97
98    # Measure ancillary
99    qc.measure(qreg[2], creg[0])
100
101    # run on quantum computer
102    # job = execute(qc, backend=qcomp, shots=1024)
103    # job_monitor(job)
104
105    # Reset qubits
106    qc.reset(qreg)
107
108    # Register and execute job
109    job = execute(qc, backend=backend, shots=1024)
110    result = job.result().get_counts(qc)
111    results_list.append(result['1'])
112
113et = time.time()
114# --------- end time ----------
115
116print(results_list)
117print('final circuit fig')
118print(qc.draw())
119
120# Create a list to hold the possible classes
121class_list = ['Green', 'Blue', 'Black']
122
123# Find out which class the new data point belongs to 
124# according to our distance estimation algorithm
125quantum_p_class = class_list[results_list.index(min(results_list))]
126
127# Find out which class the new data point belongs to 
128# according to classical euclidean distance calculation
129
130# classical start time
131cst = time.time()
132distances_list = [((x_p - i[0]) ** 2 + (y_p - i[1]) ** 2) ** 0.5 for i in [(xgc, ygc), (xbc, ybc), (xkc, ykc)]]
133cet = time.time()
134
135classical_p_class = class_list[distances_list.index(min(distances_list))]
136
137
138# Print time taken
139print(&quot;classical time =&gt; &quot;, cet-cst)
140print(&quot;quantum time =&gt; &quot;, et-st)
141
142# Print results
143print(&quot;&quot;&quot;According to our distance algorithm, the new data point belongs to the&quot;&quot;&quot;, quantum_p_class, 'class.\n')
144print('Euclidean distances: ', distances_list, '\n')
145print(&quot;&quot;&quot;According to euclidean distance calculations, the new data point belongs to the&quot;&quot;&quot;, classical_p_class,
146      'class.')
147
148
149classical time =&gt;  **1.0967254638671875e-05**
150quantum time =&gt;  **0.2530648708343506**  // more time
151According to our distance algorithm, the new data point belongs to the Blue class.
152
153Euclidean distances:  [0.520285324797846, 0.4905204028376393, 0.7014755294377704] 
154
155According to euclidean distance calculations, the new data point belongs to the Blue class.
156
157# IBMQ Configure
158# IBMQ.save_account(os.environ.get('IBM'))
159# IBMQ.load_account()
160# provider = IBMQ.get_provider('ibm-q')
161# qcomp = provider.get_backend('ibmq_16_melbourne')
162# Get backend using the Aer provider
163backend = Aer.get_backend('qasm_simulator')
164

Source https://stackoverflow.com/questions/66071608

QUESTION

how to only replace \n which has some char after that

Asked 2020-Jun-17 at 08:39

1quan-
2tum population.
3

should be in one sentence. I so I replace \n with " and this issue is solved. But other \n are also replace which I don't want to.

1quan-
2tum population.
3Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
4
5Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
6
7Abstract
8With advancement in Quantum computing, classical algorithms are adapted and integrated
9with Quantum properties such as qubit representation and entanglement. Although these
10properties perform better however pre-mature convergence is the main issue in Quantum
11Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-
12tum population. In this paper, we introduced a new way to update the quantum population
13of QEA to avoid premature convergence
14
15'Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, 
16Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical 
17algorithms are adapted and integrated\nwith Quantum properties such as qubit representation 
18and entanglement', ' Although these\nproperties perform better however pre-mature 
19convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only 
20the best individual to update quan-\ntum population', ' In this paper, we introduced a new 
21way to update the quantum population\nof QEA to avoid premature convergence',
22

I have tried this code.

1quan-
2tum population.
3Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
4
5Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
6
7Abstract
8With advancement in Quantum computing, classical algorithms are adapted and integrated
9with Quantum properties such as qubit representation and entanglement. Although these
10properties perform better however pre-mature convergence is the main issue in Quantum
11Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-
12tum population. In this paper, we introduced a new way to update the quantum population
13of QEA to avoid premature convergence
14
15'Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, 
16Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical 
17algorithms are adapted and integrated\nwith Quantum properties such as qubit representation 
18and entanglement', ' Although these\nproperties perform better however pre-mature 
19convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only 
20the best individual to update quan-\ntum population', ' In this paper, we introduced a new 
21way to update the quantum population\nof QEA to avoid premature convergence',
22lines =tokenize.sent_tokenize(txt_str)
23for l in lines:
24    s = l.replace('\n', '')
25    print(s)
26

This results in this.

1quan-
2tum population.
3Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
4
5Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
6
7Abstract
8With advancement in Quantum computing, classical algorithms are adapted and integrated
9with Quantum properties such as qubit representation and entanglement. Although these
10properties perform better however pre-mature convergence is the main issue in Quantum
11Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-
12tum population. In this paper, we introduced a new way to update the quantum population
13of QEA to avoid premature convergence
14
15'Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, 
16Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical 
17algorithms are adapted and integrated\nwith Quantum properties such as qubit representation 
18and entanglement', ' Although these\nproperties perform better however pre-mature 
19convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only 
20the best individual to update quan-\ntum population', ' In this paper, we introduced a new 
21way to update the quantum population\nof QEA to avoid premature convergence',
22lines =tokenize.sent_tokenize(txt_str)
23for l in lines:
24    s = l.replace('\n', '')
25    print(s)
26Balanced Quantum Classical Evolutionary Algorithm(BQCEA)Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer BegAbstractWith advancement in Quantum computing, classical algorithms are adapted and integratedwith Quantum properties such as qubit representation and entanglement.
27Although theseproperties perform better however pre-mature convergence is the main issue in QuantumEvolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population.
28In this paper, we introduced a new way to update the quantum populationof QEA to avoid premature convergence.
29

but this is not wanted text. I want text in this version.

1quan-
2tum population.
3Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
4
5Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
6
7Abstract
8With advancement in Quantum computing, classical algorithms are adapted and integrated
9with Quantum properties such as qubit representation and entanglement. Although these
10properties perform better however pre-mature convergence is the main issue in Quantum
11Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-
12tum population. In this paper, we introduced a new way to update the quantum population
13of QEA to avoid premature convergence
14
15'Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, 
16Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical 
17algorithms are adapted and integrated\nwith Quantum properties such as qubit representation 
18and entanglement', ' Although these\nproperties perform better however pre-mature 
19convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only 
20the best individual to update quan-\ntum population', ' In this paper, we introduced a new 
21way to update the quantum population\nof QEA to avoid premature convergence',
22lines =tokenize.sent_tokenize(txt_str)
23for l in lines:
24    s = l.replace('\n', '')
25    print(s)
26Balanced Quantum Classical Evolutionary Algorithm(BQCEA)Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer BegAbstractWith advancement in Quantum computing, classical algorithms are adapted and integratedwith Quantum properties such as qubit representation and entanglement.
27Although theseproperties perform better however pre-mature convergence is the main issue in QuantumEvolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population.
28In this paper, we introduced a new way to update the quantum populationof QEA to avoid premature convergence.
29Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
30
31Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
32
33Abstract
34With advancement in Quantum computing, classical algorithms are adapted and integrated with Quantum properties such as qubit representation and entanglement. Although these properties perform better however pre-mature convergence is the main issue in Quantum Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population. In this paper, we introduced a new way to update the quantum population of QEA to avoid premature convergence
35

I don't want empty lines to disappear. I hope you understand.

ANSWER

Answered 2020-Jun-17 at 06:23

1quan-
2tum population.
3Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
4
5Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
6
7Abstract
8With advancement in Quantum computing, classical algorithms are adapted and integrated
9with Quantum properties such as qubit representation and entanglement. Although these
10properties perform better however pre-mature convergence is the main issue in Quantum
11Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-
12tum population. In this paper, we introduced a new way to update the quantum population
13of QEA to avoid premature convergence
14
15'Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, 
16Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical 
17algorithms are adapted and integrated\nwith Quantum properties such as qubit representation 
18and entanglement', ' Although these\nproperties perform better however pre-mature 
19convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only 
20the best individual to update quan-\ntum population', ' In this paper, we introduced a new 
21way to update the quantum population\nof QEA to avoid premature convergence',
22lines =tokenize.sent_tokenize(txt_str)
23for l in lines:
24    s = l.replace('\n', '')
25    print(s)
26Balanced Quantum Classical Evolutionary Algorithm(BQCEA)Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer BegAbstractWith advancement in Quantum computing, classical algorithms are adapted and integratedwith Quantum properties such as qubit representation and entanglement.
27Although theseproperties perform better however pre-mature convergence is the main issue in QuantumEvolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population.
28In this paper, we introduced a new way to update the quantum populationof QEA to avoid premature convergence.
29Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
30
31Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
32
33Abstract
34With advancement in Quantum computing, classical algorithms are adapted and integrated with Quantum properties such as qubit representation and entanglement. Although these properties perform better however pre-mature convergence is the main issue in Quantum Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population. In this paper, we introduced a new way to update the quantum population of QEA to avoid premature convergence
35(?&lt;=\S)(?&lt;!\bAbstract)\n(?=\S)
36

You can try this.See demo.

https://regex101.com/r/crj3aD/1

Python script:

1quan-
2tum population.
3Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
4
5Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
6
7Abstract
8With advancement in Quantum computing, classical algorithms are adapted and integrated
9with Quantum properties such as qubit representation and entanglement. Although these
10properties perform better however pre-mature convergence is the main issue in Quantum
11Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-
12tum population. In this paper, we introduced a new way to update the quantum population
13of QEA to avoid premature convergence
14
15'Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, 
16Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical 
17algorithms are adapted and integrated\nwith Quantum properties such as qubit representation 
18and entanglement', ' Although these\nproperties perform better however pre-mature 
19convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only 
20the best individual to update quan-\ntum population', ' In this paper, we introduced a new 
21way to update the quantum population\nof QEA to avoid premature convergence',
22lines =tokenize.sent_tokenize(txt_str)
23for l in lines:
24    s = l.replace('\n', '')
25    print(s)
26Balanced Quantum Classical Evolutionary Algorithm(BQCEA)Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer BegAbstractWith advancement in Quantum computing, classical algorithms are adapted and integratedwith Quantum properties such as qubit representation and entanglement.
27Although theseproperties perform better however pre-mature convergence is the main issue in QuantumEvolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population.
28In this paper, we introduced a new way to update the quantum populationof QEA to avoid premature convergence.
29Balanced Quantum Classical Evolutionary Algorithm(BQCEA)
30
31Muhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg
32
33Abstract
34With advancement in Quantum computing, classical algorithms are adapted and integrated with Quantum properties such as qubit representation and entanglement. Although these properties perform better however pre-mature convergence is the main issue in Quantum Evolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-tum population. In this paper, we introduced a new way to update the quantum population of QEA to avoid premature convergence
35(?&lt;=\S)(?&lt;!\bAbstract)\n(?=\S)
36inp = "Balanced Quantum Classical Evolutionary Algorithm(BQCEA)\n\nMuhammad Shahid, Hasan Mujtaba, Muhammad Asim, Omer Beg\n\nAbstract\nWith advancement in Quantum computing, classical algorithms are adapted and integrated\nwith Quantum properties such as qubit representation and entanglement', ' Although these\nproperties perform better however pre-mature convergence is the main issue in Quantum\nEvolutionary Algorithms(QEA) because QEA uses only the best individual to update quan-\ntum population', ' In this paper, we introduced a new way to update the quantum population\nof QEA to avoid premature convergence"
37