Quantum Computing

1dotnet nuget add source  https://api.nuget.org/v3/index.json -n nuget.org
2

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

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

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

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("classical time => ", cet-cst)
140print("quantum time => ", et-st)
141
142# Print results
143print("""According to our distance algorithm, the new data point belongs to the""", quantum_p_class, 'class.\n')
144print('Euclidean distances: ', distances_list, '\n')
145print("""According to euclidean distance calculations, the new data point belongs to the""", classical_p_class,
146      'class.')
147
148
149classical time =>  **1.0967254638671875e-05**
150quantum time =>  **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("classical time => ", cet-cst)
140print("quantum time => ", et-st)
141
142# Print results
143print("""According to our distance algorithm, the new data point belongs to the""", quantum_p_class, 'class.\n')
144print('Euclidean distances: ', distances_list, '\n')
145print("""According to euclidean distance calculations, the new data point belongs to the""", classical_p_class,
146      'class.')
147
148
149classical time =>  **1.0967254638671875e-05**
150quantum time =>  **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

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(?<=\S)(?<!\bAbstract)\n(?=\S)
36

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(?<=\S)(?<!\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'(?<=\S)(?<!\bAbstract)\n(?=\S)', ' ', inp)
39print(output)
40

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(?<=\S)(?<!\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'(?<=\S)(?<!\bAbstract)\n(?=\S)', ' ', inp)
39print(output)
40(?<=\S)(?<!\bAbstract)(?:\n|\\n)(?=\S)
41

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

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

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] & M[:,j] # Combine the columns with AND operator
18    count = np.sum(result & 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] & M # np.tile or np.repeat is used to horizontally repeat the column
22  counts = np.sum(result & 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] & M[:, j] & M[:, k]
30                out[i, j, k] = np.sum(result & N.ravel())
31    return out
32np.einsum('ij,ik,i->jk',M,M.astype(int),N.ravel())
33

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] & M[:,j] # Combine the columns with AND operator
18    count = np.sum(result & 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] & M # np.tile or np.repeat is used to horizontally repeat the column
22  counts = np.sum(result & 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] & M[:, j] & M[:, k]
30                out[i, j, k] = np.sum(result & N.ravel())
31    return out
32np.einsum('ij,ik,i->jk',M,M.astype(int),N.ravel())
33(M&N).T.dot(M.astype(int))
34(M&N).T.dot(M.astype(np.float32))
35

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] & M[:,j] # Combine the columns with AND operator
18    count = np.sum(result & 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] & M # np.tile or np.repeat is used to horizontally repeat the column
22  counts = np.sum(result & 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] & M[:, j] & M[:, k]
30                out[i, j, k] = np.sum(result & N.ravel())
31    return out
32np.einsum('ij,ik,i->jk',M,M.astype(int),N.ravel())
33(M&N).T.dot(M.astype(int))
34(M&N).T.dot(M.astype(np.float32))
35In [110]: np.random.seed(0)
36     ...: M = np.random.rand(500,300)>0.5
37     ...: N = np.random.rand(500,1)>0.5
38
39In [111]: %timeit np.einsum('ij,ik,i->jk',M,M.astype(int),N.ravel())
40     ...: %timeit (M&N).T.dot(M.astype(int))
41     ...: %timeit (M&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

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] & M[:,j] # Combine the columns with AND operator
18    count = np.sum(result & 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] & M # np.tile or np.repeat is used to horizontally repeat the column
22  counts = np.sum(result & 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] & M[:, j] & M[:, k]
30                out[i, j, k] = np.sum(result & N.ravel())
31    return out
32np.einsum('ij,ik,i->jk',M,M.astype(int),N.ravel())
33(M&N).T.dot(M.astype(int))
34(M&N).T.dot(M.astype(np.float32))
35In [110]: np.random.seed(0)
36     ...: M = np.random.rand(500,300)>0.5
37     ...: N = np.random.rand(500,1)>0.5
38
39In [111]: %timeit np.einsum('ij,ik,i->jk',M,M.astype(int),N.ravel())
40     ...: %timeit (M&N).T.dot(M.astype(int))
41     ...: %timeit (M&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&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