Datasets:

Dahoas

/

base_code_review

like 1

<p>The goal is to transpose the excel file that comes in the following form</p> <p><a href="https://i.stack.imgur.com/Svd49.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/Svd49.png" alt="enter image description here" /></a></p> <p>into this</p> <p><a href="https://i.stack.imgur.com/PlbRB.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/PlbRB.png" alt="enter image description here" /></a></p> <p>The code I created works properly, but I think it can be improved.</p> <p>I would also like to avoid using <code>reduce</code> to avoid importing <code>functools</code>.</p> <pre><code>#importing the libraries import pandas as pd from functools import reduce #defining the mapping list descriptions_pizzeria = [ &quot;Pizzeria Da Michele - Napoli&quot;, &quot;Pizzeria Da Michele - Roma&quot;, &quot;Pizzeria Da Michele - Bologna&quot;, &quot;Pizzeria Da Michele - Londra&quot;, ] pizzeria_code = [ 1, 2, 3 ] #path where the data are stored url_path = &quot;https://github.com/uomodellamansarda/AC_StackQuestions/blob/main/Pizzerie.xlsx? raw=true&quot; #reading the data df = pd.read_excel(url_path, index_col=0, header=3) #printing to have an idea print(df) #from an inspection we now that #the first column is where the Pizzeria code is stored #but we need to rename it #we need to rename the first column df = df.rename(columns={&quot;Unnamed: 1&quot;:&quot;Pizzeria code&quot;}) print(df.info()) #Grouping based on the pizzeria code G = df.groupby('Pizzeria code') pizzeria_df_list = [] for i, code in enumerate(pizzeria_code): #selecting the related Pizzeria commercial name description = descriptions_pizzeria[i] df_temp = G.get_group(code) #Dropping and trasposing the Pizzeria Code column df_temp = df_temp.drop(columns=&quot;Pizzeria code&quot;).transpose() #Based on what we know about the columns we can create the suffix col_suffix = ['Average Values', '# of customers ', 'Servings'] #and rename the columns df_temp.columns = [description + &quot;_&quot; + x for x in col_suffix] pizzeria_df_list.append(df_temp) pizzeria_df = reduce(lambda x, y: pd.merge(x, y,right_index=True, left_index=True), pizzeria_df_list) pizzeria_df.to_excel(&quot;Pizzeria_trasposed.xlsx&quot;) </code></pre>

270174

<p>I have (for example) the following license plate image: <a href="https://i.stack.imgur.com/ibnL8.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/ibnL8.png" alt="enter image description here" /></a></p> <p>And I want to segment the characters. The code I have so far consists of me using <code>cv2.MSER</code> to detect regions in the image. Afterwards I create bounding rectangles for each of the contours and create a dictionary according to height of the bounding boxes (characters). Then I get a dictionary key with the biggest number of items, this is an assumption, as there should not be anything else in the image other than the characters that are clearly visible and of the same height (relatively). The values of the key are x,y coordinates and width and height parameters of the bounding box. Afterwards, I sort the items of this dict key according to the x value, so that they are ordered as in the license plate image from left to right. Then I loop through the list in reverse order to remove duplicates (based on Euclidean distance I believe). What I want to know if there is any step of this process that could be improved upon, or if there is a defect in the thinking process. Code for show:</p> <pre><code>import cv2 import numpy as np img = cv2.imread('path_to_img', 0) mser = cv2.MSER_create() regions = mser.detectRegions(img)[0] h_dict = {} # group contours according to height for cnt in regions: x,y,w,h = cv2.boundingRect(cnt) if h in h_dict: if (x,y,w,h) not in h_dict[h]: h_dict[h].append((x,y,w,h)) else: continue else: h_dict[h] = [(x,y,w,h)] longest_key = max(h_dict, key=lambda x: len(h_dict[x])) sorted_longest = sorted(h_dict[longest_key], key=lambda x: [x][0]) # order according to x coordinate # remove duplicates for i, val in reversed(list(enumerate(sorted_longest))): for j, val2 in reversed(list(enumerate(sorted_longest))): if j &gt; i: result_dist = np.linalg.norm(np.asarray(val) - np.asarray(val2)) if result_dist &lt; 2: del sorted_longest[j] </code></pre> <p>Resulting image horizontally stacked: <a href="https://i.stack.imgur.com/26qLJ.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/26qLJ.png" alt="enter image description here" /></a></p>

270175

<p>I have this calculator. The user is asked to provide three numbers as well as the numeric operation they wish to perform. Based on this input, a certain case will be executed. The calculator is supposed to cover the basic arithmetic options such as + - * / as well as that &quot;dividing or multiplying numbers are stronger actions than adding or subtracting numbers&quot;, if that makes sense (sorry, I am not a native speaker).</p> <p>I think it works, but the code is clumsy and way too long. I feel like there must be a better way, but I don't really know how to improve the code as I am new to this.</p> <p>This is the code:</p> <pre class="lang-cs prettyprint-override"><code>using System; namespace Program { class Taschenrechner2 { public static void Main() { double eingabe1, eingabe2, eingabe3; string rechenoperator1, rechenoperator2; Console.WriteLine(&quot;Geben Sie die erste Zahl ein.&quot;); eingabe1 = Convert.ToDouble(Console.ReadLine()); Console.WriteLine(&quot;Geben Sie die erste Rechenoperation ein.&quot;); rechenoperator1 = Console.ReadLine(); Console.WriteLine(&quot;Geben Sie die zweite Zahl ein.&quot;); eingabe2 = Convert.ToDouble(Console.ReadLine()); Console.WriteLine(&quot;Geben Sie die zweite Rechenoperation ein.&quot;); rechenoperator2 = Console.ReadLine(); Console.WriteLine(&quot;Geben Sie die dritte Zahl ein.&quot;); eingabe3 = Convert.ToDouble(Console.ReadLine()); if (rechenoperator1 == &quot;-&quot; &amp;&amp; rechenoperator2 == &quot;-&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + (eingabe1 - eingabe2 - eingabe3)); Console.ReadKey(); } if (rechenoperator1 == &quot;+&quot; &amp;&amp; rechenoperator2 == &quot;+&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + (eingabe1 + eingabe2 + eingabe3)); Console.ReadKey(); } if (rechenoperator1 == &quot;+&quot; &amp;&amp; rechenoperator2 == &quot;-&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + (eingabe1 + eingabe2 - eingabe3)); Console.ReadKey(); } if (rechenoperator1 == &quot;-&quot; &amp;&amp; rechenoperator2 == &quot;+&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + (eingabe1 - eingabe2 + eingabe3)); Console.ReadKey(); } if (rechenoperator1 == &quot;*&quot; &amp;&amp; rechenoperator2 == &quot;+&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + ((eingabe1 * eingabe2) + eingabe3)); Console.ReadKey(); } if (rechenoperator1 == &quot;+&quot; &amp;&amp; rechenoperator2 == &quot;*&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + ((eingabe1 + eingabe2) * eingabe3)); Console.ReadKey(); } if (rechenoperator1 == &quot;-&quot; &amp;&amp; rechenoperator2 == &quot;*&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + ((eingabe1 - eingabe2) * eingabe3)); Console.ReadKey(); } if (rechenoperator1 == &quot;*&quot; &amp;&amp; rechenoperator2 == &quot;-&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + ((eingabe1 * eingabe2) - eingabe3)); Console.ReadKey(); } if (rechenoperator1 == &quot;*&quot; &amp;&amp; rechenoperator2 == &quot;*&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + (eingabe1 * eingabe2 * eingabe3)); Console.ReadKey(); } if (rechenoperator1 == &quot;*&quot; &amp;&amp; rechenoperator2 == &quot;/&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + ((eingabe1 * eingabe2) / eingabe3)); Console.ReadKey(); } if (rechenoperator1 == &quot;/&quot; &amp;&amp; rechenoperator2 == &quot;*&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + ((eingabe1 / eingabe2) * eingabe3)); Console.ReadKey(); } if (rechenoperator1 == &quot;-&quot; &amp;&amp; rechenoperator2 == &quot;/&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + (eingabe1 - (eingabe2 / eingabe3))); Console.ReadKey(); } if (rechenoperator1 == &quot;/&quot; &amp;&amp; rechenoperator2 == &quot;-&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + ((eingabe1 / eingabe2) - eingabe3)); Console.ReadKey(); } if (rechenoperator1 == &quot;+&quot; &amp;&amp; rechenoperator2 == &quot;/&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + (eingabe1 + (eingabe2 / eingabe3))); Console.ReadKey(); } if (rechenoperator1 == &quot;/&quot; &amp;&amp; rechenoperator2 == &quot;+&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + ((eingabe1 / eingabe2) + eingabe3)); Console.ReadKey(); } if (rechenoperator1 == &quot;/&quot; &amp;&amp; rechenoperator2 == &quot;/&quot;) { Console.WriteLine(&quot;Das Ergebnis ist: &quot; + ((eingabe1 / eingabe2) / eingabe3)); Console.ReadKey(); } } } } </code></pre> <p>I have tried to teach myself how to program multiple times, but every time I didn't manage to get further than the basics... This time I hope to get further, so any help would be appreciated!</p>

270177

<p>My assignment was to write a function that computes the value of an expression written in infix notation. We assume that we are using the four classical arithmetic operations +, -, * and / and that each binary operation is enclosed in parentheses.</p> <p>My stack:</p> <pre><code>class Stack: def __init__(self): self._arr = list() def push(self, item): self._arr.append(item) #return self def pop(self): assert not self.is_empty(), &quot;pop() on empty stack&quot; return self._arr.pop() def is_empty(self): return not bool(self._arr) def peek(self): assert not self.is_empty(), &quot;peek() on empty stack&quot; return self._arr[-1] def all_items(self): return self._arr def value_at_index(self, value): try: return self.items[value] except: return False def __len__(self): return len(self._arr) </code></pre> <p>The code:</p> <pre><code>def infix_brackets_eval(data): Stack = Stack() i = 0 ret = 0 while i &lt; len(data): if data[i] != ' ': if data[i] not in '+-*/()': temp = 0 while data[i] != ' ' and data[i]!= ')': temp = temp * 10 + int(data[i]) i+=1 i-=1 elif data[i] == ')': B = Stack.peek() Stack.pop() x = Stack.peek() Stack.pop() A = Stack.peek() Stack.pop() if Stack.peek() == '(': Stack.pop() if x == '-': temp = A - B elif x == '+': temp = A + B elif x == '*': temp = A * B elif x == '/': temp = A / B else: temp = data[i] #print(temp) Stack.push(temp) i += 1 return Stack.peek() infix_brackets_eval(&quot;((12 * 3) + (2 + 3) * (1 * 3))&quot;) </code></pre> <p>Output:</p> <pre><code>15 </code></pre> <p>Apart from the code comments of course, could any of you point me to an example use of a tokenizer or parser? I am very curious about the application and mechanics of how to use it, in the case when the tokens are operands, tokenize also need multi-digit numbers. Unfortunately I do not know where to look. I tried to rely on various documentation but I can not translate it to this example.</p>

270180

<p>I'm a Python novice. The system I'm using is called IBM <a href="http://ibm.com/docs/en/mam/7.6.1.2" rel="nofollow noreferrer">Maximo Asset Management</a>. In Maximo, we can write Python scripts that utilize Maximo's Java API/methods. So the script is technically a <a href="https://www.jython.org/" rel="nofollow noreferrer">Jython</a> script (Python + Java methods).</p> <hr /> <p>I've written a <a href="https://www.ibm.com/docs/en/mam/7.6.1.2?topic=product-automating-routine-tasks" rel="nofollow noreferrer">scheduled Jython 2.7 script</a> for checking an external system's <a href="https://enterprise.arcgis.com/en/server/10.7/publish-services/windows/what-is-a-map-service.htm" rel="nofollow noreferrer">web service</a> for issues.</p> <p>The idea is that this script would be run on a nightly schedule -- just after a scheduled integration has completed. I don't have control over the scheduled integration (I can't build this script right into the integration), but at least I can run a separate job to check for possible issues afterwards. And make it email me if it finds any issues.</p> <ol> <li>Did the web service produce an error?</li> <li>Are there any records that haven't been synced? (this is the <strong>main reason</strong> for the script)</li> <li>Did the web service time out? (the web service didn't have an error, it just didn't respond)</li> </ol> <hr /> <pre><code>from psdi.mbo import MboConstants from java.util import HashMap from com.ibm.json.java import JSONObject #The web service's vendor provides a public sample server that can be used for testing purposes: url = &quot;https://sampleserver6.arcgisonline.com/arcgis/rest/services/ServiceRequest/MapServer/1/query?where=SUBMITDT%3CDATE%272018-05-11%27&amp;f=pjson&amp;returnCountOnly=true&quot; def fetch_row_count(url): #Get the JSON text from the web service. ctx = HashMap() ctx.put(&quot;url&quot;, url) service.invokeScript(&quot;LIBHTTPCLIENT&quot;, ctx) json_text = str(ctx.get(&quot;response&quot;)) #Parse the row count from the JSON text` obj = JSONObject.parse(json_text) parsed_val = obj.get(&quot;count&quot;) return parsed_val try: result = fetch_row_count(url) if result == 0: print &quot;All records are synced. No need to do anything.&quot; #Check 1: elif result is None: #Email Template &quot;ERROR&quot;: &quot;The web service had an error when pinged.&quot; # &quot;Check for records that have not been synced.&quot; ctMboSet = mbo.getMboSet(&quot;$commtemp&quot;, &quot;COMMTEMPLATE&quot;, &quot;TEMPLATEID ='ERROR'&quot;) ctMbo = ctMboSet.getMbo(0) ctMbo.sendMessage(mbo, mbo) #Check 2: elif result &gt; 0: #Email Template &quot;NOSYNC&quot;: &quot;There are records that have not been synced.&quot; ctMboSet = mbo.getMboSet(&quot;$commtemp&quot;, &quot;COMMTEMPLATE&quot;, &quot;TEMPLATEID ='NOSYNC'&quot;) ctMbo = ctMboSet.getMbo(0) ctMbo.sendMessage(mbo, mbo) except: #Check 3 #Email Template &quot;TIMEOUT&quot;: &quot;The web service timed-out when pinged.&quot; # &quot;Check for records that have not been synced.&quot;&quot; ctMboSet = mbo.getMboSet(&quot;$commtemp&quot;, &quot;COMMTEMPLATE&quot;, &quot;TEMPLATEID ='TIMEOUT'&quot;) ctMbo = ctMboSet.getMbo(0) ctMbo.sendMessage(mbo, mbo) </code></pre> <p>You'll notice that I'm not passing information about errors to the emails that I'm sending (the emails are called &quot;Communication Templates&quot;). I'm not aware of an easy way to pass information, like &quot;Error 500&quot;, to the email communication templates. I think I'm stuck with sending generic emails -- the recipient will need to refer to the timestamp of the email and investigate the logs.</p> <hr /> <p>This is what's called a &quot;<a href="https://www.ibm.com/docs/en/maximo-for-utilities/7.6.0?topic=SSLLAM_7.6.0/com.ibm.mbs.doc/autoscript/c_example_reuse.html" rel="nofollow noreferrer">library script</a>&quot; in Maximo:</p> <p>LIBHTTPCLIENT (referenced in line #11 above)</p> <pre><code>from psdi.iface.router import HTTPHandler from java.util import HashMap from java.lang import String handler = HTTPHandler() map = HashMap() map.put(&quot;URL&quot;, url) map.put(&quot;HTTPMETHOD&quot;, &quot;GET&quot;) responseBytes = handler.invoke(map, None) response = String(responseBytes, &quot;utf-8&quot;) </code></pre> <hr /> <p>As a novice, I'm wondering if the script can be improved. Cheers.</p>

270182

<p>this is my first ansible playbook.</p> <p>it installs docker in swarm mode and automatically joins the cluster.</p> <p>could you guys please review my code and show me where it can be improved?</p> <pre><code>- hosts: all tasks: - name: Add apt key apt_key: url: https://download.docker.com/linux/raspbian/gpg state: present - name: Remove some packages apt: autoclean: yes autoremove: yes state: absent pkg: [python2, python-configparser, python-is-python2] - name: Install a list of packages apt: update_cache: yes pkg: - apt-transport-https - aptitude - ca-certificates - curl - libffi-dev - libssl-dev - python3 - python-is-python3 - software-properties-common - name: Get docker convenience script shell: curl -fsSL https://get.docker.com -o get-docker.sh args: creates: ~/get-docker.sh - name: Install docker shell: sh ~/get-docker.sh args: creates: /usr/bin/docker - name: Config user permissions user: name=&quot;{{ ansible_user_id }}&quot; groups=docker append=yes generate_ssh_key=yes #shell: usermod -aG docker $(whoami) - name: Install docker-compose pip: name=docker-compose state=latest #shell: pip3 -v install -U docker-compose #args: # creates: /usr/local/bin/docker-compose - name: Start service service: name=docker enabled=yes state=started - name: Get docker info shell: docker info register: docker_info changed_when: False - hosts: docker_swarm_manager tasks: - name: Create primary swarm manager shell: docker swarm init --advertise-addr {{ ansible_default_ipv4.address }} when: &quot;docker_info.stdout.find('Swarm: inactive') &gt; 0&quot; - name: Get docker swarm manager ip copy: content: '{{ ansible_default_ipv4.address }}' dest: '/tmp/dsm_ip' - name: Get docker swarm manager token shell: docker swarm join-token -q manager register: swarm_manager_token - copy: content: '{{ swarm_manager_token.stdout }}' dest: '/tmp/dsm_mt' - name: Get docker swarm worker token shell: docker swarm join-token -q worker register: swarm_worker_token - copy: content: '{{ swarm_worker_token.stdout }}' dest: '/tmp/dsm_wt' - hosts: all tasks: - name: Join the swarm shell: &quot;docker swarm join --token {{ lookup('file', '/tmp/dsm_mt') }} {{ lookup('file', '/tmp/dsm_ip') }}:2377&quot; when: &quot;docker_info.stdout.find('Swarm: inactive') &gt; 0&quot; retries: 5 delay: 5 </code></pre> <hr /> <blockquote> <p>A couple queries: 1. What version of ansible are you using? 2. Why are you not using the docker_swarm module? – 0xSheepdog</p> </blockquote> <ol> <li>ansible [core 2.11.6]</li> </ol> <pre><code>root@minipc:~# ansible --version ansible [core 2.11.6] config file = None configured module search path = ['/root/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules'] ansible python module location = /usr/local/lib/python3.8/dist-packages/ansible ansible collection location = /root/.ansible/collections:/usr/share/ansible/collections executable location = /usr/local/bin/ansible python version = 3.8.10 (default, Sep 28 2021, 16:10:42) [GCC 9.3.0] jinja version = 3.0.3 libyaml = True </code></pre> <ol start="2"> <li>i didnt even know there was a docker_swarm module. maybe you could post an answer showing how you would write the playbook using this module? my playbook was pretty simple to write, if using the module can save time, i dont mind changing.</li> </ol>

270183

<p>This code is Cholesky decomposition in numerical linear algebra.</p> <pre><code>function LLT = Cholesky(A) if is_pos_def(A) == 1 disp('Cholesky Decomposition is used only for positive definite matrixes') else n = rank(A); L = zeros(rank(A)); L(1,1) = sqrt(A(1,1)); for i=2:n L(i,1)=A(i,1)/L(1,1); end for i = 2:n L(i,i)= sqrt(A(i,i)- sum(power(L(i,1:i-1),2))); for j = i+1:n L(j,i) = (A(i,j)-(dot(L(j,1:i-1), L(i,1:i-1))))/L(i,i); end end end LLT = L; end </code></pre> <p>I'd prefer to use vectorized code instead of the second <code>for</code> loop.</p> <p>Is it possible to replace the inner (<code>j</code>) loop?</p>

270188

<p>This code converts a 3-letter English month abbreviation to its numeric equivalent (as a string).</p> <pre class="lang-java prettyprint-override"><code>public static String numericMonth(String monthInFull) { monthInFull = monthInFull.toUpperCase(); if (monthInFull.equals(&quot;JAN&quot;)) { return &quot;01&quot;; } if (monthInFull.equals(&quot;FEB&quot;)) { return &quot;02&quot;; } if (monthInFull.equals(&quot;MAR&quot;)) { return &quot;03&quot;; } if (monthInFull.equals(&quot;APR&quot;)) { return &quot;04&quot;; } if (monthInFull.equals(&quot;MAY&quot;)) { return &quot;05&quot;; } if (monthInFull.equals(&quot;JUN&quot;)) { return &quot;06&quot;; } if (monthInFull.equals(&quot;JUL&quot;)) { return &quot;07&quot;; } if (monthInFull.equals(&quot;AUG&quot;)) { return &quot;08&quot;; } if (monthInFull.equals(&quot;SEP&quot;)) { return &quot;09&quot;; } if (monthInFull.equals(&quot;OCT&quot;)) { return &quot;10&quot;; } if (monthInFull.equals(&quot;NOV&quot;)) { return &quot;11&quot;; } if (monthInFull.equals(&quot;DEC&quot;)) { return &quot;12&quot;; } return &quot;&quot;; } </code></pre> <p>Is it possible to create an array (or Enum?) listing the month names and their respective index (or index + 1) and avoid this excess of <code>if</code>?</p>

270196

<p>After having a good experience with virtualenvwrapper built on top of the venv, I thought maybe it could be benefitial to have similar shortcuts for standard activities with git which could be time saving as opposite to typing many commands.</p> <p>I've given it a try like the following:</p> <p>Start session (sync current repository with origin, create a session branch for the to-be merge request):</p> <pre><code>#!/bin/bash set -ex DATE=$(date +%F) git fetch --all --prune git pull git branch &quot;$USER-$DATE&quot; git checkout &quot;$USER-$DATE&quot; </code></pre> <p>Close session and integrate results to origin:</p> <pre><code>#!/bin/bash set -ex DATE=$(date +%F) DEFAULT_BRANCH = &quot;main&quot; git add . --all git commit -m &quot;$1&quot; git push -o merge_request.create -o merge_request.target=$DEFAULT_BRANCH origin &quot;$USER-$DATE&quot; git checkout $DEFAULT_BRANCH git branch -d &quot;$USER-$DATE&quot; </code></pre> <p>This works.. more or less, but it would be great to sort out some concerns I have got, general and specific.</p> <ul> <li>In general, maybe there is something I am missing therefore fixing details is waste of time because then I will discover some fundamental blocker, or maybe it's a common problem already solved (maybe in this, or other way)</li> <li>Specifically, there is some bash scripting yet to do which I could though sort out in separately, but maybe this is not all, therefore I try to review these details myself first.</li> </ul> <p>So the issues with the code are, from what I see:</p> <ul> <li>It's random whether the default branch is called &quot;main&quot; either &quot;master&quot;. So the script needs to detect/decide that somehow.</li> <li>The merge request branch name could be derived from repository name</li> <li>Not sure what could be a proper error handling to enable for defined states</li> <li>Is it matter of taste, or reasonable decision to put these scripts as separate files under <code>~/bin</code>, either integrate as functions to something bigger, and call through command line parameters? Then I will have possibly to look on Bash tabbing as well.</li> </ul> <p>Thanks for reading and looking forward to your feedback!</p>

270197

<p>This is original Code</p> <pre><code>if($(&quot;#dcl#dynamicID#&quot;).length &gt; 0){ var dcl = document.getElementById(&quot;dcl#dynamicID#&quot;); if(dcl.addEventListener){ dcl.addEventListener(&quot;click&quot;,function(e){ showDelete(this); (e.preventDefault) ? e.preventDefault() : e.returnValue = false; }); }else if(dcl.attachEvent){ dcl.attachEvent(&quot;onclick&quot;,function(e){ showDelete(dcl); (e.preventDefault) ? e.preventDefault() : e.returnValue = false; }); } } </code></pre> <p>and this is what i wrote</p> <pre><code>$(document).on('click','#dcl',function(e) { var eContactLink = $(this).attr('data-delete-pid'); showDelete(this); (e.preventDefault) ? e.preventDefault() : e.returnValue = false; }); </code></pre> <p>please note the <code>dynamicID</code> is the a dynamicvalue coming from <strong>coldfusion</strong></p>

270198

<p>Hello I'm relatively new to VBA and I have this macro to VLookup information into corresponding cells in the sheet that works, the issue is that it depends on a For Loop to iterate through 10s of thousands of rows. This is taking a significant amount of time to iterate and I know I'm asking a good amount of it but I feel like there's a faster way than how I have it currently. Any help would be appreciated!</p> <pre><code>Sub Test() Application.ScreenUpdating = False Dim Calc_Setting As Long Calc_Setting = Application.Calculation Application.Calculation = xlCalculationManual On Error Resume Next If ActiveSheet.AutoFilterMode Then ActiveSheet.ShowAllData On Error GoTo 0 Dim wb As Workbook Set wb = ActiveWorkbook Dim MARCws As Worksheet, FTws As Worksheet Dim MARCLastRow As Long, FTLastRow As Long, x As Long Dim dataRng As Range Set MARCws = wb.Sheets(&quot;MARC-MARA Pivot Values&quot;) Set FTws = wb.Sheets(&quot;Forecasting Template&quot;) MARCLastRow = MARCws.Range(&quot;A&quot; &amp; Rows.Count).End(xlUp).Row FTLastRow = FTws.Range(&quot;A&quot; &amp; Rows.Count).End(xlUp).Row Set dataRng = MARCws.Range(&quot;A4:Q&quot; &amp; MARCLastRow) For x = 4 To MARCLastRow On Error Resume Next FTws.Range(&quot;C&quot; &amp; x) = Application.WorksheetFunction.VLookup(FTws.Range(&quot;A&quot; &amp; x).Value, dataRng, 2, False) FTws.Range(&quot;E&quot; &amp; x) = Application.WorksheetFunction.VLookup(FTws.Range(&quot;A&quot; &amp; x).Value, dataRng, 3, False) FTws.Range(&quot;F&quot; &amp; x) = Application.WorksheetFunction.VLookup(FTws.Range(&quot;A&quot; &amp; x).Value, dataRng, 4, False) FTws.Range(&quot;G&quot; &amp; x) = Application.WorksheetFunction.VLookup(FTws.Range(&quot;A&quot; &amp; x).Value, dataRng, 5, False) FTws.Range(&quot;H&quot; &amp; x) = Application.WorksheetFunction.VLookup(FTws.Range(&quot;A&quot; &amp; x).Value, dataRng, 6, False) FTws.Range(&quot;I&quot; &amp; x) = Application.WorksheetFunction.VLookup(FTws.Range(&quot;A&quot; &amp; x).Value, dataRng, 7, False) FTws.Range(&quot;J&quot; &amp; x) = Application.WorksheetFunction.VLookup(FTws.Range(&quot;A&quot; &amp; x).Value, dataRng, 8, False) FTws.Range(&quot;K&quot; &amp; x) = Application.WorksheetFunction.VLookup(FTws.Range(&quot;A&quot; &amp; x).Value, dataRng, 9, False) FTws.Range(&quot;L&quot; &amp; x) = Application.WorksheetFunction.VLookup(FTws.Range(&quot;A&quot; &amp; x).Value, dataRng, 10, False) FTws.Range(&quot;M&quot; &amp; x) = Application.WorksheetFunction.VLookup(FTws.Range(&quot;A&quot; &amp; x).Value, dataRng, 12, False) FTws.Range(&quot;AZ&quot; &amp; x) = Application.WorksheetFunction.VLookup(FTws.Range(&quot;A&quot; &amp; x).Value, dataRng, 17, False) FTws.Range(&quot;BA&quot; &amp; x) = (FTws.Range(&quot;AZ&quot; &amp; x).Value / 30) Next x Application.ScreenUpdating = True Application.Calculation = Calc_Setting End Sub </code></pre>

270202

<p>I have put together <a href="https://github.com/lancejpollard/normalize-ast.js/blob/make/index.js" rel="nofollow noreferrer">this complete runnable source code</a> with an example set of <a href="https://github.com/lancejpollard/normalize-ast.js/blob/make/test.js" rel="nofollow noreferrer">test expressions</a> which it parses and prints. The code requires <code>acorn</code>, which is a JS AST generator from a string, so it can't easily run in StackOverflow I don't think. But here is the main <a href="https://github.com/lancejpollard/normalize-ast.js/blob/1a44a0be767015fafebccd4e0ef7efc9aba85785/index.js" rel="nofollow noreferrer">index.js</a> which I would like to refactor:</p> <pre><code>const acorn = require('acorn') const print = require('./print') const { createMemberExpression, createConditionalExpression, createBinaryExpression, createLogicalExpression, createIdentifier, createLiteral, createExpressionStatement, createVariableDeclaration, createVariableDeclarator, createAssignmentExpression, createCallExpression, createFunctionDeclaration, createFunctionExpression, createArrowFunctionExpression, createAssignmentPattern, createReturnStatement, createIfStatement, createBlockStatement, createObjectExpression, createProperty, createArrayExpression, createForInStatement, createForOfStatement, createWhileStatement, createLabeledStatement } = require('./create') module.exports = { parse, print, normalize } function parse(string) { return acorn.parse(string, { ecmaVersion: 2021, sourceType: 'module' }) } function normalize(input) { const output = { type: 'Program', body: [] } const scope = { index: 0, } input.body.forEach(node =&gt; { output.body.push(...normalizeBodyNode(node, scope)) }) return output } function normalizeBodyNode(node, scope) { const output = [] const normalizers = { VariableDeclaration() { const declarations = normalizeVariableDeclaration(node, scope) output.push(...declarations) }, ExpressionStatement() { const expressions = normalizeExpressionStatement(node.expression, scope) output.push(...expressions) }, FunctionDeclaration() { output.push(...normalizeFunctionDeclaration(node, scope)) }, ReturnStatement() { output.push(...normalizeReturnStatement(node, scope)) }, IfStatement() { const [ifStatement, expressions] = normalizeIfStatement(node, scope) output.push(...expressions) output.push(ifStatement) }, SwitchStatement() { const [swtch, expressions] = normalizeSwitchStatement(node, scope) }, ForInStatement() { const [forInStatement, expressions] = normalizeForInStatement(node, scope) output.push(...expressions) output.push(forInStatement) }, ForOfStatement() { const [forOfStatement, expressions] = normalizeForOfStatement(node, scope) output.push(...expressions) output.push(forOfStatement) }, WhileStatement() { const [whileStatement, expressions] = normalizeWhileStatement(node, scope) output.push(...expressions) output.push(whileStatement) }, ClassDeclaration() { const [clss, expressions] = normalizeClassDeclaration(node, scope) output.push(...expressions) output.push(clss) }, BreakStatement() { output.push(node) }, LabeledStatement() { const [body] = normalizeBodyNode(node.body, scope) const [label] = normalizeExpression(node.label, scope) output.push(createLabeledStatement(label, body)) }, ForStatement() { const blockStatement = normalizeForStatement(node, scope) output.push(blockStatement) }, BlockStatement() { output.push(normalizeBlockStatement(node, scope)) }, AssignmentExpression() { const [assign, expressions] = normalizeAssignmentExpression(node, scope) output.push(...expressions) output.push(assign) }, ExportNamedDeclaration() { const [exp, expressions] = normalizeExportNamedDeclaration(node, scope) output.push(...expressions) output.push(exp) } } call(normalizers, node.type) return output } function normalizeExportNamedDeclaration(node, scope) { const declaration = normalizeBodyNode(node.declaration, scope) const specifiers = [] } function normalizeAssignmentExpression(node, scope) { const [left, leftExps] = normalizeExpression(node.left, scope) const [right, rightExps] = normalizeExpression(node.right, scope) return [ createAssignmentExpression(left, right, node.operator), [...leftExps, ...rightExps] ] } function normalizeBlockStatement(node, scope) { const childScope = { ...scope } const body = [] node.body.forEach(bd =&gt; { body.push(...normalizeBodyNode(bd, childScope)) }) return createBlockStatement(body) } function normalizeForStatement(node, scope) { const childScope = { ...scope } let initExps if (node.init) { initExps = normalizeBodyNode(node.init, childScope) } else { initExps = [] } let test, testExps = [] if (node.test) { [test, testExps] = normalizeExpression(node.test, childScope, true) } const [update, updateExps] = normalizeExpression(node.update, childScope) const body = [] const normalizers = { BlockStatement() { node.body.body.forEach(bd =&gt; { body.push(...normalizeBodyNode(bd, childScope)) }) }, ExpressionStatement() { body.push(...normalizeBodyNode(node.body, childScope)) } } call(normalizers, node.body.type) const block = createBlockStatement([ ...initExps, createWhileStatement( createLiteral(true), [ ...testExps, createIfStatement(test, createBlockStatement([ ...body, ...updateExps, update ]), createBlockStatement([ createBreakStatement() ]) ) ] ) ]) return block } function normalizeClassDeclaration(node, scope) { const [id, idExps] = normalizeExpression(node.id, scope) const output = [...idExps] const superClass = null const [body, bodyExps] = normalizeClassBody(node.body, scope) output.push(...bodyExps) return [createClassDeclaration(id, superClass, body), output] } function createClassDeclaration(id, superClass, body) { return { type: 'ClassDeclaration', id, superClass, body } } function normalizeClassBody(node, scope) { const body = [] const output = [] node.body.forEach(bd =&gt; { const [method, methodExps] = normalizeMethodDefinition(bd, scope) output.push(...methodExps) body.push(method) }) return [createClassBody(body), output] } function createClassBody(body) { return { type: 'ClassBody', body } } function normalizeMethodDefinition(node, scope) { const [key, keyExps] = normalizeExpression(node.key, scope) const value = normalizeFunctionExpression(node.value, scope) return [createMethodDefinition(key, value.pop()), keyExps] } function createMethodDefinition(key, value) { return { type: 'MethodDefinition', key, value } } function normalizeForInStatement(node, scope) { const output = [] const [left, leftExps] = normalizeExpression(node.left, scope) const [right, rightExps] = normalizeExpression(node.right, scope) output.push(...leftExps) output.push(...rightExps) const body = [] if (node.body.type === 'BlockStatement') { node.body.body.forEach(bd =&gt; { body.push(...normalizeBodyNode(bd, { ...scope })) }) } else { body.push(...normalizeBodyNode(node.body, { ...scope })) } const forInStatement = createForInStatement(left, right, body) return [forInStatement, output] } function normalizeForOfStatement(node, scope) { const output = [] const [left, leftExps] = normalizeExpression(node.left, scope) const [right, rightExps] = normalizeExpression(node.right, scope) output.push(...leftExps) output.push(...rightExps) const body = [] node.body.body.forEach(bd =&gt; { body.push(...normalizeBodyNode(bd, { ...scope })) }) const forOfStatement = createForOfStatement(left, right, body) return [forOfStatement, output] } function createBreakStatement(label) { return { type: 'BreakStatement', label } } function normalizeWhileStatement(node, scope) { const [test, testExps] = normalizeExpression(node.test, scope, true) const body = [] node.body.body.forEach(bd =&gt; { body.push(...normalizeBodyNode(bd, { ...scope })) }) const newBody = [...testExps, createIfStatement(test, createBlockStatement(body), createBlockStatement([createBreakStatement()]))] const whileStatement = createWhileStatement(createLiteral(true), newBody) return [whileStatement, []] } function normalizeSwitchStatement(node, scope) { const discriminant = normalizeExpression(node.discriminant) return [] } function normalizeIfStatement(node, scope) { const top = [] const [test, testExpressionStatements] = normalizeExpression(node.test, scope, true) top.push(...testExpressionStatements) let consequent = [] if (node.consequent.type === 'BlockStatement') { node.consequent.body.forEach(statement =&gt; { const cons = normalizeBodyNode(statement, { ...scope }) consequent.push(...cons) }) } else { consequent.push(...normalizeExpressionStatement(node.consequent, { ...scope })) } consequent = createBlockStatement(consequent) let alternate = null if (node.alternate) { if (node.alternate.type === 'BlockStatement') { alternate = [] node.alternate.body.forEach(statement =&gt; { const alts = normalizeBodyNode(statement, { ...scope }) alternate.push(...alts) }) alternate = createBlockStatement(alternate) } else { [alternate, altExpressionStatements] = normalizeIfStatement(node.alternate, scope) top.push(...altExpressionStatements) } } const ifStatement = createIfStatement(test, consequent, alternate) return [ifStatement, top] } function normalizeReturnStatement(node, scope) { const output = [] const [arg, expressionStatements] = normalizeExpression(node.argument, scope, true) output.push(...expressionStatements) output.push(createReturnStatement(arg)) return output } function normalizeArrowFunctionExpression(node, scope) { const output = [] const params = [] node.params.forEach(param =&gt; { const [p, pExpressionStatements] = normalizeFunctionParam(param, scope) output.push(...pExpressionStatements) params.push(p) }) const normalizers = { CallExpression() { [body, expressions] = normalizeExpression(node.body, { ...scope }, true); body = createBlockStatement([ ...expressions, body ]) }, ArrayExpression() { [body, expressions] = normalizeExpression(node.body, { ...scope }); body = createBlockStatement([ ...expressions, createReturnStatement(body), ]) }, ObjectExpression() { [body, expressions] = normalizeExpression(node.body, { ...scope }); body = createBlockStatement([ ...expressions, createReturnStatement(body), ]) }, BlockStatement() { body = [] const childScope = { ...scope } node.body.body.forEach(bd =&gt; { body.push(...normalizeBodyNode(bd, childScope)) }) body = createBlockStatement(body) }, BinaryExpression() { [body, expressions] = normalizeExpression(node.body, { ...scope }); body = createBlockStatement([ ...expressions, createReturnStatement(body), ]) } } let body call(normalizers, node.body.type) return [ createArrowFunctionExpression(node.id, params, body), output ] } function normalizeFunctionExpression(node, scope) { const childScope = { ...scope } const output = [] const params = [] node.params.forEach(param =&gt; { const [p, pExpressionStatements] = normalizeFunctionParam(param, childScope) output.push(...pExpressionStatements) params.push(p) }) const body = [] node.body.body.forEach(bd =&gt; { body.push(...normalizeBodyNode(bd, childScope)) }) output.push(createFunctionExpression(node.id, params, body)) return output } function normalizeFunctionDeclaration(node, scope) { const output = [] const params = [] node.params.forEach(param =&gt; { const [p, pExpressionStatements] = normalizeFunctionParam(param, scope) output.push(...pExpressionStatements) params.push(p) }) const body = [] node.body.body.forEach(bd =&gt; { body.push(...normalizeBodyNode(bd, scope)) }) output.push(createFunctionDeclaration(node.id, params, body)) return output } function normalizeFunctionParam(node, scope) { const output = [] const expressionStatements = [] const normalizers = { Identifier() { output.push(node) }, AssignmentPattern() { const [left] = normalizeExpression(node.left, scope) const [right, rightExpressionStatements] = normalizeExpression(node.right, scope) expressionStatements.push(...rightExpressionStatements) // TODO: do inside the function. output.push( createAssignmentPattern(left, right) ) }, RestElement() { const [rest, restExps] = normalizeRestElement(node, scope) expressionStatements.push(...restExps) output.push(rest) } } call(normalizers, node.type) output.push(expressionStatements) return output } function normalizeRestElement(node, scope) { const [arg, argExps] = normalizeExpression(node.argument, scope) return [ createRestElement(arg), argExps ] } function createRestElement(argument) { return { type: 'RestElement', argument } } function normalizeVariableDeclaration(node, scope) { const output = [] node.declarations.forEach(dec =&gt; { const declarations = normalizeVariableDeclarator(node, dec, scope) output.push(...declarations) }) return output } function normalizeVariableDeclarator(parent, node, scope) { const output = [] const normalizeId = { Identifier() { const normalizeInit = { Identifier() { output.push( createVariableDeclaration(parent.kind, [ createVariableDeclarator(node.id, node.init) ]) ) }, Literal() { output.push( createVariableDeclaration(parent.kind, [ createVariableDeclarator(node.id, node.init) ]) ) }, ObjectExpression() { const props = [] node.init.properties.forEach(prop =&gt; { const [p, pExpressionStatements] = normalizeProperty(prop, scope) props.push(p) output.push(...pExpressionStatements) }) output.push(createVariableDeclaration(parent.kind, [ createVariableDeclarator(node.id, createObjectExpression(props) ) ])) }, ArrayExpression() { const els = [] node.init.elements.forEach(element =&gt; { const [p, pExpressionStatements] = normalizeExpression(element, scope) els.push(p) output.push(...pExpressionStatements) }) output.push(createVariableDeclaration(parent.kind, [ createVariableDeclarator(node.id, createArrayExpression(els) ) ])) }, ConditionalExpression() { const [test, testExpressionStatements] = normalizeExpression(node.init.test, scope) const [consequent, consequentExpressionStatements] = normalizeExpression(node.init.consequent, scope) const [alternate, alternateExpressionStatements] = normalizeExpression(node.init.alternate, scope) output.push(...testExpressionStatements) output.push(...consequentExpressionStatements) output.push(...alternateExpressionStatements) output.push(createVariableDeclaration(parent.kind, [ createVariableDeclarator(node.id, createConditionalExpression( test, consequent, alternate ) ) ])) }, FunctionExpression() { // output.push(...normalizeFunctionExpression(node.init, { ...scope })) }, MemberExpression() { const [object, objectStatements] = normalizeExpression(node.init.object, scope) const [property, propertyStatements] = normalizeExpression(node.init.property, scope) output.push(...objectStatements) output.push(...propertyStatements) output.push(createVariableDeclaration(parent.kind, [ createVariableDeclarator(node.id, createMemberExpression( object, property, node.init.computed ) ) ])) }, BinaryExpression() { const [left, leftExpressionStatements] = normalizeExpression(node.init.left, scope, true) const [right, rightExpressionStatements] = normalizeExpression(node.init.right, scope, true) output.push(...leftExpressionStatements) output.push(...rightExpressionStatements) output.push(createVariable(parent.kind, node.id, createBinaryExpression( left, node.init.operator, right ))) }, ArrowFunctionExpression() { const [func, expressions] = normalizeArrowFunctionExpression(node.init, scope) output.push(...expressions) output.push(createVariable(parent.kind, node.id, func)) }, NewExpression() { const [ctor, expressions] = normalizeNewExpression(node.init, scope) output.push(...expressions) output.push(createVariable(parent.kind, node.id, ctor)) }, CallExpression() { const [_callee, calleeStatements] = normalizeExpression(node.init.callee, scope) const args = [] node.init.arguments.forEach(arg =&gt; { const [argument, argumentStatements] = normalizeExpression(arg, scope, true) output.push(...argumentStatements) args.push(argument) }) output.push(...calleeStatements) output.push(createVariable(parent.kind, node.id, createCallExpression(_callee, args) )) }, TemplateLiteral() { const [template, expressions] = normalizeTemplateLiteral(node.init, scope) output.push(...expressions) output.push(createVariable(parent.kind, node.id, template)) }, TaggedTemplateExpression() { const [template, expressions] = normalizeTaggedTemplateExpression(node.init, scope) output.push(...expressions) output.push(createVariable(parent.kind, node.id, template)) }, UnaryExpression() { const [update, updateExps] = normalizeUnaryExpression(node.init, scope, true) output.push(...updateExps) // if (isolate) { // const name = `tmp${scope.index++}` // output.push( // createVariable('const', // createIdentifier(name), // update // ) // ) // output.push(createVariable(parent.kind, node.id, createIdentifier(name))) // } else { output.push(createVariable(parent.kind, node.id, update)) // } } } if (node.init) { call(normalizeInit, node.init.type) } else { output.push(createVariableDeclaration(parent.kind, [ createVariableDeclarator(node.id) ])) } }, ObjectPattern() { throw new Error('todo') }, ArrayPattern() { const normalizeInit = { Identifier() { node.id.elements.forEach(el =&gt; { output.push( createVariableDeclaration(parent.kind, [ createVariableDeclarator(el, createMemberExpression(node.init, el)) ]) ) }) }, MemberExpression() { node.id.elements.forEach(el =&gt; { output.push( createVariableDeclaration(parent.kind, [ createVariableDeclarator(el, createMemberExpression(node.init, el)) ]) ) }) }, // CallExpression() { // const [_callee, calleeStatements] = normalizeExpression(node.init.callee, scope) // const args = [] // node.init.arguments.forEach(arg =&gt; { // const [argument, argumentStatements] = normalizeExpression(arg, scope) // output.push(...argumentStatements) // args.push(argument) // }) // output.push(...calleeStatements) // output.push(createVariable(parent.kind, // createCallExpression(_callee, args) // )) // }, } call(normalizeInit, node.init.type) } } call(normalizeId, node.id.type) return output } function normalizeTaggedTemplateExpression(node, scope) { const [tag, tagExps] = normalizeExpression(node.tag, scope) const [template, templateExps] = normalizeTemplateLiteral(node.quasi, scope) return [ createTaggedTemplateExpression(tag, template), [...templateExps, ...tagExps] ] } function createTaggedTemplateExpression(tag, quasi) { return { type: 'TaggedTemplateExpression', tag, quasi } } function normalizeTemplateLiteral(node, scope) { const quasis = [] const expressions = [] const exps = [] node.expressions.forEach(expression =&gt; { const [exp, expExps] = normalizeExpression(expression, scope) expressions.push(exp) exps.push(...expExps) }) node.quasis.forEach(q =&gt; { quasis.push(normalizeTemplateElement(q, scope)) }) return [ createTemplateLiteral(expressions, quasis), exps ] } function normalizeTemplateElement(node, scope) { return node } function createTemplateLiteral(expressions, quasis) { return { type: 'TemplateLiteral', expressions, quasis } } function createVariable(kind, id, init) { return createVariableDeclaration(kind, [ createVariableDeclarator(id, init) ]) } function normalizeNewExpression(node, scope) { const [ctor, ctorExps] = normalizeExpression(node.callee, scope) const argExps = [] const args = [] node.arguments.forEach(arg =&gt; { const [argument, argumentExps] = normalizeExpression(arg, { ...scope }, true) args.push(argument) argExps.push(...argumentExps) }) return [createNewExpression(ctor, args), ctorExps.concat(argExps)] } function createNewExpression(ctor, args) { return { type: 'NewExpression', callee: ctor, arguments: args } } function normalizeSpreadElement(node, scope) { const [arg, argExps] = normalizeExpression(node.argument, scope) return [ createSpreadElement(arg), argExps ] } function createSpreadElement(argument) { return { type: 'SpreadElement', argument } } function normalizeProperty(node, scope) { if (node.type === 'SpreadElement') { return normalizeSpreadElement(node, scope) } const output = [] const [key, keyExpressionStatements] = normalizeExpression(node.key, scope) const [value, valueExpressionStatements] = normalizeExpression(node.value, scope) output.push(...keyExpressionStatements) output.push(...valueExpressionStatements) return [createProperty(key, value), output] } function normalizeExpressionStatement(node, scope) { const output = [] const normalizers = { AssignmentExpression() { // if node.left.type === 'ArrayPattern' const [left, leftExpressionStatements] = normalizeExpression(node.left, scope) const [right, rightExpressionStatements] = normalizeExpression(node.right, scope) output.push(...leftExpressionStatements) output.push(...rightExpressionStatements) if (Array.isArray(left)) { const name = `tmp${scope.index++}` output.push(createExpressionStatement( createAssignmentExpression( createIdentifier(name), right ) )) left.forEach(l =&gt; { output.push(createExpressionStatement( createAssignmentExpression(l, createMemberExpression( createIdentifier(name), l)) )) }) } else { output.push(createExpressionStatement( createAssignmentExpression(left, right) )) } }, Identifier() { output.push(createExpressionStatement(node)) }, MemberExpression() { const [object, objectStatements] = normalizeExpression(node.object, scope) const [property, propertyStatements] = normalizeExpression(node.property, scope) output.push(...objectStatements) output.push(...propertyStatements) output.push(createExpressionStatement( createMemberExpression( object, property, node.computed )) ) }, CallExpression() { const [_callee, calleeStatements] = normalizeExpression(node.callee, scope) const args = [] node.arguments.forEach(arg =&gt; { const [argument, argumentStatements] = normalizeExpression(arg, scope, true) output.push(...argumentStatements) args.push(argument) }) output.push(...calleeStatements) output.push(createExpressionStatement( createCallExpression(_callee, args) )) }, FunctionExpression() { output.push(...normalizeFunctionExpression(node, { ...scope })) }, NewExpression() { const [ctor, expressions] = normalizeNewExpression(node, scope) output.push(...expressions) output.push(createExpressionStatement(ctor)) }, TaggedTemplateExpression() { const [template, expressions] = normalizeTaggedTemplateExpression(node, scope) output.push(...expressions) output.push(createExpressionStatement(template)) }, SequenceExpression() { const expressions = normalizeSequenceExpression(node, scope) output.push(...expressions) }, ReturnStatement() { output.push(...normalizeReturnStatement(node, scope)) }, Literal() { output.push(node) }, ThrowStatement() { const [thrw, expressions] = normalizeThrowStatement(node, scope) output.push(...expressions) output.push(createExpressionStatement(thrw)) } } call(normalizers, node.type) return output } function normalizeThrowStatement(node, scope) { const [argument, argumentExps] = normalizeExpression(node.argument, scope) return [ createThrowStatement(argument), argumentExps ] } function createThrowStatement(argument) { return { type: 'ThrowStatement', argument } } function normalizeSequenceExpression(node, scope) { const expressions = [] // this just flattens the list and gets rid of the node type // in the normalized output node.expressions.forEach(exp =&gt; { expressions.push(...normalizeExpressionStatement(exp, scope)) }) return expressions } function normalizeExpression(node, scope, isolate = false) { const expressionStatements = [] const output = [] const normalizers = { Identifier() { output.push(node) }, MemberExpression() { const [object, objectStatements] = normalizeExpression(node.object, scope, isolate) const [property, propertyStatements] = normalizeExpression(node.property, scope, isolate) expressionStatements.push(...objectStatements) expressionStatements.push(...propertyStatements) output.push(createMemberExpression( object, property, node.computed )) }, CallExpression() { const [_callee, calleeStatements] = normalizeExpression(node.callee, scope, isolate) const args = [] node.arguments.forEach(arg =&gt; { const [argument, argumentStatements] = normalizeExpression(arg, scope, true) expressionStatements.push(...argumentStatements) args.push(argument) }) expressionStatements.push(...calleeStatements) const name = `tmp${scope.index++}` output.push(createIdentifier(name)) expressionStatements.push( createVariableDeclaration('const', [ createVariableDeclarator( createIdentifier(name), createCallExpression(_callee, args) ) ]) ) }, LogicalExpression() { const [left, leftExpressionStatements] = normalizeExpression(node.left, scope, true) const [right, rightExpressionStatements] = normalizeExpression(node.right, scope, true) expressionStatements.push(...leftExpressionStatements) expressionStatements.push(...rightExpressionStatements) const logicalExp = createLogicalExpression( left, node.operator, right ) if (isolate) { const name = `tmp${scope.index++}` expressionStatements.push( createVariable('const', createIdentifier(name), logicalExp ) ) output.push(createIdentifier(name)) } else { output.push(logicalExp) } }, BinaryExpression() { const [left, leftExpressionStatements] = normalizeExpression(node.left, scope, true) const [right, rightExpressionStatements] = normalizeExpression(node.right, scope, true) expressionStatements.push(...leftExpressionStatements) expressionStatements.push(...rightExpressionStatements) const binary = createBinaryExpression( left, node.operator, right ) if (isolate) { const name = `tmp${scope.index++}` expressionStatements.push( createVariable('const', createIdentifier(name), binary ) ) output.push(createIdentifier(name)) } else { output.push(binary) } }, ConditionalExpression() { const [test, testExpressionStatements] = normalizeExpression(node.test, scope, true) const [consequent, consequentExpressionStatements] = normalizeExpression(node.consequent, scope, true) const [alternate, alternateExpressionStatements] = normalizeExpression(node.alternate, scope, true) expressionStatements.push(...testExpressionStatements) expressionStatements.push(...consequentExpressionStatements) expressionStatements.push(...alternateExpressionStatements) const conditional = createConditionalExpression( test, consequent, alternate ) if (isolate) { const name = `tmp${scope.index++}` expressionStatements.push( createVariable('const', createIdentifier(name), conditional ) ) output.push(createIdentifier(name)) } else { output.push(conditional) } }, AssignmentExpression() { const [assign, expressions] = normalizeAssignmentExpression(node, scope) expressionStatements.push(...expressions) output.push(assign) }, ArrayPattern() { const array = [] node.elements.forEach(element =&gt; { const [el, elExpressionStatements] = normalizeExpression(element, scope) array.push(el) expressionStatements.push(...elExpressionStatements) }) output.push(array) }, Literal() { output.push(node) }, ObjectExpression() { const array = [] node.properties.forEach(prop =&gt; { const [el, elExpressionStatements] = normalizeExpression(prop, scope) array.push(el) expressionStatements.push(...elExpressionStatements) }) const objectExp = createObjectExpression(array) if (isolate) { const name = `tmp${scope.index++}` expressionStatements.push( createVariable('const', createIdentifier(name), objectExp ) ) output.push(createIdentifier(name)) } else { output.push(objectExp) } }, Property() { const [key, keyExps] = normalizeExpression(node.key, scope) const [value, valueExps] = normalizeExpression(node.value, scope) expressionStatements.push(...keyExps) expressionStatements.push(...valueExps) output.push(createProperty(key, value)) }, ArrayExpression() { const array = [] node.elements.forEach(element =&gt; { const [el, elExpressionStatements] = normalizeExpression(element, scope) array.push(el) expressionStatements.push(...elExpressionStatements) }) output.push(createArrayExpression(array)) }, FunctionExpression() { output.push(...normalizeFunctionExpression(node, scope)) }, VariableDeclaration() { output.push(...normalizeVariableDeclaration(node, scope)) }, ThisExpression() { output.push(node) }, SpreadElement() { const [spread, expressions] = normalizeSpreadElement(node, scope) expressionStatements.push(...expressions) output.push(spread) }, ArrowFunctionExpression() { const [arrow, arrowExps] = normalizeArrowFunctionExpression(node, scope) expressionStatements.push(...arrowExps) output.push(arrow) }, UpdateExpression() { const [update, updateExps] = normalizeUpdateExpression(node, scope) expressionStatements.push(...updateExps) output.push(update) }, UnaryExpression() { const [update, updateExps] = normalizeUnaryExpression(node, scope, isolate) expressionStatements.push(...updateExps) if (isolate) { const name = `tmp${scope.index++}` expressionStatements.push( createVariable('const', createIdentifier(name), update ) ) output.push(createIdentifier(name)) } else { output.push(update) } }, NewExpression() { const [ctor, expressions] = normalizeNewExpression(node, scope) expressionStatements.push(...expressions) output.push(ctor) } } call(normalizers, node.type) output.push(expressionStatements) return output } function normalizeUnaryExpression(node, scope, isolate) { const [argument, argumentExps] = normalizeExpression(node.argument, scope, isolate) return [ createUnaryExpression(argument, node.operator, node.prefix), argumentExps ] } function createUnaryExpression(argument, operator, prefix) { return { type: 'UnaryExpression', argument, operator, prefix } } function normalizeUpdateExpression(node, scope) { const [argument, argumentExps] = normalizeExpression(node.argument, scope) return [ createUpdateExpression(argument, node.operator, node.prefix), argumentExps ] } function createUpdateExpression(argument, operator, prefix) { return { type: 'UpdateExpression', argument, operator, prefix } } function call(obj, method, ...args) { if (!obj.hasOwnProperty(method)) { throw new Error(`Missing method ${method}`) } return obj[method](...args) } </code></pre> <p>So what this does is take a JavaScript source string, parse it into an AST, the traverse the AST and &quot;normalize&quot; it in a certain way, essentially hoisting variables and putting everything on a single line, so there are no nested expressions really. I am doing this for a side project, to transpile JS into a custom programming language, which only has rudimentary structures. So I simplify/normalize the JS so it can be easily converted into the target language.</p> <p>The way the code above works is, it is at a certain node. Then within that node you have a context of property expressions you can parse, so based on the context of the parent node, you have a few options for parsing the child property nodes. For example, the VariableDeclaration has an <code>id</code> prop, and an <code>init</code> prop. The <code>id</code> prop can be a simple name, or it can be an array expression (or an object expression, but I haven't handled that case just yet, only the array expression case). So we might have these examples:</p> <pre><code>const a1 = 123 const a2 = b const [a3, a4] = c const { a5, a6 } = d </code></pre> <p>For the array expression, it converts it into two different variable declarations, so it would be:</p> <pre><code>const a3 = c[0] const a4 = c[1] const a5 = d.a5 const a6 = d.a6 </code></pre> <p>Stuff like that. So that handling is based on the context. Likewise, in the ExpressionStatement context, we assume we have a whole line to ourselves. While in the plain Expression context, we could be nested inside something else. So you might have a ternary/conditional expression as an ExpressionStatement (on a line), or nested in an argument to a CallExpression. That sort of stuff. Or as the result of a variable. Etc.</p> <p>So what I ended up doing to &quot;solve&quot; these cases is to just duplicate a lot of the logic in multiple different contexts as you'll notice. They have slightly different final result handling, but the bulk of it is the same.</p> <p>How could I accomplish the following?</p> <ol> <li><strong>Reduce the duplication.</strong> So that there is only ideally one normalizer per node type, or at least the bulk of it is abstracted away somehow.</li> <li><strong>We can remove the <code>normalizers</code> objects</strong>. This is a dynamically constructed object with function handlers for each node type <em>depending on the context of the parent</em>. It uses a <code>node</code> property for the most part, coming from the parent function scope. Ideally we wouldn't be constructing functions like this on the fly. Instead, there would be a flat list of normalizer functions, independent of context potentially? I dunno if that is possible. But something to remove the scope-dependent implementation like I have.</li> </ol> <p><em>Do you even need the <code>normalizers</code> objects? Do you need to keep track of the parent context, and have a normalize function for each parent/child context pair? I'm not sure.</em></p> <p>You don't have to rewrite the entire file as it's over 1,000 lines currently and it is probably too much work. But if you could paint the picture on how to specifically refactor it to address these 2 points, that would be wonderful. Thank you.</p> <p><em>Note: what I'm finding is that I haven't handled every combination of contexts (parent/child relationships), so I keep having to add more normalizers to the normalizer map as I encounter them. But I have handled almost every type of expression at least once, so in theory I should not have to extend the code any further. That's sort of what I'm thinking.</em></p>

270208

<p>Consider the following piece of code I wrote (a templated Linked List):</p> <pre class="lang-java prettyprint-override"><code>package com.data_structures; public class LinkedList&lt;NodeDataType&gt; { public LinkedList() { super(); } class LinkedListNode&lt;DataType&gt; { private DataType data; LinkedListNode&lt;DataType&gt; nextNode; public LinkedListNode(DataType data) { this.data = data; this.nextNode = null; } public DataType getData() { return data; } public void setData(DataType data) { this.data = data; } @Override public String toString() { return String.valueOf(data).toString(); } } private LinkedListNode&lt;NodeDataType&gt; rootNode = null; private int nodeCount = 0; private void addTail(LinkedList&lt;NodeDataType&gt;.LinkedListNode&lt;NodeDataType&gt; node) { LinkedList&lt;NodeDataType&gt;.LinkedListNode&lt;NodeDataType&gt; temp = rootNode; while (temp.nextNode != null) { temp = temp.nextNode; } temp.nextNode = node; } private void changeRoot(LinkedList&lt;NodeDataType&gt;.LinkedListNode&lt;NodeDataType&gt; node) { node.nextNode = this.rootNode; this.rootNode = node; } private void addNodeAt(LinkedList&lt;NodeDataType&gt;.LinkedListNode&lt;NodeDataType&gt; node, int position) { LinkedListNode&lt;NodeDataType&gt; temp = this.rootNode; for (int i = 0; i &lt; position - 1; i++) { temp = temp.nextNode; } node.nextNode = temp.nextNode; temp.nextNode = node; } public LinkedList(NodeDataType data) { this.rootNode = new LinkedListNode&lt;&gt;(data); this.nodeCount++; } public int getNodeCount() { return nodeCount; } public void addNode(NodeDataType data, int position) { LinkedListNode&lt;NodeDataType&gt; node = new LinkedListNode&lt;&gt;(data); if (position &lt;= 1 || this.rootNode == null) { changeRoot(node); } else if (position &gt;= this.nodeCount) { addTail(node); } else { addNodeAt(node, position); } this.nodeCount++; } private void eraseRoot() { this.rootNode = this.rootNode.nextNode; } private void eraseTail() { LinkedList&lt;NodeDataType&gt;.LinkedListNode&lt;NodeDataType&gt; temp = this.rootNode; LinkedList&lt;NodeDataType&gt;.LinkedListNode&lt;NodeDataType&gt; temp2 = temp; while (temp.nextNode != null) { temp2 = temp; temp = temp.nextNode; } temp2.nextNode = null; } private void eraseNodeAt(int position) { LinkedList&lt;NodeDataType&gt;.LinkedListNode&lt;NodeDataType&gt; temp = this.rootNode; LinkedList&lt;NodeDataType&gt;.LinkedListNode&lt;NodeDataType&gt; temp2 = temp; for (int i = 0; i &lt; position - 1; i++) { temp2 = temp; temp = temp.nextNode; } temp2.nextNode = temp.nextNode; } public void deleteNode(int position) { if (position &lt;= 1) { eraseRoot(); } else if (position &gt;= this.nodeCount) { eraseTail(); } else { eraseNodeAt(position); } this.nodeCount--; } public NodeDataType getNode(int position) { if (position &lt;= 1) { return this.rootNode.data; } else { LinkedList&lt;NodeDataType&gt;.LinkedListNode&lt;NodeDataType&gt; node = this.rootNode; for (int i = 0; i &lt; position - 1 &amp;&amp; node.nextNode != null; i++) { node = node.nextNode; } return node.data; } } } </code></pre> <p>If we take a careful look at <code>addNode</code> and <code>deleteNode</code> functions, we see that I essentially had to write separate logic for &quot;ends&quot; and &quot;in-betweeners&quot;. I don't usually code in Java, and am not very good at Java. Is there a better logic for these 2 functions?</p>

270210

<h1>Front Matter</h1> <p>I'm learning Scala and have not gotten used to functional programming and the language. I'm hoping a review of my naively implemented code can help me bridge my object-oriented ways to something more functional and Scala-prescribed.</p> <p>I've uploaded all of my code here: <a href="https://gitlab.com/-/snippets/2209023/" rel="nofollow noreferrer">https://gitlab.com/-/snippets/2209023/</a></p> <h1>Problem</h1> <p>I have to merge 2 data sets and product a XML output.</p> <ul> <li>one dataset is entity data, e.g. <code>entity.csv</code></li> </ul> <pre><code>name, ip, name1,, name1,1.2.3.4, name3,1.2.3.4, name4,1.2.3.4, </code></pre> <ul> <li>another data set is streaming data, e.g. <code>streaming.csv</code></li> </ul> <pre><code>name, event, name1, event1, name1, event2, name2, event3, name3, event4, </code></pre> <h1>Concerns</h1> <p>I was not sure how to merge the 2 datasets without storing the data in a list of model objects. Is there a functional programming pattern to do this type of joining/merging?</p> <p>I thought that if I get a list of objects then I can feed it to a templating engine to produce the XML output. Is there a functional programming pattern to render the merged data as XML?</p> <h1>Approach</h1> <p>My naive approach is to:</p> <ol> <li>get a list of all the device names</li> <li>iterate through this list and fill out all of the relevant data needed for the XML output</li> <li>feed the list to a templating engine to product the XML file <ul> <li>This part has not been completed yet</li> </ul> </li> </ol> <h1>Implementation</h1> <h2>Step 1: Get List of Devices</h2> <p>In <code>Main.scala</code>, get a list of all the devices, e.g. <code>devices_list</code>:</p> <pre><code> val streaming = spark.read ... .load(&quot;src/main/resources/streaming.csv&quot;) // using steaming data because we want devices that has events ... val devices_df = streaming .select( &quot;name&quot;, ) .distinct val devices_list = new Devices(devices_df).devices() </code></pre> <p>In <code>Devices.scala</code>:</p> <pre><code>import org.apache.spark.sql.{Dataset, Row} import scala.collection.mutable.ListBuffer class Devices( val devices_df: Dataset[Row], ){ private var _devices = List[Device]() def devices(): List[Device] = { _get_devices() } private[this] def _get_devices(): List[Device] = { if (_devices.isEmpty) { _devices = _initialize_list_of_devices() } _devices } private[this] def _initialize_list_of_devices(): List[Device] = { val devices_list = ListBuffer[Device]() for (device &lt;- devices_df.collect()) { devices_list += new Device( device.getAs[String](&quot;name&quot;), ) } devices_list.toList } } </code></pre> <p>In <code>Device.scala</code>:</p> <pre><code>class Device( val name: String, ){ private var _events = List[String]() private var _ip = &quot;&quot; def getName(): String = { name } def getEvents(): List[String] = { _events } def setEvents(events: List[String]): Unit = { _events = events } def getIp(): String = { _ip } def setIp(ip: String): Unit = { _ip = ip } } </code></pre> <h2>Step 2: Fill Out Data for Each Device</h2> <p>In <code>Main.scala</code>, iterate through the list of devices and use <code>DataFiller</code> class:</p> <pre><code> for (device &lt;- devices_list) { new DataFiller( device, streaming, entity, ).fill() } </code></pre> <p>In <code>DataFiller</code>:</p> <pre><code>import org.apache.spark.sql.{Dataset, SparkSession, Row} import org.apache.spark.sql.functions.col class DataFiller( var device: Device, val streaming: Dataset[Row], val entity: Dataset[Row], ){ def fill() = { _fillEvents() _fillIp() } private[this] def _fillEvents(): Unit = { device.setEvents( streaming .filter(col(&quot;name&quot;) === device.getName()) .select(&quot;event&quot;) .rdd.map(event =&gt; { event.getAs[String](&quot;event&quot;) }) .collect.toList ) } private[this] def _fillIp(): Unit = { val ip_column = device_network_info .filter(col(&quot;name&quot;) === device.getName()) .filter(row =&gt; { !row.getAs[String](&quot;ip&quot;).isEmpty }) .select(&quot;ip&quot;) var ip:Any = &quot;&quot; if(!ip_column.rdd.isEmpty) { ip = ip_column.first().get(0) device.setIp(ip.toString) } } } </code></pre> <h2>Step 3: Output to XML</h2> <p>I have not implemented this part yet. I was thinking to use a templating engine and render the <code>devices_list</code>. I was not sure how to do this functionally without having a list with all of the data in model classes.</p> <p>Thank you for your time </p> <p>Here's the entire <code>Main.scala</code>:</p> <pre><code>import org.apache.spark.sql.SparkSession object Main extends App { val spark = SparkSession .builder() .master(&quot;local&quot;) .getOrCreate() val streaming = spark.read ... .load(&quot;src/main/resources/streaming.csv&quot;) val entity = spark.read ... .load(&quot;src/main/resources/entity.csv&quot;) val devices_df = streaming .select( &quot;name&quot;, ) .distinct val devices_list = new Devices(devices_df).devices() for (device &lt;- devices_list) { new DataFiller( device, streaming, entity, ).fill() } // output devices_list to XML spark.stop() } <span class="math-container">```</span> </code></pre>

270213

<p>I'm testing to use a fluent builder pattern for generating a pdf file using AbcPDF. I've looked at several methods of accomplishing this and I'd be very glad to get some input on what I've written so far to see if I'm going in the right direction or if there's some criticism.</p> <p>The idea is that I have a builder for each component in the pdf:</p> <ul> <li>Footer builder</li> <li>Page numbers builder</li> <li>Index builder</li> <li>Project information builder</li> <li>Customer information builder</li> <li>Document content (the main text) builder</li> </ul> <p>So for example I have an &quot;umbrella&quot; builder for generating a customer document that can contain some or all parts in that list. And then another &quot;umbrella&quot; builder for generating another type of document but contains some parts of the list.</p> <p>The main idea is to use the builders in the list for generating different types of documents. For example a sales report may contain some main content, footer and page numbers, whilst a customer document also needs customer information and maybe project information.</p> <p>I've looked at some that use inheritance with recursive generics, and fatected builders but in those examples my &quot;component builders&quot; (ref list above) would be coupled to the sales report builder or customer document builder. At least in those examples I've read(?).</p> <p>But yeah, the general idea is to have small builders not coupled with anything that can be reused by bigger builders that expose a set of the small builders that are appropriate to have in that context. Or is there a pattern better suited for this goal? Thanks :) And yeah, I don't know if the interfaces are neccessary, but I guess I kept them there to hear about what you guys thought about it.</p> <p>And the Doc variable is from the ABC pdf nuget package. It's the variable I write everything to. <a href="https://www.websupergoo.com/helppdfnet/default.htm" rel="nofollow noreferrer">Documentation</a></p> <pre><code>public class Main { public void Run() { CustomerDocumentBuilder.Create() .AddCustomerInformation(new CustomerInformation { Name = &quot;customer&quot; }) .AddProjectInformation(new ProjectInformation { Name = &quot;Project&quot; }) .AddDocument(new DocumentInformation { Name = &quot;Document text&quot; }) .AddPageNumbers() .AddFooter(&quot;Footer text&quot;) .Build(); } } public class CustomerDocumentBuilder { private readonly Doc _document; private CustomerDocumentBuilder() { _document = new(); } public static CustomerDocumentBuilder Create() =&gt; new(); public void Build() { _document.Save(&quot;C:\\pdf\\textflow.pdf&quot;); } public CustomerDocumentBuilder AddDocument( DocumentInformation documentInfo) { new DocumentBuilder(_document).AddDocument(documentInfo); return this; } public CustomerDocumentBuilder AddCustomerInformation( CustomerInformation customerInfo) { new CustomerBuilder(_document).AddCustomerInformation(customerInfo); return this; } public CustomerDocumentBuilder AddProjectInformation( ProjectInformation projectInfo) { new ProjectInfoBuilder(_document).AddProjectInformation(projectInfo); return this; } public CustomerDocumentBuilder AddFooter( string footerText) { new FooterBuilder(_document).AddFooter(footerText); return this; } public CustomerDocumentBuilder AddPageNumbers() { new PageNumbersBuilder(_document).AddPageNumbers(); return this; } } public class SalesReportBuilder { private readonly Doc _document; private SalesReportBuilder() { _document = new(); } public static SalesReportBuilder Create() =&gt; new(); public void Build() { _document.Save(&quot;C:\\pdf\\textflow.pdf&quot;); } public SalesReportBuilder AddDocument( DocumentInformation documentInfo) { new DocumentBuilder(_document).AddDocument(documentInfo); return this; } public SalesReportBuilder AddFooter( string footerText) { new FooterBuilder(_document).AddFooter(footerText); return this; } public SalesReportBuilder AddPageNumbers( DocumentInformation documentInfo) { new PageNumbersBuilder(_document).AddPageNumbers(); return this; } } public class CustomerBuilder : ICustomerBuilder { private readonly Doc _document; public CustomerBuilder( Doc document) { _document = document; } public ICustomerBuilder AddCustomerInformation( CustomerInformation customerInfo) { _document.AddTextStyled(customerInfo.Name); // etc... return this; } } public class DocumentBuilder : IDocumentBuilder { private readonly Doc _document; public DocumentBuilder( Doc document) { _document = document; } public IDocumentBuilder AddDocument( DocumentInformation documentInfo) { _document.AddTextStyled(documentInfo.Name); // etc... return this; } } public class ProjectInfoBuilder : IProjectInfoBuilder { private readonly Doc _document; public ProjectInfoBuilder( Doc document) { _document = document; } public IProjectInfoBuilder AddProjectInformation( ProjectInformation projectInfo) { _document.AddTextStyled(projectInfo.Name); // etc... return this; } } public class FooterBuilder : IFooterBuilder { private readonly Doc _document; public FooterBuilder( Doc document) { _document = document; } public IFooterBuilder AddFooter( string footerText) { _document.AddTextStyled(footerText); // etc... return this; } } public class PageNumbersBuilder : IPageNumbersBuilder { private readonly Doc _document; public PageNumbersBuilder( Doc document) { _document = document; } public IPageNumbersBuilder AddPageNumbers() { //calculcate pages and insert // page number to each pages return this; } } public interface IDocumentBuilder { IDocumentBuilder AddDocument(DocumentInformation documentInfo); } public interface ICustomerBuilder { ICustomerBuilder AddCustomerInformation(CustomerInformation customerInfo); } public interface IProjectInfoBuilder { IProjectInfoBuilder AddProjectInformation(ProjectInformation projectInfo); } public interface IFooterBuilder { IFooterBuilder AddFooter(string footerText); } public interface IPageNumbersBuilder { IPageNumbersBuilder AddPageNumbers(); } public class CustomerInformation { public string Name { get; set; } } public class ProjectInformation { public string Name { get; set; } } public class DocumentInformation { public string Name { get; set; } } </code></pre> <p><strong>Updated example:</strong></p> <pre><code> public interface ICustomerTextDocumentBuilder { Doc Build(); CustomerTextDocumentBuilder WithTextDocument( DocumentInformation documentInfo); CustomerTextDocumentBuilder WithCustomerInformation( CustomerInformation customerInfo); CustomerTextDocumentBuilder WithProjectInformation( ProjectInformation projectInfo); CustomerTextDocumentBuilder WithFooter( FooterInformation footerInfo); CustomerTextDocumentBuilder WithPageNumbers(); } public class CustomerTextDocumentBuilder : ICustomerTextDocumentBuilder { private readonly Doc _document; private CustomerTextDocumentBuilder() { _document = new(); } // private footerBuilder; public static CustomerTextDocumentBuilder Create() =&gt; new(); public Doc Build() { return _document; } public CustomerTextDocumentBuilder WithTextDocument( DocumentInformation documentInfo) { new TextDocumentPdfWriter(_document).AddDocument(documentInfo); return this; } public CustomerTextDocumentBuilder WithCustomerInformation( CustomerInformation customerInfo) { new CustomerInfoPdfWriter(_document).AddCustomerInformation(customerInfo); return this; } public CustomerTextDocumentBuilder WithProjectInformation( ProjectInformation projectInfo) { new ProjectInfoPdfWriter(_document).AddProjectInformation(projectInfo); return this; } public CustomerTextDocumentBuilder WithFooter( FooterInformation footerInfo) { new FooterPdfWriter(_document).AddFooter(footerInfo); return this; } public CustomerTextDocumentBuilder WithPageNumbers() { new PageNumbersPdfWriter(_document).AddPageNumbers(); return this; } } public class CustomerInfoPdfWriter : PdfWriter { private readonly Doc _document; public CustomerInfoPdfWriter( Doc document) { _document = document; } public void AddCustomerInformation( CustomerInformation customerInfo) { // write to doc... } } public class TextDocumentPdfWriter : PdfWriter { private readonly Doc _document; public TextDocumentPdfWriter( Doc document) { _document = document; } public void AddDocument( DocumentInformation documentInfo) { _document.Width = 4; _document.FontSize = 32; _document.TextStyle.Justification = 1; _document.Rect.String = &quot;100 200 500 600&quot;; _document.FrameRect(); var theId = _document.AddTextStyled(documentInfo.Name); while (_document.Chainable(theId)) { _document.Page = _document.AddPage(); _document.FrameRect(); theId = _document.AddTextStyled(&quot;&quot;, theId); } } } public class ProjectInfoPdfWriter : PdfWriter { private readonly Doc _document; public ProjectInfoPdfWriter( Doc document) { _document = document; } public void AddProjectInformation( ProjectInformation projectInfo) { _document.Width = 2; _document.FontSize = 20; _document.TextStyle.Justification = 5; _document.Rect.String = &quot;100 650 500 750&quot;; _document.FrameRect(); _document.AddText(projectInfo.Name); } } public class FooterPdfWriter : PdfWriter { private readonly Doc _document; public FooterPdfWriter( Doc document) { _document = document; } private void AddFooterOnPage(FooterInformation footerInfo) { var top = PDF_Document_page_footer_top; _document.TextStyle.HPos = PDF_Text_Align_Left; _document.Color.String = &quot;0 0 0&quot;; _document.FontSize = 7; _document.TextStyle.Font = _document.AddFont(PDF_Fonts_Regular); const int topMargin = 4; SetRect(_document, top - topMargin, 10, 28 + 12, PDF_Document_width - 28); _document.AddText(footerInfo.OrganizationName); _document.Rect.Top = top - topMargin - 10; _document.AddText(&quot;Organization number&quot; + &quot; &quot; + footerInfo.OrganizationNumber); SetRect(_document, top - 4, top - 11, PDF_Document_Margin, PDF_Document_width - PDF_Document_Margin); _document.Color.String = PDF_Color_Grey; _document.TextStyle.HPos = PDF_Text_Align_Center; _document.AddText($&quot;Document generated at {DateTime.UtcNow:dd.MM.yyyy}&quot;); } // Adds footer on all pages public void AddFooter( FooterInformation footerInfo) { var theCount = _document.PageCount; for (int i = 1; i &lt;= theCount; i++) { _document.PageNumber = i; AddFooterOnPage(footerInfo); } } } public class PageNumbersPdfWriter : PdfWriter { private readonly Doc _document; public PageNumbersPdfWriter( Doc document) { _document = document; } public void AddPageNumbers() { //calculcate pages and insert // page number to each pages } } public abstract class PdfWriter { protected const string PDF_Fonts_Regular = &quot;Helvetica&quot;; protected const int PDF_Document_width = 595; protected const int PDF_Document_page_footer_top = 42; protected const int PDF_Document_Margin = 28; protected const string PDF_Color_Grey = &quot;120 144 156&quot;; protected const double PDF_Text_Align_Left = 0; protected const double PDF_Text_Align_Center = 0.5; protected static void SetRect(Doc theDoc, double top, double bottom, double left, double right) { theDoc.Rect.Top = top; theDoc.Rect.Bottom = bottom; theDoc.Rect.Left = left; theDoc.Rect.Right = right; } } public class FooterInformation { public string OrganizationNumber { get; set; } public string OrganizationName { get; set; } } public class CustomerInformation { public string Name { get; set; } } public class ProjectInformation { public string Name { get; set; } } public class DocumentInformation { public string Name { get; set; } } </code></pre>

270215

<p>I have to write a program in python that will take a number and print a right triangle attempting to use all numbers from 1 to that number. For example:</p> <pre><code>Enter number: 10 Output: 7 8 9 10 4 5 6 2 3 1 Enter number: 6 Output: 4 5 6 2 3 1 Enter number: 20 Output: 11 12 13 14 15 7 8 9 10 4 5 6 2 3 1 </code></pre> <p>For which I have written the following function</p> <pre><code>def print_right_triangle(num): c = 1 k = 0 l = [] while(k &lt; num-1): v = [] for i in range(c): v.append(k+1) k += 1 c += 1 if k &gt; num: break l.append(v) p = len(l) for i in range(p): for j in l[p-(i+1)]: print(j, end=' ') print() return None print_right_triangle(10) </code></pre> <p>It's giving the same output and solved my problem. <strong>I was wondering is there any more pythonic way to do this</strong></p>

270218

<p>JSFiddle: <a href="https://jsfiddle.net/EddTally/jsa69f7r/3/#&amp;togetherjs=zMFpAQcRTt" rel="nofollow noreferrer">https://jsfiddle.net/EddTally/jsa69f7r/3/#&amp;togetherjs=zMFpAQcRTt</a></p> <p>Those who cannot access JSFiddle:</p> <pre><code>/** * Utilizes recursion to search through an item of any type (currently accepted types are object, array and string) * to find if it contains such a value. * * @param item * @param value */ function filterItem(item, value){ // Isn't object if(typeof item == 'string'){ return filterString(item, value) } // Is Array else if(Array.isArray(item)){ return filterArray(item, value) } // Is Object else{ return filterObj(item, value) } } /** * Checks if an object contains the value by recursively calling the filterItem function to work it's way through the obj. * * @param obj * @param value */ const filterObj = (obj, value) =&gt; { let contains = false; for(let [key, val] of Object.entries(obj)){ if(key.toString().toLowerCase().includes(value)){ contains = true break; }else{ if(filterItem(val, value)){ contains = true break; } } } return contains } /** * Used in the recursive function above, goes all the way down until it reaches the base string, then would return * the result of the .includes() funtion. * * @param array * @param value */ const filterArray = (array, value) =&gt; { let contains = false; for(let x of array){ if(filterItem(x, value)){ contains = true break; } } return contains } /** * Checks if an string contains the value * @param string * @param value */ const filterString = (string, value) =&gt; { return string.toString().toLowerCase().includes(value) } let exampleObj = {&quot;hi&quot;: [&quot;five&quot;, &quot;twenty&quot;, {&quot;11&quot;: 44, &quot;eggs&quot;: [&quot;egge&quot;]}]} console.log(filterItem(exampleObj, &quot;egge&quot;)) //Should come back true </code></pre> <p>I am wondering if this search/filter function is good or not, any potential things I may have missed out on or things to make it better.</p>

270220

<p>I have a class <code>Scholar</code> which is basically a teacher in a university. I have to calculate the yearly salary of a scholar instance where the formula is <code>12-month salary + bonus</code><br/> the bonus is determined by the academic_position <br/> if the teacher is:</p> <ul> <li>a Professor --&gt; bonus = 70000</li> <li>an Associate Professor --&gt; bonus = 50000</li> <li>an Assistant Professor --&gt; bonus = 30000</li> </ul> <p>I want to keep the <code>bonus</code> in a separate variable so i implemented it in <code>__init__</code>, but it looks messy. not sure if it is the way to do or not. do you have any suggestion on my code? Is there a way to improve readibility? what normally a pythonista do with this kind of problem?</p> <pre><code>class Scholar: def __init__(self, name, salary, academic_position): self.name = name self.salary = salary self.academic_position = academic_position if self.academic_position == 'Professor': self.bonus = 70000 elif self.academic_position == 'Associate Professor': self.bonus = 50000 elif self.academic_position == 'Assistance Professor': self.bonus = 30000 </code></pre>

270222

<p>I decided to implement a solver for linear systems of equations based on the gaussian elimination and reduction to upper triangular form. The gaussian elimination is quite simple to implement but the function to go from a &quot;gauss-eliminated&quot; matrix (upper triangular form) to a solution is excessively complicated in my opinion (<code>solve_given_augmented_gauss_eliminated</code>), I am interested in both improving the readability of this function and in improving the performance that as of now is about 100x times slower than the <code>np.linalg</code> implementation. Probably trying to avoid pure python for loops and using vectorialized operations would improve performance but I am not sure how to proceed.</p> <pre><code>import numpy as np import doctest import time def gauss_elimination(matrix): &quot;&quot;&quot; Performs gaussian elimination. Example from: http://sites.science.oregonstate.edu/math/home/programs/undergrad/CalculusQuestStudyGuides/vcalc/gauss/gauss.html &gt;&gt;&gt; gauss_elimination(np.array([[1,-3,1,4],\ [2,-8,8,-2],\ [-6,3,-15,9]], dtype=float)) array([[ 1., -3., 1., 4.], [ 0., -2., 6., -10.], [ 0., 0., -54., 108.]]) &quot;&quot;&quot; for i in range(len(matrix)): for j in range(i): weight_j = matrix[i][j] / matrix[j][j] matrix[i] -= (matrix[j] * weight_j) return matrix def solve_given_augmented_gauss_eliminated(gauss_eliminated): &quot;&quot;&quot; The augmented matrix is the matrix of the coefficients of the system with the known terms vector added to the right, for example: 1x + 0y = 1 1x + 1y = 3 is represented by: &gt;&gt;&gt; m = np.array([[1, 0, 1],\ [1, 1, 3]], dtype=float) The gaussian eliminated form is upper triangular and is: 1x + 0y = 1 0x + 1y = 2 So &gt;&gt;&gt; m = np.array([[1, 0, 1],\ [0, 1, 2]], dtype=float) &gt;&gt;&gt; solve_given_augmented_gauss_eliminated(m.copy()) array([1., 2.]) &quot;&quot;&quot; row_len = len(gauss_eliminated[0]) # start with ones, so unknown variables make no difference when multiplied values = np.ones(len(gauss_eliminated)) for i in range(len(gauss_eliminated)-1, -1, -1): # substitute the values of the known variables gauss_eliminated[i][:len(values)] = gauss_eliminated[i][:len(values)] * values # the numerator is the element on the left minus the sum of the elements on the right numerator = gauss_eliminated[i][row_len-1] - sum(gauss_eliminated[i][i+1:row_len-1]) # determine the value of the i-th element of the solution vector values[i] = numerator / gauss_eliminated[i][i] return values def check_solution(aug_gauss_eliminated, sol): &quot;&quot;&quot; &gt;&gt;&gt; m = np.array([[1, 0, 1],\ [1, 1, 3]], dtype=float) &gt;&gt;&gt; check_solution(m, np.array([1,2])) True &quot;&quot;&quot; return all( (sum(row[:len(sol)] * sol) == row[-1]) for row in aug_gauss_eliminated) def solve(aug_matrix): &quot;&quot;&quot; Example from https://www.cliffsnotes.com/study-guides/algebra/linear-algebra/linear-systems/gaussian-elimination examples 1 and 3 Be careful, the input matrix will be changed in a weird way, use .copy() to be safe. &gt;&gt;&gt; m1 = np.array([[1, 1, 3],\ [3, -2, 4]], dtype=float) &gt;&gt;&gt; solve(m1.copy()) array([2., 1.]) &gt;&gt;&gt; check_solution(m1, _) True &gt;&gt;&gt; m3 = np.array([[1, -2, 1, 0],\ [2, 1, -3, 5],\ [4, -7, 1, -1]], dtype=float) &gt;&gt;&gt; solve(m3.copy()) array([3., 2., 1.]) &gt;&gt;&gt; check_solution(m3, _) True &quot;&quot;&quot; gauss_eliminated = gauss_elimination(aug_matrix) return solve_given_augmented_gauss_eliminated(gauss_eliminated) if __name__ == &quot;__main__&quot;: doctest.testmod() for size in [10, 100, 200, 500, 1000]: coefficients = np.random.rand(size, size) known = np.random.rand(size) random_system = np.hstack((coefficients,known.reshape(size,1))) start = time.time() sol1 = solve(random_system) print(&quot;Size: &quot;, size) print(time.time() - start) start = time.time() sol2 = np.linalg.solve(coefficients, known) print(time.time() - start) # Final check, does my code give the same result as numpy? print(np.allclose(sol1, sol2)) print() </code></pre> <p>I also run the cProfile utility on my code finding out that the <code>gauss_elimination</code> is taking the longest time because it is a quadratic algorithm while <code>solve_given_augmented_gauss_eliminated</code> is linear, if my big O analysis is correct.</p> <pre><code>$&gt;python -m cProfile -s tottime gauss_elim.py Size: 10 0.0005228519439697266 0.0 True Size: 100 0.012234210968017578 0.0023505687713623047 True Size: 200 0.052938222885131836 0.003468036651611328 True Size: 500 0.3867616653442383 0.00789952278137207 True Size: 1000 1.7185072898864746 0.015315055847167969 True 127075 function calls (124279 primitive calls) in 2.382 seconds Ordered by: internal time ncalls tottime percall cumtime percall filename:lineno(function) 5 2.113 0.423 2.113 0.423 gauss_elim.py:5(gauss_elimination) 1810 0.051 0.000 0.051 0.000 {built-in method builtins.sum} 5 0.028 0.006 0.029 0.006 linalg.py:313(solve) 788 0.028 0.000 0.028 0.000 {built-in method nt.stat} 18 0.013 0.001 0.015 0.001 {built-in method _imp.create_dynamic} 316 0.013 0.000 0.013 0.000 {built-in method builtins.compile} 131 0.011 0.000 0.011 0.000 {built-in method marshal.loads} 10 0.009 0.001 0.009 0.001 {method 'rand' of 'numpy.random.mtrand.RandomState' objects} 2111 0.009 0.000 0.014 0.000 &lt;frozen importlib._bootstrap_external&gt;:91(_path_join) 181 0.007 0.000 0.007 0.000 {built-in method io.open_code} 181 0.007 0.000 0.007 0.000 {method 'read' of '_io.BufferedReader' objects} 5 0.006 0.001 0.057 0.011 gauss_elim.py:22(solve_given_augmented_gauss_eliminated) 1 0.004 0.004 0.004 0.004 {method 'read' of '_io.TextIOWrapper' objects} 318/315 0.004 0.000 0.008 0.000 {built-in method builtins.__build_class__} 57/22 0.003 0.000 0.032 0.001 {built-in method numpy.core._multiarray_umath.implement_array_function} 1 0.003 0.003 0.003 0.003 {built-in method _winapi.CreateProcess} 433 0.003 0.000 0.039 0.000 &lt;frozen importlib._bootstrap_external&gt;:1505(find_spec) 25 0.002 0.000 0.002 0.000 {built-in method builtins.print} 130/43 0.002 0.000 0.005 0.000 sre_parse.py:493(_parse) 18/13 0.001 0.000 0.012 0.001 {built-in method _imp.exec_dynamic} 182 0.001 0.000 0.001 0.000 {method '__exit__' of '_io._IOBase' objects} 131 0.001 0.000 0.035 0.000 &lt;frozen importlib._bootstrap_external&gt;:916(get_code) 13378/13119 0.001 0.000 0.001 0.000 {built-in method builtins.len} 4345 0.001 0.000 0.001 0.000 {built-in method builtins.getattr} 7061 0.001 0.000 0.001 0.000 {method 'endswith' of 'str' objects} 185/17 0.001 0.000 0.165 0.010 &lt;frozen importlib._bootstrap&gt;:1002(_find_and_load) 2111 0.001 0.000 0.001 0.000 &lt;frozen importlib._bootstrap_external&gt;:114(&lt;listcomp&gt;) 612 0.001 0.000 0.001 0.000 _inspect.py:65(getargs) 240/41 0.001 0.000 0.003 0.000 sre_compile.py:71(_compile) 500 0.001 0.000 0.002 0.000 &lt;frozen importlib._bootstrap&gt;:166(_get_module_lock) 5361 0.001 0.000 0.001 0.000 {method 'startswith' of 'str' objects} 8571 0.001 0.000 0.001 0.000 {built-in method builtins.isinstance} 182 0.001 0.000 0.044 0.000 &lt;frozen importlib._bootstrap&gt;:901(_find_spec) 169 0.001 0.000 0.042 0.000 &lt;frozen importlib._bootstrap_external&gt;:1374(_get_spec) 14 0.001 0.000 0.001 0.000 {built-in method nt.listdir} 334 0.001 0.000 0.001 0.000 functools.py:35(update_wrapper) 6614 0.001 0.000 0.001 0.000 {method 'append' of 'list' objects} 262 0.001 0.000 0.004 0.000 &lt;frozen importlib._bootstrap_external&gt;:361(cache_from_source) 286 0.001 0.000 0.003 0.000 overrides.py:89(verify_matching_signatures) 32 0.001 0.000 0.001 0.000 {built-in method io.open} 883 0.001 0.000 0.001 0.000 {method 'format' of 'str' objects} 500 0.001 0.000 0.001 0.000 &lt;frozen importlib._bootstrap&gt;:87(acquire) 6599 0.001 0.000 0.001 0.000 {method 'rstrip' of 'str' objects} 2570/2499 0.001 0.000 0.016 0.000 {method 'join' of 'str' objects} 316 0.001 0.000 0.020 0.000 overrides.py:183(decorator) 162/2 0.001 0.000 0.155 0.077 &lt;frozen importlib._bootstrap&gt;:659(_load_unlocked) 1026 0.001 0.000 0.001 0.000 {method 'match' of 're.Pattern' objects} 14 0.001 0.000 0.285 0.020 __init__.py:1(&lt;module&gt;) 500 0.001 0.000 0.001 0.000 &lt;frozen importlib._bootstrap&gt;:112(release) 448/1 0.001 0.000 2.383 2.383 {built-in method builtins.exec} 686 0.001 0.000 0.001 0.000 {built-in method __new__ of type object at 0x00007FFCBD32CC60} 616 0.001 0.000 0.002 0.000 _inspect.py:96(getargspec) 92 0.001 0.000 0.001 0.000 sre_compile.py:276(_optimize_charset) 2 0.001 0.000 0.001 0.000 {built-in method _ctypes.LoadLibrary} 2334 0.001 0.000 0.001 0.000 sre_parse.py:233(__next) 28 0.001 0.000 0.001 0.000 inspect.py:626(cleandoc) 162 0.001 0.000 0.004 0.000 &lt;frozen importlib._bootstrap&gt;:486(_init_module_attrs) 181 0.001 0.000 0.015 0.000 &lt;frozen importlib._bootstrap_external&gt;:1036(get_data) 185/17 0.000 0.000 0.165 0.010 &lt;frozen importlib._bootstrap&gt;:967(_find_and_load_unlocked) 50 0.000 0.000 0.000 0.000 {built-in method _imp.source_hash} 2253 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:231(_verbose_message) 1729 0.000 0.000 0.001 0.000 sre_parse.py:164(__getitem__) 1925 0.000 0.000 0.000 0.000 {built-in method builtins.hasattr} 131/2 0.000 0.000 0.155 0.077 &lt;frozen importlib._bootstrap_external&gt;:844(exec_module) 1982 0.000 0.000 0.001 0.000 sre_parse.py:254(get) 1 0.000 0.000 0.000 0.000 {built-in method _winapi.WaitForSingleObject} 10 0.000 0.000 0.000 0.000 {built-in method builtins.eval} 290/98 0.000 0.000 0.000 0.000 sre_parse.py:174(getwidth) 1 0.000 0.000 2.383 2.383 gauss_elim.py:1(&lt;module&gt;) 769 0.000 0.000 0.028 0.000 &lt;frozen importlib._bootstrap_external&gt;:135(_path_stat) 371 0.000 0.000 0.000 0.000 {built-in method _thread.allocate_lock} 193/25 0.000 0.000 0.130 0.005 &lt;frozen importlib._bootstrap&gt;:1033(_handle_fromlist) 284 0.000 0.000 0.002 0.000 function_base.py:475(add_newdoc) 177 0.000 0.000 0.010 0.000 re.py:289(_compile) 13 0.000 0.000 0.000 0.000 {built-in method _imp.create_builtin} 1246 0.000 0.000 0.000 0.000 {method 'rpartition' of 'str' objects} 149 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:696(spec_from_file_location) 10 0.000 0.000 0.001 0.000 __init__.py:345(namedtuple) 336/11 0.000 0.000 0.130 0.012 {built-in method builtins.__import__} 119/41 0.000 0.000 0.005 0.000 sre_parse.py:435(_parse_sub) 262 0.000 0.000 0.001 0.000 &lt;frozen importlib._bootstrap_external&gt;:127(_path_split) 1798 0.000 0.000 0.000 0.000 {built-in method builtins.setattr} 162/159 0.000 0.000 0.020 0.000 &lt;frozen importlib._bootstrap&gt;:558(module_from_spec) 433 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:64(_relax_case) 315 0.000 0.000 0.001 0.000 &lt;frozen importlib._bootstrap&gt;:203(_lock_unlock_module) 279 0.000 0.000 0.001 0.000 {built-in method builtins.max} 131 0.000 0.000 0.011 0.000 &lt;frozen importlib._bootstrap_external&gt;:645(_compile_bytecode) 495 0.000 0.000 0.002 0.000 &lt;frozen importlib._bootstrap_external&gt;:1337(_path_importer_cache) 14 0.000 0.000 0.001 0.000 &lt;frozen importlib._bootstrap_external&gt;:1556(_fill_cache) 184 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:185(cb) 131 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:560(_classify_pyc) 786 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:129(&lt;genexpr&gt;) 6 0.000 0.000 0.001 0.000 enum.py:179(__new__) 1 0.000 0.000 0.002 0.002 core.py:1(&lt;module&gt;) 191 0.000 0.000 0.007 0.000 &lt;frozen importlib._bootstrap_external&gt;:145(_path_is_mode_type) 1206 0.000 0.000 0.000 0.000 {built-in method builtins.min} 149 0.000 0.000 0.001 0.000 &lt;frozen importlib._bootstrap_external&gt;:1500(_get_spec) 378 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:398(parent) 15 0.000 0.000 0.001 0.000 doctest.py:1074(_find_lineno) 293 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:79(_unpack_uint32) 616 0.000 0.000 0.000 0.000 _inspect.py:13(ismethod) 149 0.000 0.000 0.003 0.000 &lt;frozen importlib._bootstrap_external&gt;:491(_get_cached) 184 0.000 0.000 0.001 0.000 &lt;frozen importlib._bootstrap&gt;:58(__init__) 41 0.000 0.000 0.009 0.000 sre_compile.py:759(compile) 280 0.000 0.000 0.003 0.000 &lt;frozen importlib._bootstrap&gt;:385(cached) 545 0.000 0.000 0.000 0.000 sre_parse.py:172(append) 343 0.000 0.000 0.000 0.000 {method 'strip' of 'str' objects} 52 0.000 0.000 0.000 0.000 core.py:889(__init__) 1204 0.000 0.000 0.000 0.000 {built-in method _imp.acquire_lock} 185 0.000 0.000 0.002 0.000 &lt;frozen importlib._bootstrap&gt;:156(__enter__) 23 0.000 0.000 0.000 0.000 {built-in method _abc._abc_init} 332 0.000 0.000 0.000 0.000 functools.py:65(wraps) 520 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:878(__exit__) 41 0.000 0.000 0.001 0.000 sre_compile.py:536(_compile_info) 520 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:874(__enter__) 245/2 0.000 0.000 0.154 0.077 &lt;frozen importlib._bootstrap&gt;:220(_call_with_frames_removed) 1002 0.000 0.000 0.000 0.000 {method '__exit__' of '_thread.lock' objects} 2 0.000 0.000 0.000 0.000 {built-in method sys.getwindowsversion} 1 0.000 0.000 0.008 0.008 numeric.py:1(&lt;module&gt;) 1204 0.000 0.000 0.000 0.000 {built-in method _imp.release_lock} 169 0.000 0.000 0.042 0.000 &lt;frozen importlib._bootstrap_external&gt;:1406(find_spec) 131 0.000 0.000 0.000 0.000 {built-in method _imp._fix_co_filename} 1 0.000 0.000 0.013 0.013 multiarray.py:1(&lt;module&gt;) 851 0.000 0.000 0.000 0.000 {method 'get' of 'dict' objects} 524 0.000 0.000 0.000 0.000 {method 'rfind' of 'str' objects} 612 0.000 0.000 0.000 0.000 _inspect.py:41(iscode) 616 0.000 0.000 0.000 0.000 _inspect.py:26(isfunction) 1016 0.000 0.000 0.000 0.000 {built-in method _thread.get_ident} 6 0.000 0.000 0.001 0.000 enum.py:545(&lt;listcomp&gt;) 15 0.000 0.000 0.010 0.001 pdb.py:142(__init__) 131 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:523(_check_name_wrapper) 15 0.000 0.000 0.011 0.001 doctest.py:1423(run) 92 0.000 0.000 0.000 0.000 sre_compile.py:249(_compile_charset) 626 0.000 0.000 0.000 0.000 sre_parse.py:249(match) 106 0.000 0.000 0.000 0.000 {built-in method numpy.array} 131 0.000 0.000 0.005 0.000 &lt;frozen importlib._bootstrap_external&gt;:1077(path_stats) 41 0.000 0.000 0.005 0.000 sre_parse.py:937(parse) 284 0.000 0.000 0.000 0.000 function_base.py:443(_needs_add_docstring) 1 0.000 0.000 0.001 0.001 getlimits.py:94(_register_known_types) 522 0.000 0.000 0.000 0.000 sre_parse.py:160(__len__) 40 0.000 0.000 0.000 0.000 _inspect.py:140(formatargspec) 284 0.000 0.000 0.000 0.000 function_base.py:461(_add_docstring) 177 0.000 0.000 0.007 0.000 &lt;frozen importlib._bootstrap_external&gt;:154(_path_isfile) 381 0.000 0.000 0.000 0.000 sre_parse.py:286(tell) 63 0.000 0.000 0.000 0.000 sre_parse.py:432(_uniq) 182 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:351(__init__) 309 0.000 0.000 0.000 0.000 {built-in method numpy.core._multiarray_umath.add_docstring} 2 0.000 0.000 0.003 0.001 function_base.py:1(&lt;module&gt;) 529 0.000 0.000 0.000 0.000 {method 'lower' of 'str' objects} 6 0.000 0.000 0.000 0.000 getlimits.py:35(__init__) 75 0.000 0.000 0.000 0.000 {built-in method _imp.is_builtin} 131 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:35(_new_module) 364 0.000 0.000 0.000 0.000 {method 'update' of 'dict' objects} 53 0.000 0.000 0.000 0.000 enum.py:88(__setitem__) 316 0.000 0.000 0.000 0.000 overrides.py:141(array_function_dispatch) 879 0.000 0.000 0.000 0.000 {method 'lstrip' of 'str' objects} 6 0.000 0.000 0.000 0.000 enum.py:221(&lt;setcomp&gt;) 185 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:160(__exit__) 83 0.000 0.000 0.000 0.000 enum.py:462(__setattr__) 1 0.000 0.000 0.002 0.002 _add_newdocs.py:1(&lt;module&gt;) 169 0.000 0.000 0.000 0.000 {built-in method _imp.is_frozen} 5 0.000 0.000 0.000 0.000 numeric.py:2257(isclose) 1 0.000 0.000 0.003 0.003 defchararray.py:1(&lt;module&gt;) 86 0.000 0.000 0.000 0.000 sre_parse.py:355(_escape) 5 0.000 0.000 0.000 0.000 numeric.py:2337(within_tol) 41 0.000 0.000 0.000 0.000 enum.py:977(__and__) 24 0.000 0.000 0.015 0.001 _add_newdocs_scalars.py:55(add_newdoc_for_scalar_type) 118 0.000 0.000 0.000 0.000 sre_compile.py:423(_simple) 15/1 0.000 0.000 0.002 0.002 doctest.py:975(_find) 1 0.000 0.000 0.000 0.000 core.py:2706(MaskedArray) 104 0.000 0.000 0.001 0.000 enum.py:358(__call__) 81 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:593(_validate_timestamp_pyc) 294 0.000 0.000 0.000 0.000 {built-in method from_bytes} 52/36 0.000 0.000 0.000 0.000 sre_compile.py:461(_get_literal_prefix) 1 0.000 0.000 0.000 0.000 {function SeedSequence.generate_state at 0x0000019E2E6AFCA0} 256 0.000 0.000 0.000 0.000 sre_parse.py:111(__init__) 151 0.000 0.000 0.000 0.000 {built-in method builtins.issubclass} 1 0.000 0.000 0.000 0.000 threading.py:1(&lt;module&gt;) 43 0.000 0.000 0.000 0.000 {method 'expandtabs' of 'str' objects} 865 0.000 0.000 0.000 0.000 {method 'isupper' of 'str' objects} 1 0.000 0.000 0.005 0.005 socket.py:4(&lt;module&gt;) 63 0.000 0.000 0.000 0.000 {built-in method fromkeys} 2 0.000 0.000 0.002 0.001 polynomial.py:1(&lt;module&gt;) 15 0.000 0.000 0.000 0.000 {method 'reduce' of 'numpy.ufunc' objects} 1 0.000 0.000 0.000 0.000 decoder.py:254(JSONDecoder) 12 0.000 0.000 0.000 0.000 datetime.py:492(__new__) 1 0.000 0.000 0.003 0.003 fromnumeric.py:1(&lt;module&gt;) 2 0.000 0.000 0.000 0.000 {built-in method nt.putenv} 6 0.000 0.000 0.002 0.000 enum.py:528(_convert_) 42 0.000 0.000 0.000 0.000 {method 'split' of 'str' objects} 185 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:152(__init__) 92 0.000 0.000 0.000 0.000 {method 'replace' of 'str' objects} 1 0.000 0.000 0.002 0.002 numerictypes.py:1(&lt;module&gt;) 14 0.000 0.000 0.000 0.000 {method 'split' of 're.Pattern' objects} 41 0.000 0.000 0.003 0.000 sre_compile.py:598(_code) 6 0.000 0.000 0.000 0.000 numeric.py:2514(extend_all) 268 0.000 0.000 0.000 0.000 {method 'find' of 'bytearray' objects} 106 0.000 0.000 0.000 0.000 {method 'extend' of 'list' objects} 209 0.000 0.000 0.000 0.000 socket.py:88(&lt;lambda&gt;) 450 0.000 0.000 0.000 0.000 {built-in method nt.fspath} 14 0.000 0.000 0.000 0.000 hashlib.py:126(__get_openssl_constructor) 18 0.000 0.000 0.000 0.000 sre_compile.py:413(&lt;listcomp&gt;) 57 0.000 0.000 0.000 0.000 sre_parse.py:84(opengroup) 30 0.000 0.000 0.000 0.000 getlimits.py:41(&lt;lambda&gt;) 2 0.000 0.000 0.005 0.003 shape_base.py:1(&lt;module&gt;) 182 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:736(find_spec) 32 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:167(_path_isabs) 14 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:1585(&lt;setcomp&gt;) 169 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:811(find_spec) 1 0.000 0.000 0.005 0.005 linalg.py:1(&lt;module&gt;) 1 0.000 0.000 0.002 0.002 scimath.py:1(&lt;module&gt;) 62 0.000 0.000 0.000 0.000 {built-in method nt.getcwd} 107 0.000 0.000 0.000 0.000 re.py:188(match) 14 0.000 0.000 0.001 0.000 &lt;frozen zipimport&gt;:63(__init__) 1 0.000 0.000 0.000 0.000 ctypeslib.py:365(&lt;dictcomp&gt;) 50 0.000 0.000 0.000 0.000 _internal.py:815(_ufunc_doc_signature_formatter) 14 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:1466(__init__) 1 0.000 0.000 0.000 0.000 laguerre.py:1(&lt;module&gt;) 1 0.000 0.000 0.006 0.006 pdb.py:3(&lt;module&gt;) 20 0.000 0.000 0.000 0.000 {method 'findall' of 're.Pattern' objects} 15 0.000 0.000 0.000 0.000 ntpath.py:289(expanduser) 1 0.000 0.000 0.002 0.002 npyio.py:1(&lt;module&gt;) 14 0.000 0.000 0.000 0.000 mixins.py:26(_reflected_binary_method) 41 0.000 0.000 0.000 0.000 sre_parse.py:224(__init__) 15 0.000 0.000 0.000 0.000 doctest.py:183(_extract_future_flags) 1 0.000 0.000 0.000 0.000 {built-in method nt._add_dll_directory} 14 0.000 0.000 0.001 0.000 &lt;frozen importlib._bootstrap_external&gt;:1324(_path_hooks) 131 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:1006(__init__) 210 0.000 0.000 0.000 0.000 socket.py:93(&lt;lambda&gt;) 1 0.000 0.000 0.001 0.001 nanfunctions.py:1(&lt;module&gt;) 15 0.000 0.000 0.000 0.000 doctest.py:1277(__run) 207 0.000 0.000 0.000 0.000 socket.py:78(&lt;lambda&gt;) 208 0.000 0.000 0.000 0.000 socket.py:83(&lt;lambda&gt;) 98 0.000 0.000 0.000 0.000 enum.py:670(__new__) 1 0.000 0.000 0.002 0.002 hmac.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 stride_tricks.py:1(&lt;module&gt;) 18 0.000 0.000 0.015 0.001 &lt;frozen importlib._bootstrap_external&gt;:1171(create_module) 345 0.000 0.000 0.000 0.000 {method 'add' of 'set' objects} 1 0.000 0.000 0.001 0.001 datetime.py:1(&lt;module&gt;) 1 0.000 0.000 0.011 0.011 index_tricks.py:1(&lt;module&gt;) 18 0.000 0.000 0.000 0.000 _ufunc_config.py:32(seterr) 1 0.000 0.000 0.004 0.004 subprocess.py:10(&lt;module&gt;) 178 0.000 0.000 0.000 0.000 {method 'pop' of 'dict' objects} 1 0.000 0.000 0.000 0.000 subprocess.py:700(Popen) 41 0.000 0.000 0.000 0.000 {built-in method _sre.compile} 13 0.000 0.000 0.000 0.000 {built-in method _imp.exec_builtin} 37 0.000 0.000 0.000 0.000 os.py:674(__getitem__) 41 0.000 0.000 0.000 0.000 os.py:746(encodekey) 1 0.000 0.000 0.000 0.000 result.py:24(TestResult) 1 0.000 0.000 0.000 0.000 _compat_pickle.py:9(&lt;module&gt;) 1 0.000 0.000 0.001 0.001 _type_aliases.py:1(&lt;module&gt;) 32 0.000 0.000 0.000 0.000 {built-in method nt._path_splitroot} 14 0.000 0.000 0.001 0.000 core.py:116(doc_note) 197 0.000 0.000 0.000 0.000 sre_parse.py:81(groups) 18 0.000 0.000 0.000 0.000 sre_compile.py:411(_mk_bitmap) 6 0.000 0.000 0.001 0.000 enum.py:475(_create_) 1 0.000 0.000 0.001 0.001 extras.py:1(&lt;module&gt;) 449 0.000 0.000 0.000 0.000 {built-in method builtins.ord} 1 0.000 0.000 0.000 0.000 arrayprint.py:1(&lt;module&gt;) 15 0.000 0.000 0.000 0.000 arrayprint.py:1527(_guarded_repr_or_str) 265 0.000 0.000 0.000 0.000 {method 'partition' of 'str' objects} 15 0.000 0.000 0.001 0.000 linecache.py:52(checkcache) 1 0.000 0.000 0.004 0.004 subprocess.py:1334(_execute_child) 1 0.000 0.000 0.002 0.002 twodim_base.py:1(&lt;module&gt;) 15 0.000 0.000 0.000 0.000 doctest.py:627(parse) 44 0.000 0.000 0.000 0.000 core.py:132(get_object_signature) 1 0.000 0.000 0.000 0.000 _string_helpers.py:9(&lt;listcomp&gt;) 1 0.000 0.000 0.002 0.002 pickle.py:1(&lt;module&gt;) 15 0.000 0.000 0.000 0.000 fromnumeric.py:69(_wrapreduction) 3 0.000 0.000 0.000 0.000 enum.py:1017(_decompose) 1 0.000 0.000 0.004 0.004 subprocess.py:756(__init__) 1 0.000 0.000 0.018 0.018 doctest.py:9(&lt;module&gt;) 41 0.000 0.000 0.000 0.000 sre_parse.py:76(__init__) 1 0.000 0.000 0.001 0.001 random.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 {built-in method winreg.OpenKeyEx} 40 0.000 0.000 0.000 0.000 sre_parse.py:295(_class_escape) 26 0.000 0.000 0.000 0.000 core.py:6755(getdoc) 15 0.000 0.000 0.001 0.000 bdb.py:54(reset) 18 0.000 0.000 0.000 0.000 _ufunc_config.py:131(geterr) 30 0.000 0.000 0.000 0.000 inspect.py:295(isroutine) 30 0.000 0.000 0.000 0.000 sre_compile.py:492(_get_charset_prefix) 1 0.000 0.000 0.000 0.000 {method 'readlines' of '_io._IOBase' objects} 1 0.000 0.000 0.000 0.000 subprocess.py:1207(_close_pipe_fds) 53 0.000 0.000 0.000 0.000 enum.py:44(_is_private) 1 0.000 0.000 0.001 0.001 parse.py:1(&lt;module&gt;) 10 0.000 0.000 0.000 0.000 {method 'sub' of 're.Pattern' objects} 1 0.000 0.000 0.002 0.002 pathlib.py:1(&lt;module&gt;) 18 0.000 0.000 0.000 0.000 enum.py:582(_find_data_type) 1 0.000 0.000 0.001 0.001 type_check.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 umath.py:1(&lt;module&gt;) 22/12 0.000 0.000 0.000 0.000 {built-in method _abc._abc_subclasscheck} 60 0.000 0.000 0.000 0.000 {method 'copy' of 'numpy.ndarray' objects} 16 0.000 0.000 0.000 0.000 _type_aliases.py:58(bitname) 123 0.000 0.000 0.000 0.000 sre_parse.py:168(__setitem__) 41 0.000 0.000 0.000 0.000 sre_parse.py:921(fix_flags) 1 0.000 0.000 0.002 0.002 _pocketfft.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 encoder.py:1(&lt;module&gt;) 18 0.000 0.000 0.000 0.000 sre_parse.py:267(getuntil) 13 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:757(create_module) 39 0.000 0.000 0.015 0.000 _add_newdocs_scalars.py:62(&lt;genexpr&gt;) 23 0.000 0.000 0.000 0.000 abc.py:105(__new__) 82 0.000 0.000 0.000 0.000 sre_compile.py:595(isstring) 371 0.000 0.000 0.000 0.000 {built-in method builtins.globals} 106 0.000 0.000 0.000 0.000 {built-in method builtins.abs} 51 0.000 0.000 0.009 0.000 re.py:250(compile) 13 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:415(spec_from_loader) 1 0.000 0.000 0.000 0.000 pickle.py:197(&lt;listcomp&gt;) 90 0.000 0.000 0.000 0.000 sre_compile.py:65(_combine_flags) 1 0.000 0.000 0.000 0.000 chebyshev.py:1(&lt;module&gt;) 57 0.000 0.000 0.000 0.000 sre_parse.py:96(closegroup) 1 0.000 0.000 0.000 0.000 {built-in method nt.scandir} 10 0.000 0.000 0.000 0.000 {method 'sort' of 'list' objects} 5 0.000 0.000 0.000 0.000 linalg.py:135(_commonType) 14 0.000 0.000 0.001 0.000 &lt;frozen importlib._bootstrap_external&gt;:1597(path_hook_for_FileFinder) 2 0.000 0.000 0.000 0.000 {built-in method builtins.dir} 43 0.000 0.000 0.000 0.000 os.py:740(check_str) 90 0.000 0.000 0.000 0.000 _inspect.py:131(strseq) 1 0.000 0.000 0.001 0.001 _methods.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 _type_aliases.py:94(_add_aliases) 18/13 0.000 0.000 0.012 0.001 &lt;frozen importlib._bootstrap_external&gt;:1179(exec_module) 50 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:621(_validate_hash_pyc) 1 0.000 0.000 0.000 0.000 getlimits.py:1(&lt;module&gt;) 5 0.000 0.000 0.029 0.006 &lt;__array_function__ internals&gt;:2(solve) 15 0.000 0.000 0.001 0.000 doctest.py:1036(_get_test) 46 0.000 0.000 0.000 0.000 types.py:171(__get__) 2 0.000 0.000 0.000 0.000 {built-in method nt.unsetenv} 15 0.000 0.000 0.000 0.000 arrayprint.py:468(wrapper) 162 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:406(has_location) 1 0.000 0.000 0.024 0.024 _add_newdocs_scalars.py:1(&lt;module&gt;) 1 0.000 0.000 0.002 0.002 decoder.py:1(&lt;module&gt;) 1 0.000 0.000 0.005 0.005 subprocess.py:1090(communicate) 1 0.000 0.000 0.000 0.000 base64.py:3(&lt;module&gt;) 19 0.000 0.000 0.000 0.000 {built-in method numpy.seterrobj} 2 0.000 0.000 0.000 0.000 {built-in method _ctypes.POINTER} 4 0.000 0.000 0.000 0.000 contextlib.py:452(callback) 1 0.000 0.000 0.001 0.001 _internal.py:1(&lt;module&gt;) 257 0.000 0.000 0.000 0.000 hmac.py:18(&lt;genexpr&gt;) 1 0.000 0.000 0.000 0.000 {built-in method _socket.gethostname} 13 0.000 0.000 0.000 0.000 ntpath.py:124(splitdrive) 1 0.000 0.000 0.007 0.007 platform.py:3(&lt;module&gt;) 41 0.000 0.000 0.000 0.000 doctest.py:568(__lt__) 15 0.000 0.000 0.000 0.000 fromnumeric.py:2367(all) 1 0.000 0.000 0.015 0.015 _pickle.py:1(&lt;module&gt;) 1 0.000 0.000 0.013 0.013 doctest.py:1862(testmod) 26 0.000 0.000 0.000 0.000 core.py:916(__init__) 75 0.000 0.000 0.000 0.000 overrides.py:122(decorator) 13 0.000 0.000 0.000 0.000 _dtype_ctypes.py:100(dtype_from_ctypes_type) 53 0.000 0.000 0.000 0.000 enum.py:22(_is_dunder) 30 0.000 0.000 0.015 0.000 platform.py:825(uname) 15 0.000 0.000 0.010 0.001 doctest.py:359(__init__) 6 0.000 0.000 0.000 0.000 enum.py:443(__members__) 29 0.000 0.000 0.000 0.000 inspect.py:727(getmodule) 288 0.000 0.000 0.000 0.000 {built-in method builtins.chr} 257 0.000 0.000 0.000 0.000 hmac.py:19(&lt;genexpr&gt;) 2 0.000 0.000 0.000 0.000 glob.py:117(_iterdir) 53 0.000 0.000 0.000 0.000 enum.py:33(_is_sunder) 1 0.000 0.000 0.001 0.001 selectors.py:1(&lt;module&gt;) 1 0.000 0.000 0.007 0.007 py3k.py:1(&lt;module&gt;) 10 0.000 0.000 0.001 0.000 extras.py:239(getdoc) 23 0.000 0.000 0.001 0.000 overrides.py:223(decorator) 30 0.000 0.000 0.000 0.000 getlimits.py:25(_fr1) 1 0.000 0.000 0.000 0.000 threading.py:95(_RLock) 1 0.000 0.000 0.000 0.000 utils.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 {built-in method _winapi.CreatePipe} 6 0.000 0.000 0.000 0.000 enum.py:618(_find_new_) 15 0.000 0.000 0.000 0.000 doctest.py:1402(__record_outcome) 1 0.000 0.000 0.000 0.000 version.py:1(&lt;module&gt;) 1 0.000 0.000 0.001 0.001 signal.py:1(&lt;module&gt;) 7 0.000 0.000 0.000 0.000 getlimits.py:514(__init__) 1 0.000 0.000 0.009 0.009 platform.py:360(win32_ver) 1 0.000 0.000 0.000 0.000 _polybase.py:18(ABCPolyBase) 5 0.000 0.000 0.000 0.000 textwrap.py:414(dedent) 13 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:241(_requires_builtin_wrapper) 15 0.000 0.000 0.001 0.000 pdb.py:196(reset) 14 0.000 0.000 0.000 0.000 __init__.py:142(_check_size) 1 0.000 0.000 0.000 0.000 __init__.py:337(_sanity_check) 1 0.000 0.000 0.011 0.011 overrides.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 _ufunc_config.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 hermite.py:1(&lt;module&gt;) 75 0.000 0.000 0.000 0.000 overrides.py:111(set_module) 1 0.000 0.000 0.001 0.001 arraysetops.py:1(&lt;module&gt;) 59 0.000 0.000 0.000 0.000 _inspect.py:144(&lt;lambda&gt;) 6 0.000 0.000 0.000 0.000 numeric.py:149(ones) 30 0.000 0.000 0.000 0.000 getlimits.py:40(&lt;lambda&gt;) 131 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:1031(get_filename) 8 0.000 0.000 0.000 0.000 enum.py:971(__or__) 82 0.000 0.000 0.000 0.000 sre_compile.py:453(_get_iscased) 13 0.000 0.000 0.000 0.000 {method 'setter' of 'property' objects} 5 0.000 0.000 0.003 0.001 shape_base.py:285(hstack) 3 0.000 0.000 0.000 0.000 enum.py:938(_create_pseudo_member_) 33 0.000 0.000 0.000 0.000 {method 'items' of 'mappingproxy' objects} 131 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:841(create_module) 115 0.000 0.000 0.000 0.000 {method 'items' of 'dict' objects} 30 0.000 0.000 0.000 0.000 getlimits.py:17(_fr0) 3 0.000 0.000 0.000 0.000 decoder.py:343(raw_decode) 18 0.000 0.000 0.000 0.000 enum.py:571(_get_mixins_) 1 0.000 0.000 0.008 0.008 _distributor_init.py:2(&lt;module&gt;) 112 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:1472(&lt;genexpr&gt;) 41 0.000 0.000 0.000 0.000 enum.py:12(_is_descriptor) 76 0.000 0.000 0.000 0.000 inspect.py:64(ismodule) 1 0.000 0.000 0.000 0.000 hashlib.py:5(&lt;module&gt;) 2 0.000 0.000 0.000 0.000 core.py:2974(__array_finalize__) 3 0.000 0.000 0.000 0.000 ntpath.py:180(split) 5 0.000 0.000 0.001 0.000 &lt;__array_function__ internals&gt;:2(allclose) 2 0.000 0.000 0.000 0.000 ntpath.py:450(normpath) 1 0.000 0.000 0.000 0.000 case.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 _endian.py:1(&lt;module&gt;) 5 0.000 0.000 2.170 0.434 gauss_elim.py:68(solve) 1 0.000 0.000 0.000 0.000 records.py:1(&lt;module&gt;) 16 0.000 0.000 0.000 0.000 _type_aliases.py:44(_bits_of) 1 0.000 0.000 0.000 0.000 ctypeslib.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 case.py:309(TestCase) 18 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:1155(__init__) 61 0.000 0.000 0.000 0.000 {method 'translate' of 'str' objects} 17 0.000 0.000 0.000 0.000 inspect.py:494(unwrap) 78 0.000 0.000 0.000 0.000 _internal.py:826(&lt;genexpr&gt;) 1 0.000 0.000 0.000 0.000 pprint.py:103(PrettyPrinter) 15 0.000 0.000 0.000 0.000 arrayprint.py:1534(_array_str_implementation) 7 0.000 0.000 0.000 0.000 {method 'remove' of 'list' objects} 18 0.000 0.000 0.000 0.000 core.py:992(__init__) 6 0.000 0.000 0.000 0.000 {built-in method numpy.empty} 15 0.000 0.000 0.000 0.000 &lt;__array_function__ internals&gt;:2(all) 9 0.000 0.000 0.000 0.000 _ufunc_config.py:429(__enter__) 26 0.000 0.000 0.000 0.000 core.py:6750(__init__) 17 0.000 0.000 0.000 0.000 _collections_abc.py:767(__contains__) 6 0.000 0.000 0.000 0.000 &lt;__array_function__ internals&gt;:2(copyto) 17 0.000 0.000 0.000 0.000 inspect.py:91(ismethoddescriptor) 5 0.000 0.000 0.001 0.000 numeric.py:2179(allclose) 1 0.000 0.000 0.009 0.009 subprocess.py:464(run) 6 0.000 0.000 0.000 0.000 enum.py:164(__prepare__) 1 0.000 0.000 0.000 0.000 numerictypes.py:442(_construct_lookups) 8 0.000 0.000 0.000 0.000 core.py:8103(getdoc) 1 0.000 0.000 0.000 0.000 argparse.py:4(&lt;module&gt;) 15 0.000 0.000 0.000 0.000 doctest.py:776(_min_indent) 1 0.000 0.000 0.000 0.000 {built-in method _hashlib.openssl_sha512} 1 0.000 0.000 0.000 0.000 pickle.py:1136(_Unpickler) 15 0.000 0.000 0.000 0.000 doctest.py:666(get_doctest) 1 0.000 0.000 0.000 0.000 fnmatch.py:80(translate) 1 0.000 0.000 0.000 0.000 posixpath.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 pathlib.py:653(PurePath) 15 0.000 0.000 0.000 0.000 doctest.py:528(__init__) 2 0.000 0.000 0.000 0.000 {method 'close' of '_io.TextIOWrapper' objects} 64 0.000 0.000 0.000 0.000 inspect.py:73(isclass) 15 0.000 0.000 0.000 0.000 pdb.py:200(forget) 1 0.000 0.000 0.000 0.000 _type_aliases.py:74(_add_types) 30 0.000 0.000 0.000 0.000 _type_aliases.py:203(_add_array_type) 1 0.000 0.000 0.005 0.005 secrets.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 difflib.py:1(&lt;module&gt;) 52 0.000 0.000 0.000 0.000 _add_newdocs.py:6230(refer_to_array_attribute) 1 0.000 0.000 0.009 0.009 platform.py:261(_syscmd_ver) 144 0.000 0.000 0.000 0.000 {built-in method builtins.id} 31 0.000 0.000 0.000 0.000 signal.py:10(&lt;lambda&gt;) 1 0.000 0.000 0.000 0.000 mixins.py:59(NDArrayOperatorsMixin) 14 0.000 0.000 0.000 0.000 re.py:223(split) 1 0.000 0.000 0.000 0.000 hermite_e.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 core.py:6439(__new__) 1 0.000 0.000 0.000 0.000 legendre.py:1(&lt;module&gt;) 83 0.000 0.000 0.000 0.000 {method 'get' of 'mappingproxy' objects} 4 0.000 0.000 0.000 0.000 ntpath.py:77(join) 50 0.000 0.000 0.000 0.000 {built-in method sys.intern} 1 0.000 0.000 0.000 0.000 __config__.py:3(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 _globals.py:1(&lt;module&gt;) 59 0.000 0.000 0.000 0.000 {built-in method builtins.repr} 24 0.000 0.000 0.000 0.000 numerictypes.py:515(_scalar_type_key) 5 0.000 0.000 0.000 0.000 shape_base.py:23(atleast_1d) 1 0.000 0.000 0.006 0.006 defmatrix.py:1(&lt;module&gt;) 6 0.000 0.000 0.003 0.001 &lt;__array_function__ internals&gt;:2(concatenate) 1 0.000 0.000 0.000 0.000 histograms.py:1(&lt;module&gt;) 15 0.000 0.000 0.000 0.000 doctest.py:678(get_examples) 5 0.000 0.000 0.000 0.000 {method 'astype' of 'numpy.ndarray' objects} 61 0.000 0.000 0.000 0.000 inspect.py:159(isfunction) 49 0.000 0.000 0.000 0.000 _string_helpers.py:16(english_lower) 1 0.000 0.000 0.000 0.000 loader.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 einsumfunc.py:1(&lt;module&gt;) 1 0.000 0.000 0.009 0.009 subprocess.py:377(check_output) 11 0.000 0.000 0.000 0.000 {built-in method _abc._abc_register} 4 0.000 0.000 0.000 0.000 warnings.py:181(_add_filter) 10 0.000 0.000 0.000 0.000 linalg.py:107(_makearray) 1 0.000 0.000 0.000 0.000 _iotools.py:451(StringConverter) 3 0.000 0.000 0.001 0.000 __init__.py:340(__init__) 1 0.000 0.000 0.000 0.000 os.py:48(&lt;listcomp&gt;) 50 0.000 0.000 0.000 0.000 __init__.py:419(&lt;genexpr&gt;) 15 0.000 0.000 0.000 0.000 bdb.py:273(_set_stopinfo) 2 0.000 0.000 0.000 0.000 {built-in method builtins.sorted} 1 0.000 0.000 0.000 0.000 tokenize.py:388(open) 7 0.000 0.000 0.000 0.000 core.py:2553(_arraymethod) 52 0.000 0.000 0.000 0.000 {method 'setdefault' of 'dict' objects} 91 0.000 0.000 0.000 0.000 {built-in method _sre.unicode_iscased} 2 0.000 0.000 0.000 0.000 {method 'readline' of '_io.BufferedReader' objects} 1 0.000 0.000 0.000 0.000 _exceptions.py:1(&lt;module&gt;) 14 0.000 0.000 0.000 0.000 doctest.py:947(_from_module) 68 0.000 0.000 0.000 0.000 {method 'isidentifier' of 'str' objects} 36 0.000 0.000 0.000 0.000 getlimits.py:39(&lt;lambda&gt;) 1 0.000 0.000 0.000 0.000 {method 'dot' of 'numpy.ndarray' objects} 15 0.000 0.000 0.000 0.000 cmd.py:76(__init__) 1 0.000 0.000 0.001 0.001 scanner.py:1(&lt;module&gt;) 13 0.000 0.000 0.000 0.000 _dtype_ctypes.py:71(_from_ctypes_scalar) 1 0.000 0.000 0.000 0.000 helper.py:1(&lt;module&gt;) 3 0.000 0.000 0.000 0.000 decoder.py:332(decode) 32 0.000 0.000 0.000 0.000 _type_aliases.py:46(&lt;genexpr&gt;) 9 0.000 0.000 0.000 0.000 _ufunc_config.py:434(__exit__) 1 0.000 0.000 0.000 0.000 {built-in method _hashlib.openssl_md5} 3 0.000 0.000 0.000 0.000 warnings.py:130(filterwarnings) 1 0.000 0.000 0.000 0.000 _string_helpers.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 _type_aliases.py:130(_add_integer_aliases) 1 0.000 0.000 0.001 0.001 runner.py:1(&lt;module&gt;) 5 0.000 0.000 0.003 0.001 &lt;__array_function__ internals&gt;:2(hstack) 1 0.000 0.000 0.000 0.000 memmap.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 ufunclike.py:1(&lt;module&gt;) 38 0.000 0.000 0.000 0.000 {built-in method numpy.geterrobj} 48 0.000 0.000 0.000 0.000 inspect.py:81(ismethod) 1 0.000 0.000 0.000 0.000 {built-in method nt.open} 13 0.000 0.000 0.000 0.000 mixins.py:44(_numeric_methods) 1 0.000 0.000 0.000 0.000 defchararray.py:1805(chararray) 30 0.000 0.000 0.000 0.000 enum.py:438(&lt;genexpr&gt;) 2 0.000 0.000 0.000 0.000 subprocess.py:1462(_wait) 5 0.000 0.000 0.000 0.000 sre_parse.py:861(_parse_flags) 1 0.000 0.000 0.002 0.002 main.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 pprint.py:11(&lt;module&gt;) 20 0.000 0.000 0.000 0.000 {built-in method time.time} 63 0.000 0.000 0.000 0.000 abc.py:7(abstractmethod) 1 0.000 0.000 0.000 0.000 polynomial.py:1068(poly1d) 1 0.000 0.000 0.000 0.000 arraypad.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 pdb.py:138(Pdb) 33 0.000 0.000 0.000 0.000 {method 'clear' of 'dict' objects} 1 0.000 0.000 0.000 0.000 bdb.py:1(&lt;module&gt;) 14 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap_external&gt;:159(_path_isdir) 1 0.000 0.000 0.000 0.000 contextlib.py:489(__exit__) 6 0.000 0.000 0.000 0.000 sre_compile.py:432(_generate_overlap_table) 1 0.000 0.000 0.000 0.000 _datasource.py:1(&lt;module&gt;) 50 0.000 0.000 0.000 0.000 {method '__contains__' of 'frozenset' objects} 1 0.000 0.000 0.000 0.000 pathlib.py:120(_WindowsFlavour) 1 0.000 0.000 0.000 0.000 subprocess.py:1240(_get_handles) 1 0.000 0.000 0.000 0.000 format.py:1(&lt;module&gt;) 1 0.000 0.000 0.002 0.002 doctest.py:579(DocTestParser) 10 0.000 0.000 0.001 0.000 extras.py:235(__init__) 1 0.000 0.000 0.000 0.000 _globals.py:77(__new__) 1 0.000 0.000 0.001 0.001 fnmatch.py:1(&lt;module&gt;) 5 0.000 0.000 0.000 0.000 &lt;__array_function__ internals&gt;:2(result_type) 5 0.000 0.000 0.000 0.000 &lt;__array_function__ internals&gt;:2(isclose) 1 0.000 0.000 0.000 0.000 _iotools.py:1(&lt;module&gt;) 2 0.000 0.000 0.000 0.000 core.py:2948(_update_from) 1 0.000 0.000 0.001 0.001 string.py:1(&lt;module&gt;) 18 0.000 0.000 0.000 0.000 {method 'translate' of 'bytearray' objects} 2 0.000 0.000 0.000 0.000 genericpath.py:39(isdir) 46 0.000 0.000 0.000 0.000 enum.py:792(value) 1 0.000 0.000 0.000 0.000 numbers.py:32(Complex) 8 0.000 0.000 0.000 0.000 core.py:8098(__init__) 1 0.000 0.000 0.000 0.000 linalg.py:73(_determine_error_states) 4/3 0.000 0.000 0.000 0.000 {method 'view' of 'numpy.ndarray' objects} 25 0.000 0.000 0.000 0.000 {built-in method numpy.asanyarray} 16 0.000 0.000 0.000 0.000 {built-in method builtins.any} 86 0.000 0.000 0.000 0.000 _compat_pickle.py:167(&lt;genexpr&gt;) 1 0.000 0.000 0.000 0.000 random.py:101(Random) 1 0.000 0.000 0.000 0.000 traceback.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 _asarray.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 platform.py:233(_norm_version) 1 0.000 0.000 0.002 0.002 doctest.py:845(find) 1 0.000 0.000 0.000 0.000 util.py:1(&lt;module&gt;) 6 0.000 0.000 0.000 0.000 enum.py:561(_check_for_existing_members) 48 0.000 0.000 0.000 0.000 {method 'pop' of 'list' objects} 13 0.000 0.000 0.000 0.000 &lt;frozen importlib._bootstrap&gt;:765(exec_module) 16 0.000 0.000 0.000 0.000 {method 'copy' of 'dict' objects} 1 0.000 0.000 0.001 0.001 result.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 suite.py:1(&lt;module&gt;) 15 0.000 0.000 0.000 0.000 {method 'finditer' of 're.Pattern' objects} 2 0.000 0.000 0.000 0.000 sre_compile.py:416(_bytes_to_codes) 1 0.000 0.000 0.000 0.000 datetime.py:1245(time) 1 0.000 0.000 0.000 0.000 _type_aliases.py:211(_set_array_types) 1 0.000 0.000 0.000 0.000 {function Random.seed at 0x0000019E2E70E280} 5 0.000 0.000 0.000 0.000 _collections_abc.py:760(get) 1 0.000 0.000 0.000 0.000 datetime.py:1594(datetime) 15 0.000 0.000 0.000 0.000 fromnumeric.py:70(&lt;dictcomp&gt;) 1 0.000 0.000 0.000 0.000 core.py:2817(__new__) 1 0.000 0.000 0.001 0.001 string.py:69(__init_subclass__) 1 0.000 0.000 0.000 0.000 threading.py:795(__init__) 20 0.000 0.000 0.000 0.000 mixins.py:16(_binary_method) 5 0.000 0.000 0.000 0.000 {method 'reshape' of 'numpy.ndarray' objects} 71 0.000 0.000 0.000 0.000 {built-in method _sre.unicode_tolower} 60 0.000 0.000 0.000 0.000 {built-in method builtins.divmod} 1 0.000 0.000 0.000 0.000 cp1252.py:22(decode) 1 0.000 0.000 0.000 0.000 contextlib.py:76(inner) 6 0.000 0.000 0.000 0.000 enum.py:81(__init__) 1 0.000 0.000 0.000 0.000 linecache.py:80(updatecache) 1 0.000 0.000 0.000 0.000 _type_aliases.py:158(_set_up_aliases) 1 0.000 0.000 0.001 0.001 code.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 numbers.py:4(&lt;module&gt;) 17 0.000 0.000 0.000 0.000 &lt;string&gt;:1(&lt;lambda&gt;) 1 0.000 0.000 0.000 0.000 _polybase.py:1(&lt;module&gt;) 18 0.000 0.000 0.000 0.000 ntpath.py:34(_get_bothseps) 2 0.000 0.000 0.000 0.000 functools.py:478(lru_cache) 1 0.000 0.000 0.002 0.002 glob.py:1(&lt;module&gt;) 1 0.000 0.000 0.000 0.000 struct.py:1(&lt;module&gt;) 16 0.000 0.000 0.000 0.000 _add_newdocs_scalars.py:18(type_aliases_gen) 1 0.000 0.000 0.000 0.000 threading.py:1307(__init__) 6 0.000 0.000 0.000 0.000 enum.py:197(&lt;dictcomp&gt;) 41 0.000 0.000 0.000 0.000 enum.py:551(&lt;lambda&gt;) </code></pre> <p>I cut the output to stay within the characther limit.</p>

270226

<p>Environnement :</p> <ul> <li>Rails 6.1.4.1</li> <li>db : PostgreSQL</li> </ul> <p>Hi everyone, I've been working on this for some hours now and want to know how other Rails developpers would react to this type of project structure.</p> <p>Goal of the code structure :</p> <ol> <li>Permit API high versionability by : <ul> <li>Removing all logic from models (making them as agnostic to the project state as possible)</li> <li>Segregating logic and validation through individual controller concerns</li> <li>Using helpers to quickly add or remove concerns from a controller</li> </ul> </li> <li>Avoid controller actions code redundancy</li> <li>Make everything reusable and extendable</li> </ol> <p>As an example, for this project the main resource looks like this :</p> <pre class="lang-rb prettyprint-override"><code>class Iban &lt; ApplicationRecord # Logic is fully handled by the controller for higher versionability # - this can still serve if some behaviours must be ensured within any versions end </code></pre> <p>with a migration simply setting :</p> <ul> <li>id:uuid</li> <li>name:string</li> <li>region:string</li> <li>timestamp</li> </ul> <p>So controllers for each api version inherit from the main Api::ApplicationController:</p> <pre class="lang-rb prettyprint-override"><code># app/controllers/api/application_controller.rb module Api class ApplicationController &lt; ::ApplicationController ''' ---------------- ''' ''' STATIC SHORTCUTS ''' ''' ---------------- ''' def model_class self.class.get_model_class end def permitted_params self.class.get_permitted_params end ''' ------- ''' ''' PRIVATE ''' ''' ------- ''' private def set_model @model = model_class.find_by(id: params[:id]) end def model_params params.require(model_class.to_s.downcase.to_sym).permit(*permitted_params) end ''' ------ ''' ''' STATIC ''' ''' ------ ''' class &lt;&lt; self def model_class(klass) # Class shorthand @model_klass = klass end def get_model_class @model_klass end def permitted_params(*params_list) @permitted_params = params_list end def get_permitted_params @permitted_params end # cherry pick action methods def include_common_concerns(*concerns_sym_list) concerns_sym_list.each do |sym| include &quot;Api::Concerns::#{sym}&quot;.constantize end end # cherry pick included concerns with version def include_versioned_concerns(version, *concerns_sym_list) concerns_sym_list.each do |sym| include &quot;Api::V#{version}::Concerns::#{sym}&quot;.constantize end end end end end </code></pre> <p>Base controller actions are stored in concerns within <code>controllers/api/concerns</code>. An example for <code>Indexable</code> :</p> <pre class="lang-rb prettyprint-override"><code>module Api module Concerns module Indexable extend ActiveSupport::Concern def index @models = model_class.all paginate status: 200, json: @models, adapter: :json_api end end end end </code></pre> <p>and <code>Creatable</code>:</p> <pre class="lang-rb prettyprint-override"><code>require 'errors/standard_error' module Api module Concerns module Creatable extend ActiveSupport::Concern def create @model = model_class.new(model_params) if @model.save success_handler(@model, :created) else raise @model.errors end end end end end </code></pre> <p><code>Errors::StandardError</code> is the base error of the app and inherits from Ruby StandardError.</p> <p>An abstract versioned controller looks like this :</p> <pre class="lang-rb prettyprint-override"><code>module Api module V1 class ApplicationController &lt; ::Api::ApplicationController # cf api/v1/concerns include_versioned_concerns 1, *%i[ ResponseHandler ] end end end </code></pre> <p><code>ResponseHandler</code> is segragated per version so :</p> <pre class="lang-rb prettyprint-override"><code>module Api module V1 module Concerns module ResponseHandler extend ActiveSupport::Concern included do rescue_from ::StandardError do | ex | response_handler(ex) end end def response_handler(res) if res.kind_of? ::StandardError error_handler(res) else success_handler(res) end end def error_handler(e) code = (e.status if e.respond_to?(:status)) || 500 message = (e.detail if e.respond_to?(:detail)) || 'Internal Server Error' render status: code, json: { success: false, error: message, code: code } end def success_handler(e, code = 200) render status: code, json: { success: true, data: e } end end end end end </code></pre> <p>and here what looks like an example resource controller :</p> <pre class="lang-rb prettyprint-override"><code>module Api module V1 class IbansController &lt; ApplicationController # Define which model it should handle model_class ::Iban # Define what CRUD actions are present within this controller - cf : controllers/api/concerns include_common_concerns *%i[ Indexable Showable RandomPickable Creatable Updatable Destroyable ] # limits which params are passed for update or create permitted_params *%i[ name region ] # validations are concerns, this way you can cherry pick which to include in other API versions if no changes are needed # - cf : controllers/api/v1/concerns include_versioned_concerns 1, *%i[ IbanValidation RegionValidation ] # Define valid regions valid_regions *%i[ FRANCE UK ] # Handling attribute validation in the controller for better API versionability before_action :validate_mutation_params, only: [:create, :update] private ''' ---------- ''' ''' OVERWRITES ''' ''' ---------- ''' def set_model return if (@model = model_class.find_by(id: params[:id])).present? @model = model_class.find_by(name: params[:id]) end def model_params hash = super hash[:name] = hash[:name].gsub(/\s+/, &quot;&quot;) hash end ''' ----- ''' ''' HOOKS ''' ''' ----- ''' def validate_mutation_params valid_region? valid_iban? end end end end </code></pre> <p>As said before logic is fully delegated within concerns. And <code>IbanValidation</code> and <code>RegionValidation</code> are V1 concerns implementing the <code>valid_&lt;concern&gt;?</code> methods, they raise custom errors or return true.</p> <p>What do you think about this composition and how would you react to it within a professional environment ? Is it something you would avoid at any price, or something you would prefer over common Rails structure ?</p> <p>The main problems I can see are :</p> <ul> <li>structure could put off other developpers - since it's unconventional</li> <li>I don't know hom much the concern inclusion is hitting on performance - I Think this should only slow the app start up but not sure if inclusions are made each time the controllers are called</li> <li>Could derail into composition monster if structure is not strictly applied</li> </ul> <p>But the pros I see are :</p> <ul> <li>Avoid most merging conflicts once structure is in place</li> <li>Quickly evolve from a version to another</li> <li>Permit high scallability from the get go</li> <li>Can ensure code segregation for maintainability if used correctly</li> </ul> <p>So ... is it complete garbage or are there any bit of concept to save within this project ?</p>

270228

<p>I've implemented a thread pool using C++20. I'm fairly new to concurrently/multi-threaded programming and wanted to work on a project that I could learn from while also getting to know some of the new features available in C++20.</p> <p>To that end I've specifically made use of:</p> <ul> <li><code>std::binary_semaphore</code></li> <li><code>concepts</code></li> <li><code>std::jthread</code></li> </ul> <p>I've also made use of some other language features and overall have tried to implement best practices for &quot;modern&quot; C++ standards.</p> <p>The most up to date version of the code is available <a href="https://github.com/DeveloperPaul123/thread-pool" rel="noreferrer">here</a>. The library I created is header only. For brevity, I have omitted all documentation related comments.</p> <h2><code>thread_pool.h</code></h2> <pre class="lang-cpp prettyprint-override"><code>#pragma once #include &lt;concepts&gt; #include &lt;functional&gt; #include &lt;future&gt; #include &lt;memory&gt; #include &lt;queue&gt; #include &lt;semaphore&gt; #include &lt;thread&gt; #include &lt;type_traits&gt; #include &quot;thread_pool/thread_safe_queue.h&quot; namespace dp { namespace detail { template &lt;class T&gt; std::decay_t&lt;T&gt; decay_copy(T &amp;&amp;v) { return std::forward&lt;T&gt;(v); } // Bind F and args... into a nullary one-shot lambda. Lambda captures by value. template &lt;typename... Args, typename F&gt; auto bind(F &amp;&amp;f, Args &amp;&amp;...args) { return [f = decay_copy(std::forward&lt;F&gt;(f)), ... args = decay_copy(std::forward&lt;Args&gt;(args))]() mutable -&gt; decltype(auto) { return std::invoke(std::move(f), std::move(args)...); }; } template &lt;class Queue, class U = typename Queue::value_type&gt; concept is_valid_queue = requires(Queue q) { { q.empty() } -&gt; std::convertible_to&lt;bool&gt;; { q.front() } -&gt; std::convertible_to&lt;U &amp;&gt;; { q.back() } -&gt; std::convertible_to&lt;U &amp;&gt;; q.pop(); }; static_assert(detail::is_valid_queue&lt;std::queue&lt;int&gt;&gt;); static_assert(detail::is_valid_queue&lt;dp::thread_safe_queue&lt;int&gt;&gt;); } // namespace detail template &lt;template &lt;class T&gt; class Queue, typename FunctionType = std::function&lt;void()&gt;&gt; requires std::invocable&lt;FunctionType&gt; &amp;&amp; std::is_same_v&lt;void, std::invoke_result_t&lt;FunctionType&gt;&gt; &amp;&amp; detail::is_valid_queue&lt;Queue&lt;FunctionType&gt;&gt; class thread_pool_impl { public: thread_pool_impl( const unsigned int &amp;number_of_threads = std::thread::hardware_concurrency()) { for (std::size_t i = 0; i &lt; number_of_threads; ++i) { queues_.push_back(std::make_unique&lt;task_pair&gt;()); threads_.emplace_back([&amp;, id = i](std::stop_token stop_tok) { do { // check if we have task if (queues_[id]-&gt;tasks.empty()) { // no tasks, so we wait instead of spinning queues_[id]-&gt;semaphore.acquire(); } // ensure we have a task before getting task // since the dtor releases the semaphore as well if (!queues_[id]-&gt;tasks.empty()) { // get the task auto &amp;task = queues_[id]-&gt;tasks.front(); // invoke the task std::invoke(std::move(task)); // remove task from the queue queues_[id]-&gt;tasks.pop(); } } while (!stop_tok.stop_requested()); }); } } ~thread_pool_impl() { // stop all threads for (std::size_t i = 0; i &lt; threads_.size(); ++i) { threads_[i].request_stop(); queues_[i]-&gt;semaphore.release(); threads_[i].join(); } } /// thread pool is non-copyable thread_pool_impl(const thread_pool_impl &amp;) = delete; thread_pool_impl &amp;operator=(const thread_pool_impl &amp;) = delete; template &lt;typename Function, typename... Args, typename ReturnType = std::invoke_result_t&lt;Function &amp;&amp;, Args &amp;&amp;...&gt;&gt; requires std::invocable&lt;Function, Args...&gt; [[nodiscard]] std::future&lt;ReturnType&gt; enqueue(Function &amp;&amp;f, Args &amp;&amp;...args) { // use shared promise here so that we don't break the promise later auto shared_promise = std::make_shared&lt;std::promise&lt;ReturnType&gt;&gt;(); auto task = [func = std::move(f), ... largs = std::move(args), promise = shared_promise]() { promise-&gt;set_value(func(largs...)); }; // get the future before enqueuing the task auto future = shared_promise-&gt;get_future(); // enqueue the task enqueue_task(std::move(task)); return future; } template &lt;typename Function, typename... Args&gt; requires std::invocable&lt;Function, Args...&gt; &amp;&amp; std::is_same_v&lt;void, std::invoke_result_t&lt;Function &amp;&amp;, Args &amp;&amp;...&gt;&gt; void enqueue_detach(Function &amp;&amp;func, Args &amp;&amp;...args) { enqueue_task(detail::bind(std::forward&lt;Function&gt;(func), std::forward&lt;Args&gt;(args)...)); } private: using semaphore_type = std::binary_semaphore; using task_type = FunctionType; struct task_pair { semaphore_type semaphore{0}; Queue&lt;task_type&gt; tasks{}; }; template &lt;typename Function&gt; void enqueue_task(Function &amp;&amp;f) { const std::size_t i = count_++ % queues_.size(); queues_[i]-&gt;tasks.push(std::forward&lt;Function&gt;(f)); queues_[i]-&gt;semaphore.release(); } std::vector&lt;std::jthread&gt; threads_; // have to use unique_ptr here because std::binary_semaphore is not move/copy // assignable/constructible std::vector&lt;std::unique_ptr&lt;task_pair&gt;&gt; queues_; std::size_t count_ = 0; }; using thread_pool = thread_pool_impl&lt;dp::thread_safe_queue&gt;; } // namespace dp </code></pre> <p>For the sake of completeness, I will also include my safe queue implementation though it is not necessary to review that here. I will more than likely open a new code review post for that class specifically.</p> <h2><code>thread_safe_queue.h</code></h2> <pre class="lang-cpp prettyprint-override"><code>#pragma once #include &lt;condition_variable&gt; #include &lt;mutex&gt; #include &lt;queue&gt; namespace dp { template &lt;typename T&gt; class thread_safe_queue { public: using value_type = T; using size_type = typename std::queue&lt;T&gt;::size_type; thread_safe_queue() = default; void push(T&amp;&amp; value) { std::lock_guard lock(mutex_); data_.push(std::forward&lt;T&gt;(value)); condition_variable_.notify_all(); } bool empty() { std::lock_guard lock(mutex_); return data_.empty(); } [[nodiscard]] size_type size() { std::lock_guard lock(mutex_); return data_.size(); } [[nodiscard]] T&amp; front() { std::unique_lock lock(mutex_); condition_variable_.wait(lock, [this] { return !data_.empty(); }); return data_.front(); } [[nodiscard]] T&amp; back() { std::unique_lock lock(mutex_); condition_variable_.wait(lock, [this] { return !data_.empty(); }); return data_.back(); } void pop() { std::unique_lock lock(mutex_); condition_variable_.wait(lock, [this] { return !data_.empty(); }); data_.pop(); } private: using mutex_type = std::mutex; std::queue&lt;T&gt; data_; mutable mutex_type mutex_{}; std::condition_variable condition_variable_{}; }; } // namespace dp </code></pre> <p>Example driver code illustration how to use the thread pool:</p> <pre class="lang-cpp prettyprint-override"><code>dp::thread_pool pool(4); const auto total_tasks = 30; std::vector&lt;std::future&lt;int&gt;&gt; futures; for (auto i = 0; i &lt; total_tasks; i++) { auto task = [index = i]() { return index; }; futures.push_back(pool.enqueue(task)); } </code></pre> <p>Any feedback anyone has would be much appreciated. One thing in particular I'm not too thrilled about is the use of a <code>std::shared_ptr</code> in conjunction with a <code>std::promise</code> in the <code>enqueue</code> function.</p> <pre class="lang-cpp prettyprint-override"><code>auto shared_promise = std::make_shared&lt;std::promise&lt;ReturnType&gt;&gt;(); </code></pre> <p>I could not find a good way around this. I tried pretty extensively to get <code>std::packaged_task</code> to work, but I ran into issues that I wasn't able to solve since <code>std::packaged_task</code> is move only. This, however, may just be due to my lack of familiarity with this part of the standard.</p>

270236

<h3>Intro</h3> <p>This is a spiritual successor to the question <a href="https://codereview.stackexchange.com/questions/262728/stop-cheating-on-home-exams-using-python">Stop cheating on home exams using python</a></p> <p>The details are not important, but I decided to reimplement everything using dataclasses. My script is now working, but is a bit big (around 1200 lines). So in order to ease the burden I will split my codereview into a few questions spaced over a few days or weeks.</p> <p><strong>This question only focuses on how I store and use the configuration options provided by the user</strong></p> <p>My filestructure is as follows</p> <pre><code>uni.py &lt;- mainfile candidates.py exam.py texfile.py variable.py problem.py tools.py default_config.py </code></pre> <p>Now the defaults of the program is stored in a <code>config.py</code> file which looks like this</p> <pre><code>from default_config import Config CONFIG: Config = { &quot;texfile&quot;: &quot;None&quot;, &quot;candidates&quot;: 0, &quot;set_variable&quot;: &quot;setfpvar&quot;, &quot;get_variable&quot;: &quot;fv&quot;, &quot;input_formats&quot;: [&quot;input&quot;, &quot;include&quot;], &quot;latex_comment&quot;: &quot;%&quot;, &quot;PDFLATEX_OR_XELATEX&quot;: &quot;xelatex&quot;, &quot;equal_comment_indent_per_problem&quot;: True, &quot;python_code_as_comment&quot;: True, &quot;use_python_in_comment&quot;: False, &quot;candidate_number_pad&quot;: 3, &quot;subdir&quot;: True, &quot;all_subdirs_equal&quot;: True, &quot;tex_dir&quot;: &quot;tex&quot;, &quot;pdf_dir&quot;: &quot;pdf&quot;, &quot;solution_dir&quot;: &quot;solution&quot;, &quot;build_dir&quot;: &quot;aux&quot; } </code></pre> <p>Every file that needs it, imports this file to read of the default values. For ease of readability I decided that the user interacts with this config file using a <code>config.yaml</code> file that is identical, but with added comments.</p> <pre><code>config: texfile: None candidates: 0 # Sets the names of misc commands used in the texfile set_variable: setfpvar get_variable: fv input_formats: - input - include latex_comment: '%' # Decides which engine to use to compile the texfile # Standard options are 'xelatex' or 'pdflatex' PDFLATEX_OR_XELATEX: xelatex # If comment is true the python code to generate the # variable's value is placed as a comment next to it # in the tex file equal_comment_indent_per_problem: true python_code_as_comment: true # If true the comment mentined above can be used in reverse; # meaning if a comment is present next to a varible we try # to run it as a Python command to generate the value. # DANGEROUS use_python_in_comment: false # Number of places to pad the candidate number (001)=3 candidate_number_pad: 3 # Defines which subdirectories to put each file in # if subdir is false everything is dumped into main subdir: true all_subdirs_equal: true tex_dir: tex pdf_dir: pdf solution_dir: solution build_dir: aux </code></pre> <p>The idea is that command line arguments succeed the config options, which again succeeds the default config options. The following code below has two jobs it either populates the <code>config.py</code> file, or it creates a <code>config.yaml</code> file for the user to play around with.</p> <ul> <li>I was very happy with being able to do <code>from config import CONFIG</code> in all of my classes, which was a major reason why I decided to implement the config system in this manner.</li> </ul> <p>This is just the parser, as mentioned I have not included the exam generation. Run as</p> <p><code>uni.py exam -h</code> or <code>uni.py config -h</code></p> <p>To see the possible options.</p> <h3>uni.py</h3> <pre><code>import argparse from pathlib import Path from typing import Union from default_config import ( dump_config_2_yaml, load_default_config, load_yaml_from_config, dump_config_2_python, ) def is_float(potential_float: str) -&gt; bool: try: float(potential_float) return True except ValueError: return False # Refference # Title: In Python, using argparse, allow only positive integers # Source: https://stackoverflow.com/a/14117511/1048781 def non_negative_int(value: str): &quot;&quot;&quot;Raises an exception unless value is non-negative Args: param1: A value parsed as a string Returns: The input string value as an integer. Raises: ArgumentTypeError: uni.py: error: argument --candidates/-n: Expected a positive int for number of candidates, got &quot;&quot;&quot; if not is_float(value): raise argparse.ArgumentTypeError( f&quot;Expected a positive int for number of candidates, got {value}&quot; ) negative, not_integer = (ivalue := float(value)) &lt; 0, int(ivalue) != ivalue if negative or not_integer: raise argparse.ArgumentTypeError( f&quot;Expected a positive int for number of candidates, got {value}&quot; ) return ivalue def check_dir(path: Union[Path, str]): if (dir_ := Path(path)).is_dir(): return dir_.resolve() raise argparse.ArgumentTypeError( f&quot;Expected a directory, but got '{path}' instead, which does not exist&quot; ) def check_path(path: Path, suffix: str) -&gt; Path: if not path.is_file(): raise argparse.ArgumentTypeError( &quot;Expected a .{suffix} file, but the path provided does not exist&quot; ) elif not path.suffix == &quot;.&quot; + suffix: raise argparse.ArgumentTypeError( f&quot;Expected a .{suffix} file, got a {path.suffix} instead&quot; ) return path def texfile(path: str) -&gt; Path: &quot;&quot;&quot;Check if the provided path is an existing tex file&quot;&quot;&quot; return check_path(Path(path), &quot;tex&quot;) def yamlfile(path: str) -&gt; Path: &quot;&quot;&quot;Check if the provided path is an existing yaml file&quot;&quot;&quot; return check_path(Path(path), &quot;yaml&quot;) def yaml_or_texfile(path: str) -&gt; Path: suffixes = [&quot;.tex&quot;, &quot;.yaml&quot;] if not (path_ := Path(path)).is_file(): raise argparse.ArgumentTypeError( &quot;Expected one of {suffixes} type file,&quot; + &quot; but the path provided does not exist&quot; ) elif path_.suffix not in suffixes: raise argparse.ArgumentTypeError( &quot;Expected one of {suffixes} type file, &quot; + f&quot;but got a {path_.suffix} instead&quot; ) return path_ def yaml_or_dir(path: str) -&gt; Path: suffixes = [&quot;.yaml&quot;] if (path_ := Path(path)).is_dir(): return path_.resolve() if path_.suffix in suffixes: return path_ raise argparse.ArgumentTypeError( &quot;Expected a '.yaml' type filename or an &quot; + f&quot;existing dir, got a {path_} type instead&quot; ) def new_parser(): # create the top-level parser parser = argparse.ArgumentParser(prog=&quot;PROG&quot;) subparsers = parser.add_subparsers( help=&quot;command help&quot;, dest=&quot;commands&quot;, required=True ) # ================================================================================= # uni exam # ================================================================================= parsers_exam = subparsers.add_parser( &quot;exam&quot;, help=&quot;Generate random variants from a texfile&quot; ) parsers_exam.add_argument( &quot;path&quot;, type=yaml_or_texfile, metavar=&quot;PATH&quot;, help=&quot;The exam.tex file OR a config.yaml file (use 'uni generate&quot; + &quot;config' to generate a default config file&quot;, ) parsers_exam.add_argument( &quot;--texfile&quot;, type=texfile, metavar=&quot;PATH&quot;, help=&quot;The exam.tex (Useful if you set a config file using PATH&quot; + &quot; , and want to override the texfile in it)&quot;, ) parsers_exam.add_argument( &quot;--candidates&quot;, &quot;-n&quot;, type=non_negative_int, help=&quot;Number of candidates (Exams to generate)&quot;, ) parsers_exam.add_argument( &quot;--subdirs-equal&quot;, action=argparse.BooleanOptionalAction, default=None ) parsers_exam.add_argument( &quot;--texdir&quot;, type=str, help=&quot;Sets the directory to place the tex files&quot;, ) parsers_exam.add_argument( &quot;--pdfdir&quot;, type=str, help=&quot;Sets the directory to place the pdf files&quot;, ) parsers_exam.add_argument( &quot;--solutiondir&quot;, type=str, help=&quot;Sets the directory to place the solutions files&quot;, ) parsers_exam.add_argument( &quot;--builddir&quot;, type=str, help=&quot;Sets the directory to place the build files&quot;, ) parsers_exam.add_argument( &quot;--save-config&quot;, type=yaml_or_dir, metavar=&quot;PATH&quot;, nargs=&quot;?&quot;, const=Path().cwd(), default=None, help=&quot;Save the current settings.&quot; + &quot; Default path is current working directory&quot;, ) # ================================================================================= # uni config # ================================================================================= parser_default_config = subparsers.add_parser( &quot;config&quot;, help=&quot;Use to generate the default config file in PATH&quot; ) parser_default_config.add_argument( &quot;path&quot;, type=yaml_or_dir, metavar=&quot;PATH&quot;, nargs=&quot;?&quot;, default=Path().cwd(), help=&quot;Path (filename or dir) to generate the&quot; + &quot; default config file for exams&quot;, ) return parser ARGPARSE_2_CONFIG = { &quot;texfile&quot;: &quot;texfile&quot;, &quot;candidates&quot;: &quot;candidates&quot;, &quot;subdirs_equal&quot;: &quot;subdirs-equal&quot;, &quot;texdir&quot;: &quot;texdir&quot;, &quot;solutiondir&quot;: &quot;solutiondir&quot;, &quot;builddir&quot;: &quot;builddir&quot;, &quot;pdfdir&quot;: &quot;pdfdir&quot;, } def generate_config(args): if args.path.suffix == &quot;.yaml&quot;: config = load_yaml_from_config(args.path) else: config = load_default_config() # The default config has no texfile by default config[&quot;config&quot;][&quot;texfile&quot;] = args.path # Command line arguments takes president over config.yaml for argparse_name, config_name in ARGPARSE_2_CONFIG.items(): if (argument := getattr(args, argparse_name)) is not None: config[&quot;config&quot;][config_name] = argument return config def exam(args): config = generate_config(args) # The user may have written a badly formated value for number of candidates non_negative_int(config[&quot;config&quot;][&quot;candidates&quot;]) if config[&quot;config&quot;][&quot;texfile&quot;] is None: raise argparse.ArgumentTypeError( &quot;PROG exam: error: the following arguments&quot; + &quot; are required: PATH, --candidates/-n&quot; ) if args.save_config is not None: if args.save_config.is_dir(): directory = args.save_config name = &quot;config.yaml&quot; else: directory = args.save_config.parent name = args.save_config.name dump_config_2_yaml(config=config, path=directory / name) dump_config_2_python(config) def config(args): if args.path.suffix == &quot;.yaml&quot;: config_path = args.path else: directory = args.path config_path = directory / &quot;config.yaml&quot; if dump_config_2_yaml(config=load_default_config(), path=config_path): print(f&quot;'{config_path}' successfully created&quot;) if __name__ == &quot;__main__&quot;: parser = new_parser() args = parser.parse_args() if args.commands == &quot;exam&quot;: exam(args) elif args.commands == &quot;config&quot;: config(args) </code></pre> <h3>default_config.py</h3> <pre><code>import pprint from pathlib import Path import ruamel.yaml from typing import TypedDict yaml = ruamel.yaml.YAML() yaml.preserve_quotes = True DEFAULT_YAML = &quot;&quot;&quot;\ config: texfile: None candidates: 0 # Sets the names of misc commands used in the texfile set_variable: setfpvar get_variable: fv input_formats: - input - include latex_comment: '%' # Decides which engine to use to compile the texfile # Standard options are 'xelatex' or 'pdflatex' PDFLATEX_OR_XELATEX: xelatex # If comment is true the python code to generate the # variable's value is placed as a comment next to it # in the tex file equal_comment_indent_per_problem: True python_code_as_comment: True # If true the comment mentined above can be used in reverse; # meaning if a comment is present next to a varible we try # to run it as a Python command to generate the value. # DANGEROUS use_python_in_comment: False # Number of places to pad the candidate number (001)=3 candidate_number_pad: 3 # Defines which subdirectories to put each file in # if subdir is false everything is dumped into main subdir: True all_subdirs_equal: True tex_dir: tex pdf_dir: pdf solution_dir: solution build_dir: aux &quot;&quot;&quot; class Config(TypedDict): texfile: str candidates: int set_variable: str get_variable: str input_formats: list[str] latex_comment: str PDFLATEX_OR_XELATEX: str equal_comment_indent_per_problem: bool python_code_as_comment: bool use_python_in_comment: bool candidate_number_pad: int subdir: bool all_subdirs_equal: bool tex_dir: str pdf_dir: str solution_dir: str build_dir: str PATH = Path(__file__) DIR = PATH.parent YAML_CONFIG_PATH = DIR / PATH.with_suffix(&quot;.yaml&quot;) PYTHON_CONFIG_PATH = DIR / &quot;config.py&quot; if not YAML_CONFIG_PATH.is_file(): yaml.dump(yaml.load(DEFAULT_YAML), YAML_CONFIG_PATH) def load_yaml_from_config(path): return yaml.load(path) def dump_config_2_yaml(config, path): if not path.is_file(): yaml.dump(config, path) return True print( &quot;Ooops, it looks like the file \n\n&quot; + str(path) + &quot;\n\n already exists. Do you want to override it?&quot; ) if input(&quot;[y/N]&quot;).lower()[0] == &quot;y&quot;: yaml.dump(config, path) return True return False def load_default_config(path=YAML_CONFIG_PATH): if not path.is_file(): yaml.dump(yaml.load(path), YAML_CONFIG_PATH) return yaml.load(path) def dump_config_2_python(config, path=PYTHON_CONFIG_PATH, indent=4): imports = &quot;from default_config import Config&quot; config_body = pprint.pformat(config[&quot;config&quot;], indent=indent, sort_dicts=False)[ 1:-1 ] with open(path, &quot;w&quot;) as f: f.writelines( imports + &quot;\n\nCONFIG: Config = {\n &quot; + config_body.replace(&quot;'&quot;, '&quot;') + &quot;\n}&quot; ) </code></pre>

270244

<p>This is my code to extract data from the DOL website for a project I'm doing for my portfolio. The code does extract all of the data that I need, however it runs really slowly. I think it took like 15 minutes for it to finish extracting everything. I would really appreciate if someone could just point me in the right direction.</p> <pre class="lang-py prettyprint-override"><code>import pandas as pd from selenium import webdriver from webdriver_manager.chrome import ChromeDriverManager from selenium.webdriver.support.select import Select from selenium.webdriver.common.action_chains import ActionChains url = 'https://oui.doleta.gov/unemploy/claims.asp' driver = webdriver.Chrome(executable_path=r&quot;C:\Program Files (x86)\chromedriver.exe&quot;) driver.implicitly_wait(10) driver.get(url) driver.find_element_by_css_selector('input[name=&quot;level&quot;][value=&quot;state&quot;]').click() Select(driver.find_element_by_name('strtdate')).select_by_value('2020') Select(driver.find_element_by_name('enddate')).select_by_value('2021') driver.find_element_by_css_selector('input[name=&quot;filetype&quot;][value=&quot;html&quot;]').click() select = Select(driver.find_element_by_id('states')) for opt in select.options: opt.click() input('Press ENTER to submit the form') driver.find_element_by_css_selector('input[name=&quot;submit&quot;][value=&quot;Submit&quot;]').click() rows = driver.find_elements_by_xpath('//*[@id=&quot;content&quot;]/table/tbody') unemployment = [] # Iterate over the rows # Loop through tables from url with help of BeautifulSoup for table in rows: headers = [] for head in table.find_elements_by_xpath('//*[@id=&quot;content&quot;]/table/tbody/tr[2]/th'): headers.append(head.text) values = [] for row in table.find_elements_by_xpath('//*[@id=&quot;content&quot;]/table/tbody/tr')[2:]: values = [] for col in row.find_elements_by_xpath(&quot;./*[name()='th' or name()='td']&quot;): values.append(col.text) if values: unemp_dict = {headers[i]: values[i] for i in range(len(headers))} unemployment.append(unemp_dict) input('Press ENTER to close the automated browser') driver.quit() <span class="math-container">```</span> </code></pre>

270245

<p>Although I have long experience of other languages, I've not used C until playing around with microcontrollers using the Arduino IDE. I'm a bit uncomfortable with my use of pointers in conjunction with C strings.</p> <p>Since this is a microcontroller project, I want to avoid the String class and try to write code that will be reasonably efficient as well as readable by C programmers (i.e. idiomatic or following best practise)</p> <p>I read data from a serial port, including a number in ASCII character form. I will display that number on a three-digit seven-segment display, so I want to right-justify numbers less than three digits and if the number is larger than 999 I just want to display the last three digits. I can indicate errors like out-of range numbers separately.</p> <p>I have the following working code</p> <pre><code>void setup() { Serial.begin(115200); Serial.println(last3Digits(&quot;12345&quot;)); // 345 Serial.println(last3Digits(&quot;789&quot;)); // 789 Serial.println(last3Digits(&quot;60&quot;)); // _60 Serial.println(last3Digits(&quot;5&quot;)); // __5 Serial.println(last3Digits(&quot;&quot;)); // __0 } char * last3Digits(char * aString) { char * retVal = &quot;abc&quot;; byte len = strlen(aString); switch (len) { case 0: strncpy(retVal, &quot;__0&quot;, 3); break; case 1: retVal[0] = '_'; retVal[1] = '_'; retVal[2] = aString[0]; break; case 2: retVal[0] = '_'; retVal[1] = aString[0]; retVal[2] = aString[1]; break; default: // len &gt;= 3 strncpy(retVal, aString+len-3, 3); // copy only last 3 digits } retVal[3] = 0; return retVal; } // --------------------------------------------------- byte counter = 0; void loop() { Serial.print(counter); Serial.print(&quot; &quot;); delay(1000); if (++counter &gt; 9) { counter = 0; } } </code></pre> <p>The above can be run in an online emulator at <a href="https://wokwi.com/arduino/projects/315730913481720385" rel="nofollow noreferrer">https://wokwi.com/arduino/projects/315730913481720385</a></p> <p>My function <code>last3Digits()</code> seems clumsy to me. I imagine it can be made smaller without losing readability, and I imagine I must have made some other rookie mistakes.</p> <ul> <li>overwriting a string constant (what is the better way to allocate space?)</li> <li>redundant setting of string terminator (felt safer)</li> <li>?</li> </ul>

270248

JScript is a scripting language based on the ECMAScript standard, created by Microsoft and implemented in a range of environments. You would expect this tag to accompany questions regarding these environments, such as Windows Script Host (WSH), Active Server Pages (ASP) and HTML Applications (HTA).

270250

<p>I wrote the code below as a Kata to practice the <a href="https://clean-code-developer.com/grades/grade-1-red/#Integration_Operation_Segregation_Principle_IOSP" rel="nofollow noreferrer">Integration Operation Segregation Principle (IOSP, <code>clean-code-developers.com</code>)</a>. I would like to have some feedback on the code wrt. IOSP.</p> <p>I know that the code is not as efficient as it could be (mostly due to the fact that I am generating some copies of <code>List</code>s), but as I said: the focus of the Kata is IOSP, not efficiency.</p> <hr /> <p>Acceptance criteria:</p> <ul> <li>Method <code>merge(...)</code>: <ul> <li>takes two (possibly <code>null</code> or empty), sorted <code>List</code>s of some <code>T extends Comparable&lt;T&gt;</code> <ul> <li>If either of the input-<code>List</code>s is <code>null</code>, it should be treated as empty list</li> </ul> </li> <li>returns a single <code>List</code>, containing all elements of the two input lists, that is also sorted</li> </ul> </li> <li>The method should be pure, i.e.: <ul> <li>it must not throw any exception, and</li> <li>the input-<code>List</code>s should not be modified</li> </ul> </li> <li>Method <code>merge(...)</code> does not need to be stable.</li> </ul> <hr /> <p>Implementation:</p> <pre><code>import java.util.ArrayList; import java.util.List; import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; class SortedListMerger&lt;T extends Comparable&lt;T&gt;&gt; { private static final ConcurrentHashMap&lt;Class&lt;?&gt;, SortedListMerger&lt;?&gt;&gt; instanceMap = new ConcurrentHashMap&lt;&gt;(); @SuppressWarnings(&quot;unchecked&quot;) public static &lt;T extends Comparable&lt;T&gt;&gt; SortedListMerger&lt;T&gt; getInstance(Class&lt;T&gt; clazz) { return (SortedListMerger&lt;T&gt;) instanceMap.computeIfAbsent( clazz, unused -&gt; new SortedListMerger&lt;T&gt;()); } private SortedListMerger() { } public List&lt;T&gt; merge(List&lt;? extends T&gt; lhs, List&lt;? extends T&gt; rhs) { final MergeResult&lt;T&gt; mergeResult = mergeLists(lhs, rhs); return appendRest(mergeResult); } private MergeResult&lt;T&gt; mergeLists(List&lt;? extends T&gt; lhs, List&lt;? extends T&gt; rhs) { final List&lt;? extends T&gt; safeLhs = Optional.ofNullable(lhs).orElseGet(List::of); final List&lt;? extends T&gt; safeRhs = Optional.ofNullable(rhs).orElseGet(List::of); final int lhsSize = safeLhs.size(); final int rhsSize = safeRhs.size(); ArrayList&lt;T&gt; merged = new ArrayList&lt;&gt;(lhsSize + rhsSize); int lhsIndex = 0; int rhsIndex = 0; while (lhsIndex &lt; lhsSize &amp;&amp; rhsIndex &lt; rhsSize) { final T lhsValue = safeLhs.get(lhsIndex); final T rhsValue = safeRhs.get(rhsIndex); if (lhsValue.compareTo(rhsValue) &lt;= 0) { merged.add(lhsValue); ++lhsIndex; } else { merged.add(rhsValue); ++rhsIndex; } } return new MergeResult&lt;&gt;(safeLhs, lhsIndex, safeRhs, rhsIndex, merged); } private List&lt;T&gt; appendRest(MergeResult&lt;T&gt; result) { final List&lt;T&gt; intermediate = appendRest( result.safeLhs(), result.lhsIndex(), result.merged()); return appendRest(result.safeRhs(), result.rhsIndex(), intermediate); } private List&lt;T&gt; appendRest(List&lt;? extends T&gt; from, int firstIndexOfRest, List&lt;T&gt; to) { List&lt;T&gt; result = new ArrayList&lt;&gt;(to); int index = firstIndexOfRest; while (index &lt; from.size()) { result.add(from.get(index)); ++index; } return result; } private record MergeResult&lt;T extends Comparable&lt;T&gt;&gt;( List&lt;? extends T&gt; safeLhs, int lhsIndex, List&lt;? extends T&gt; safeRhs, int rhsIndex, List&lt;T&gt; merged) { private MergeResult( List&lt;? extends T&gt; safeLhs, int lhsIndex, List&lt;? extends T&gt; safeRhs, int rhsIndex, List&lt;T&gt; merged) { this.safeLhs = List.copyOf(safeLhs); this.lhsIndex = lhsIndex; this.safeRhs = List.copyOf(safeRhs); this.rhsIndex = rhsIndex; this.merged = List.copyOf(merged); } } } </code></pre> <hr /> <p>In case you want to run the code, here are some manual tests:</p> <pre><code>class Main { public static void main(String[] args) { final SortedListMerger&lt;Integer&gt; merger = SortedListMerger.getInstance(Integer.class); System.out.println(merger.merge(null, null)); System.out.println(merger.merge(List.of(), null)); System.out.println(merger.merge(null, List.of())); System.out.println(merger.merge(List.of(), List.of())); System.out.println(merger.merge(null, List.of(0, 1, 3, 5, 7, 9, 11))); System.out.println(merger.merge(List.of(), List.of(0, 1, 3, 5, 7, 9, 11))); System.out.println(merger.merge(List.of(0, 2, 4, 6), null)); System.out.println(merger.merge(List.of(0, 2, 4, 6), List.of())); System.out.println(merger.merge(List.of(0, 2, 4, 6), List.of(0, 1, 3, 5, 7, 9, 11))); } } </code></pre>

270256

<p>While playing with a <a href="https://codereview.stackexchange.com/questions/252659/fast-native-memory-manipulation-in-vba">VBA project</a> involving Windows APIs, I have noticed some odd behavior: API calls under Excel 2016/VBA7/x64 appeared to be much slower than under Excel 2002/VBA6/x32. Since I wanted to follow the recipe described in the <a href="https://rubberduckvba.wordpress.com/2018/09/11/lazy-object-weak-reference/" rel="nofollow noreferrer">Weak Reference</a> post, I decided to look into this performance matter more closely.</p> <h3>DLL side: Mock DLL library with test fixtures and a C-client</h3> <p>To simplify the interpretation of results, I created a small C-based dll with several stubs (memtools.c shown below) and a C-based client calling this dll and timing the calls (memtoolsclient.c). This C-code to C-code call timings provide performance references. The DLL includes five stubs. The first function, PerfGauge, takes a loop counter, times execution of an empty For loop within the DLL, and returns the result. The remaining stubs permit timing the dll calls and examine differences associated with passing arguments and returning a value. As their names suggest, these stubs</p> <ul> <li>are either a Sub or Function and</li> <li>take either zero or three arguments.</li> </ul> <p><strong>memtools.c</strong></p> <pre class="lang-c prettyprint-override"><code>#include &quot;memtools.h&quot; // Volatile loop counter should be used here to prevent optimization. MEMTOOLSAPI int MEMTOOLSCALL PerfGauge(unsigned int ForCount) { struct timeb start, end; ftime(&amp;start); for (volatile unsigned int i=0; i &lt; ForCount; i++) { ; } ftime(&amp;end); return 1000 * (end.time - start.time) + (end.millitm - start.millitm); } MEMTOOLSAPI void MEMTOOLSCALL DummySub0Args() { return; } MEMTOOLSAPI void MEMTOOLSCALL DummySub3Args(void* Destination, const void* Source, size_t Length) { return; } MEMTOOLSAPI int MEMTOOLSCALL DummyFnc0Args() { volatile int Result = 10241024; return Result; } MEMTOOLSAPI int MEMTOOLSCALL DummyFnc3Args(void* Destination, const void* Source, size_t Length) { volatile int Result = 10241024; return Result; } </code></pre> <p><strong>memtools.h</strong></p> <pre class="lang-c prettyprint-override"><code>#include &lt;stdlib.h&gt; #include &lt;stdint.h&gt; #include &lt;math.h&gt; #include &lt;stdio.h&gt; #include &lt;time.h&gt; #include &lt;string.h&gt; #ifndef MEMTOOLS_H #define MEMTOOLS_H #ifdef _WIN32 /* You should define MEMTOOLS_EXPORTS *only* when building the DLL. */ #ifdef MEMTOOLS_EXPORTS #define MEMTOOLSAPI __declspec(dllexport) #else #define MEMTOOLSAPI __declspec(dllimport) #endif /* Define calling convention in one place, for convenience. */ #define MEMTOOLSCALL __stdcall #else /* _WIN32 not defined. */ /* Define with no value on non-Windows OSes. */ #define MEMTOOLSAPI #define MEMTOOLSCALL #endif /* _WIN32 */ /* Make sure functions are exported with C linkage under C++ compilers. */ #ifdef __cplusplus extern &quot;C&quot; { #endif /* Declare our function using the above definitions. */ MEMTOOLSAPI int MEMTOOLSCALL PerfGauge(unsigned int ForCount); MEMTOOLSAPI void MEMTOOLSCALL DummySub0Args(); MEMTOOLSAPI void MEMTOOLSCALL DummySub3Args(void*, const void*, size_t); MEMTOOLSAPI int MEMTOOLSCALL DummyFnc0Args(); MEMTOOLSAPI int MEMTOOLSCALL DummyFnc3Args(void*, const void*, size_t); #ifdef __cplusplus } // extern &quot;C&quot; #endif #endif /* MEMTOOLS_H */ </code></pre> <p><strong>memtoolsclient.c</strong></p> <pre class="lang-c prettyprint-override"><code>#include &quot;memtools.h&quot; void DummySub0ArgsGauge(); void DummySub3ArgsGauge(); void DummyFnc0ArgsGauge(); void DummyFnc3ArgsGauge(); int main(int argc, char** argv) { DummySub0ArgsGauge(); DummySub3ArgsGauge(); DummyFnc0ArgsGauge(); DummyFnc3ArgsGauge(); return 0; } void DummySub0ArgsGauge() { void (*volatile MEMTOOLSCALL pDummySub0Args)(); pDummySub0Args = DummySub0Args; struct timeb start, end; ftime(&amp;start); for (volatile int i=0; i &lt; 1e9; i++) { pDummySub0Args(); } ftime(&amp;end); const int MSEC_IN_SEC = 1000; int diff; diff = MSEC_IN_SEC * (end.time - start.time) + (end.millitm - start.millitm); printf(&quot;\nDummySub0Args - 1e9 times - %u milliseconds\n&quot;, diff); } void DummySub3ArgsGauge() { char Src[] = &quot;ABCDEFGHIJKLMNOPGRSTUVWXYZABCDEFGHIJKLMNOPGRSTUVWXYZ&quot;; char Dst[255]; size_t SrcLen = sizeof(Src); struct timeb start, end; ftime(&amp;start); for (volatile int i=0; i &lt; 1e9; i++) { DummySub3Args(Dst, Src, SrcLen); } ftime(&amp;end); const int MSEC_IN_SEC = 1000; int diff; diff = MSEC_IN_SEC * (end.time - start.time) + (end.millitm - start.millitm); printf(&quot;\nDummySub3Args - 1e9 times - %u milliseconds\n&quot;, diff); } void DummyFnc0ArgsGauge() { int Result __attribute__((unused)); struct timeb start, end; ftime(&amp;start); for (volatile int i=0; i &lt; 1e9; i++) { Result = DummyFnc0Args(); } ftime(&amp;end); const int MSEC_IN_SEC = 1000; int diff; diff = MSEC_IN_SEC * (end.time - start.time) + (end.millitm - start.millitm); printf(&quot;\nDummyFnc0Args - 1e9 times - %u milliseconds\n&quot;, diff); } void DummyFnc3ArgsGauge() { char Src[] = &quot;ABCDEFGHIJKLMNOPGRSTUVWXYZABCDEFGHIJKLMNOPGRSTUVWXYZ&quot;; char Dst[255]; size_t SrcLen = sizeof(Src); int Result __attribute__((unused)); struct timeb start, end; ftime(&amp;start); for (volatile int i=0; i &lt; 1e9; i++) { Result = DummyFnc3Args(Dst, Src, SrcLen); } ftime(&amp;end); const int MSEC_IN_SEC = 1000; int diff; diff = MSEC_IN_SEC * (end.time - start.time) + (end.millitm - start.millitm); printf(&quot;\nDummyFnc3Args - 1e9 times - %u milliseconds\n&quot;, diff); } </code></pre> <hr /> <h3>VBA side: DllPerfLib class with VBA fixtures</h3> <p>The DllPerfLib VBA class calls these stubs and times them. Out of curiosity, I also added VBA stubs with signatures matching those in the dll so that DllPerfLib also times calls to these stubs yielding performance of native calls. DllPerfLib includes several blocks. The first block starting from the top contains dll stub declarations, factory, constructor, and attribute accessors. The second block handles dll loading from the project directory via the <a href="https://codereview.stackexchange.com/questions/268630/">DllManager</a> class. Then follows a wrapper for the performance reference routine (empty timed For loop inside the dll). The next block includes four functions, timing calls to corresponding dll stubs and their VBA twins defined in the last section of the class.</p> <p><strong>DllPerfLib.cls</strong></p> <pre class="lang-vb prettyprint-override"><code>'@Folder &quot;DllManager.Demo.Custom and Extended DLL.DLL Call Performance&quot; '@ModuleDescription &quot;Provides utilities for guaging performance of DLL calls via the memtools DLL.&quot; '@PredeclaredId Option Explicit Private Const LIB_NAME As String = &quot;DllManager&quot; Private Const PATH_SEP As String = &quot;\&quot; Private Const LIB_RPREFIX As String = _ &quot;Library&quot; &amp; PATH_SEP &amp; LIB_NAME &amp; PATH_SEP &amp; _ &quot;Demo - DLL - STDCALL and Adapter&quot; &amp; PATH_SEP Public Enum TargetTypeEnum TARGET_DLL = 0&amp; TARGET_VBA = 1&amp; End Enum #If Win64 Then Private Declare PtrSafe Sub DummySub0Args Lib &quot;MemToolsLib&quot; () Private Declare PtrSafe Sub DummySub3Args Lib &quot;MemToolsLib&quot; (ByRef Destination As Any, ByRef Source As Any, ByVal Length As Long) Private Declare PtrSafe Function DummyFnc0Args Lib &quot;MemToolsLib&quot; () As Long Private Declare PtrSafe Function DummyFnc3Args Lib &quot;MemToolsLib&quot; (ByRef Destination As Any, ByRef Source As Any, ByVal Length As Long) As Long Private Declare PtrSafe Function PerfGauge Lib &quot;MemToolsLib&quot; (ByVal ForCount As Long) As Long #Else Private Declare Sub DummySub0Args Lib &quot;MemToolsLib&quot; () Private Declare Sub DummySub3Args Lib &quot;MemToolsLib&quot; (ByRef Destination As Any, ByRef Source As Any, ByVal Length As Long) Private Declare Function DummyFnc0Args Lib &quot;MemToolsLib&quot; () As Long Private Declare Function DummyFnc3Args Lib &quot;MemToolsLib&quot; (ByRef Destination As Any, ByRef Source As Any, ByVal Length As Long) As Long Private Declare Function PerfGauge Lib &quot;MemToolsLib&quot; (ByVal ForCount As Long) As Long #End If Private Type TDllPerfLib DllMan As DllManager DummyForCount As Long GaugeForCount As Long PrintToImmediate As Boolean Src() As Byte Dst() As Byte SrcLen As Long End Type Private this As TDllPerfLib Public Function Create( _ Optional ByVal DummyForCount As Long = 10000000, _ Optional ByVal GaugeForCount As Long = 10000000) As DllPerfLib Dim Instance As DllPerfLib Set Instance = New DllPerfLib Instance.Init DummyForCount, GaugeForCount Set Create = Instance End Function Friend Sub Init(Optional ByVal DummyForCount As Long = 10000000, _ Optional ByVal GaugeForCount As Long = 10000000) With this .DummyForCount = DummyForCount .GaugeForCount = GaugeForCount .PrintToImmediate = True End With Set this.DllMan = DllManager.Singleton If DllManager.Singleton Is Nothing Then LoadDlls this.Src = &quot;ABCDEFGHIJKLMNOPGRSTUVWXYZ&quot; this.Dst = String(255, &quot;_&quot;) this.SrcLen = (UBound(this.Src) - LBound(this.Src) + 1 + Len(vbNullChar)) * 2 End Sub Private Sub Class_Terminate() UnLoadDlls End Sub Public Property Get DummyForCount() As Long DummyForCount = this.DummyForCount End Property Public Property Let DummyForCount(ByVal Value As Long) this.DummyForCount = Value End Property Public Property Get GaugeForCount() As Long GaugeForCount = this.GaugeForCount End Property Public Property Let GaugeForCount(ByVal Value As Long) this.GaugeForCount = Value End Property Public Sub TogglePrint() this.PrintToImmediate = Not this.PrintToImmediate End Sub '''' ==================== HANDLE DLL LOADING ==================== '''' Private Sub LoadDlls() Dim DllPath As String DllPath = ThisWorkbook.Path &amp; PATH_SEP &amp; LIB_RPREFIX &amp; &quot;memtools\&quot; &amp; ARCH Dim DllName As String DllName = &quot;MemToolsLib.dll&quot; Set this.DllMan = DllManager.Create(DllPath, DllName, True) End Sub Private Sub UnLoadDlls() this.DllMan.ForgetSingleton this.DllMan.FreeMultiple Set this.DllMan = Nothing End Sub '''' ==================== PERFORMANCE GAUGE WRAPPER ==================== '''' Public Function PerfGaugeGet(Optional ByVal GaugeForCount As Long = -1) As Long Dim GaugeMax As Long GaugeMax = IIf(GaugeForCount &gt; 0, GaugeForCount, this.GaugeForCount) Dim TimeDiffMs As Long TimeDiffMs = PerfGauge(GaugeMax) If this.PrintToImmediate Then Debug.Print &quot;PerfGauge&quot; &amp; &quot;:&quot; &amp; &quot; - &quot; &amp; Format$(GaugeMax, &quot;#,##0&quot;) &amp; _ &quot; times in &quot; &amp; TimeDiffMs &amp; &quot; ms&quot; End If PerfGaugeGet = TimeDiffMs End Function '''' ==================== TEST STUBS WRAPPERS ==================== '''' Public Function Sub0ArgsDLLVBA(Optional ByVal DummyForCount As Long = -1, _ Optional ByVal TargetType As TargetTypeEnum = TARGET_DLL) As Long Dim DummyMax As Long DummyMax = IIf(DummyForCount &gt; 0, DummyForCount, this.DummyForCount) Dim CycleIndex As Long Dim Start As Single Start = Timer If TargetType = TARGET_DLL Then For CycleIndex = 0 To DummyMax DummySub0Args Next CycleIndex Else For CycleIndex = 0 To DummyMax DummySub0ArgsVBA Next CycleIndex End If Dim TimeDiffMs As Long TimeDiffMs = Round((Timer - Start) * 1000, 0) Dim Source As String Source = &quot;Sub0ArgsDLLVBA/&quot; &amp; Array(&quot;DLL&quot;, &quot;VBA&quot;)(TargetType) If this.PrintToImmediate Then Debug.Print Source &amp; &quot;:&quot; &amp; &quot; - &quot; &amp; Format$(DummyMax, &quot;#,##0&quot;) _ &amp; &quot; times in &quot; &amp; TimeDiffMs &amp; &quot; ms&quot; End If Sub0ArgsDLLVBA = TimeDiffMs End Function Public Function Sub3ArgsDLLVBA(Optional ByVal DummyForCount As Long = -1, _ Optional ByVal TargetType As TargetTypeEnum = TARGET_DLL) As Long Dim Src() As Byte Src = this.Src Dim Dst() As Byte Dst = this.Dst Dim SrcLen As Long SrcLen = this.SrcLen Dim DummyMax As Long DummyMax = IIf(DummyForCount &gt; 0, DummyForCount, this.DummyForCount) Dim CycleIndex As Long Dim Start As Single Start = Timer If TargetType = TARGET_DLL Then For CycleIndex = 0 To DummyMax DummySub3Args Dst(0), Src(0), SrcLen Next CycleIndex Else For CycleIndex = 0 To DummyMax DummySub3ArgsVBA Dst(0), Src(0), SrcLen Next CycleIndex End If Dim TimeDiffMs As Long TimeDiffMs = Round((Timer - Start) * 1000, 0) If this.PrintToImmediate Then Debug.Print &quot;Sub3ArgsDLLVBA&quot; &amp; &quot;:&quot; &amp; &quot; - &quot; &amp; Format$(DummyMax, &quot;#,##0&quot;) _ &amp; &quot; times in &quot; &amp; TimeDiffMs &amp; &quot; ms&quot; End If Sub3ArgsDLLVBA = TimeDiffMs End Function Public Function Fnc0ArgsDLLVBA(Optional ByVal DummyForCount As Long = -1, _ Optional ByVal TargetType As TargetTypeEnum = TARGET_DLL) As Long Dim Result As Long Dim DummyMax As Long DummyMax = IIf(DummyForCount &gt; 0, DummyForCount, this.DummyForCount) Dim CycleIndex As Long Dim Start As Single Start = Timer If TargetType = TARGET_DLL Then For CycleIndex = 0 To DummyMax Result = DummyFnc0Args Next CycleIndex Else For CycleIndex = 0 To DummyMax Result = DummyFnc0ArgsVBA Next CycleIndex End If Dim TimeDiffMs As Long TimeDiffMs = Round((Timer - Start) * 1000, 0) If this.PrintToImmediate Then Debug.Print &quot;Fnc0ArgsDLLVBA&quot; &amp; &quot;:&quot; &amp; &quot; - &quot; &amp; Format$(DummyMax, &quot;#,##0&quot;) _ &amp; &quot; times in &quot; &amp; TimeDiffMs &amp; &quot; ms&quot; End If Fnc0ArgsDLLVBA = TimeDiffMs End Function Public Function Fnc3ArgsDLLVBA(Optional ByVal DummyForCount As Long = -1, _ Optional ByVal TargetType As TargetTypeEnum = TARGET_DLL) As Long Dim Src() As Byte Src = this.Src Dim Dst() As Byte Dst = this.Dst Dim SrcLen As Long SrcLen = this.SrcLen Dim Result As Long Dim DummyMax As Long DummyMax = IIf(DummyForCount &gt; 0, DummyForCount, this.DummyForCount) Dim CycleIndex As Long Dim Start As Single Start = Timer If TargetType = TARGET_DLL Then For CycleIndex = 0 To DummyMax Result = DummyFnc3Args(Dst(0), Src(0), SrcLen) Next CycleIndex Else For CycleIndex = 0 To DummyMax Result = DummyFnc3ArgsVBA(Dst(0), Src(0), SrcLen) Next CycleIndex End If Dim TimeDiffMs As Long TimeDiffMs = Round((Timer - Start) * 1000, 0) If this.PrintToImmediate Then Debug.Print &quot;Fnc3ArgsDLLVBA&quot; &amp; &quot;:&quot; &amp; &quot; - &quot; &amp; Format$(DummyMax, &quot;#,##0&quot;) _ &amp; &quot; times in &quot; &amp; TimeDiffMs &amp; &quot; ms&quot; End If Fnc3ArgsDLLVBA = TimeDiffMs End Function '''' ==================== PERFORMANCE TEST STUBS ==================== '''' Private Sub DummySub0ArgsVBA() End Sub Private Sub DummySub3ArgsVBA(ByRef Destination As Byte, _ ByRef Source As Byte, ByVal Length As Long) End Sub Private Function DummyFnc0ArgsVBA() As Long Dim Result As Long Result = 10241024 DummyFnc0ArgsVBA = Result End Function Private Function DummyFnc3ArgsVBA(ByRef Destination As Byte, _ ByRef Source As Byte, ByVal Length As Long) As Long Dim Result As Long Result = 10241024 DummyFnc3ArgsVBA = Result End Function </code></pre> <p>The runner instantiates the DllPerLib class, sets repetition counts, and calls individual test members of DllPerLib performing secondary averaging.</p> <p><strong>DllPerfRun.bas</strong></p> <pre class="lang-vb prettyprint-override"><code>'@Folder &quot;DllManager.Demo.Custom and Extended DLL.DLL Call Performance&quot; Option Explicit Private Sub Runner() Dim GaugeMax As Long GaugeMax = 10 ^ 9 Dim DummyMax As Long DummyMax = 10 ^ 7 Dim PerfTool As DllPerfLib Set PerfTool = DllPerfLib.Create(DummyMax, GaugeMax) Dim TimeDiffMs As Long Dim LoopIndex As Long With PerfTool .TogglePrint Dim AverageCountGAU As Long Dim AverageCountDLL As Long Dim AverageCountVBA As Long AverageCountGAU = 20 AverageCountDLL = 2 AverageCountVBA = 10 '''' ========== PerfGauge ========== '''' TimeDiffMs = 0 For LoopIndex = 1 To AverageCountGAU TimeDiffMs = TimeDiffMs + .PerfGaugeGet Next LoopIndex If AverageCountGAU &gt; 0 Then TimeDiffMs = TimeDiffMs / AverageCountGAU Debug.Print &quot;PerfGauge&quot; &amp; &quot;:&quot; &amp; &quot; - &quot; &amp; Format$(GaugeMax, &quot;#,##0&quot;) &amp; _ &quot; times in &quot; &amp; TimeDiffMs &amp; &quot; ms&quot; End If DoEvents '''' ---------- PerfGauge ---------- '''' '''' ========== Sub0ArgsDLLVBA ========== '''' TimeDiffMs = 0 For LoopIndex = 1 To AverageCountDLL TimeDiffMs = TimeDiffMs + .Sub0ArgsDLLVBA(, TARGET_DLL) Next LoopIndex If AverageCountDLL &gt; 0 Then TimeDiffMs = TimeDiffMs / AverageCountDLL Debug.Print &quot;Sub0ArgsDLLVBA/DLL&quot; &amp; &quot;:&quot; &amp; &quot; - &quot; &amp; Format$(DummyMax, &quot;#,##0&quot;) &amp; _ &quot; times in &quot; &amp; TimeDiffMs &amp; &quot; ms&quot; End If DoEvents TimeDiffMs = 0 For LoopIndex = 1 To AverageCountVBA TimeDiffMs = TimeDiffMs + .Sub0ArgsDLLVBA(, TARGET_VBA) Next LoopIndex If AverageCountVBA &gt; 0 Then TimeDiffMs = TimeDiffMs / AverageCountVBA Debug.Print &quot;Sub0ArgsDLLVBA/VBA&quot; &amp; &quot;:&quot; &amp; &quot; - &quot; &amp; Format$(DummyMax, &quot;#,##0&quot;) &amp; _ &quot; times in &quot; &amp; TimeDiffMs &amp; &quot; ms&quot; End If DoEvents '''' ---------- Sub0ArgsDLLVBA ---------- '''' '''' ========== Sub3ArgsDLLVBA ========== '''' TimeDiffMs = 0 For LoopIndex = 1 To AverageCountDLL TimeDiffMs = TimeDiffMs + .Sub3ArgsDLLVBA(, TARGET_DLL) Next LoopIndex If AverageCountDLL &gt; 0 Then TimeDiffMs = TimeDiffMs / AverageCountDLL Debug.Print &quot;Sub3ArgsDLLVBA/DLL&quot; &amp; &quot;:&quot; &amp; &quot; - &quot; &amp; Format$(DummyMax, &quot;#,##0&quot;) &amp; _ &quot; times in &quot; &amp; TimeDiffMs &amp; &quot; ms&quot; End If DoEvents TimeDiffMs = 0 For LoopIndex = 1 To AverageCountVBA TimeDiffMs = TimeDiffMs + .Sub3ArgsDLLVBA(, TARGET_VBA) Next LoopIndex If AverageCountVBA &gt; 0 Then TimeDiffMs = TimeDiffMs / AverageCountVBA Debug.Print &quot;Sub3ArgsDLLVBA/VBA&quot; &amp; &quot;:&quot; &amp; &quot; - &quot; &amp; Format$(DummyMax, &quot;#,##0&quot;) &amp; _ &quot; times in &quot; &amp; TimeDiffMs &amp; &quot; ms&quot; End If DoEvents '''' ---------- Sub3ArgsDLLVBA ---------- '''' '''' ========== Fnc0ArgsDLLVBA ========== '''' TimeDiffMs = 0 For LoopIndex = 1 To AverageCountDLL TimeDiffMs = TimeDiffMs + .Fnc0ArgsDLLVBA(, TARGET_DLL) Next LoopIndex If AverageCountDLL &gt; 0 Then TimeDiffMs = TimeDiffMs / AverageCountDLL Debug.Print &quot;Fnc0ArgsDLLVBA/DLL&quot; &amp; &quot;:&quot; &amp; &quot; - &quot; &amp; Format$(DummyMax, &quot;#,##0&quot;) &amp; _ &quot; times in &quot; &amp; TimeDiffMs &amp; &quot; ms&quot; End If DoEvents TimeDiffMs = 0 For LoopIndex = 1 To AverageCountVBA TimeDiffMs = TimeDiffMs + .Fnc0ArgsDLLVBA(, TARGET_VBA) Next LoopIndex If AverageCountVBA &gt; 0 Then TimeDiffMs = TimeDiffMs / AverageCountVBA Debug.Print &quot;Fnc0ArgsDLLVBA/VBA&quot; &amp; &quot;:&quot; &amp; &quot; - &quot; &amp; Format$(DummyMax, &quot;#,##0&quot;) &amp; _ &quot; times in &quot; &amp; TimeDiffMs &amp; &quot; ms&quot; End If DoEvents '''' ---------- Fnc0ArgsDLLVBA ---------- '''' '''' ========== Fnc3ArgsDLLVBA ========== '''' TimeDiffMs = 0 For LoopIndex = 1 To AverageCountDLL TimeDiffMs = TimeDiffMs + .Fnc3ArgsDLLVBA(, TARGET_DLL) Next LoopIndex If AverageCountDLL &gt; 0 Then TimeDiffMs = TimeDiffMs / AverageCountDLL Debug.Print &quot;Fnc3ArgsDLLVBA/DLL&quot; &amp; &quot;:&quot; &amp; &quot; - &quot; &amp; Format$(DummyMax, &quot;#,##0&quot;) &amp; _ &quot; times in &quot; &amp; TimeDiffMs &amp; &quot; ms&quot; End If DoEvents TimeDiffMs = 0 For LoopIndex = 1 To AverageCountVBA TimeDiffMs = TimeDiffMs + .Fnc3ArgsDLLVBA(, TARGET_VBA) Next LoopIndex If AverageCountVBA &gt; 0 Then TimeDiffMs = TimeDiffMs / AverageCountVBA Debug.Print &quot;Fnc3ArgsDLLVBA/VBA&quot; &amp; &quot;:&quot; &amp; &quot; - &quot; &amp; Format$(DummyMax, &quot;#,##0&quot;) &amp; _ &quot; times in &quot; &amp; TimeDiffMs &amp; &quot; ms&quot; End If DoEvents '''' ---------- Fnc3ArgsDLLVBA ---------- '''' End With End Sub </code></pre> <h3>Test results</h3> <p>I compiled x32 and x64 versions of the DLL and the C-client with MSYS/MinGW toolchains on Windows with no optimization (-O0), ran tests on each pair, and used the two DLL's to run tests from Excel 2002/VBA6/x32 and Excel 2016/VBA7/x64 respectively. I ran DllPerfRun.Runner multiple times, discarded results that were much slower than the rest, and calculated average timings. Table 1 shows a representative subset of results.</p> <p><strong>Table 1. Time in seconds required for completion of 10⁹ repetitions.</strong> <br /> <img src="https://raw.githubusercontent.com/pchemguy/SQLiteC-for-VBA/develop/Assets/Diagrams/VBA%20Performance.png" alt="Results" /></p> <h4>C-client timings</h4> <p>The leftmost column of Table 1 contains the PerfGauge timing. While I am not examining the disassembled code (which is a prudent thing to do), an empty unoptimized C-language For loop should require at least three machine instructions:</p> <ul> <li>increment the loop variable,</li> <li>compare the loop variable with the target,</li> <li>perform a conditional jump.</li> </ul> <p>On a 2.2 GHz multi-core processor with dynamic frequency adjustment (Intel Core i7-8750H @2.2GHz), the number of 2.1 s for 10⁹ repetitions, therefore, appears to be qualitatively reasonable. The second column shows the timing for calling DummySub0Args from the C-client (see DummySub0ArgsGauge routine). I do not have sufficient experience to explain why the numbers in the second column are lower. However, I am more concerned about the results in the right half of the table.</p> <h4>VBA timings</h4> <p>The green cell highlights the efficiency of calling a DLL routine from VBA6/x32/Excel 2002. This number indicates that a DLL call taking no arguments and returning no value is only 5x times slower than the same call from a compiled C-client. Further, this call is 7x times faster than a native VBA call (rightmost column) with the same signature. When the called routine either takes arguments or returns a value, the difference is less pronounced. Still, with the other three implemented mock calls, the tendency is qualitatively similar.</p> <p>The primary concern is the cell with an orange background, indicating that a single DLL call takes 2 microseconds under 2016/VBA7/x64 instead of 8 nanoseconds under VBA6/x32/Excel 2002.</p> <p>Sources and precompiled binaries are available from the GitHub <a href="https://github.com/pchemguy/DllTools" rel="nofollow noreferrer">repository</a> and additional information - from GitHub <a href="https://pchemguy.github.io/DllTools/" rel="nofollow noreferrer">pages</a>.</p>

270258

<p>I just joined here. I have been doing python for a couple of weeks and I would like for some experienced programmers to review my code. I made this for a school project and I am proud of it. The code below works well but I would like to know what things I can improve on. Thank you for taking the time to review this.</p> <p><strong>main.py</strong></p> <pre><code>main_grid = [['+' for col in range(3)] for row in range(3)] player_one = {'key': 'P1', 'name': None, 'symbol': 'X', 'pos': []} player_two = {'key': 'P2', 'name': None, 'symbol': 'O', 'pos': []} player_list = [player_one, player_two] def title_screen(): print(' '*15, ' _____ _____ _____') print(' '*15, '|__ __|__ __| ____|') print(' '*15, ' | | |_| |_| |___') print(' '*15, ' _|_|_|_____|_____|') print(' '*15, '|__ __| ___ | ____|') print(' '*15, ' | | | | | | |___ ') print(' '*15, '__|_|_|_|_|_|_____|') print(' '*15, '|__ __| ___ | ____|') print(' '*15, ' | | | |_| | ____|') print(' '*15, ' |_| |_____|_____|') def info_screen(): print('-'*51) print('2021 L.A | A python school project. ') print() print(&quot;This game is a python version of 'TIC TAC TOE'.&quot;) print('I hope you enjoy! :]') print() def intro_screen(): print('RULES:') print('Rows and columns can only have inputs from [0-2].') print('Players can only enter value once unless value is') print('not valid.') print(&quot;Players can't put their symbol in already occupied&quot;) print('cells.') print('Players win if their symbol is placed 3 in a row') print('horizontally, vertically or diagonally. Anything') print('else does not count as a win.') print('If the grid is filled, the game results as a tie.') print() def start_screen(): title_screen() info_screen() intro_screen() def get_name(): for player_type in player_list: print(f&quot;Enter [{player_type['key']}] name:&quot;) player_type['name'] = input(f&quot;[{player_type['key']}] &gt; &quot;) print() def get_input(player_type, desc): print(desc) user_input = input(f&quot;[{player_type['key']}] {player_type['name']} &gt; &quot;) print() return user_input def get_point(player_type, desc): &quot;&quot;&quot;Makes user get a point value which could be a row or col.&quot;&quot;&quot; point = -1 while point not in range(3): try: point = int(get_input(player_type, desc)) except ValueError: print('The entered value must be an integer.') print('Please try again.') print() continue if point in range(3): return point elif point not in range(3): print('The entered value must be in range between 0-2.') print('Please try again.') print() continue else: print('Unknown error') print('Please try again.') print() continue def check_pos(pos): &quot;&quot;&quot;Check whether the pos value is in a player's coords list.&quot;&quot;&quot; if pos in player_one['pos'] or pos in player_two['pos']: print('The entered coordinate is occupied by a player.') print('Please try again.') print() return False else: return True def update_grid(pos): &quot;&quot;&quot;Updates grid using player coords.&quot;&quot;&quot; for player_type in player_list: for prev_pos in player_type['pos']: main_grid[prev_pos[0]][prev_pos[1]] = player_type['symbol'] def print_stats(player_type, turn_count): &quot;&quot;&quot;Prints current game stats.&quot;&quot;&quot; print('-'*51) print(f&quot;CURRENT TURNS | {turn_count}/9&quot;) print(f&quot;CURRENT PLAYER | {player_type['key']}&quot;) print(f&quot;CURRENT SYMBOL | {player_type['symbol']}&quot;) def print_grid(): &quot;&quot;&quot;Prints the grid&quot;&quot;&quot; print() for row in range(3): print(' '*21, end='') for col in range(3): print(main_grid[row][col], end=' ') print() print() def check_grid(player_type, pos): &quot;&quot;&quot;End game when symbol is three in a row or grid is filled. Continues if not three in a row or not filled.&quot;&quot;&quot; row = pos[0] col = pos[1] symbol = player_type['symbol'] win_msg = f&quot;[{player_type['key']}] {player_type['name']} has won the game.&quot; tie_msg = 'The game has resulted a tie.' if symbol == main_grid[row][0] == main_grid[row][1] == main_grid[row][2]: print_result(win_msg) return True elif symbol == main_grid[0][col] == main_grid[1][col] == main_grid[2][col]: print_result(win_msg) return True elif row == col and symbol == main_grid[0][0] == main_grid[1][1] == main_grid[2][2]: print_result(win_msg) return True elif row + col == 2 and symbol == main_grid[0][2] == main_grid[1][1] == main_grid[2][0]: print_result(win_msg) return True elif '+' not in main_grid[0] and '+' not in main_grid[1] and '+' not in main_grid[2]: print_result(tie_msg) return True else: return False def print_result(msg): &quot;&quot;&quot;Prints end result of game&quot;&quot;&quot; print('-'*51) print('RESULT:') print_grid() print(msg) exit_result() def setup_pos(player_type): &quot;&quot;&quot;Sets up position value Gets each point value. Checks each point value Checks position value Adds position value to player dictionary &quot;&quot;&quot; valid_pos = False while valid_pos is False: row = get_point(player_type, 'Select a row:') col = get_point(player_type, 'Select a column:') new_pos = (row, col) valid_pos = check_pos(new_pos) if valid_pos is True: player_type['pos'].append(new_pos) return new_pos def exit_result(): &quot;&quot;&quot;Choice to exit result screen.&quot;&quot;&quot; print() print(f&quot;Press any key to exit.&quot;) user_input = input('&gt; ') exit(0) def setup_game(): turn_count = 1 game_finish = False while game_finish is False: for player_type in player_list: print_stats(player_type, turn_count) print_grid() new_pos = setup_pos(player_type) update_grid(new_pos) game_finish = check_grid(player_type, new_pos) turn_count += 1 if game_finish is True: # If player won, break for loop on player's turn. break def main(): start_screen() get_name() setup_game() if __name__ == '__main__': main() </code></pre>

270261

<p>I have implemented generic doubly linked list in C language in which you can store any data type you want. Just like in C++ and Java, where a list can store any data type, like - string, int, long, structure, etc., you can do the same using this program.</p> <p>Can someone please review the code.</p> <p>The code is below:</p> <hr /> <h2>generic_doubly_linked_list.c</h2> <pre><code> #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #include &quot;generic_doubly_linked_list.h&quot; /* * generic_doubly_linked_list.c: * * This program implements a linked list in which you can store any data type * you want. Just like in C++ and Java, a list can store any data type, like - * string, int, long, structure, etc., you can do the same using this program. * * There are comments in generic_doubly_linked_list.h which will help in * understanding the program. */ /* * char *get_error_string(int error_num): * * Function get_error_string() returns the string that corresponds to the error * number passed to it. * */ char *get_error_string(int error_num) { if (error_num == NO_ERROR) { return &quot;No error happened.&quot;; } else if (error_num == INVALID_DATA_TYPE) { return &quot;Argument 'data_type' is neither SIMPLE_DATA_TYPE nor COMPLEX_DATA_TYPE.&quot;; } else if (error_num == NO_MEMORY) { return &quot;No memory available.&quot;; } else if (error_num == INVALID_DATA_LEN) { return &quot;Argument 'data_len' is &lt;= 0.&quot;; } else if (error_num == ROOT_IS_NULL) { return &quot;Argument 'root' is NULL.&quot;; } else if (error_num == MATCHING_NODE_NOT_FOUND) { return &quot;No node found whose data matches the data given by the user.&quot;; } else if (error_num == DATA_IS_NULL) { return &quot;Argument 'data' is NULL.&quot;; } else { return &quot;Invalid error number given.&quot;; } } // end of get_error_string /* * dlln_ptr add_to_front(dlln_ptr root, long double data, int data_type, long data_len, int *error_num): * * Function add_to_front() adds a list node to the front of the list contaning data * passed to it by the user and the new root is returned. The root of the list will * change because the list node is added to front, so the user must update the * root value with the value returned by this function. * * In case any error happens, the error number is saved in the argument 'error_num'. * * If 'data_type' is SIMPLE_DATA_TYPE then the argument 'data_len' is ignored. * * The details of SIMPLE_DATA_TYPE and COMPLEX_DATA_TYPE can be found in * generic_doubly_linked_list.h. * * When you pass in a simple data type, the same data is stored in the data field * of the list node. So, if you pass in interger 4 then 4 will be stored in the * data field. If you pass a pointer to integer (for example - 0xABABABAB) * then 0xABABABAB will be stored in the data field. * * When you pass in a complex data type, then the data pointed to by the passed * in pointer is copied and not the pointer itself. So, if you pass in a pointer * to a string then new memory is allocated whose length is equal to the passed * in parameter 'data_len' and then contents of string are copied into this * new memory. Same goes for pointers to structures, unions, etc. */ dlln_ptr add_to_front(dlln_ptr root, long double data, int data_type, long data_len, int *error_num) { dlln_ptr temp = NULL; *error_num = NO_ERROR; if ((data_type != SIMPLE_DATA_TYPE) &amp;&amp; (data_type != COMPLEX_DATA_TYPE)) { *error_num = INVALID_DATA_TYPE; return root; } if (data_type == COMPLEX_DATA_TYPE) { //check if data is NULL if (data == 0) { *error_num = DATA_IS_NULL; return root; } // check data_len if (data_len &lt;= 0) { *error_num = INVALID_DATA_LEN; return root; } } temp = calloc(1, DLL_STRUCT_SIZE); if (!temp) { *error_num = NO_MEMORY; return root; } #if DEBUG_ON printf(&quot;Allocated memory for list node. Number of bytes allocated = %ld.\n&quot;, DLL_STRUCT_SIZE); #endif temp-&gt;data_type = data_type; if (data_type == SIMPLE_DATA_TYPE) { temp-&gt;data_len = 0; temp-&gt;data = data; } else { // COMPLEX_DATA_TYPE temp-&gt;data_len = data_len; temp-&gt;data = (long long)(calloc(data_len, 1)); if (temp-&gt;data == 0) { *error_num = NO_MEMORY; // zero out memory before free to catch some use after free bugs if any memset(temp, 0, DLL_STRUCT_SIZE); free(temp); return root; } #if DEBUG_ON printf(&quot;Allocated memory for data. Number of bytes allocated = %ld.\n&quot;, data_len); #endif memcpy((void *)(long long)(temp-&gt;data), (void *)(long long)(data), data_len); } // end of if else condition data_type == SIMPLE_DATA_TYPE temp-&gt;next = root; if (root) root-&gt;prev = temp; temp-&gt;prev = NULL; return temp; } // end of add_to_front /* * dlln_ptr delete_node_matching_data(dlln_ptr root, long double data, int data_type, long data_len, int *error_num): * * Function delete_node_matching_data() deletes a list node that contains the data * that matches the data passed in by the user and [new] root is returned. * In case, the list node to be deleted is the root itself then the list will have * a new root, so the user must update the root value with the value returned * by this function. * * In case any error happens, the error number is saved in the argument 'error_num'. * * If 'data_type' is SIMPLE_DATA_TYPE then the user supplied data is directly * compared with the data in the list node. If both the data are same, then * the node is deleted else the next node is inspected. In SIMPLE_DATA_TYPE data * type case argument 'data_len' is ignored. * * If 'data_type' is COMPLEX_DATA_TYPE then the value of the argument 'data_len' is * compared to the value of 'data_len' field of the list node. If they are not * equal then next node is inspected. If they are equal then the contents of the * memory pointed to by the user supplied data pointer is compared with the contents * of the memory pointed to by the data pointer in the list node and if they are * same then this node is deleted else the next node is inspected. * */ dlln_ptr delete_node_matching_data(dlln_ptr root, long double data, int data_type, long data_len, int *error_num) { dlln_ptr temp = NULL; int delete_this_node = 0; *error_num = NO_ERROR; if (!root) { *error_num = ROOT_IS_NULL; return root; } if ((data_type != SIMPLE_DATA_TYPE) &amp;&amp; (data_type != COMPLEX_DATA_TYPE)) { *error_num = INVALID_DATA_TYPE; return root; } if (data_type == COMPLEX_DATA_TYPE) { //check if data is NULL if (data == 0) { *error_num = DATA_IS_NULL; return root; } // check data_len if (data_len &lt;= 0) { *error_num = INVALID_DATA_LEN; return root; } } for (temp = root; temp != NULL; temp = temp-&gt;next) { if (data_type == SIMPLE_DATA_TYPE) { if (temp-&gt;data == data) { root = delete_node(root, temp); return root; } } else { // COMPLEX_DATA_TYPE if (temp-&gt;data_len != data_len) { continue; } if (memcmp((void *)(long long)(temp-&gt;data), (void *)(long long)(data), data_len) == 0) { root = delete_node(root, temp); return root; } } // end of if else condition data_type == SIMPLE_DATA_TYPE } // end of for loop // matching node not found *error_num = MATCHING_NODE_NOT_FOUND; return root; } // end of delete_node_matching_data /* * dlln_ptr delete_node(dlln_ptr root, dlln_ptr node_to_delete): * * Function delete_node() deletes the list node whose pointer is passed in the * argument 'node_to_delete' and returns [new] root. * * In case, the list node to be deleted is the root itself then the list will have * a new root, so the user must update the root value with the value returned * by this function. * */ dlln_ptr delete_node(dlln_ptr root, dlln_ptr node_to_delete) { dlln_ptr new_root = root; if (!root) { return root; } if (!node_to_delete) { return root; } if (node_to_delete == root) { // deleting root node new_root = root-&gt;next; if (new_root) { new_root-&gt;prev = NULL; } } else { node_to_delete-&gt;prev-&gt;next = node_to_delete-&gt;next; if (node_to_delete-&gt;next) { node_to_delete-&gt;next-&gt;prev = node_to_delete-&gt;prev; } } if (node_to_delete-&gt;data_type == COMPLEX_DATA_TYPE) { void *cmp_data = (void *)(long long)(node_to_delete-&gt;data); // zero out memory before free to catch some use after free bugs if any memset(cmp_data, 0, node_to_delete-&gt;data_len); free(cmp_data); #if DEBUG_ON printf(&quot;Freed data memory.\n&quot;); #endif } // zero out memory before free to catch some use after free bugs if any memset(node_to_delete, 0, DLL_STRUCT_SIZE); free(node_to_delete); #if DEBUG_ON printf(&quot;Freed list node memory.\n&quot;); #endif return new_root; } // end of delete_node /* * dlln_ptr delete_all_nodes_from_list(dlln_ptr root): * * Function delete_all_nodes_from_list() deletes all the nodes in the list and * returns NULL. * */ dlln_ptr delete_all_nodes_from_list(dlln_ptr root) { while (root) { root = delete_node(root, root); } return NULL; } // end of delete_all_nodes_from_list </code></pre> <hr /> <h2>generic_doubly_linked_list.h</h2> <pre><code> #ifndef _GENERIC_DOUBLY_LINKED_LIST_H #define _GENERIC_DOUBLY_LINKED_LIST_H /* * generic_doubly_linked_list.c: * * This program implements a linked list in which you can store any data type * you want. Just like in C++ and Java, a list can store any data type, like - * string, int, long, structure, etc., you can do the same using this program. * * There are comments in in this header file which will help in understanding * the program. */ #define NO_ERROR 0 // no error happened. #define INVALID_DATA_TYPE -1 // argument 'data_type' is neither SIMPLE_DATA_TYPE nor COMPLEX_DATA_TYPE. #define NO_MEMORY -2 // no memory available. #define INVALID_DATA_LEN -3 // argument 'data_len' is &lt;= 0. #define ROOT_IS_NULL -4 // argument 'root' is NULL. #define MATCHING_NODE_NOT_FOUND -5 // no node found whose data matches the data given by the user. #define DATA_IS_NULL -6 // argument 'data' is NULL. /* * SIMPLE_DATA_TYPE and COMPLEX_DATA_TYPE are used to tell the program that the * data is of simple type or of complex type. * * SIMPLE_DATA_TYPE: * Simple data type means char, short, int, long, float, double, long long, * long double, etc. and pointers to these data types. When you pass in a * simple data type, the same data is stored in the data field of the list node. * So, if you pass in interger 4 then 4 will be stored in the data field. If * you pass a pointer to integer (for example - 0xABABABAB) then 0xABABABAB will * be stored in the data field. The argument 'data_len' is ignored for * SIMPLE_DATA_TYPE. * * COMPLEX_DATA_TYPE: * Complex data type is always a pointer and it is a pointer to string, * structures, unions, etc. But pointer to int, float, etc. (basically, pointer * to basic data types) should be considered as SIMPLE_DATA_TYPE. When you * pass in a complex data type, then the data pointed to by the passed in pointer * is copied and not the pointer itself. So, if you pass in a pointer to a * string then new memory is allocated whose length is equal to the passed in * parameter 'data_len' and then contents of string are copied into this new memory. * Same goes for pointers to structures, unions, etc. * * IMPORTANT NOTE: When you are passing in a pointer to string, please make sure that * the length of the data that you pass in includes 1 extra byte * for null byte. */ #define SIMPLE_DATA_TYPE 1 // char, short, int, long, float, double, long long, long double, etc. and pointers to these data types #define COMPLEX_DATA_TYPE 2 // always a pointer which is pointer to string, structures, unions, etc. /* * Converting from long double to pointer and vice-versa: * * If you want to convert long double type to pointer type then please follow * the code below: * long double a; * char *b = (char *)(long long)(a); * * If you want to convert pointer type to long double type then please follow * the code below: * char *a; * long double b = (long double)(long long)(a); */ struct doubly_linked_list_node { int data_type; long data_len; long double data; struct doubly_linked_list_node *prev; struct doubly_linked_list_node *next; }; #define DLL_STRUCT_SIZE sizeof(struct doubly_linked_list_node) typedef struct doubly_linked_list_node *dlln_ptr; /* * NOTE: * * If you want to loop through the list and get the data then you can use the * following code: * * dlln_ptr temp = root; * while (temp) { * YOUR_DATA_TYPE data = (YOUR_DATA_TYPE)(long long)(temp-&gt;data); * // do something with data * temp = temp-&gt;next; * } */ /* * char *get_error_string(int error_num): * * Function get_error_string() returns the string that corresponds to the error * number passed to it. * */ char *get_error_string(int error_num); /* * dlln_ptr add_to_front(dlln_ptr root, long double data, int data_type, long data_len, int *error_num): * * Function add_to_front() adds a list node to the front of the list contaning data * passed to it by the user and the new root is returned. The root of the list will * change because the list node is added to front, so the user must update the * root value with the value returned by this function. * * In case any error happens, the error number is saved in the argument 'error_num'. * * If 'data_type' is SIMPLE_DATA_TYPE then the argument 'data_len' is ignored. * * The details of SIMPLE_DATA_TYPE and COMPLEX_DATA_TYPE can be found in * generic_doubly_linked_list.h. * * When you pass in a simple data type, the same data is stored in the data field * of the list node. So, if you pass in interger 4 then 4 will be stored in the * data field. If you pass a pointer to integer (for example - 0xABABABAB) * then 0xABABABAB will be stored in the data field. * * When you pass in a complex data type, then the data pointed to by the passed * in pointer is copied and not the pointer itself. So, if you pass in a pointer * to a string then new memory is allocated whose length is equal to the passed * in parameter 'data_len' and then contents of string are copied into this * new memory. Same goes for pointers to structures, unions, etc. */ dlln_ptr add_to_front(dlln_ptr root, long double data, int data_type, long data_len, int *error_num); /* * dlln_ptr delete_node_matching_data(dlln_ptr root, long double data, int data_type, long data_len, int *error_num): * * Function delete_node_matching_data() deletes a list node that contains the data * that matches the data passed in by the user and [new] root is returned. * In case, the list node to be deleted is the root itself then the list will have * a new root, so the user must update the root value with the value returned * by this function. * * In case any error happens, the error number is saved in the argument 'error_num'. * * If 'data_type' is SIMPLE_DATA_TYPE then the user supplied data is directly * compared with the data in the list node. If both the data are same, then * the node is deleted else the next node is inspected. In SIMPLE_DATA_TYPE data * type case argument 'data_len' is ignored. * * If 'data_type' is COMPLEX_DATA_TYPE then the value of the argument 'data_len' is * compared to the value of 'data_len' field of the list node. If they are not * equal then next node is inspected. If they are equal then the contents of the * memory pointed to by the user supplied data pointer is compared with the contents * of the memory pointed to by the data pointer in the list node and if they are * same then this node is deleted else the next node is inspected. * */ dlln_ptr delete_node_matching_data(dlln_ptr root, long double data, int data_type, long data_len, int *error_num); /* * dlln_ptr delete_node(dlln_ptr root, dlln_ptr node_to_delete): * * Function delete_node() deletes the list node whose pointer is passed in the * argument 'node_to_delete' and returns [new] root. * * In case, the list node to be deleted is the root itself then the list will have * a new root, so the user must update the root value with the value returned * by this function. * */ dlln_ptr delete_node(dlln_ptr root, dlln_ptr node_to_delete); /* * dlln_ptr delete_all_nodes_from_list(dlln_ptr root): * * Function delete_all_nodes_from_list() deletes all the nodes in the list and * returns NULL. * */ dlln_ptr delete_all_nodes_from_list(dlln_ptr root); #endif </code></pre>

270262

<p>I have a simple project that I built that protects the routes/pages of the website by using the if and else statement and putting each page with a function <code>withAuth()</code>, but I'm not sure if that is the best way to protect routes with nextjs, and I noticed that there is a delay in protecting the route or pages, like 2-3 seconds long, in which they can see the content of the page before it redirects the visitor or unregistered user to the login page.</p> <p>Is there a way to get rid of it or make the request faster so that unregistered users don't view the page's content? Is there a better approach to safeguard a certain route in the nextjs framework?</p> <h1>Code</h1> <hr /> <pre><code>import { useContext, useEffect } from &quot;react&quot;; import { AuthContext } from &quot;@context/auth&quot;; import Router from &quot;next/router&quot;; const withAuth = (Component) =&gt; { const Auth = (props) =&gt; { const { user } = useContext(AuthContext); useEffect(() =&gt; { if (!user) Router.push(&quot;/login&quot;); }); return &lt;Component {...props} /&gt;; }; return Auth; }; export default withAuth; </code></pre> <h2>Sample of the use of withAuth</h2> <pre><code>import React from &quot;react&quot;; import withAuth from &quot;./withAuth&quot;; function sample() { return &lt;div&gt;This is a protected page&lt;/div&gt;; } export default withAuth(sample); </code></pre>

270263

<p>I'm currently learning C/C++ and I saw this question on Reddit on how to create a linked from an array and decided that would make a good exercise for learning the absolute basics of C, so without looking at the answers I wrote this.</p> <p>Anyways, preamble aside, here's the code:</p> <pre class="lang-c prettyprint-override"><code>#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;stdint.h&gt; typedef struct Node Node; typedef struct Node { int data; Node *next; } Node; Node *array_to_list(int32_t array[], int32_t length) { if (length &lt;= 0) { return NULL; } Node* tail = NULL; for (int32_t i = length - 1; i &gt;= 0; i--) { Node* current = (Node*) malloc(sizeof(Node)); current-&gt;data = array[i]; current-&gt;next = tail; tail = current; } return tail; } void free_list(Node *head) { while (head != NULL) { Node *next = head-&gt;next; free(head); head = next; } } int main() { int array[] = { 1, 2, 3, 4, 5 }; Node *list = array_to_list(array, 5); Node *current = list; while (current != NULL) { printf(&quot;%d\n&quot;, current-&gt;data); current = current-&gt;next; } free_list(list); return 0; } </code></pre> <p>As of now this is all inside <code>main.c</code> and I didn't implement any other methods a linked list would normally have, I'm just trying to see if I'm doing things right</p>

270268

<p>Could you please have a look at our naive bayes model. We look at a corpus of emails where an email is either spam or not. To classifiy we naively assume a bag of words and estimate prior probabilities through maximum likelihood. The model defintion can be found <a href="https://en.wikipedia.org/wiki/Naive_Bayes_classifier#Probabilistic_model" rel="nofollow noreferrer">here</a>:</p> <p>Specifically we are interested to understand if:</p> <ol> <li>Usage of <code>self</code> variables is fine or e.g. if methods should return things functionally instead of changing inplace.</li> <li>Splitting of methods is good practice or if it should be more condensed (i.e., less methods, bigger methods)</li> <li>Any unpythonic things or things you find hard to understand.</li> <li>I am aware lambda functions are supposedly no good practice but for the purpose I found them convenient. But please comment on that as well. I could declare a local function instead of using lambda.</li> </ol> <p><strong>Model</strong>:</p> <pre class="lang-py prettyprint-override"><code>from collections import defaultdict import sys import os import pickle import operator import math class NaiveBayes: def __init__(self, mode): # Sets file path arguments depending on mode of model usage self.mode = mode self.set_arguments() # Variables to save frequencies to self.freq_word_given_class = self.create_class_defaultdict() self.freq_word = defaultdict(int) self.freq_class = defaultdict(int) # Variables to save ML estimators to self.prob_word_given_class = self.create_class_defaultdict() self.prob_word = defaultdict(int) self.prob_class = defaultdict(int) # Variables needed for backoff smoothing self.rel_freq_word_given_class = self.create_class_defaultdict() self.prob_word_given_class_backoff = self.create_class_defaultdict() def predict(self): &quot;&quot;&quot; Doc string &quot;&quot;&quot; for file, target in self.get_files(): with open(f&quot;{os.getcwd()}/test/{target}/{file}&quot;, encoding=&quot;latin-1&quot;) as f: email = f.read().split() # Get probability score for each class # Operating in log space because probabilities get very small log_score = dict() for _class in self.classes: log_prob_class = math.log(self.prob_class[_class]) log_prob_doc = 0 for word in email: prob_given_class = self.prob_word_given_class_backoff[_class] # It would be bad to assume unknown have 0 probability. That would likely # misclassify documents simply because a word wasnt seen during data. if word not in prob_given_class: continue # Just skip log_prob_doc += math.log(prob_given_class[word]) log_score[_class] = log_prob_class + log_prob_doc # Save the prediction prediction = max(log_score.items(), key=operator.itemgetter(1))[0] self.save_score(target, prediction) print(file + &quot;\t&quot; + prediction + &quot;\n&quot;) # Show result self.show_score(which=&quot;accuracy&quot;) def save_score(self, target, prediction): &quot;&quot;&quot;Increase counter[0] when classified correctly else increase counter[1] by 1.&quot;&quot;&quot; self.counter[target==prediction] += 1 def show_score(self, which): &quot;&quot;&quot; Doc string &quot;&quot;&quot; if which == &quot;accuracy&quot;: accuracy = self.counter[0]/(self.counter[0] + self.counter[1]) print(&quot;Accuracy: &quot; + str(accuracy)) # print(self.counter) def fit(self): &quot;&quot;&quot;Estimates probabilities given the frequencies. Then apply backoff smoothing.&quot;&quot;&quot; if self.mode == &quot;test&quot;: params = self.load_parameters() self.prob_word_given_class = params[&quot;prob_word_given_class&quot;] self.prob_word = params[&quot;prob_word&quot;] self.prob_class = params[&quot;prob_class&quot;] self.prob_word_given_class_backoff = params[&quot;prob_word_given_class_backoff&quot;] self.counter = [0,0] # Preliminary counter to count how many times classification is right elif self.mode == &quot;train&quot;: self.count_frequencies() self.estimate_parameters() self.smooth_parameters() def count_frequencies(self): &quot;&quot;&quot;Count word frequencies, word frequencies given the class and class frequencies.&quot;&quot;&quot; for file, _class in self.get_files(): file = os.path.join(os.getcwd(),&quot;train&quot;, _class, file) with open(file, encoding=&quot;latin-1&quot;) as f: email = f.read().split() # Count emails frequencies self.freq_class[_class] += 1 for word in email: self.freq_word_given_class[_class][word] += 1 self.freq_word[word] += 1 def estimate_parameters(self): &quot;&quot;&quot;Estimates the model parameters given the words frequencies.&quot;&quot;&quot; for _class in self.classes: # Estimate probability of word given class: p(w|c) = f(w,c) / sum_w' f(w',c) frequencies = self.freq_word_given_class[_class] _sum = sum(frequencies.values()) self.prob_word_given_class[_class] = {k: v/_sum for k, v in frequencies.items()} # Estimate probability of word: p(w) = f(w) / sum(f(w') _sum = sum(self.freq_word.values()) self.prob_word = {k: v/_sum for k, v in self.freq_word.items()} # Estimate probability of class: p(c) = f(c) / sum(f(c')) _sum = sum(self.freq_class.values()) self.prob_class = {k: v/_sum for k, v in self.freq_class.items()} def smooth_parameters(self): &quot;&quot;&quot;Smoothes the model by Kneser-Ney smoothing.&quot;&quot;&quot; # Calulcate discount factor delta after Kneser/Essen/Ney n = lambda x: sum(list(self.freq_word_given_class[_class].values()).count(x) for _class in self.classes) delta = n(1) / (n(1) + 2*n(2)) # Calulcate relativ frequencies of word given class: r(w|c) = max(0, f(w,c) - delta) / sum_w' f(w',c) for _class in self.classes: _sum = sum(self.freq_word_given_class[_class].values()) # Sum_w' f(w',c) self.rel_freq_word_given_class[_class] = {k: max(0, v - delta) / _sum for k, v in self.freq_word_given_class[_class].items()} # Dynamically calculate backoff factor alpha alpha = lambda _class: 1 - sum(self.rel_freq_word_given_class[_class].values()) # Calulcate discount probability: p(w|c) = r(w|c) + alpha(c)p(w) for _class in self.classes: _alpha, rel_word_freq = alpha(_class), self.rel_freq_word_given_class[_class] self.prob_word_given_class_backoff[_class]= {k: rel_word_freq[k] + _alpha * self.prob_word[k] for k, v in self.prob_word_given_class[_class].items()} def set_arguments(self): &quot;&quot;&quot;Sets variables depending on the mode of model usage.&quot;&quot;&quot; self.paramfile = sys.argv[1] self.data_dir = sys.argv[2] # In train mode parameters are passed vice versa if self.mode == &quot;train&quot;: self.data_dir, self.paramfile = self.paramfile, self.data_dir self.classes = next(os.walk(self.data_dir))[1] def create_class_defaultdict(self): &quot;&quot;&quot;Helper method to create defaultdict of classes.&quot;&quot;&quot; return {_class: defaultdict(int) for _class in self.classes} def get_files(self): &quot;&quot;&quot; Generator object that returns the next file and its corresponding class every time next() is called. &quot;&quot;&quot; for root, dirs, files in os.walk(self.data_dir): for _class in self.classes: if root.endswith(_class): for file in files: yield file, _class def load_parameters(self): with open(self.paramfile, 'rb') as handle: return pickle.load(handle) def save_parameters(self): params = {&quot;prob_word&quot;: self.prob_word, &quot;prob_class&quot;: self.prob_class, &quot;prob_word_given_class&quot;: self.prob_word_given_class, &quot;prob_word_given_class_backoff&quot;: self.prob_word_given_class_backoff} with open(f&quot;{self.paramfile}.pickle&quot;, 'wb') as handle: pickle.dump(params, handle, protocol=pickle.HIGHEST_PROTOCOL) </code></pre> <p><strong>Training call:</strong></p> <pre><code>from model import NaiveBayes import sys if __name__ == &quot;__main__&quot;: assert len(sys.argv) == 3, &quot;Call script as $ python3 test.py paramfile mail-dir&quot; nb = NaiveBayes(mode=&quot;train&quot;) nb.fit() nb.save_parameters() </code></pre> <p><strong>Test/inference call:</strong></p> <pre><code>from model import NaiveBayes import sys if __name__ == &quot;__main__&quot;: assert len(sys.argv) == 3, &quot;Call script as python3 train.py train-dir paramfile&quot; nb = NaiveBayes(mode=&quot;test&quot;) nb.fit() nb.predict() </code></pre>

270270

<p><strong>Edit</strong>: A new and improved version can be found in <a href="https://codereview.stackexchange.com/questions/270439/custom-implementation-to-provide-an-immutable-range-of-a-container-without-copyi">this question</a>, based on the feedback!</p> <hr /> <p>I needed to pass a const reference to part of a <code>std::vector</code> without copy.</p> <p>Some research, particularly <a href="//stackoverflow.com/q/30469063">this SO question</a>, suggested that it is not something supported by default, so I created my own code for it:</p> <pre class="lang-cpp prettyprint-override"><code>#include &lt;iterator&gt; #include &lt;vector&gt; template &lt;typename T&gt; class ConstVectorSubrange{ public: ConstVectorSubrange(typename std::vector&lt;T&gt;::const_iterator start_, uint32 size_) : start(start_) , range_size(size_) { } ConstVectorSubrange(std::initializer_list&lt;typename std::vector&lt;T&gt;::const_iterator&gt; list) : start(*list.begin()) , range_size(std::distance(*list.begin(), *(list.end()-1))) { } const T&amp; operator[](std::size_t index) const{ assert(index &lt; range_size); return *(start + index); } const T&amp; back(void) const{ return *(cend()-1); } std::size_t size(void) const{ return range_size; } const typename std::vector&lt;T&gt;::const_iterator cbegin(void) const{ return start; } const typename std::vector&lt;T&gt;::const_iterator cend(void) const{ return (start + range_size); } private: const typename std::vector&lt;T&gt;::const_iterator start; const uint32 range_size; }; </code></pre> <p>An example of using this would be a member function where not the whole array is visible, although copies are to be avoided:</p> <pre class="lang-cpp prettyprint-override"><code>#include &lt;vector&gt; class BigData{ std::vector&lt;int&gt; big_array = vector&lt;int&gt;(10000); public: ConstVectorSubrange get_last_five_thousand_elements(){ return{(big_array.cend()-5000), big_array.cend()}; } }; </code></pre> <p>How can this code be improved?</p> <p>Especially considering the iterators might be invalidated after the creation of this object, is there a way to make it safer?</p>

270271

<p>Given 2 values and an array, I must return the minimal distance between the indices of both values, as efficiently as I can in terms of run time and space.</p> <p>This is my solution:</p> <pre><code> public static int minDist (int[] a, int x, int y) { int index_one = a[0]; int index_two = a[0]; for(int i = 0 ; i &lt; a.length ; i++) if(a[i] == x) index_one = i; else if(a[i] == y) index_two = i; return(Math.abs(index_one - index_two)); } </code></pre> <p>I'm not sure it works, especially for extreme cases, but I thought the best way is to run the loop one time and find the index of both numbers.</p> <p>Can I make it more efficient?</p>

270273

<p>There are many template engines but my question is: Why do they still exist? Can we not achieve the same job with readily available JavaScript Template Literals?</p> <p>So influenced from <a href="https://2ality.com/2015/01/template-strings-html.html" rel="nofollow noreferrer">this blogpost</a>, I have come up with something as follows. Do you think this is reasonable in daily JavaScript?</p> <p>The following code is pure JavaScript. Lets start with a proper data.</p> <pre><code>var data = { labels: ['ID','Name'] , rows : [ {&quot;id&quot;: &quot;1&quot;, 'name': &quot;richard&quot;} , {&quot;id&quot;: &quot;2&quot;, 'name': &quot;santos&quot;} ] }; </code></pre> <p>Now let's define a <code>tableTemplate</code> function which takes the <code>data</code> and gives us an HTML table.</p> <pre><code>function tableTemplate(data){ return ` &lt;table&gt; &lt;tr&gt; ${data.labels.map(label =&gt; html` &lt;th&gt;&amp;${label}&lt;/th&gt;`).join(&quot;&quot;)} &lt;/tr&gt;${data.rows.map(row =&gt; html` &lt;tr&gt; &lt;td&gt;&amp;${row.id}&lt;/td&gt; &lt;td&gt;&amp;${row.name}&lt;/td&gt; &lt;/tr&gt;`).join(&quot;&quot;)} &lt;/table&gt;`; } </code></pre> <p>So what is this <code>html`</code> thingy and also that <code>&amp;$</code>?</p> <ul> <li>First of all <code>html`</code> is just a generic <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#tagged_templates" rel="nofollow noreferrer">tag function</a> that we define only once and without modifying it, we can use it for all of our template functions.</li> <li><code>&amp;$</code> on the other hand is simple. <code>&amp;</code> is just a simple string character and the second one is the escaping <code>$</code> character for variables in template strings such as <code>${x}</code>. We can use a tag function to validate our HTML code by escaping invalid HTML characters like <code>&amp;</code>, <code>&gt;</code>, <code>&lt;</code>, <code>&quot;</code>, <code>'</code> or <code>`</code>. The version I give below looks a little convoluted but it's really simple and very useful. It basically escapes invalid HTML characters and provides a &quot;raw&quot; version of the template string.</li> </ul> <p>Please follow above links for further information. Here it is:</p> <pre><code>function html(lits,...vars){ var esc = { &quot;&amp;&quot;: &quot;&amp;amp;&quot; , &quot;&gt;&quot;: &quot;&amp;gt;&quot; , &quot;&lt;&quot;: &quot;&amp;lt;&quot; , '&quot;': &quot;&amp;quot;&quot; , &quot;'&quot;: &quot;&amp;#39;&quot; , &quot;`&quot;: &quot;&amp;#96;&quot; }; return lits.raw .reduce( (res,lit,i) =&gt; (res += lit.endsWith(&quot;&amp;&quot;) ? lit.slice(0,-1) + [...vars[i].toString()].reduce((s,c) =&gt; s += esc[c] || c, &quot;&quot;) : lit + (vars[i] || &quot;&quot;)) , &quot;&quot; ); } </code></pre> <p>Now, it's time to put everything together for a working sample. Let's also add <code>&lt;thead&gt;</code> and <code>&lt;tbody&gt;</code> tags and some CSS this time.</p> <p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false"> <div class="snippet-code"> <pre class="snippet-code-js lang-js prettyprint-override"><code>function html(lits,...vars){ var esc = { "&amp;": "&amp;amp;" , "&gt;": "&amp;gt;" , "&lt;": "&amp;lt;" , '"': "&amp;quot;" , "'": "&amp;#39;" , "`": "&amp;#96;" }; return lits.raw .reduce( (res,lit,i) =&gt; (res += lit.endsWith("&amp;") ? lit.slice(0,-1) + [...vars[i].toString()].reduce((s,c) =&gt; s += esc[c] || c, "") : lit + (vars[i] || "")) , "" ); } function tableTemplate(data){ return ` &lt;table&gt; &lt;thead&gt; &lt;tr&gt;${data.labels.map(label =&gt; html` &lt;th&gt;&amp;${label}&lt;/th&gt;`).join("")} &lt;/tr&gt; &lt;/thead&gt; &lt;tbody&gt;${data.rows.map(row =&gt; html` &lt;tr&gt; &lt;td&gt;&amp;${row.id}&lt;/td&gt; &lt;td&gt;&amp;${row.name}&lt;/td&gt; &lt;/tr&gt;`).join("")} &lt;/tbody&gt; &lt;/table&gt;`; } var data = { labels: ['ID','Name'] , rows : [ {"id": 1, 'name': "richard"} , {"id": 2, 'name': "santos"} , {"id": 3, 'name': "&lt;ömer &amp; `x`&gt;"} ] }; document.write(tableTemplate(data));</code></pre> <pre class="snippet-code-css lang-css prettyprint-override"><code>table { background-color: LightPink; border : 0.2em solid #00493E; border-radius : 0.4em; padding : 0.2em } thead { background-color: #00493E; color : #E6FFB6 } tbody { background-color: #E6FFB6; color : #00493E }</code></pre> </div> </div> </p> <p>Obviously you can now insert <code>&lt;style&gt;</code> tag or <code>class=&quot;whatever&quot;</code> attribute into your quasi-HTML template literal in the <code>tableTemplate</code> function just the way you would normally do in an HTML text file.</p> <p>Also please note that if you <code>console.log</code> the resulting HTML text string, thanks to the raw conversion, it would beautifully display (according to your indenting in the <code>tableTemplate</code> function) just like below:</p> <pre><code>&lt;table&gt; &lt;thead&gt; &lt;tr&gt; &lt;th&gt;ID&lt;/th&gt; &lt;th&gt;Name&lt;/th&gt; &lt;/tr&gt; &lt;/thead&gt; &lt;tbody&gt; &lt;tr&gt; &lt;td&gt;1&lt;/td&gt; &lt;td&gt;richard&lt;/td&gt; &lt;/tr&gt; &lt;tr&gt; &lt;td&gt;2&lt;/td&gt; &lt;td&gt;santos&lt;/td&gt; &lt;/tr&gt; &lt;tr&gt; &lt;td&gt;317&lt;/td&gt; &lt;td&gt;&amp;lt;ömer &amp;amp; &amp;#39;x&amp;#39;&amp;gt;&lt;/td&gt; &lt;/tr&gt; &lt;/tbody&gt; &lt;/table&gt; </code></pre>

270275

<pre><code>/// #include &lt;stdio.h&gt; void ConvertNumberToBinary(int Number, int *Array) { for(int I = 0; I &lt; 32; ++I) { int ZeroOrOne = Number%2; if(ZeroOrOne &lt; 0) { ZeroOrOne = 1; } *(Array + I) = ZeroOrOne; Number = (Number &gt;&gt; 1); } } int main() { int Number = 5; int NumberInBinary[32] = {}; ConvertNumberToBinary(Number, NumberInBinary); return(0); } /// </code></pre> <p>A way to convert a number to binary is to use the mod operator, this thing -&gt; % will give you the remainder of a divide for whole numbers. For example (4%3) will give you a remainder of 1. (3 goes into 4 one time, there is a remainder of 1 since 1 can't be divided by 3)</p> <p>What's really useful about mod in solving this problem is it can effectively tell you the least-significant bit of any number in binary. The least significant bit representing 2^0 or 1 when turned on.</p> <p>In order to do this all you have to do is divide any number by 2 and the remainder of that divide will either give you ZeroOrOne which maps directly to the least significant bit of any binary number.</p> <pre><code>I.e 000011001 ^ Any number Mod by 2 (Number%2) will tell you the value for this bit </code></pre> <p>So in the code that's exactly what happens, we pass in a Number to the &quot;ConvertNumberToBinary&quot; function and once we start looping through our array of numbers, we take the Number we passed in, we Mod it by 2, and store that remainder in the ZeroOrOne variable, the we write to the array using that variable.</p> <p>A second thing we do is we take the number and shift it down by one to remove the least-significant bit so we can see the data for the next bit.</p> <pre><code>Here's the steps viewing the number 5 in binary 0101 ^ This Number%2 will be 1, we store that in the array, then we shift 0010 --- 1 &lt; This 1 has been shifted out ^ We now mod this by 2 and check its value, it is zero, we store zero into the array then shift 0001 --- 0 &lt; This 0 has been shifted out ^ We mod by two again and get 1, we store that in the array, then we shift. 0000 --- 1 &lt; This 1 has been shifted out --- Repeat until it's been done 32 times --- Reach the end of the loop then break out of the function and the array will have the result in binary (it will be in little endian though - least significant bit will be the first array element) </code></pre> <p>And that's everything so far, two things to mention though, the function only works for arrays greater than 32 elements, otherwise it will break.</p> <p>And the other thing is this code</p> <pre><code>if(ZeroOrOne &lt; 0) { ZeroOrOne = 1; } </code></pre> <p>If you pass in a negative number and mod it by two there will be a remainder, but the remainder will be -1 which isn't a binary value, so I just set ZeroOrOne to 1 if it was negative</p>

270278

<h3>The feature</h3> <p>Here is a Grid class representing a 2d grid.<br /> The class will get templated once it reach a satisfactory state.<br /> At this time the cells are <code>int</code> values.</p> <p>This Grid class allow for iteration by rows using simple range-for syntax.</p> <pre><code> Grid grid(8, 8); for (auto&amp;&amp; row_it : grid.Rows()) { for (auto&amp;&amp; cell : row_it) std::cout &lt;&lt; std::setw(2) &lt;&lt; std::setfill('0') &lt;&lt; cell &lt;&lt; ','; std::cout &lt;&lt; '\n'; } </code></pre> <h3>The retrospective</h3> <p>It works well, but it is my first time creating custom iterators and I do not think that its is nicely done.</p> <p>More in particular:</p> <ul> <li>Are the classes <code>GridRows</code>, <code>RowsIterator</code> and <code>RowIterator</code> really needed?</li> <li>The range-for will automatically call <code>operator*</code> on the type returned from begin(), which seems to force the existence of <code>RowIterator</code> instead of returning directly an int* from <code>RowsIterator::begin</code></li> <li>How best to minimize and simplify?</li> </ul> <h3>Standard library compatibility</h3> <p>According to this article, custom iterators should include the following properties: <a href="https://www.internalpointers.com/post/writing-custom-iterators-modern-cpp" rel="nofollow noreferrer">https://www.internalpointers.com/post/writing-custom-iterators-modern-cpp</a></p> <ul> <li>iterator_category</li> <li>difference_type</li> <li>value_type</li> <li>pointer</li> <li>reference</li> </ul> <h3>The complete code</h3> <pre><code>#include &lt;iostream&gt; #include &lt;iomanip&gt; struct RowIterator { int* _it, * _end; RowIterator(int* begin, int* end) : _it{ begin }, _end{ end } {} int&amp; operator*() { return *_it; } int* operator-&gt;() { return _it; } RowIterator&amp; operator++() { ++_it; return *this; } RowIterator operator++(int) { auto self = *this; ++* this; return *this; } friend bool operator==(RowIterator lhs, RowIterator rhs) { return lhs._it == rhs._it; } friend bool operator!=(RowIterator lhs, RowIterator rhs) { return lhs._it != rhs._it; } int* begin() { return _it; } int* end() { return _end; } }; struct RowsIterator { int* _it, * _end; int _row_length; RowIterator _row_begin, _row_end; RowsIterator(int* begin, int row_length) : _it{ begin }, _end{ begin + row_length }, _row_length{ row_length }, _row_begin{ _it, _end }, _row_end{ _end, _end } {} RowIterator&amp; operator*() { return _row_begin; } RowIterator* operator-&gt;() { return &amp;_row_begin; } RowsIterator&amp; operator++() { _it += _row_length; _end += _row_length; _row_begin = { _it, _end }; _row_end = { _end, _end }; return *this; } RowsIterator operator++(int) { auto self = *this; ++* this; return *this; } friend bool operator==(RowsIterator lhs, RowsIterator rhs) { return lhs._it == rhs._it; } friend bool operator!=(RowsIterator lhs, RowsIterator rhs) { return lhs._it != rhs._it; } RowIterator begin() const { return _row_begin; } RowIterator end() const { return _row_end; } }; struct GridRows { RowsIterator _begin, _end; GridRows(int* begin, int* end, int row_length) : _begin{ begin, row_length }, _end{ end, row_length } {} RowsIterator begin() { return _begin; } RowsIterator end() { return _end; } }; struct Grid { Grid(int width, int height) : _width{ width }, _height{ height } { size_t size = width * height; _begin = new int[size]; _end = _begin + size; InitializeValues(); } ~Grid() { if (_begin) { delete[] _begin; _begin = nullptr; _end = nullptr; } } void InitializeValues() { for (int i = 0; auto &amp;&amp; it : *this) it = ++i; } int* begin() const { return _begin; } int* end() const { return _end; } GridRows Rows() const { return GridRows{ _begin, _end, _width }; } int* _begin, * _end; int _width, _height; }; void IterateWithFor(const Grid&amp; grid) { std::cout &lt;&lt; &quot;Iterate though all rows cells\n&quot;; auto&amp;&amp; rows = grid.Rows(); for (auto&amp;&amp; row_it = rows.begin(); row_it != rows.end(); ++row_it) { for (auto&amp;&amp; cell = row_it.begin(); cell != row_it.end(); ++cell) { std::cout &lt;&lt; std::setw(2) &lt;&lt; std::setfill('0') &lt;&lt; *cell &lt;&lt; ','; } std::cout &lt;&lt; '\n'; } std::cout &lt;&lt; '\n'; } void IterateWithRangeFor(const Grid&amp; grid) { std::cout &lt;&lt; &quot;Iterate though all rows cells\n&quot;; for (auto&amp;&amp; row_it : grid.Rows()) { for (auto&amp;&amp; cell : row_it) std::cout &lt;&lt; std::setw(2) &lt;&lt; std::setfill('0') &lt;&lt; cell &lt;&lt; ','; std::cout &lt;&lt; '\n'; } std::cout &lt;&lt; '\n'; } int main() { Grid grid(8, 8); IterateWithFor(grid); IterateWithRangeFor(grid); return 0; } </code></pre> <h3>Thank you</h3> <p>Thank you very much for your time and valuable feedback.</p>

270281

<p>At the moment, it is simply massive. I already reduced the size by about a hundred lines but it still seems way too big... Would appreciate some help :)</p> <pre><code>using System; class Program { static int turns = 1; static int player = 2; static char[] board = { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' }; static char playerSignature = 'X'; private static void Introduction() { Console.WriteLine(&quot;This is a simple TicTacToe game. Enter y if you have played before and n if you are new to this.&quot;); string input1 = &quot; &quot;; while (input1 != &quot;y&quot; || input1 != &quot;n&quot;) { input1 = Console.ReadLine(); switch (input1) { case &quot;y&quot;: Console.WriteLine(&quot;Alright, let's get started, you are X, your friend is O.&quot;); DrawBoard(board); break; case &quot;n&quot;: Console.WriteLine(&quot;TicTacToeRules:&quot;); Console.WriteLine(&quot;1. The game is played on a grid that's 3 squares by 3 squares.&quot;); Console.WriteLine(&quot;2. You are X, your friend is O. Players take turns putting their marks in empty squares.&quot;); Console.WriteLine(&quot;3. The first player to get 3 of her marks in a row (up, down, across, or diagonally) is the winner.&quot;); Console.WriteLine(&quot;4. When all 9 squares are full, the game is over.&quot;); Console.WriteLine(&quot;If you have read the rules, press any key to continue.&quot;); Console.ReadKey(); Console.Clear(); DrawBoard(board); break; default: Console.WriteLine(&quot;Please enter y/n.&quot;); break; } } } private static void DrawBoard(char[] board) { string row = &quot;| {0} | {1} | {2} |&quot;; string sep = &quot;|___|___|___|&quot;; Console.WriteLine(&quot; ___ ___ ___ &quot;); Console.WriteLine(row, board[0], board[1], board[2]); Console.WriteLine(sep); Console.WriteLine(row, board[3], board[4], board[5]); Console.WriteLine(sep); Console.WriteLine(row, board[6], board[7], board[8]); Console.WriteLine(sep); } private static void Reset() { char[] reset = { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' }; board = reset; DrawBoard(board); } private static void Draw() { Console.WriteLine(&quot;It's a draw!\n&quot; + &quot;Press any key to play again.&quot;); Console.ReadKey(); Reset(); } public static void Main() { Introduction(); while (true) { bool isrow = false; bool iscol = false; int row = 0; int col = 0; while (!isrow) { Console.WriteLine(&quot;Choose a row (1-3): &quot;); try { row = Convert.ToInt32(Console.ReadLine()); } catch { Console.WriteLine(&quot;Please enter a number between 1 and 3.&quot;); } if (row == 1 || row == 2 || row == 3) { isrow = true; } else { Console.WriteLine(&quot;\nInvalid row!&quot;); } } while (!iscol) { Console.WriteLine(&quot;Choose a column (1-3): &quot;); try { col = Convert.ToInt32(Console.ReadLine()); } catch { Console.WriteLine(&quot;Please enter a number between 1 and 3.&quot;); } if (col == 1 || col == 2 || col == 3) { iscol = true; } else { Console.WriteLine(&quot;\nInvalid column!&quot;); } } int[] input = { row, col }; if (player == 2) { player = 1; XorO(player, input); } else { player = 2; XorO(player, input); } DrawBoard(board); Win(); turns++; if (turns == 10 &amp;&amp; (board[0] == playerSignature &amp;&amp; board[1] == playerSignature &amp;&amp; board[2] == playerSignature &amp;&amp; board[3] == playerSignature &amp;&amp; board[4] == playerSignature &amp;&amp; board[5] == playerSignature &amp;&amp; board[6] == playerSignature &amp;&amp; board[7] == playerSignature &amp;&amp; board[8] == playerSignature)) { Draw(); } } } private static void XorO(int player, int[] input) { playerSignature = (player == 1) ? 'X' : 'O';//if player ==1 dann ps = 'X', else 'O' int index = ((input[0] - 1) * 3) + (input[1] - 1);//3 - 1 = 2 , 2*3 = 6 + 2 = 8 für 3 3 | compact layout if (board[index] == ' ') { board[index] = playerSignature; } else { Console.WriteLine(&quot;That spot is already taken! Try again!&quot;); } } private static void Win() { if ((board[6] == playerSignature &amp;&amp; board[4] == playerSignature &amp;&amp; board[2] == playerSignature || board[0] == playerSignature &amp;&amp; board[4] == playerSignature &amp;&amp; board[8] == playerSignature) || (board[0] == playerSignature &amp;&amp; board[1] == playerSignature &amp;&amp; board[2] == playerSignature || board[3] == playerSignature &amp;&amp; board[4] == playerSignature &amp;&amp; board[5] == playerSignature || board[6] == playerSignature &amp;&amp; board[7] == playerSignature &amp;&amp; board[8] == playerSignature) || (board[0] == playerSignature &amp;&amp; board[3] == playerSignature &amp;&amp; board[6] == playerSignature || board[1] == playerSignature &amp;&amp; board[4] == playerSignature &amp;&amp; board[7] == playerSignature || board[2] == playerSignature &amp;&amp; board[5] == playerSignature &amp;&amp; board[8] == playerSignature)) { if (player == 1) { Console.WriteLine(&quot;Congratulations Player 1, you win!\n&quot;); Console.WriteLine(&quot;Play again? y/n.&quot;); Playagain(); } else if (player == 2) { Console.WriteLine(&quot;Congratulations Player 2, you win!\n&quot;); Console.WriteLine(&quot;Play again y/n?&quot;); Playagain(); } } } private static void Playagain() { string input2 = &quot; &quot;; input2 = Console.ReadLine(); if (input2 == &quot;y&quot;) { Reset(); Console.Clear(); } else if (input2 == &quot;n&quot;) { Console.Clear(); Console.WriteLine(&quot;Close the window to exit the game.&quot;); Console.ReadKey(); } else { Console.WriteLine(&quot;Please enter y/n.&quot;); } } } </code></pre>

270285

<p>I need to handle different states of a complex GUI control (such as NORMAL, DRAGGING, MARKING, ...). I came upon this idea:</p> <pre><code>void dispatch(auto const i, auto&amp;&amp; ...f) noexcept(noexcept((f(), ...))) { std::underlying_type&lt;std::remove_const_t&lt;decltype(i)&gt;&gt; j{}; ((j++ == i ? (f(), 0) : 0), ...); } </code></pre> <p>There would be an enum like this:</p> <pre><code>enum State { NORMAL, DRAGGING, MARKING }; </code></pre> <p>and I would use <code>dispatch()</code> in event handlers like so:</p> <pre><code>dispatch( state_, []{}, []{} ); </code></pre> <p>What do you think?</p> <p>EDIT: This might help to prevent nested <code>switch</code>es, which I find very hard to track.</p>

270289

<p>This is a simple Python 3 program that verifies whether a string is a valid IPv6 address or not, parses IPv6 address to its hexadecimal and decimal values, and converts an integer to IPv6 format.</p> <p>I am writing a webscraper, and to reduce network IO bound time complexity I need to programmatically lookup DNS records of target addresses and change hosts file accordingly due to DNS poisoning by GFW.</p> <p>I use this API: 'https://www.robtex.com/dns-lookup/{website}' to get the addresses using XPaths, and the scraped results contains both IPv4 and IPv6 addresses, I would like to differentiate between IPv4 and IPv6 addresses and validate them separately.</p> <p>For IPv4 addresses I have written this simple regex:</p> <pre><code>'^((25[0-5]|2[0-4]\d|1?[1-9]\d?|0)\.){3}(25[0-5]|2[0-4]\d|1?[1-9]\d?|0)$' </code></pre> <p>It does the validation in one step, but IPv6 is another thing, and after trying and failing to solve this using regex many times I gave up, I have searched for a regex to validate IPv6 and after I realized the regexes that work perfectly are way to long I changed my approach.</p> <p>An IPv6 address is an integer between 0 and 2 ^ 128 (340282366920938463463374607431768211456) represented as 32 hexadecimal digits, formatted as 8 fields of 4 hex digits separated by 7 colons.</p> <p>If not for the shortening rules IPv6 addresses can easily be validated by regexes.</p> <p>There are two shortening rules that are used together, the first rule trims leading zeros in each field.</p> <p>Now with only the first rule applied IPv6 can still be verified using this regex:</p> <pre><code>'^([\da-fA-F]{1,4}\:){7}([\da-fA-F]{1,4})$' </code></pre> <p>But there is the second rule, that omits continuous zero fields for once and uses <code>'::'</code> in its place, for example,</p> <pre><code>0:0:0:0:0:0:0:0 -&gt; :: 0:0:0:0:0:0:0:1 –&gt; ::1 fe80:0:0:0:0:0:0:1 –&gt; fe80::1 fe80:0:0:0:0:1:0:1 -&gt; fe80::1:0:1 </code></pre> <p>Because of the second rule, each of the eight places where the omitted fields can be requires at least one regex, so that is at least 8 regexes in total...</p> <p>So I have written my own code, and here it is:</p> <pre class="lang-py prettyprint-override"><code>import re from ipaddress import ip_address, IPv6Address from typing import Iterable COLONS = {':', '::'} DIGITS = frozenset('0123456789ABCDEFabcdef') MAX_IPV6 = 2**128 - 1 ALL_ZEROS = '0:'*7 + '0' LEADING = re.compile('^(0:)+') TRAILING = re.compile('(:0)+$') MIDDLE = re.compile('(:0)+') def is_ipv6(ip: str) -&gt; bool: if not isinstance(ip, str): raise TypeError('Argument must be an instance of str') if not ip or len(ip) &gt; 39: return False first = True digits = 0 colons = 0 fields = 0 compressed = False for i in ip: if i == ':': digits = 0 first = False colons += 1 if colons == 2: if not compressed: compressed = True else: return False elif colons &gt; 2: return False else: if i not in DIGITS: return False digits += 1 if digits &gt; 4: return False if colons or first: first = False colons = 0 fields += 1 if fields &gt; 8 - compressed: return False if (fields == 8 and colons != 1) or compressed: return True return False def split_ipv6(ip: str) -&gt; Iterable[str]: if not isinstance(ip, str): raise TypeError('Argument must be an instance of str') buffer = '' chunks = [] digits = 0 colons = 0 fields = 0 compressed = False for i in ip: tail = True if i == ':': if digits: chunks.append(buffer) digits = 0 colons += 1 if colons == 2: if not compressed: compressed = True tail = False else: return False if colons &gt; 2: return False else: if i not in DIGITS: return False digits += 1 if digits &gt; 4: return False if colons or not buffer: if colons: chunks.append(':' * colons) colons = 0 fields += 1 buffer = i if fields &gt; 8 - compressed: return False else: buffer += i if tail: chunks.append(buffer) else: chunks.append('::') if (fields == 8 and colons != 1) or compressed: return chunks return False def parse_ipv6(ip: str) -&gt; dict: segments = split_ipv6(ip) if not segments: raise ValueError('Argument is not a valid IPv6 address') compressed = False empty_fields = None if '::' in segments: fields = ['0'] * 8 compressed = True cut = segments.index('::') left = [i for i in segments[:cut] if i not in COLONS] right = [i for i in segments[cut+1:] if i not in COLONS] fields[8-len(right):] = right fields[:len(left)] = left empty_fields = [i for i, f in enumerate(fields) if f == '0'] else: fields = [c for c in segments if c not in COLONS] digits = [int(f, 16) for f in fields] # decimal = sum(d * 65536 ** i for i, d in enumerate(digits[::-1])) hexadecimal = '0x' + ''.join(i.zfill(4) for i in fields) decimal = int(hexadecimal, 16) parsed = { 'segments': segments, 'fields': fields, 'digits': digits, 'hexadecimal': hexadecimal, 'decimal': decimal, 'compressed': compressed, 'empty fields': empty_fields } return parsed def trim_left(s: str) -&gt; str: return s[:-1].lstrip('0') + s[-1] def to_ipv6(n: int, compress=True) -&gt; str: if not isinstance(n, int): raise TypeError('Argument should be an instance of int') if not 0 &lt;= n &lt;= MAX_IPV6: raise ValueError('Argument is not in the valid range that IPv6 can represent') hexa = hex(n).removeprefix('0x').zfill(32) ipv6 = ':'.join(hexa[i:i+4] for i in range(0, 32, 4)) if compress: ipv6 = ':'.join(trim_left(i) for i in ipv6.split(':')) if ipv6 == ALL_ZEROS: return '::' elif LEADING.match(ipv6): return LEADING.sub('::', ipv6) elif TRAILING.search(ipv6): return TRAILING.sub('::', ipv6) ipv6 = MIDDLE.sub(':', ipv6, 1) return ipv6 if __name__ == '__main__': test_cases = [ (42540766411282592856904265327123268393, '2001:db8::ff00:42:8329'), (42540766411282592875278671431329809193, '2001:db8::ff00:0:42:8329'), (0, '::'), (1, '::1'), (5192296858534827628530496329220096, '1::'), (338288524927261089654018896841347694593, 'fe80::1'), (160289081533862935099527363545323831451, '7896:8ddf:4b26:f07f:a4cd:65de:ee90:809b'), (264029623924138153874706093713361856950, 'c6a2:4182:24b2:20f3:2d00:d2bb:3619:e9b6'), (155302777326544552126794348175886719955, '74d6:3a18:151d:948f:d13e:4d87:4fed:1bd3'), (152846031713612901234538066636429037612, '72fd:132e:fe1d:d05c:27d0:6001:a05f:902c'), (21824427460045008308753734783456952407, '106b:3b59:a20b:25dc:61b9:698e:d1e:c057'), (267115622348742355941753354636068900005, 'c8f4:98fa:50b3:e935:2bc9:25b0:593b:cca5'), (16777215, '::ff:ffff'), (3232235777, '::c0a8:101'), (4294967295, '::ffff:ffff'), (2155905152, '::8080:8080'), (18446744073709551615, '::ffff:ffff:ffff:ffff'), (18446744073709551616, '::1:0:0:0:0') ] for number, ip in test_cases: assert to_ipv6(number) == ip assert parse_ipv6(ip)['decimal'] == number </code></pre> <p>As you can see, the first function validates input and splits the input into chunks, in the same loop, I could have used a regex to split the input but that isn't much faster than the manual approach and I figure if I use regex I need at least another for loop to validate the result, in this approach I can save the cost of one loop and do early returns if the input is invalid.</p> <p>And about the two other functions after I have written the first I just couldn't help myself.</p> <p>All functions are working properly and there's exactly 0 chance that there are bugs introduced by me, everything returns what I assume to be correct, that is, addresses like <code>'1::'</code> are treated by the functions to be valid, I don't know if such syntax exists but I assume it does.</p> <p>How can my code be improved?</p> <hr /> <h2>Update</h2> <p>I have written a new function that does only the validation and therefore is much faster.</p> <p>And why did I write these functions in the first place? Why I don't just use <code>ipaddress</code> library?</p> <p>Well, I am reinventing the wheel and I have good reasons to do it.</p> <p>The library code is not perfect, for one thing, I need to validate IPv6 addresses, and yes this means the strings might be invalid, and if the string is not a valid IP address, <code>ipaddress.ip_address</code> raises <code>ValueError</code> so I have to use try catch clauses...</p> <pre><code>In [690]: ipaddress.ip_address('100') --------------------------------------------------------------------------- ValueError Traceback (most recent call last) &lt;ipython-input-690-10b17acc39c6&gt; in &lt;module&gt; ----&gt; 1 ipaddress.ip_address('100') C:\Program Files\Python39\lib\ipaddress.py in ip_address(address) 51 pass 52 ---&gt; 53 raise ValueError('%r does not appear to be an IPv4 or IPv6 address' % 54 address) 55 ValueError: '100' does not appear to be an IPv4 or IPv6 address </code></pre> <p>And it validates both IPv4 and IPv6 addresses so I have to use <code>isinstance</code> checks...</p> <p>My custom function only validates IPv6 addresses and doesn't raise exceptions, so there is not any extra step needed.</p> <p>Secondly it is much slower than my functions:</p> <pre><code>Python 3.9.7 (tags/v3.9.7:1016ef3, Aug 30 2021, 20:19:38) [MSC v.1929 64 bit (AMD64)] Type 'copyright', 'credits' or 'license' for more information IPython 7.28.0 -- An enhanced Interactive Python. Type '?' for help. In [1]: ...: if compress: ...: ipv6 = ':'.join(trim_left(i) for i in ipv6.split(':')) ...: if ipv6 == ALL_ZEROS: ...: return '::' ...: ...: elif LEADING.match(ipv6): ...: return LEADING.sub('::', ipv6) ...: ...: elif TRAILING.search(ipv6): ...: return TRAILING.sub('::', ipv6) ...: ...: ipv6 = MIDDLE.sub(':', ipv6, 1) ...: ...: return ipv6 ...: ...: ...: def ipaddress_test(s): ...: try: ...: return isinstance(ip_address(s), IPv6Address) ...: except ValueError: ...: return False ...: ...: if __name__ == '__main__': ...: test_cases = [ ...: (42540766411282592856904265327123268393, '2001:db8::ff00:42:8329'), ...: (42540766411282592875278671431329809193, '2001:db8::ff00:0:42:8329'), ...: (0, '::'), ...: (1, '::1'), ...: (5192296858534827628530496329220096, '1::'), ...: (338288524927261089654018896841347694593, 'fe80::1'), ...: (160289081533862935099527363545323831451, '7896:8ddf:4b26:f07f:a4cd:65de:ee90:809b'), ...: (264029623924138153874706093713361856950, 'c6a2:4182:24b2:20f3:2d00:d2bb:3619:e9b6'), ...: (155302777326544552126794348175886719955, '74d6:3a18:151d:948f:d13e:4d87:4fed:1bd3'), ...: (152846031713612901234538066636429037612, '72fd:132e:fe1d:d05c:27d0:6001:a05f:902c'), ...: (21824427460045008308753734783456952407, '106b:3b59:a20b:25dc:61b9:698e:d1e:c057'), ...: (267115622348742355941753354636068900005, 'c8f4:98fa:50b3:e935:2bc9:25b0:593b:cca5'), ...: (16777215, '::ff:ffff'), ...: (3232235777, '::c0a8:101'), ...: (4294967295, '::ffff:ffff'), ...: (2155905152, '::8080:8080'), ...: (18446744073709551615, '::ffff:ffff:ffff:ffff'), ...: (18446744073709551616, '::1:0:0:0:0') ...: ] ...: for number, ip in test_cases: ...: assert to_ipv6(number) == ip ...: assert parse_ipv6(ip)['decimal'] == number In [2]: ip_address('2001:0db8:0000:0000:ff00:0000:0042:8329') Out[2]: IPv6Address('2001:db8::ff00:0:42:8329') In [3]: type(ip_address('2001:0db8:0000:0000:ff00:0000:0042:8329')) == IPv6Address Out[3]: True In [4]: %timeit ipaddress_test('2001:0db8:0000:0000:ff00:0000:0042:8329') 12.2 µs ± 685 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [5]: %timeit is_ipv6('2001:0db8:0000:0000:ff00:0000:0042:8329') 6.01 µs ± 557 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [6]: %timeit ipaddress_test('2001:0db8:0000:0000:ff00:0000:0042:8329') 12.3 µs ± 657 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [7]: %timeit parse_ipv6('2001:0db8:0000:0000:ff00:0000:0042:8329') 15.2 µs ± 302 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [8]: %timeit parse_ipv6('2001:db8::ff00:0:42:8329') 14.6 µs ± 629 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [9]: %timeit is_ipv6('2001:db8::ff00:0:42:8329') 4.02 µs ± 561 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [10]: %timeit ipaddress_test('2001:db8::ff00:0:42:8329') 10.4 µs ± 204 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [11]: %%timeit ...: for number, ip in test_cases: ...: assert is_ipv6(ip) == True 62.5 µs ± 5.24 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each) In [12]: %%timeit ...: for number, ip in test_cases: ...: assert ipaddress_test(ip) == True 169 µs ± 4.58 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each) In [13]: is_ipv6('f:'*7) Out[13]: False In [14]: is_ipv6('f:'*8) Out[14]: False In [15]: is_ipv6('f:'*9) Out[15]: False In [16]: is_ipv6('f:'*7+':') Out[16]: True In [17]: is_ipv6('f:'*7+'f') Out[17]: True In [18]: %timeit is_ipv6('f:'*7) 2.57 µs ± 392 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [19]: %timeit is_ipv6('f:'*8) 2.9 µs ± 468 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [20]: %timeit is_ipv6('f:'*9) 3.06 µs ± 368 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [21]: %timeit is_ipv6('f:'*7+':') 2.76 µs ± 468 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [22]: ipaddress_test('f:'*7) Out[22]: False In [23]: ipaddress_test('f:'*8) Out[23]: False In [24]: ipaddress_test('f:'*9) Out[24]: False In [25]: ipaddress_test('f:'*7+'f') Out[25]: True In [26]: %timeit ipaddress_test('f:'*7) 5.88 µs ± 684 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [27]: %timeit ipaddress_test('f:'*8) 5.87 µs ± 753 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [28]: %timeit ipaddress_test('f:'*9) 5.14 µs ± 770 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [29]: %timeit ipaddress_test('f:'*7+'f') 11.1 µs ± 400 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [30]: ipaddress_test('f::') Out[30]: True In [31]: ipaddress_test('::f') Out[31]: True In [32]: ipaddress_test('f::f') Out[32]: True In [33]: ipaddress_test('f:::f') Out[33]: False In [34]: %timeit ipaddress_test('f::') 5.53 µs ± 639 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [35]: %timeit ipaddress_test('::f') 5.54 µs ± 552 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [36]: %timeit ipaddress_test('f:::f') 5.25 µs ± 581 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [37]: %timeit ipaddress_test('100') 4.52 µs ± 591 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [38]: is_ipv6('100') Out[38]: False In [39]: %timeit is_ipv6('100') 747 ns ± 34.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) In [40]: %timeit is_ipv6('f::') 741 ns ± 60.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) In [41]: %timeit is_ipv6('::f') 735 ns ± 43 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) In [42]: %timeit is_ipv6('f:::f') 864 ns ± 49.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) In [43]: %timeit is_ipv6('windows') 278 ns ± 38.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) In [44]: %timeit ipaddress_test('windows') 4.62 µs ± 749 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [45]: </code></pre> <p>As you can see the library code is nowhere near the speed of my functions and in particular my custom functions spots invalid inputs much much faster than the library code...</p> <p>Have I made myself clear?</p> <hr /> <p>Again, <code>IPv6Address</code> is not fast enough:</p> <pre><code>In [107]: from ipaddress import AddressValueError In [108]: IPv6Address('100') --------------------------------------------------------------------------- AddressValueError Traceback (most recent call last) &lt;ipython-input-108-46a502d0274c&gt; in &lt;module&gt; ----&gt; 1 IPv6Address('100') C:\Program Files\Python39\lib\ipaddress.py in __init__(self, address) 1916 addr_str, self._scope_id = self._split_scope_id(addr_str) 1917 -&gt; 1918 self._ip = self._ip_int_from_string(addr_str) 1919 1920 def __str__(self): C:\Program Files\Python39\lib\ipaddress.py in _ip_int_from_string(cls, ip_str) 1629 if len(parts) &lt; _min_parts: 1630 msg = &quot;At least %d parts expected in %r&quot; % (_min_parts, ip_str) -&gt; 1631 raise AddressValueError(msg) 1632 1633 # If the address has an IPv4-style suffix, convert it to hexadecimal. AddressValueError: At least 3 parts expected in '100' In [109]: def IPv6Address_test(s): ...: try: ...: IPv6Address(s) ...: return True ...: except AddressValueError: ...: return False In [110]: %timeit IPv6Address_test('100') 2.13 µs ± 33.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) In [111]: IPv6Address_test('100::') Out[111]: True In [112]: IPv6Address_test('255.255.255.255') Out[112]: False In [113]: valid_long = [ ...: '2001:0db8:0000:0000:ff00:0000:0042:8329', ...: '2001:db8::ff00:0:42:8329', ...: 'f:'*7+':', ...: 'f:'*7+'f', ...: '7896:8ddf:4b26:f07f:a4cd:65de:ee90:809b', ...: 'c6a2:4182:24b2:20f3:2d00:d2bb:3619:e9b6', ...: '74d6:3a18:151d:948f:d13e:4d87:4fed:1bd3', ...: '72fd:132e:fe1d:d05c:27d0:6001:a05f:902c', ...: '106b:3b59:a20b:25dc:61b9:698e:d1e:c057', ...: 'c8f4:98fa:50b3:e935:2bc9:25b0:593b:cca5', ...: '2001:db8::ff00:42:8329', ...: '2001:db8::ff00:0:42:8329' ...: ] In [114]: valid_short = [ ...: '::', ...: '::1', ...: '1::', ...: 'fe80::1', ...: '::ff:ffff', ...: '::c0a8:101', ...: '::ffff:ffff', ...: '::8080:8080', ...: '::ffff:ffff:ffff:ffff', ...: '::1:0:0:0:0', ...: 'f::', ...: '::f', ...: 'f::f' ...: ] In [115]: invalid = [ ...: '100', ...: 'windows', ...: 'intelligence', ...: 'this is not an IPv6 address', ...: 'esperanza', ...: 'hispana', ...: 'esperanta', ...: '255.255.255.255', ...: '192.168.1.1', ...: '127.0.0.1', ...: '151.101.129.69', ...: 'f:::f', ...: 'f:'*7, ...: 'f:'*8, ...: 'f:'*9 ...: ] In [116]: %timeit for i in valid_long: assert is_ipv6(i) == True 65 µs ± 7.37 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each) In [117]: %timeit for i in valid_long: assert IPv6Address_test(i) == True 122 µs ± 5.68 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each) In [118]: %timeit for i in valid_short: assert is_ipv6(i) == True 19.8 µs ± 485 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [119]: %timeit for i in valid_short: assert IPv6Address_test(i) == True 59.4 µs ± 6.72 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each) In [120]: %timeit for i in invalid: assert is_ipv6(i) == False 16.6 µs ± 650 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [121]: %timeit for i in invalid: assert IPv6Address_test(i) == False 38.3 µs ± 7.13 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each) In [122]: %timeit is_ipv6('::') 526 ns ± 25.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) In [123]: is_ipv6('::') Out[123]: True In [124]: %timeit is_ipv6('::1') 739 ns ± 41.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) In [125]: %timeit is_ipv6('1::') 741 ns ± 33.4 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) In [126]: %timeit is_ipv6('100') 761 ns ± 43.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) In [127]: %timeit IPv6Address_test('::') 2.65 µs ± 468 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [128]: %timeit IPv6Address_test('::1') 3.38 µs ± 687 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [129]: %timeit IPv6Address_test('1::') 3.4 µs ± 684 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) In [130]: %timeit IPv6Address_test('100') 2.13 µs ± 41.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) In [131]: %timeit IPv6Address_test('g') 2.11 µs ± 29 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) In [132]: %timeit is_ipv6('g') 289 ns ± 54.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) In [133]: <span class="math-container">```</span> </code></pre>

270290

<p>This macro calculates some basic figures from a given set of data. But it runs very slow probably due to me referencing the sheet again and again. Does anyone have a better idea on how to optimize this code:</p> <pre><code>Sub Handler_Fees() Dim strFile, tarFile As String Dim Source As Workbook Dim Target As ThisWorkbook Dim ws1 As Worksheet Dim ThisCell, ThatCell, WhichCell As Range Dim t As Single Application.ScreenUpdating = False Application.DisplayStatusBar = False Application.EnableEvents = False strFile = Application.GetOpenFilename(FileFilter:=&quot;Excel Files (*.xlsx*), *.xlsx*&quot;, Title:=&quot;Choose the export from the inducement engine&quot;) Workbooks.Open (strFile) t = Timer ActiveWorkbook.ActiveSheet.Range(&quot;R3&quot;) = &quot;Price per share&quot; Range(&quot;R4&quot;).Select ActiveCell.Value = &quot;=J4/F4&quot; Selection.AutoFill Destination:=Range(&quot;R4:R&quot; &amp; Range(&quot;E&quot; &amp; Rows.Count).End(xlUp).Row) Range(Selection, Selection.End(xlDown)).Select Set ws1 = ActiveSheet Set Source = ActiveWorkbook Set Target = ThisWorkbook ThisWorkbook.Activate Range(&quot;H2&quot;).Select ActiveCell.Formula2R1C1 = &quot;=INDEX('[&quot; &amp; Source.Name &amp; &quot;]&quot; &amp; ws1.Name &amp; &quot;'!R4C18:R38C18, MATCH(RC3&amp;RC1,'[&quot; &amp; Source.Name &amp; &quot;]&quot; &amp; ws1.Name &amp; &quot;'!R4C3:R38C3 &amp; '[&quot; &amp; Source.Name &amp; &quot;]&quot; &amp; ws1.Name &amp; &quot;'!R4C5:R38C5,0))&quot; Selection.AutoFill Destination:=Range(&quot;H2:H&quot; &amp; Range(&quot;E&quot; &amp; Rows.Count).End(xlUp).Row) Range(Selection, Selection.End(xlDown)).Select Target.ActiveSheet.Range(&quot;G1&quot;) = &quot;Corrected Quantity&quot; Range(&quot;G2&quot;).Select ActiveCell.Formula = &quot;=D2/(10^E2)&quot; Selection.AutoFill Destination:=Range(&quot;G2:G&quot; &amp; Range(&quot;E&quot; &amp; Rows.Count).End(xlUp).Row) Range(Selection, Selection.End(xlDown)).Select Target.ActiveSheet.Range(&quot;H1&quot;) = &quot;Price per share&quot; Target.ActiveSheet.Range(&quot;I1&quot;) = &quot;Assessment&quot; Range(&quot;I2&quot;).Select ActiveCell.Formula = &quot;=G2*H2&quot; Selection.AutoFill Destination:=Range(&quot;I2:I&quot; &amp; Range(&quot;E&quot; &amp; Rows.Count).End(xlUp).Row) Range(Selection, Selection.End(xlDown)).Select Target.ActiveSheet.Range(&quot;J1&quot;) = &quot;Portfolio commission percentage&quot; Range(&quot;J2&quot;).Select ActiveCell.Formula2R1C1 = &quot;=VLOOKUP(RC3,'[&quot; &amp; Source.Name &amp; &quot;]&quot; &amp; ws1.Name &amp; &quot;'!R4C3:R38C11,9,0)&quot; Selection.AutoFill Destination:=Range(&quot;J2:J&quot; &amp; Range(&quot;E&quot; &amp; Rows.Count).End(xlUp).Row) Range(Selection, Selection.End(xlDown)).Select Target.ActiveSheet.Range(&quot;K1&quot;) = &quot;Trailer Fees&quot; Range(&quot;K2&quot;).Select ActiveCell.Value = &quot;=((I2/100)*J2)/365&quot; Selection.AutoFill Destination:=Range(&quot;K2:K&quot; &amp; Range(&quot;E&quot; &amp; Rows.Count).End(xlUp).Row) Range(Selection, Selection.End(xlDown)).Select Range(&quot;J2&quot;).Select Selection.AutoFill Destination:=Range(&quot;J2:J&quot; &amp; Range(&quot;E&quot; &amp; Rows.Count).End(xlUp).Row) Range(Selection, Selection.End(xlDown)).Select Selection.Copy Selection.PasteSpecial Paste:=xlPasteValues, Operation:=xlNone, SkipBlanks:=False, Transpose:=False 'Selection.Value = Format(ActiveCell, &quot;0.00&quot;) Range(&quot;K2&quot;).Select Selection.AutoFill Destination:=Range(&quot;K2:K&quot; &amp; Range(&quot;E&quot; &amp; Rows.Count).End(xlUp).Row) Range(Selection, Selection.End(xlDown)).Select Selection.Copy Selection.PasteSpecial Paste:=xlPasteValues, Operation:=xlNone, SkipBlanks:=False, Transpose:=False 'Selection.Value = Format(ActiveCell, &quot;0.00&quot;) For Each ThisCell In Range(&quot;K2:K&quot; &amp; Range(&quot;E&quot; &amp; Rows.Count).End(xlUp).Row) Range(Selection, Selection.End(xlDown)).Select ThisCell.Value = Application.Round(ThisCell.Value, 2) Next ThisCell Range(&quot;H2&quot;).Select Selection.AutoFill Destination:=Range(&quot;H2:H&quot; &amp; Range(&quot;E&quot; &amp; Rows.Count).End(xlUp).Row) Range(Selection, Selection.End(xlDown)).Select Selection.Copy Selection.PasteSpecial Paste:=xlPasteValues, Operation:=xlNone, SkipBlanks:=False, Transpose:=False For Each ThatCell In Range(&quot;H2:H&quot; &amp; Range(&quot;E&quot; &amp; Rows.Count).End(xlUp).Row) Range(Selection, Selection.End(xlDown)).Select ThatCell.Value = Application.Round(ThatCell.Value, 2) Next ThatCell For Each WhichCell In Range(&quot;I2:I&quot; &amp; Range(&quot;E&quot; &amp; Rows.Count).End(xlUp).Row) Range(Selection, Selection.End(xlDown)).Select WhichCell.Value = Application.Round(WhichCell.Value, 2) Next WhichCell Range(&quot;A1&quot;).Select Application.ScreenUpdating = True Application.DisplayStatusBar = True Application.EnableEvents = True MsgBox Timer - t End Sub </code></pre>

270291

<p>I'm using TypeScript for my Vue app and have a custom type I'm working with</p> <pre><code>type MyCustomType = { fooProperty: string, barProperty: string /* ... other fields ... */ }; </code></pre> <p>This type holds a bunch of properties acting as a &quot;composite key&quot;. So the combination of all properties must be unique.</p> <hr /> <p><strong>First approach:</strong></p> <p>The first idea coming to my mind is to simply use a <code>Set&lt;T&gt;</code></p> <pre><code>const set: Set&lt;MyCustomType&gt; = new Set&lt;MyCustomType&gt;(); set.add({ fooProperty: &quot;a&quot;, barProperty: &quot;b&quot; }); console.log(set.has({ fooProperty: &quot;a&quot;, barProperty: &quot;b&quot; })); // expected: true, actual: false </code></pre> <p>The problem is that this set is not able to compare the objects. So <code>{ fooProperty: &quot;a&quot;, barProperty: &quot;b&quot; } === { fooProperty: &quot;a&quot;, barProperty: &quot;b&quot; } // false</code> ( based on <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#same-value-zero_equality" rel="nofollow noreferrer">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#same-value-zero_equality</a> )</p> <hr /> <p><strong>Second approach:</strong></p> <p>An internal <code>Map&lt;string, T&gt;</code> holding <code>T</code> as a stringified key might be a good idea</p> <pre><code>class TrulyUniqueSet&lt;ElementType&gt; { private readonly elements: Map&lt;string, ElementType&gt; = new Map&lt;string, ElementType&gt;(); private elementToKey(element: ElementType): string { return JSON.stringify(element); } public get size(): number { return this.elements.size; } public add(element: ElementType): TrulyUniqueSet&lt;ElementType&gt; { const elementKey: string = this.elementToKey(element); this.elements.set(elementKey, element); return this; } public clear(): void { this.elements.clear(); } public delete(element: ElementType): boolean { const elementKey: string = this.elementToKey(element); return this.elements.delete(elementKey); } public has(element: ElementType): boolean { const elementKey: string = this.elementToKey(element); return this.elements.has(elementKey); } public values(): IterableIterator&lt;ElementType&gt; { return this.elements.values(); } public forEach(callbackfn: (element: ElementType) =&gt; void): void { return this.elements.forEach((element: ElementType) =&gt; callbackfn(element)); } } </code></pre> <p>but things might get buggy if the structure of an object changes</p> <pre><code>const set: TrulyUniqueSet&lt;MyCustomType&gt; = new TrulyUniqueSet&lt;MyCustomType&gt;(); set.add({ fooProperty: &quot;a&quot;, barProperty: &quot;b&quot; }); console.log(set.has({ fooProperty: &quot;a&quot;, barProperty: &quot;b&quot; })); // expected: true, actual: true console.log(set.has({ barProperty: &quot;b&quot;, fooProperty: &quot;a&quot; })); // expected: true, actual: false </code></pre> <p>obviously because of different JSON strings.</p> <hr /> <p><strong>Third approach:</strong></p> <p>I tried to extend the <code>Set</code> by overriding the equality check</p> <pre><code>class MyCustomTypeCollection extends Set&lt;MyCustomType&gt; { private customTypesAreEqual(firstValue: MyCustomType, secondValue: MyCustomType): boolean { return firstValue.fooProperty === secondValue.fooProperty &amp;&amp; firstValue.barProperty=== secondValue.barProperty; /* add other equality checks here */ } public add(value: MyCustomType): this { if (!this.has(value)) { super.add(value); } return this; } public has(value: MyCustomType): boolean { // truly check for duplicates return Array .from(this) .some((currentValue: MyCustomType) =&gt; this.customTypesAreEqual(currentValue, value)); } public delete(value: MyCustomType): boolean { const filteredValues: MyCustomType[] = Array .from(this) .filter((currentValue: MyCustomType) =&gt; !this.customTypesAreEqual(currentValue, value)); // remove the value from the collection if(filteredValues.length &lt; this.size) { // &quot;rebuild&quot; the collection this.clear(); filteredValues.forEach(this.add); return true; } return false; } } </code></pre> <p>The usage works as expected</p> <pre><code>const set: MyCustomTypeCollection = new MyCustomTypeCollection(); set.add({ fooProperty: &quot;a&quot;, barProperty: &quot;b&quot; }); console.log(set.has({ fooProperty: &quot;a&quot;, barProperty: &quot;b&quot; })); // expected: true, actual: true console.log(set.has({ barProperty: &quot;b&quot;, fooProperty: &quot;a&quot; })); // expected: true, actual: true set.delete({ fooProperty: &quot;a&quot;, barProperty: &quot;b&quot; }); console.log(set.has({ fooProperty: &quot;a&quot;, barProperty: &quot;b&quot; })); // expected: false, actual: false console.log(set.has({ barProperty: &quot;b&quot;, fooProperty: &quot;a&quot; })); // expected: false, actual: false </code></pre> <p><strong>but</strong> the implementation looks very slow in terms of performance.</p> <hr /> <p>I think I will go with the third approach but do you have any suggestions, better ideas or code improvements?</p> <p>Thanks in advance!</p>

270293

<p>I made a custom Binance API wrapper (<code>BinanceRestClient</code>) which uses <code>IHttpClientFactory</code> in order to prevent socket exhaustion, while also ensuring that DNS changes are respected.</p> <p>I looked at the implementation of a deprecated API wrapper (<a href="https://github.com/glitch100/BinanceDotNet/blob/master/BinanceExchange.API/Client/BinanceClient.cs#L354" rel="nofollow noreferrer">this one</a>) and I realized how clean they did it. For ex. my <code>GetBalances()</code> method is around 20 lines of code, compared to theirs (1 line of code). <a href="https://codereview.stackexchange.com/questions/124155/custom-httpclient-wrapper">This one</a> could be added as a reference too.</p> <p>I then tried to do the same by creating the <code>BinanceApiProcessor</code> class. It works. However, I think my implementation of <code>InvokeAsync&lt;T&gt;</code> is not clean. This is how we call the class:</p> <pre class="lang-cs prettyprint-override"><code>public Task&lt;AccountTradeResponse?&gt; GetMyTrades(CancellationToken ct = default) { using var apiProcessor = new BinanceApiProcessor(_httpClientFactory); const string symbol = &quot;DOGEUSDT&quot;; return apiProcessor.InvokeAsync&lt;AccountTradeResponse&gt;(HttpMethod.Get, EndpointSecurityType.UserData, &quot;/api/v3/myTrades&quot;, $&quot;symbol={symbol}&amp;recvWindow=5000&quot;, ct); } </code></pre> <p>I would like to get code review, because I know things could be made in a cleaner way.</p> <h2>API Processor class</h2> <pre class="lang-cs prettyprint-override"><code>internal class BinanceApiProcessor : IDisposable { private const string BaseAddress = &quot;https://api.binance.com&quot;; private const string ApiKey = &quot;xxx&quot;; private const string SecretKey = &quot;xxx&quot;; private readonly IHttpClientFactory _httpClientFactory; /// &lt;summary&gt; /// Whether this instance is disposed. /// &lt;/summary&gt; private bool _isDisposed; /// &lt;summary&gt; /// Initializes a new instance of the &lt;see cref=&quot;BinanceApiProcessor&quot; /&gt; class. /// &lt;/summary&gt; /// &lt;param name=&quot;httpClientFactory&quot;&gt;&lt;/param&gt; public BinanceApiProcessor(IHttpClientFactory httpClientFactory) { _httpClientFactory = httpClientFactory; } /// &lt;summary&gt; /// The HTTP client. /// &lt;/summary&gt; private HttpClient HttpClient { get { var client = _httpClientFactory.CreateClient(); Guard.Against.NullOrWhiteSpace(BaseAddress, nameof(BaseAddress), &quot;BaseAddress is required&quot;); client.BaseAddress = new Uri(BaseAddress); client.Timeout = new TimeSpan(0, 0, 0, 10); client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(&quot;application/json&quot;)); client.DefaultRequestHeaders.AcceptCharset.Add(new StringWithQualityHeaderValue(&quot;UTF-8&quot;)); return client; } } /// &lt;summary&gt; /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// &lt;/summary&gt; public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } /// &lt;summary&gt; /// Timestamp in milliseconds. /// &lt;/summary&gt; /// &lt;returns&gt;The current timestamp in milliseconds.&lt;/returns&gt; private static long GetNonce() { return DateTime.UtcNow.ToTimestamp(); } /// &lt;summary&gt; /// Creates HMAC signature for signed endpoints. /// &lt;/summary&gt; /// &lt;param name=&quot;secretKey&quot;&gt;The secret key.&lt;/param&gt; /// &lt;param name=&quot;payload&quot;&gt;URL encoded values that would usually be the query string for the request.&lt;/param&gt; /// &lt;returns&gt;A ct representing the request params.&lt;/returns&gt; private static string CreateSignature(string secretKey, string payload) { Guard.Against.NullOrWhiteSpace(secretKey, nameof(secretKey)); Guard.Against.NullOrWhiteSpace(payload, nameof(payload)); using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey)); var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(payload)); return BitConverter.ToString(computedHash).Replace(&quot;-&quot;, &quot;&quot;).ToLowerInvariant(); } public async Task&lt;T?&gt; InvokeAsync&lt;T&gt;( HttpMethod httpMethod, EndpointSecurityType securityType, string endpoint, string? parameters = default, CancellationToken ct = default) where T : class { Guard.Against.NullOrWhiteSpace(endpoint, nameof(endpoint)); ct.ThrowIfCancellationRequested(); ThrowIfDisposed(); //============================================ // TODO: Implement a rate limiter var queryBuilder = new QueryBuilder(); foreach (var (key, value) in QueryHelpers.ParseQuery(parameters)) queryBuilder.Add(key, value.ToString()); if (securityType is EndpointSecurityType.Trade or EndpointSecurityType.UserData) { queryBuilder.Add(&quot;timestamp&quot;, GetNonce().ToString()); var queryString = queryBuilder.ToQueryString().ToString()[1..]; // ignore first character '?'. Binance requires it like so: &quot;symbol=DOGEUSDT&amp;recvWindow=5000&amp;timestamp=1637590595930&quot; var signature = CreateSignature(SecretKey, queryString); queryBuilder.Add(&quot;signature&quot;, signature); } var uri = $&quot;{endpoint}{queryBuilder.ToQueryString()}&quot;; using var httpRequestMessage = new HttpRequestMessage(httpMethod, uri); if (securityType != EndpointSecurityType.None) httpRequestMessage.Headers.Add(&quot;X-MBX-APIKEY&quot;, ApiKey); using var httpContent = new StringContent(string.Empty, Encoding.UTF8, &quot;application/x-www-form-urlencoded&quot;); if (httpMethod == HttpMethod.Post || httpMethod == HttpMethod.Put || httpMethod == HttpMethod.Delete) httpRequestMessage.Content = httpContent; //============================================ using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, ct).ConfigureAwait(false); // Ensures OK status httpResponseMessage.EnsureSuccessStatusCode(); // Get response string var json = await httpResponseMessage.Content.ReadAsStringAsync(ct).ConfigureAwait(false); return json.FromJson&lt;T&gt;(); } /// &lt;summary&gt; /// The standard dispose destructor. /// &lt;/summary&gt; ~BinanceApiProcessor() { Dispose(false); } /// &lt;summary&gt; /// Throw if disposed. /// &lt;/summary&gt; /// &lt;exception cref=&quot;ObjectDisposedException&quot;&gt;&lt;/exception&gt; private void ThrowIfDisposed() { if (_isDisposed) throw new ObjectDisposedException($&quot;{nameof(BinanceApiProcessor)} has been disposed&quot;); } /// &lt;summary&gt; /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// &lt;/summary&gt; /// &lt;param name=&quot;disposing&quot;&gt;If this method is called by a user's code.&lt;/param&gt; protected virtual void Dispose(bool disposing) { if (_isDisposed) return; if (disposing) { } _isDisposed = true; } } </code></pre> <h2>REST Client class</h2> <pre class="lang-cs prettyprint-override"><code>/// &lt;summary&gt; /// Binance REST implementation. /// &lt;/summary&gt; internal class BinanceRestClient : IDisposable { private const string BaseAddress = &quot;https://api.binance.com&quot;; private const string ApiKey = &quot;xxx&quot;; private const string SecretKey = &quot;xxx&quot;; private readonly IHttpClientFactory _httpClientFactory; /// &lt;summary&gt; /// Whether this instance is disposed. /// &lt;/summary&gt; private bool _isDisposed; /// &lt;summary&gt; /// Initializes a new instance of the &lt;see cref=&quot;BinanceRestClient&quot; /&gt; class. /// &lt;/summary&gt; /// &lt;param name=&quot;httpClientFactory&quot;&gt;&lt;/param&gt; public BinanceRestClient(IHttpClientFactory httpClientFactory) { _httpClientFactory = httpClientFactory; } /// &lt;summary&gt; /// The HTTP client. /// &lt;/summary&gt; private HttpClient HttpClient { get { var client = _httpClientFactory.CreateClient(); Guard.Against.NullOrWhiteSpace(BaseAddress, nameof(BaseAddress), &quot;BaseAddress is required&quot;); client.BaseAddress = new Uri(BaseAddress); client.Timeout = new TimeSpan(0, 0, 0, 10); client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(&quot;application/json&quot;)); client.DefaultRequestHeaders.AcceptCharset.Add(new StringWithQualityHeaderValue(&quot;UTF-8&quot;)); return client; } } /// &lt;summary&gt; /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// &lt;/summary&gt; public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } /// &lt;summary&gt; /// Timestamp in milliseconds. /// &lt;/summary&gt; /// &lt;returns&gt;The current timestamp in milliseconds.&lt;/returns&gt; private static long GetNonce() { return DateTime.UtcNow.ToTimestamp(); } /// &lt;summary&gt; /// Creates HMAC signature for signed endpoints. /// &lt;/summary&gt; /// &lt;param name=&quot;secretKey&quot;&gt;The secret key.&lt;/param&gt; /// &lt;param name=&quot;payload&quot;&gt;URL encoded values that would usually be the query string for the request.&lt;/param&gt; /// &lt;returns&gt;A ct representing the request params.&lt;/returns&gt; private static string CreateSignature(string secretKey, string payload) { Guard.Against.NullOrWhiteSpace(secretKey, nameof(secretKey)); Guard.Against.NullOrWhiteSpace(payload, nameof(payload)); using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey)); var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(payload)); return BitConverter.ToString(computedHash).Replace(&quot;-&quot;, &quot;&quot;).ToLowerInvariant(); } /// &lt;summary&gt; /// Test the connectivity to the API. /// &lt;/summary&gt; public async Task&lt;EmptyResponse?&gt; TestConnectivityAsync(CancellationToken ct = default) { ct.ThrowIfCancellationRequested(); ThrowIfDisposed(); const string endpoint = &quot;/api/v3/ping&quot;; using var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, endpoint); using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, ct).ConfigureAwait(false); // Ensures OK status httpResponseMessage.EnsureSuccessStatusCode(); // Get response string var json = await httpResponseMessage.Content.ReadAsStringAsync(ct).ConfigureAwait(false); // Deserialize return json.FromJson&lt;EmptyResponse&gt;(); } /// &lt;summary&gt; /// Gets the current server time (UTC). /// &lt;/summary&gt; /// &lt;param name=&quot;ct&quot;&gt;&lt;/param&gt; /// &lt;returns&gt;&lt;/returns&gt; public async Task&lt;ServerTimeResponse?&gt; GetServerTimeAsync(CancellationToken ct = default) { ct.ThrowIfCancellationRequested(); ThrowIfDisposed(); const string endpoint = &quot;/api/v3/time&quot;; using var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, endpoint); using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, ct).ConfigureAwait(false); // Ensures OK status httpResponseMessage.EnsureSuccessStatusCode(); // Get response string var json = await httpResponseMessage.Content.ReadAsStringAsync(ct).ConfigureAwait(false); return json.FromJson&lt;ServerTimeResponse&gt;(); } /// &lt;summary&gt; /// Gets current user balances. /// &lt;/summary&gt; /// &lt;param name=&quot;ct&quot;&gt;&lt;/param&gt; /// &lt;returns&gt;&lt;/returns&gt; public async Task&lt;AccountInformationResponse?&gt; GetBalancesAsync(CancellationToken ct = default) { ct.ThrowIfCancellationRequested(); ThrowIfDisposed(); var queryString = $&quot;timestamp={GetNonce()}&quot;; var endpoint = $&quot;/api/v3/account?{queryString}&amp;signature={CreateSignature(SecretKey, queryString)}&quot;; using var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, endpoint); httpRequestMessage.Headers.Add(&quot;X-MBX-APIKEY&quot;, ApiKey); using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, ct).ConfigureAwait(false); // Ensures OK status httpResponseMessage.EnsureSuccessStatusCode(); // Get response string var json = await httpResponseMessage.Content.ReadAsStringAsync(ct).ConfigureAwait(false); return json.FromJson&lt;AccountInformationResponse&gt;(); } public Task&lt;AccountTradeResponse?&gt; GetMyTrades(CancellationToken ct = default) { using var apiProcessor = new BinanceApiProcessor(_httpClientFactory); const string symbol = &quot;DOGEUSDT&quot;; return apiProcessor.InvokeAsync&lt;AccountTradeResponse&gt;(HttpMethod.Get, EndpointSecurityType.UserData, &quot;/api/v3/myTrades&quot;, $&quot;symbol={symbol}&amp;recvWindow=5000&quot;, ct); } /// &lt;summary&gt; /// Creates a listen key. /// &lt;/summary&gt; /// &lt;param name=&quot;ct&quot;&gt;&lt;/param&gt; /// &lt;returns&gt;&lt;/returns&gt; public async Task&lt;UserDataStreamResponse?&gt; CreateListenKeyAsync(CancellationToken ct = default) { ct.ThrowIfCancellationRequested(); ThrowIfDisposed(); const string endpoint = &quot;/api/v3/userDataStream&quot;; using var httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, endpoint); httpRequestMessage.Headers.Add(&quot;X-MBX-APIKEY&quot;, ApiKey); using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, ct).ConfigureAwait(false); // Ensures OK status httpResponseMessage.EnsureSuccessStatusCode(); // Get response string var json = await httpResponseMessage.Content.ReadAsStringAsync(ct).ConfigureAwait(false); return json.FromJson&lt;UserDataStreamResponse&gt;(); } /// &lt;summary&gt; /// Keeps alive a listen key. /// &lt;/summary&gt; /// &lt;param name=&quot;listenKey&quot;&gt;The listen key.&lt;/param&gt; /// &lt;param name=&quot;ct&quot;&gt;&lt;/param&gt; /// &lt;returns&gt;&lt;/returns&gt; public async Task&lt;EmptyResponse?&gt; KeepAliveListenKeyAsync(string? listenKey, CancellationToken ct = default) { Guard.Against.NullOrWhiteSpace(listenKey, nameof(listenKey)); ct.ThrowIfCancellationRequested(); ThrowIfDisposed(); var endpoint = $&quot;/api/v3/userDataStream?listenKey={listenKey}&quot;; using var httpContent = new StringContent(string.Empty, Encoding.UTF8, &quot;application/x-www-form-urlencoded&quot;); using var httpRequestMessage = new HttpRequestMessage(HttpMethod.Put, endpoint); httpRequestMessage.Headers.Add(&quot;X-MBX-APIKEY&quot;, ApiKey); httpRequestMessage.Content = httpContent; using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, ct).ConfigureAwait(false); // Ensures OK status httpResponseMessage.EnsureSuccessStatusCode(); // Get response string var json = await httpResponseMessage.Content.ReadAsStringAsync(ct).ConfigureAwait(false); return json.FromJson&lt;EmptyResponse&gt;(); } /// &lt;summary&gt; /// Deletes a listen key. /// &lt;/summary&gt; /// &lt;param name=&quot;ct&quot;&gt;&lt;/param&gt; /// &lt;returns&gt;&lt;/returns&gt; public async Task&lt;EmptyResponse?&gt; DeleteListenKeyAsync(string? listenKey, CancellationToken ct = default) { ct.ThrowIfCancellationRequested(); ThrowIfDisposed(); var endpoint = $&quot;/api/v3/userDataStream?listenKey={listenKey}&quot;; using var httpContent = new StringContent(string.Empty, Encoding.UTF8, &quot;application/x-www-form-urlencoded&quot;); using var httpRequestMessage = new HttpRequestMessage(HttpMethod.Delete, endpoint); httpRequestMessage.Headers.Add(&quot;X-MBX-APIKEY&quot;, ApiKey); httpRequestMessage.Content = httpContent; using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, ct).ConfigureAwait(false); // Ensures OK status httpResponseMessage.EnsureSuccessStatusCode(); // Get response string var json = await httpResponseMessage.Content.ReadAsStringAsync(ct).ConfigureAwait(false); return json.FromJson&lt;EmptyResponse&gt;(); } /// &lt;summary&gt; /// The standard dispose destructor. /// &lt;/summary&gt; ~BinanceRestClient() { Dispose(false); } /// &lt;summary&gt; /// Throw if disposed. /// &lt;/summary&gt; /// &lt;exception cref=&quot;ObjectDisposedException&quot;&gt;&lt;/exception&gt; private void ThrowIfDisposed() { if (_isDisposed) throw new ObjectDisposedException($&quot;{nameof(BinanceRestClient)} has been disposed&quot;); } /// &lt;summary&gt; /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// &lt;/summary&gt; /// &lt;param name=&quot;disposing&quot;&gt;If this method is called by a user's code.&lt;/param&gt; protected virtual void Dispose(bool disposing) { if (_isDisposed) return; if (disposing) { } _isDisposed = true; } } </code></pre>

270295

<p>Added the problem link below and my implementation of it. Took me a few hours to program. I have added comments to explain my thought process. <a href="https://cs50.harvard.edu/x/2021/psets/6/dna/" rel="nofollow noreferrer">Problem Link</a> Goal - To implement a program that identifies to whom a sequence of DNA belongs.</p> <ol> <li><p>should require first command-line argument the name of a CSV file containing the STR counts for a list of individuals and sits second command-line argument the name of a text file containing the DNA sequence to identify.</p> </li> <li><p>program should print an error message if incorrect no of arguments.</p> </li> <li><p>Your program should open the CSV file and dna file and read its contents into memory.</p> </li> <li><p>first row of the CSV file will be the column names. The first column will be the word name and the remaining columns will be the STR sequences themselves.</p> </li> <li><p>Your program should open the DNA sequence and read its contents into memory.</p> </li> <li><p>For each of the STRs (from the first line of the CSV file), your program should compute the longest run of consecutive repeats of the STR in the DNA sequence to identify.</p> </li> <li><p>If the STR counts match exactly with any of the individuals in the CSV file, your program should print out the name of the matching individual and no match if there are no matches.</p> </li> <li><p>You may assume that the STR counts will not match more than one individual.</p> </li> </ol> <pre class="lang-py prettyprint-override"><code>import csv import sys import re def main(): # checking if its correct no of arguments if len(sys.argv) != 3: print(&quot;Please specify both csv and text files&quot;) sys.exit(1) data = [] # opening the file into memory with open(sys.argv[1], &quot;r&quot;) as f: reader = csv.DictReader(f) for i in reader: data.append(i) # opening text sequence file and storing as string in seq with open(sys.argv[2]) as f: seq = f.read() # getting count from sequence countDict = count(data, seq) name = &quot;&quot; # comparing with data from csv file name = check(countDict, data) # printing the name of the match if name: print(name) else: print(&quot;No match&quot;) def count(data, seq): # getting STRs from database file so we know what STRs to search for keys = list(data[0].keys()) keys.pop(0) countDict = {} # creating a dictionary to store the count for the keys with key names for i in keys: countDict[i] = 0 strlist = [] # looping through the STRs to see if any matches in the string and if there are adding to the count for key in countDict: counter = 0 for i in range(len(seq)): end = len(key) # to get the length of the key if key == seq[i:end+i]: counter += 1 v = countDict[key] if not key == seq[i+end:end+i+end]: countDict[key] = max(v, counter) counter = 0 # resetting the counter to 0 else: countDict[key] = v i += len(key) return countDict def check(countDict, data): # empty string to store match name name = &quot;&quot; # going through the csv data file with potential matches ine at a time for i in data: # removing names from the data so we can do direct comparison with the count from dna found dictExceptName = dict(list(i.items())[1:]) # converting string count to int count for comparison for key, value in dictExceptName.items(): dictExceptName[key] = int(value) # comparing each person to dna found list if dictExceptName == countDict: name = i[&quot;name&quot;] # getting name of the person if there is a match return name main() </code></pre>

270298

<p>Alright, this is one of my first real projects in python, it's basically a one-way chat where the server sends away an encoded message. The logic of it is pretty simple and I know there is some unnecessary code in there. I have also made a simple client who receives the messages and decrypts it, based on if the user input == the decrypted version of the password. Would love to get some tips on how I could improve it.</p> <p>So initially the program was supposed to encrypt a message the user enter, then create a password and encrypt that password. Then it would store this data in a text file, with the message as the name and the password as the content. Then when you wanted to open it you were supposed to enter the decrypted version of the password, and then somewhere around here I started rethinking it.</p> <p>This with creating the file and so is still in the script, but how I intend it to work now is: You enter your message in the first text box, press the button and the message will be encrypted and a password will be created which also would be displayed. Which then also gets encrypted.</p> <p>Then it should send this in the format of a dictionary over to a client. Then the client is processing this data sent by asking for the password decrypted and if it's correct it will decrypt the message. (The code below is only the server since I want to finish that first)</p> <pre><code>from tkinter import * import os import string import random import socket import pickle window = Tk() window.title(&quot;Password Crypter&quot;) window.configure(background=&quot;white&quot;) def Server(): HEADERSIZE = 10 host = '' port = 50010 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((host,port)) s.listen(5) while True: conn, addr = s.accept() print(f&quot;Connection fom {addr} has been established!&quot;) msg = pickle.dumps(d) msg = bytes(f'{len(msg):&lt;{HEADERSIZE}}', &quot;utf-8&quot;) + msg conn.send(msg) def randomword(length): letters = string.ascii_lowercase global get get = ''.join(random.choice(letters) for i in range(length)) print(get) def click(): global sample_string global inputText inputText = textEntry.get() encoder() def click1(): global inputText1 inputText1 = textEntry1.get() accesDecoder() def encoder(): global sample_string global inputText sample_string = inputText.lower() char_to_replace = {'s': 'X', 'a': 'Y', 'i': 'Z', 'b': 'W', 'k': 'V', 'o': 'U', 'e': 'T', 'c': 'S', 'l': 'R', 'j': 'Q', 'h': 'P', 'm': 'O', 'r': 'N', 'd': 'M', 'q': 'L', 'u': 'K', 'p': 'J', 'y': 'I', 's': 'H', 'f': 'G', 'w': 'F', 't': 'E', 'n': 'D', 'x': 'C', 'r': 'B', 'v': 'A'} for key, value in char_to_replace.items(): sample_string = sample_string.replace(key, value) Label (window, text=sample_string, bg=&quot;white&quot;, fg=&quot;black&quot;, font=&quot;none 12 bold&quot;) .grid(row=3, column=0, sticky=W) randomword(20) passCrypter() Label (window, textvariable=passwordVar, bg=&quot;white&quot;, fg=&quot;black&quot;, font=&quot;none 12 bold&quot;) .grid(row=4, column=0, sticky=W) passwordVar.set(get) with open(sample_string + '.txt', 'w') as messageFile: messageFile.write(sample_string2) add_element(d, sample_string, sample_string2) print(d) Server() def add_element(dict, key, value): if key not in dict: dict[key] = [] dict[key].append(value) d = {} passwordVar = StringVar() decrypted = StringVar() wrongCode = StringVar() def accesDecoder(): with open(sample_string + '.txt', 'r') as messageFile: global code code = messageFile.read() passDecrypt() if inputText1 == sample_string3 or inputText1 == sample_string: print(&quot;You have accesed the decoder.&quot;) decrypted.set('') decoder() else: Label (window, textvariable=decrypted, bg=&quot;white&quot;, fg=&quot;black&quot;, font=&quot;none 12 bold&quot;) .grid(row=4, column=1, sticky=W) decrypted.set(&quot;Wrong code, try again.&quot;) def decoder(): sample_string1 = sample_string char_to_replace1 = {'X': 's', 'Y': 'a', 'Z': 'i', 'W': 'b', 'V': 'k', 'U': 'o', 'T': 'e', 'S': 'c', 'R': 'l', 'Q': 'j', 'P': 'h', 'O': 'm', 'N': 'r', 'M': 'd', 'L': 'q', 'K': 'u', 'J': 'p', 'I': 'y', 'H': 's', 'G': 'f', 'F': 'w', 'E': 't', 'D': 'n', 'C': 'x', 'B': 'r', 'A': 'v'} for key, value in char_to_replace1.items(): sample_string1 = sample_string1.replace(key, value) print(sample_string1) decrypted.set(sample_string1) Label (window, textvariable=decrypted, bg=&quot;white&quot;, fg=&quot;black&quot;, font=&quot;none 12 bold&quot;) .grid(row=3, column=1, sticky=W) def passCrypter(): global sample_string2 sample_string2 = get char_to_replace2 = {'s': 'X', 'a': 'Y', 'i': 'Z', 'b': 'W', 'k': 'V', 'o': 'U', 'e': 'T', 'c': 'S', 'l': 'R', 'j': 'Q', 'h': 'P', 'm': 'O', 'r': 'N', 'd': 'M', 'q': 'L', 'u': 'K', 'p': 'J', 'y': 'I', 's': 'H', 'f': 'G', 'w': 'F', 't': 'E', 'n': 'D', 'x': 'C', 'r': 'B', 'v': 'A'} for key, value in char_to_replace2.items(): sample_string2 = sample_string2.replace(key, value) def passDecrypt(): global sample_string3 sample_string3 = code char_to_replace3 = {'X': 's', 'Y': 'a', 'Z': 'i', 'W': 'b', 'V': 'k', 'U': 'o', 'T': 'e', 'S': 'c', 'R': 'l', 'Q': 'j', 'P': 'h', 'O': 'm', 'N': 'r', 'M': 'd', 'L': 'q', 'K': 'u', 'J': 'p', 'I': 'y', 'H': 's', 'G': 'f', 'F': 'w', 'E': 't', 'D': 'n', 'C': 'x', 'B': 'r', 'A': 'v'} for key, value in char_to_replace3.items(): sample_string3 = sample_string3.replace(key, value) textEntry = Entry(window, width=60, bg=&quot;white&quot;) textEntry.grid(row=1, column=0, sticky=W) Button(window, text=&quot;Submit Text&quot;, width=13, command=click) .grid(row=2, column=0, sticky=W) textEntry1 = Entry(window, width=60, bg=&quot;white&quot;) textEntry1.grid(row=1, column=1, sticky=W) Button(window, text=&quot;Submit Code&quot;, width=13, command=click1) .grid(row=2, column=1, sticky=W) window.mainloop() </code></pre>

270302

<p>The code below takes a list of users and displays two lists</p> <ol> <li>Refused users</li> <li>Admitted users</li> </ol> <p>Sample output:</p> <blockquote> <p>Refuse: Phil, Lola.</p> <p>Admit: Chris, Anne, Colin, Terri, Sam, Kay, Bruce.</p> </blockquote> <p>Any feedback is highly appreciated.</p> <pre><code>const people = ['Chris', 'Anne', 'Colin', 'Terri', 'Phil', 'Lola', 'Sam', 'Kay', 'Bruce']; let refusedPeople = ['Lola', 'Phil'] let admittedPeople = people.filter(name =&gt; !refusedPeople.includes(name)) const admitted = document.querySelector('.admitted'); const refused = document.querySelector('.refused'); admitted.textContent = 'Admit: '; refused.textContent = 'Refuse: ' const refusedIndices = refusedPeople.map(x =&gt; people.indexOf(x)).sort() const admittedIndices = admittedPeople.map(x =&gt; people.indexOf(x)).sort() for (let [index, person] of people.entries()) { refusedPeople.includes(person) ? refusedIndices.slice(-1)[0] === index ? refused.textContent += `${person}.` : refused.textContent += `${person}, ` : admittedIndices.slice(-1)[0] === index ? admitted.textContent += `${person}.` : admitted.textContent += `${person}, `; } </code></pre>

270303

<p>I've implemented a menu system where all input calls ultimately go through <code>io_getline</code>, a function which reads a line of input up to the max buffer size or newline (the rest of the line is discarded if it exceeds the buffer size) and returns the number of characters written, or -1 if an EOF is encountered. When an EOF is encountered, io_getline will, from then on, permanently be in a state where the first character it attempts to read yields EOF (which is not a character) and it will always return -1. This is intentional, as I will soon demonstrate:</p> <pre><code>/* Does the same thing as getchar but with guaranteed EOF persistence */ static int getchar_eof(void) { unsigned char ch; static int eof_encountered; if(eof_encountered) return EOF; fread(&amp;ch, 1, 1, stdin); if(feof(stdin)){ eof_encountered = 1; return EOF; } return ch; } ssize_t io_getline(char *buffer, size_t bufsz) { int ch; char *bufp = buffer; while((ch = getchar_eof()) != EOF &amp;&amp; ch != '\n') if(buffer != NULL &amp;&amp; (size_t)(bufp - buffer) &lt; bufsz) *bufp++ = ch; if(ch == EOF) return -1; return bufp - buffer; } /* two functions that use io_getline: */ int generic_getter_str(struct menu_page *unused) { (void)unused; ssize_t nwritten; showprompt(); if((nwritten = io_getline(menustate.input_str, 32)) == -1) return CBRET_EOF; // causes caller to end the program if(nwritten == 0) return CBRET_RETURNTOPARENT; return CBRET_DONOTHING; } void waitcontinue(void) { printf(&quot;Press Enter to continue.&quot;); io_getline(NULL, 0); io_clearscreen(); } </code></pre> <p>A little bit about the menu structure: each page has three callbacks that are called in order: entry, getter and handler. The entry's job is to do anything that needs to be done before getting user input, the getter's job is to get input (<code>str</code>, <code>u32</code>, <code>char_or_u32</code>, and <code>none</code>) from the user, and handle EOF by ending the program, and the handler's job is to interpret the input obtained by the getter (if any). <code>waitcontinue</code> is called in some handler functions for the purpose of pagination, while <code>generic_getter_str</code> is one of the four getter functions.</p> <p>As <code>waitcontinue</code> is not a getter, it does not handle EOF, but EOF will cause it to finish (this is expected). And this design decision is where I thankfully discovered a weird nuance with <code>getchar</code>, wherein it doesn't always persist EOF status. It is possible for getchar to return EOF, be called again, and <em>prompt the user for input post-EOF</em>. I managed to produce this behavior on both a repl.it Linux VM (repl.it/languages/c, without being logged in) and minGW on Windows (where I discovered it).</p> <p>This goes against my understanding that getchar should constantly return EOF after the first time. The result of this is that any time <code>waitcontinue</code> is called in an environment where getchar behaves in this way, pressing <code>ctrl-d</code> (or <code>ctrl-z enter</code> if on Windows), the program will receive the EOF, skip the one waitcontinue call, and then continue to run, when the intent is for it to &quot;bubble out&quot; until a getter inevitably receives the EOF and ends the program.</p> <p>This led me to re-implement getchar to guarantee the behavior that I want and expect, and it works fantastically, however, this is fascinating to me, and I now wonder if there are other nuances I might be missing here.</p>

270304

<p>As a smaller part of a programming challenge, I am writing a function in Python that takes two parameters, a given number and a size constraint. The function yields a generator that produces the integer partitions of the given number up to the size constraint. I have a working solution that is derived from the rule_asc algorithm:</p> <pre><code>def rule_asc(n): a = [0 for i in range(n + 1)] k = 1 a[1] = n while k != 0: x = a[k - 1] + 1 y = a[k] - 1 k -= 1 while x &lt;= y: a[k] = x y -= x k += 1 a[k] = x + y yield a[:k + 1] </code></pre> <p>So to implement the size constraint there is a simple addition to the first nested while loop:</p> <pre><code>def generate_subproblems(total_nodes, colors): all_partitions = [0 for i in range(colors)] k = 1 all_partitions[0] = 0 all_partitions[1] = total_nodes while k != 0: x = all_partitions[k - 1] + 1 y = all_partitions[k] - 1 k -= 1 while x &lt;= y and k &lt; colors - 1: all_partitions[k] = x y -= x k += 1 all_partitions[k] = x + y current_partition = all_partitions[:k + 1] yield current_partition </code></pre> <p>This yields all the partitions of <code>total_nodes</code> with length <code>&lt;= colors</code>.</p> <p>For example, the code:</p> <pre><code>for _ in generate_subproblems(6, 3): print(_) </code></pre> <p>Prints:</p> <pre><code>[1, 1, 4] [1, 2, 3] [1, 5] [2, 2, 2] [2, 4] [3, 3] [6] </code></pre> <p>Which are all the integer partitions of the number 6 of size less than or equal to 3.</p> <p>The problem I am facing is that the algorithm is too slow for larger values, by larger I mean anything over 100. The place where I got the first algorithm (<a href="https://jeromekelleher.net/category/combinatorics.html" rel="nofollow noreferrer">https://jeromekelleher.net/category/combinatorics.html</a>) to begin with lists a different, quicker implementation:</p> <pre><code>def accel_asc(n): a = [0 for i in range(n + 1)] k = 1 y = n - 1 while k != 0: x = a[k - 1] + 1 k -= 1 while 2 * x &lt;= y: a[k] = x y -= x k += 1 l = k + 1 while x &lt;= y: a[k] = x a[l] = y yield a[:k + 2] x += 1 y -= 1 a[k] = x + y y = x + y - 1 yield a[:k + 1] </code></pre> <p>However I am unable to wrap my head around this implementation so as to introduce the size constraint. How can I modify the accel_asc function to just yield the partitions less than a specified size?</p>

270305

<p>I've been practising my coding skills because I have an interview coming up. The HackerRank challenge has 16 test cases; the code passes 9 of them and the other 7 time out.</p> <p>If you go to <a href="https://www.hackerrank.com/domains/data-structures" rel="nofollow noreferrer">HackerRank Problems Data Structures</a> you might be able to find Array Manipulation under <strong>Hard</strong> problems. I can't seem to provide a direct link.</p> <p>Using Microsoft specific parallel extensions in C++ I have gotten execution time for test case 4 down from hours down to 89 seconds when built for release. Test case 4 is one of the test cases that times out on Hacker Rank. I might be able to squeeze another couple of seconds out by using parallel processing in the merge function as well.</p> <p>Things I don't like about my solution:</p> <ul> <li>It is totally brute force</li> <li>I can't seem to run parallel on HackerRank; maybe I need to try OpenMP.</li> </ul> <p>I'm open to all answers and comments.</p> <h1>Program Challenge Statement</h1> <blockquote> <p>Starting with a 1-indexed array of zeros and a list of operations, for each operation add a value to each the array element between two given indices, inclusive. Once all operations have been performed, return the maximum value in the array.</p> <p><strong>Example</strong></p> <p>Queries are interpreted as follows: a b k<br /> 1 5 3<br /> 4 8 7<br /> 6 9 1</p> <p>Add the values of <em>k</em> between the indices <em>a</em> and <em>b</em> inclusive:</p> <p>index-&gt; 1 2 3 4 5 6 7 8 9 10<br /> [0,0,0, 0, 0,0,0,0,0, 0]<br /> [3,3,3, 3, 3,0,0,0,0, 0]<br /> [3,3,3,10,10,7,7,7,0, 0]<br /> [3,3,3,10,10,8,8,8,1, 0]</p> <p>The largest value is 10 after all operations are performed.</p> <p><strong>Function Description</strong><br /> Complete the function <code>arrayManipulation</code>.</p> <p><code>arrayManipulation</code> has the following parameters:</p> <ul> <li><code>int n</code> - the number of elements in the array</li> <li><code>int queries[q][3]</code> - a two dimensional array of queries where each <code>queries[i]</code> contains three integers, <code>a</code>, <code>b</code>, and <code>k</code>.</li> </ul> <p><strong>Returns</strong></p> <ul> <li><code>int</code> - the maximum value in the resultant array</li> </ul> <p><strong>Constraints</strong><br /> - 3 &lt; n &lt; 10⁷<br /> - 1 &lt; m &lt; 2 * 10⁵<br /> - 1 &lt; a &lt; b &lt; n<br /> - 0 &lt; k &lt; 10⁹</p> <p><strong>Sample Input</strong><br /> 5 3<br /> 1 2 100<br /> 2 5 100<br /> 3 4 100</p> <p><strong>Sample Output</strong><br /> 200</p> </blockquote> <h1>Environment</h1> <p>Dell Precision 7740</p> <p>Processor Intel(R) Core(TM) i7-9850H CPU @ 2.60GHz 2.59 GHz<br /> Installed RAM 64.0 GB (63.8 GB usable)<br /> System type 64-bit operating system, x64-based processor<br /> Edition Windows 10 Pro Version 20H2<br /> OS build 19042.1348</p> <p>Visual Studio 2019.</p> <h1>Test Cases</h1> <h2>Test Case 1</h2> <p>5<br /> 3<br /> 1 2 100<br /> 2 5 100<br /> 3 4 100</p> <h2>Test Case 2</h2> <p>10<br /> 3<br /> 1 5 3<br /> 4 8 7<br /> 6 9 1</p> <h2>Test Case 3</h2> <p>10<br /> 4<br /> 2 6 8<br /> 3 5 7<br /> 1 8 1<br /> 5 9 15</p> <h2>Test Case 4</h2> <p>This is the first 5 lines only, the complete test case is 100,002 lines. You can download the complete test case from my <a href="https://github.com/pacmaninbw/HackerRankArrayManipulation" rel="nofollow noreferrer">GitHub repository</a>.</p> <p>10000000<br /> 100000<br /> 1400906 9889280 90378<br /> 6581237 9872072 87106<br /> 4386373 9779851 52422</p> <p>This test case really shows the scope of the problem, 100,000 outer loops, some inner loops with more the 7 million executions.</p> <h2>Test Output</h2> <p>PS C:\Users\PaulC\Documents\ProjectsNfwsi\CodeReview\HackerRankArrayManip\Release&gt; HackerRankArrayManip.exe<br /> How many test cases do you want to run?4<br /> Test Case 1<br /> Test Case 1 File read time 0.271 milliseconds<br /> Test Case 1 result is 200 Execution time 2.0378 milliseconds</p> <p>Test Case 2<br /> Test Case 2 File read time 0.1541 milliseconds<br /> Test Case 2 result is 10 Execution time 0.0132 milliseconds</p> <p>Test Case 3<br /> Test Case 3 File read time 0.1068 milliseconds<br /> Test Case 3 result is 31 Execution time 0.0985 milliseconds</p> <p>Test Case 4<br /> Test Case 4 File read time 77.3068 milliseconds<br /> Test Case 4 result is 2497169732 Execution time 89.1439 Seconds</p> <p>PS C:\Users\PaulC\Documents\ProjectsNfwsi\CodeReview\HackerRankArrayManip\Release&gt;</p> <h1>C++ Source File</h1> <pre><code>#include &lt;PPL.h&gt; #include&lt;algorithm&gt; #include &lt;chrono&gt; #include&lt;execution&gt; #include &lt;fstream&gt; #include &lt;iostream&gt; #include &lt;mutex&gt; #include &lt;string&gt; #include &lt;vector&gt; constexpr int MAX_TEST_CASE = 4; /* * Infrastructure to replace HackerRank input functions */ std::vector&lt;int&gt; convertInputLineToIntVector(std::string query_string) { constexpr int query_size = 3; std::vector&lt;int&gt; query; std::string::iterator intStart = query_string.begin(); std::string::iterator intEnd; for (int i = 0; i &lt; query_size; i++) { intEnd = std::find(intStart, query_string.end(), ' '); int pos = intEnd - query_string.begin(); std::string tempInt(intStart, intEnd); query.push_back(stoi(tempInt)); if (intEnd &lt; query_string.end()) { intStart = query_string.begin() + pos + 1; } } return query; } std::vector&lt;std::vector&lt;int&gt;&gt; getIntVectors(std::ifstream* inFile) { std::vector&lt;std::vector&lt;int&gt;&gt; inputVector; std::string string_vector_count; getline(*inFile, string_vector_count); int strings_count = stoi(string_vector_count); for (int i = 0; i &lt; strings_count; i++) { std::string string_item; getline(*inFile, string_item); inputVector.push_back(convertInputLineToIntVector(string_item)); } return inputVector; } int getInputLines(std::string inputFileName, int &amp;vectorSize, std::vector&lt;std::vector&lt;int&gt;&gt;&amp; queries) { std::string string_count_size; std::ifstream inFile(inputFileName); if (!inFile.is_open()) { std::cerr &lt;&lt; &quot;Can't open &quot; &lt;&lt; inputFileName &lt;&lt; &quot; for input.\n&quot;; std::cout &lt;&lt; &quot;Can't open &quot; &lt;&lt; inputFileName &lt;&lt; &quot; for input.\n&quot;; return EXIT_FAILURE; } getline(inFile, string_count_size); vectorSize = stoi(string_count_size); queries = getIntVectors(&amp;inFile); return EXIT_SUCCESS; } void getTestCountAndFirstTestCase(int&amp; testCount, int&amp; firstTestCase) { do { std::cout &lt;&lt; &quot;How many test cases do you want to run?&quot;; std::cin &gt;&gt; testCount; if (testCount &lt; 0 || testCount &gt; MAX_TEST_CASE) { std::cerr &lt;&lt; &quot;The number of test cases must be greater &gt; 0 and less than &quot; &lt;&lt; &quot; &quot; &lt;&lt; MAX_TEST_CASE &lt;&lt; &quot;\n&quot;; } } while (testCount &lt; 0 || testCount &gt; MAX_TEST_CASE); if (testCount &lt; MAX_TEST_CASE) { bool hasErrors = true; do { std::cout &lt;&lt; &quot;What test case file do you want to start with?&quot;; std::cin &gt;&gt; firstTestCase; if (firstTestCase &lt; 0 || firstTestCase &gt; MAX_TEST_CASE) { std::cerr &lt;&lt; &quot;The first test cases must be greater &gt; 0 and less than &quot; &lt;&lt; &quot; &quot; &lt;&lt; MAX_TEST_CASE &lt;&lt; &quot;\n&quot;; hasErrors = true; } else { hasErrors = false; } if (!hasErrors &amp;&amp; testCount + firstTestCase &gt; MAX_TEST_CASE) { std::cerr &lt;&lt; &quot;The first test cases and the test count must be less than or equal to &quot; &lt;&lt; MAX_TEST_CASE &lt;&lt; &quot;\n&quot;; hasErrors = true; } } while (hasErrors); } else { firstTestCase = 1; } } /* * Begin HackerRank Solution */ constexpr int IDX_FIRST_LOCATION = 0; constexpr int IDX_LAST_LOCATION = 1; constexpr int IDX_VALUE_TO_ADD = 2; constexpr int MAX_THREADS = 16; unsigned long mergeAndFindMax(std::vector&lt;unsigned long&gt; maxValues, std::vector&lt;std::vector&lt;unsigned long&gt;&gt; calculatedValues, const size_t executionCount) { unsigned long maximumValue = 0; for (size_t i = 0; i &lt; MAX_THREADS; i++) { std::vector&lt;unsigned long&gt;::iterator cvi = calculatedValues[i].begin(); std::vector&lt;unsigned long&gt;::iterator cvEnd = calculatedValues[i].end(); std::vector&lt;unsigned long&gt;::iterator mvi = maxValues.begin(); for ( ; mvi &lt; maxValues.end() &amp;&amp; cvi &lt; cvEnd; mvi++, cvi++) { *mvi += *cvi; if (*mvi &gt; maximumValue) { maximumValue = *mvi; } } if (i &gt; executionCount) { break; } } return maximumValue; } unsigned long arrayManipulation(const int n, const std::vector&lt;std::vector&lt;int&gt;&gt; queries) { std::vector&lt;unsigned long&gt; maximumValues(n, 0); std::vector&lt;std::vector&lt;unsigned long&gt;&gt; calculatedValues(MAX_THREADS); std::mutex m; for_each(calculatedValues.begin(), calculatedValues.end(), [maximumValues](std::vector&lt;unsigned long&gt;&amp; cvi) {cvi = maximumValues; }); int executionCount = 0; Concurrency::parallel_for_each(queries.begin(), queries.end(), [&amp;m, &amp;calculatedValues, &amp;executionCount](std::vector&lt;int&gt; query) { std::lock_guard&lt;std::mutex&gt; guard(m); size_t startLoc = query[IDX_FIRST_LOCATION]; size_t endLoc = query[IDX_LAST_LOCATION]; const unsigned long valueToAdd = query[IDX_VALUE_TO_ADD]; for_each(calculatedValues[executionCount % MAX_THREADS].begin() + (startLoc - 1), calculatedValues[executionCount % MAX_THREADS].begin() + endLoc, [valueToAdd](unsigned long&amp; n) {n += valueToAdd; }); executionCount++; }); return mergeAndFindMax(maximumValues, calculatedValues, executionCount); } int executeAndTimeTestCases(int testCaseCount, int firstTestCase) { using std::chrono::high_resolution_clock; using std::chrono::duration_cast; using std::chrono::duration; using std::chrono::milliseconds; for (int i = 0; i &lt; testCaseCount; i++) { std::string testFileName = &quot;TestCase&quot; + std::to_string(firstTestCase) + &quot;.txt&quot;; int n = 0; std::vector&lt;std::vector&lt;int&gt;&gt; queries; std::cout &lt;&lt; &quot;Test Case &quot; &lt;&lt; firstTestCase &lt;&lt; &quot;\n&quot;; auto fileReadStartTime = high_resolution_clock::now(); int exitStatus = getInputLines(testFileName, n, queries); if (exitStatus != EXIT_SUCCESS) { return exitStatus; } auto fileReadEndTime = high_resolution_clock::now(); duration&lt;double, std::milli&gt; msReadTime = fileReadEndTime - fileReadStartTime; std::cout &lt;&lt; &quot;Test Case &quot; &lt;&lt; firstTestCase &lt;&lt; &quot; File read time &quot; &lt;&lt; msReadTime.count() &lt;&lt; &quot; milliseconds\n&quot;; auto executionStartTime = high_resolution_clock::now(); unsigned long result = arrayManipulation(n, queries); auto executionEndTime = high_resolution_clock::now(); duration&lt;double, std::milli&gt; msExecution = executionEndTime - executionStartTime; if (msExecution.count() &gt; 1000.0) { std::cout &lt;&lt; &quot;Test Case &quot; &lt;&lt; firstTestCase &lt;&lt; &quot; result is &quot; &lt;&lt; result &lt;&lt; &quot; Execution time &quot; &lt;&lt; msExecution.count() / 1000.0 &lt;&lt; &quot; Seconds\n\n&quot;; } else { std::cout &lt;&lt; &quot;Test Case &quot; &lt;&lt; firstTestCase &lt;&lt; &quot; result is &quot; &lt;&lt; result &lt;&lt; &quot; Execution time &quot; &lt;&lt; msExecution.count() &lt;&lt; &quot; milliseconds\n\n&quot;; } firstTestCase++; } return EXIT_SUCCESS; } int main() { int testCaseCount = 0; int firstTestCase = 0; getTestCountAndFirstTestCase(testCaseCount, firstTestCase); return executeAndTimeTestCases(testCaseCount, firstTestCase); } </code></pre>

270307

<h2>Code:</h2> <pre><code># read file of first agrument import sys, os try: data = open(sys.argv[1]).read() except: data = open(&quot;File.txt&quot;).read() sys.argv.append(&quot;File.txt&quot;) dct = {&quot;@&quot;: data, &quot;E&quot;: &quot;0&quot;} iteration = 0 RESET = False define = False printf = False replace = False inp = False join = False Reverse = False getascii = False getfirstchar = False removeallexceptcertainchar = False readfile = False comment = False multilinecomment = False takeagrument = False definebutvar = False getfilesandfolders = False haltifeof = False ################################################################################ variable = &quot;&quot; variable2 = &quot;&quot; variable3 = &quot;&quot; variable4 = &quot;&quot; variable5 = &quot;&quot; variable6 = &quot;&quot; string = &quot;&quot; escape = False isready = False isset = False isgo = False def erroring(errtype, errreason, tb): print(errreason, end=&quot;&quot;, file=sys.stderr) sys.excepthook = erroring def dctremoveallexceptcertain(string, variable): # removes all except certain characters # string = string to be modified # variable = characters to be kept # returns modified string global newstring newstring = &quot;&quot; for i in string: if i in variable: newstring += i return newstring while True: # Note you should use try and except to catch errors, not if x in y: for i in data: if printf: # print the variable of dct variable if i in dct: print(dct[i], end = &quot;&quot;) printf = False else: raise Exception(&quot;ERROR IN FILE&quot;, sys.argv[1], &quot;VARIABLE NOT FOUND IN ITERATION&quot;, iteration) break elif define: if isready: if escape: # check if i is quote or backslash add to string else add backslash and i if i == &quot;\&quot;&quot; or i == &quot;\\&quot;: string += i escape = False else: string += &quot;\\&quot; + i escape = False elif i == &quot;\&quot;&quot;: dct[variable] = string string = &quot;&quot; isready = False define = False # check if the variable is &quot;@&quot; change the data if variable == &quot;@&quot;: RESET = True break elif i == &quot;\\&quot;: escape = True continue else: string += i else: variable = i isready = True elif replace: # get 3 variables if isgo: try: dct[variable] = dct[variable2].replace(variable3, i) except: raise Exception(&quot;ERROR IN FILE&quot;, sys.argv[1], &quot;VARIABLE NOT FOUND IN ITERATION&quot;, iteration) break replace = isset = isready = isgo = False # check if the variable is &quot;@&quot; change the data if variable == &quot;@&quot;: RESET = True break elif isset: variable3 = i isgo = True elif isready: variable2 = i isset = True else: variable = i isready = True elif inp: try: dct[i] = input() dct[&quot;E&quot;] = &quot;0&quot; except EOFError: dct[&quot;E&quot;] = &quot;1&quot; inp = False if i == &quot;@&quot;: RESET = True break elif join: if isset: try: dct[variable] = dct[variable2] + dct[i] except: raise Exception(&quot;ERROR IN FILE&quot;, sys.argv[1], &quot;VARIABLE NOT FOUND IN ITERATION&quot;, iteration) break join = isset = isready = isgo = False # check if the variable is &quot;@&quot; change the data if variable == &quot;@&quot;: RESET = True break elif isready: variable2 = i isset = True else: variable = i isready = True elif Reverse: # this is equivalent to pseudocode var = var2.reverse() if isready: try: dct[variable] = dct[i][::-1] except: raise Exception(&quot;ERROR IN FILE&quot;, sys.argv[1], &quot;VARIABLE NOT FOUND IN ITERATION&quot;, iteration) break isready = False Revert = False if variable == &quot;@&quot;: RESET = True break else: variable = i isready = True elif getfirstchar: # gets the first character of the variable if isready: try: dct[variable] = dct[i][0] except: raise Exception(&quot;ERROR IN FILE&quot;, sys.argv[1], &quot;VARIABLE NOT FOUND IN ITERATION&quot;, iteration) isready = False getfirstchar = False if variable == &quot;@&quot;: RESET = True break else: variable = i isready = True elif getascii: # gets ascii value of the variable if isready: try: dct[i] try: dct[variable] = ord(dct[i]) except: raise Exception(&quot;ERROR IN FILE&quot;, sys.argv[1], &quot;INVALID NUMBER IN ITERATION&quot;, iteration) except: raise Exception(&quot;ERROR IN FILE&quot;, sys.argv[1], &quot;VARIABLE NOT FOUND IN ITERATION&quot;, iteration) getascii = False isready = False if variable == &quot;@&quot;: RESET = True break else: variable = i isready = True elif removeallexceptcertainchar: # removes all except certain character if isready: try: dct[variable] = dctremoveallexceptcertain(dct[variable], dct[i]) except: raise Exception(&quot;ERROR IN FILE&quot;, sys.argv[1], &quot;VARIABLE NOT FOUND IN ITERATION&quot;, iteration) isready = False removeallexceptcertainchar = False if variable == &quot;@&quot;: RESET = True break else: variable = i isready = True elif readfile: if isready: try: dct[i] except: raise Exception(&quot;ERROR IN FILE&quot;, sys.argv[1], &quot;VARIABLE NOT FOUND IN ITERATION&quot;, iteration) try: dct[variable] = open(dct[i], &quot;r&quot;).read() dct[&quot;E&quot;] = &quot;0&quot; except: dct[&quot;E&quot;] = &quot;1&quot; isready = False readfile = False if variable == &quot;@&quot;: RESET = True break else: variable = i isready = True elif comment: # ignore until a newline is found if i == &quot;\n&quot;: comment = False elif multilinecomment: if i == &quot;}&quot;: multilinecomment = False elif takeagrument: # checks if the variable is defined and the variable is a number if isready: try: dct[i] try: int(dct[i]) try: dct[variable] = sys.argv[int(dct[i])] dct[&quot;E&quot;] = &quot;0&quot; except: dct[&quot;E&quot;] = &quot;1&quot; except: raise Exception(&quot;ERROR IN FILE&quot;, sys.argv[1], &quot;INVALID NUMBER&quot;, iteration) except: raise Exception(&quot;ERROR IN FILE&quot;, sys.argv[1], &quot;VARIABLE NOT FOUND IN ITERATION&quot;, iteration) isready = False takeagrument = False if variable == &quot;@&quot;: RESET = True else: variable = i isready = True elif definebutvar: # like &gt; but it defines the variable if isready: try: dct[variable] = dct[i] except: raise Exception(&quot;ERROR IN FILE&quot;, sys.argv[1], &quot;VARIABLE NOT FOUND IN ITERATION&quot;, iteration) isready = False definebutvar = False if variable == &quot;@&quot;: RESET = True break else: variable = i isready = True elif getfilesandfolders: # gets all files and folders in a variable if folder not found the variable &quot;E&quot; is equal to &quot;1&quot; else &quot;0&quot; if isready: # check if variable is defined try: dct[i] except: raise Exception(&quot;ERROR IN FILE&quot;, sys.argv[1], &quot;VARIABLE NOT FOUND IN ITERATION&quot;, iteration) try: files = os.listdir(dct[i]) dct[variable] = files dct[&quot;E&quot;] = &quot;0&quot; except: dct[&quot;E&quot;] = &quot;1&quot; isready = False getfilesandfolders = False if variable == &quot;@&quot;: RESET = True break else: variable = i isready = True elif haltifeof: if dct[&quot;E&quot;] == &quot;1&quot;:break haltifeof = False elif i == &quot;@&quot;: ############################################################################################################# RESET = True break elif i == &quot;H&quot;: break elif i == &quot;&gt;&quot;: define = True elif i == &quot;*&quot;: printf = True elif i == &quot;$&quot;: replace = True elif i == &quot;&amp;&quot;: inp = True elif i == &quot;+&quot;: join = True elif i == &quot;/&quot;: Reverse = True elif i == &quot;?&quot;: getfirstchar = True elif i == &quot;.&quot;: getascii = True elif i == &quot;!&quot;: removeallexceptcertainchar = True elif i == &quot;;&quot;: readfile = True elif i == &quot;:&quot;: comment = True elif i == &quot;{&quot;: multilinecomment = True elif i == &quot;|&quot;: takeagrument = True elif i == &quot;=&quot;: definebutvar = True elif i == &quot;%&quot;: getfilesandfolders = True elif i == &quot;_&quot;: haltifeof = True # its not necessary to raise error invalid command # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # iteration += 1 # check if string still contains something put it in dct if string != &quot;&quot;: dct[variable] = string string = &quot;&quot; define = False isready = False isset = False isgo = False printf = False replace = False inp = False join, Reverse = False, False getfirstchar = False getascii = False removeallexceptcertainchar = False readfile = False comment = False multilinecomment = False takeagrument = False definebutvar = False getfilesandfolders = False # check if dct is &quot;@&quot; change the data if variable == &quot;@&quot;: RESET = True if RESET: RESET = False data = dct[&quot;@&quot;] iteration = 0 continue break try: print(dct[&quot;#&quot;], end = &quot;&quot;) except: pass </code></pre> <p>This is a programming language interpreter. I will show wiki.</p> <h2>Commands:</h2> <p>(a, b, c, d means variables next command)</p> <p>&quot;@&quot; goto first char</p> <p>&quot;H&quot; halt (must be uppercase, not lowercase)</p> <p>&quot;&gt;&quot; define var Syntax: <code>&gt;~Hello&quot;</code> Escape is backslash (the quote is optional)</p> <p>&quot;*&quot; print the next char variable</p> <p>&quot;$&quot; a = b.replace(c, d)</p> <p>&quot;&amp;&quot; Input the next char variable (&quot;E&quot; var is 1 if EOF)</p> <p>&quot;+&quot; a = b.join(c)</p> <p>&quot;/&quot; a = b.reverse()</p> <p>&quot;?&quot; a = b.getfirstchar()</p> <p>&quot;.&quot; a = chr(b)</p> <p>&quot;!&quot; a = a but non-b chars removed</p> <p>&quot;;&quot; a = readfile(b) (&quot;E&quot; = 1 if the file doesn't exist)</p> <p>&quot;:&quot; comment</p> <p>&quot;{&quot; start multiline comment</p> <p>&quot;}&quot; end multiline comment</p> <p>&quot;|&quot; a = takearg(int(b))</p> <p>&quot;=&quot; a = b</p> <p>&quot;%&quot; a = str(getfilesandfolders(b))</p> <p>&quot;_&quot; halt if EOF</p> <h2>Variables:</h2> <p>&quot;@&quot; if the variable is edited, the program changes</p> <p>&quot;#&quot; print when program ends.</p> <p>&quot;E&quot; EOF Var</p> <br> <h1>Examples:</h1> <pre><code>&gt;#Hello, World! </code></pre> <p>Hello, World!</p> <pre><code>@ </code></pre> <p>Infinite loop</p> <pre><code>&amp;#*# </code></pre> <p>read a line and output without newline twice</p> <pre><code>&gt;HHello, World!&quot; </code></pre> <p>NOP</p> <pre><code>&gt;H\&quot;&quot;*H </code></pre> <p>print double quotes</p> <br> <p>Can you find bugs?</p>

270310

<p>I've been trying to implement a simple Boost PMR allocator that has a fixed amount of memory. My first implementation (which can be found <a href="https://github.com/irods/irods/blob/master/lib/core/include/fixed_buffer_resource.hpp" rel="nofollow noreferrer">here</a>) had undefined behavior and did not handle memory alignment.</p> <p>I've been doing a lot of reading around these topics and while I'm still unclear about some of it, I believe the code posted below is closer to a real solution.</p> <p>It would be very helpful if someone could review the code below for the following:</p> <ul> <li>undefined behavior</li> <li>proper handling of memory alignment</li> <li>obvious performance enhancements</li> </ul> <p>Also, is it possible to calculate how many bytes are needed to align a buffer? See <strong>TODO</strong> comment in <code>allocate_block()</code>. What I have there now is the following, but it feels wrong.</p> <pre class="lang-cpp prettyprint-override"><code>const auto max_space_needed = sizeof(header) + sizeof(void*) + _bytes + _alignment; </code></pre> <p>For the most part, the implementation appears to work, but I want to make sure I've covered as many things as possible since this will be included in the next release of the software I work on.</p> <pre class="lang-cpp prettyprint-override"><code>#ifndef IRODS_FIXED_BUFFER_RESOURCE_HPP #define IRODS_FIXED_BUFFER_RESOURCE_HPP /// \file #include &lt;boost/container/pmr/memory_resource.hpp&gt; #include &lt;fmt/format.h&gt; #include &lt;cassert&gt; #include &lt;cstddef&gt; #include &lt;memory&gt; #include &lt;ostream&gt; #include &lt;stdexcept&gt; #include &lt;tuple&gt; #include &lt;type_traits&gt; /// A namespace containing components meant to be used with Boost.Container's PMR library. namespace irods::experimental::pmr { /// A \p fixed_buffer_resource is a special purpose memory resource class template that /// allocates memory from the buffer given on construction. It allows applications to /// enforce a cap on the amount of memory available to components. /// /// This class implements a first-fit scheme and is NOT thread-safe. /// /// \tparam ByteRep The memory representation for the underlying buffer. Must be \p char /// or \p std::byte. /// /// \since 4.2.11 template &lt;typename ByteRep&gt; class fixed_buffer_resource : public boost::container::pmr::memory_resource { public: static_assert(std::is_same_v&lt;ByteRep, char&gt; || std::is_same_v&lt;ByteRep, unsigned char&gt; || std::is_same_v&lt;ByteRep, std::uint8_t&gt; || std::is_same_v&lt;ByteRep, std::byte&gt;); /// Constructs a \p fixed_buffer_resource using the given buffer as the allocation /// source. /// /// \param[in] _buffer The buffer that will be used for allocations. /// \param[in] _buffer_size The size of the buffer in bytes. /// /// \throws std::invalid_argument If any of the incoming constructor arguments do not /// satisfy construction requirements. /// /// \since 4.2.11 fixed_buffer_resource(ByteRep* _buffer, std::int64_t _buffer_size) : boost::container::pmr::memory_resource{} , buffer_{_buffer} , buffer_size_(_buffer_size) , allocated_{} , headers_{} { if (!_buffer || _buffer_size &lt;= 0) { const auto* msg_fmt = &quot;fixed_buffer_resource: invalid constructor arguments &quot; &quot;[buffer={}, size={}].&quot;; const auto msg = fmt::format(msg_fmt, fmt::ptr(_buffer), _buffer_size); throw std::invalid_argument{msg_fmt}; } std::size_t space_left = buffer_size_; // Make sure the buffer is aligned for the header type. if (!std::align(alignof(header), sizeof(header), buffer_, space_left)) { throw std::runtime_error{&quot;fixed_buffer_resource: internal memory alignment error. &quot;}; } headers_ = new (buffer_) header; headers_-&gt;size = space_left - sizeof(header); headers_-&gt;prev = nullptr; headers_-&gt;next = nullptr; headers_-&gt;used = false; } // fixed_buffer_resource fixed_buffer_resource(const fixed_buffer_resource&amp;) = delete; auto operator=(const fixed_buffer_resource&amp;) -&gt; fixed_buffer_resource&amp; = delete; ~fixed_buffer_resource() = default; /// Returns the number of bytes used by the client. /// /// The value returned does not include memory used for tracking allocations. /// /// \return An unsigned integral type. /// /// \since 4.2.11 auto allocated() const noexcept -&gt; std::size_t { return allocated_; } // allocated /// Returns the number of bytes used for tracking allocations. /// /// \return An unsigned integral type. /// /// \since 4.2.11 auto allocation_overhead() const noexcept -&gt; std::size_t { return 0; } // allocation_overhead /// Writes the state of the allocation table to the output stream. /// /// \since 4.2.11 auto print(std::ostream&amp; _os) const -&gt; void { std::size_t i = 0; for (auto* h = headers_; h; h = h-&gt;next) { _os &lt;&lt; fmt::format(&quot;{:&gt;3}. Header Info [{}]: {{previous={:14}, next={:14}, used={:&gt;5}, data={:14}, data_size={}}}\n&quot;, i, fmt::ptr(h), fmt::ptr(h-&gt;prev), fmt::ptr(h-&gt;next), h-&gt;used, fmt::ptr(address_of_data_segment(h)), h-&gt;size); ++i; } } // print protected: auto do_allocate(std::size_t _bytes, std::size_t _alignment) -&gt; void* override { for (auto* h = headers_; h; h = h-&gt;next) { if (auto* p = allocate_block(_bytes, _alignment, h); p) { return p; } } throw std::bad_alloc{}; } // do_allocate auto do_deallocate(void* _p, std::size_t _bytes, std::size_t _alignment) -&gt; void override { void* data = *(static_cast&lt;void**&gt;(_p) - 1); auto* h = reinterpret_cast&lt;header*&gt;(static_cast&lt;ByteRep*&gt;(data) - sizeof(header)); assert(h != nullptr); assert(h-&gt;size == _bytes); h-&gt;used = false; coalesce_with_next_unused_block(h); coalesce_with_next_unused_block(h-&gt;prev); allocated_ -= _bytes; } // do_deallocate auto do_is_equal(const boost::container::pmr::memory_resource&amp; _other) const noexcept -&gt; bool override { return this == &amp;_other; } // do_is_equal private: // Header associated with an allocation within the underlying memory buffer. // All data segments will be preceded by a header. // // Memory Layout: // // +------------------------------------------------------------------+ // | padding | header | data segment | // +------------------+-----------------------------------------------+ // | padding | unaligned pointer | aligned pointer | // +-----------------------------------------------+ // struct header { std::size_t size; // Size of the memory block (excluding all management info). header* prev; // Pointer to the previous header block. header* next; // Pointer to the next header block. bool used; // Indicates whether the memory is in use. }; // struct header auto address_of_data_segment(header* _h) const noexcept -&gt; ByteRep* { return reinterpret_cast&lt;ByteRep*&gt;(_h) + sizeof(header); } // address_of_data_segment auto aligned_alloc(std::size_t _bytes, std::size_t _alignment, header* _h) -&gt; std::tuple&lt;void*, std::size_t&gt; { // The unused memory is located right after the header. void* data = address_of_data_segment(_h); auto space_left = _h-&gt;size - sizeof(void*); // Reserve space for the potentially unaligned pointer. void* aligned_data = static_cast&lt;ByteRep*&gt;(data) + sizeof(void*); if (!std::align(_alignment, _bytes, aligned_data, space_left)) { return {nullptr, 0}; } // Store the address of the original allocation directly before the // aligned memory. new (static_cast&lt;ByteRep*&gt;(aligned_data) - sizeof(void*)) void*{data}; return {aligned_data, space_left}; } // aligned_alloc auto allocate_block(std::size_t _bytes, std::size_t _alignment, header* _h) -&gt; void* { if (_h-&gt;used) { return nullptr; } // Return the block if it matches the requested number of bytes. if (_bytes == _h-&gt;size) { if (auto* aligned_data = std::get&lt;void*&gt;(aligned_alloc(_bytes, _alignment, _h)); aligned_data) { _h-&gt;used = true; allocated_ += _bytes; return aligned_data; } } // TODO Is it possible to compute the amount of memory needed to satisfy // the allocation and alignment requirements? I'm not sure if this line // is correct. const auto max_space_needed = sizeof(header) + sizeof(void*) + _bytes + _alignment; // Split the data segment managed by this header if it is large enough // to satisfy the allocation request and management information. if (max_space_needed &lt; _h-&gt;size) { auto [aligned_data, space_left] = aligned_alloc(_bytes, _alignment, _h); if (!aligned_data) { return nullptr; } void* aligned_header_storage = static_cast&lt;ByteRep*&gt;(aligned_data) + _bytes; if (!std::align(alignof(header), sizeof(header), aligned_header_storage, space_left)) { return nullptr; } // Construct a new header after the memory managed by &quot;_h&quot;. // The new header manages unused memory. auto* new_header = new (aligned_header_storage) header; new_header-&gt;size = space_left - _bytes - sizeof(header); new_header-&gt;prev = _h; new_header-&gt;next = _h-&gt;next; new_header-&gt;used = false; // Update the allocation table links for the header just after the // newly added header. if (auto* next_header = _h-&gt;next; next_header) { next_header-&gt;prev = new_header; } // Adjust the current header's size and mark it as used. _h-&gt;size = _bytes; _h-&gt;next = new_header; _h-&gt;used = true; allocated_ += _bytes; return aligned_data; } return nullptr; } // allocate_block auto coalesce_with_next_unused_block(header* _h) -&gt; void { if (!_h || _h-&gt;used) { return; } auto* header_to_remove = _h-&gt;next; // Coalesce the memory blocks if they are not in use by the client. // This means that &quot;_h&quot; will absorb the header at &quot;_h-&gt;next&quot;. if (header_to_remove &amp;&amp; !header_to_remove-&gt;used) { // TODO This does not consider the header's size. // How should I handle this? _h-&gt;size += header_to_remove-&gt;size; _h-&gt;next = header_to_remove-&gt;next; // Make sure the links between the headers are updated appropriately. // (i.e. &quot;_h&quot; and &quot;header_to_remove-&gt;next&quot; need their links updated). if (auto* new_next_header = header_to_remove-&gt;next; new_next_header) { new_next_header-&gt;prev = _h; } } } // coalesce_with_next_unused_block void* buffer_; std::size_t buffer_size_; std::size_t allocated_; header* headers_; }; // fixed_buffer_resource } // namespace irods::experimental::pmr #endif // IRODS_FIXED_BUFFER_RESOURCE_HPP </code></pre>

270311

<p>I created a method to return a copy of <code>List&lt;T&gt;</code>, basically I convert the <code>List&lt;T&gt;</code> into an array <code>T[]</code>, then perform the copy with the <code>arrayCopy(T[])</code> method and back convert again in <code>List&lt;T&gt;</code>.</p> <p>I want to know if the code will be run successfully in different scenarios and it is good in performance or is there a way to do it better.</p> <pre><code>public static &lt;T&gt; List&lt;T&gt; getCopyOfList(List&lt;T&gt; list) { return Arrays.asList((T[]) arrayCopy(list.toArray())); } public static &lt;T&gt; T[] arrayCopy(final T[] original) { return Arrays.copyOf(original, original.length); } </code></pre>

270312

<p>I am working with Raspberry Pi and I made this little Python script that plays sound while you hold down a button and it keeps repeating while you hold it. and no matter when you stopped holding button, the next time you press it it should start from beginning.</p> <p>This code works, but I fear it is slowly leaking memory, memory usage is slowly increasing while program runs, it's intended to run continuously so it could become problem after few weeks/months. Is there anything I could do to improve this script?</p> <pre><code>import digitalio import time import board from mpg123 import Mpg123, Out123 button1 = digitalio.DigitalInOut(board.D17) button1.direction = digitalio.Direction.INPUT button1.pull = digitalio.Pull.UP filepath=str('/home/pi/test/Sound001.mp3') mp3 = Mpg123(filepath) out = Out123() while True: if button1.value: del mp3 mp3 = Mpg123(filepath) for frame in mp3.iter_frames(out.start): if not button1.value: break out.play(frame) time.sleep(2) time.sleep(0.5) </code></pre>

270318

<p>I have a collection which, after the code has ran, looks something like the following:</p> <pre><code>[ { title: 'alpha', lines: [ { *some object* } ] }, { title: 'bravo', lines: [ { *some object* } ] }, { title: 'charl', lines: [ { *some object* } ] }, { title: 'delta', lines: [ { *some object*, *some object 2*, *some object 3* } ] m}, { title: 'echoo', lines: [ { *some object* } ] }, ] </code></pre> <p>The way that I'm doing this is:</p> <ol> <li>Check if there is an object in the outer array that has a matching <code>title</code> <ul> <li>If it doesn't exist, create that object with the <code>title</code> and <code>lines</code></li> </ul> </li> <li>Check if inside <code>lines</code> there is an object that exists at the specific supplied index <ul> <li>If it doesn't exist, create the object at that index</li> <li>Otherwise take the existing object at that index and append <code>val</code> to <code>a_or_b</code></li> </ul> </li> </ol> <p>This method will get called multiple times per group i.e. 4 times for <code>alpha</code>, 4 times for <code>bravo</code>, and 4 times for each line in <code>delta</code>. There is currently one group (but there may be more in the future) which has more than one object inside the <code>lines</code>.</p> <pre><code>def data_with(data, val, group, date, nom, a_or_b, line_no = 0) # add this group if it doesn't exist if data.find { |x| x[:title] == group }.nil? data &lt;&lt; { title: group, lines: [] } end # if the line at the line_no doesn't exist, create it if data.find { |x| x[:title] == group }[:lines][line_no].nil? data.find { |x| x[:title] == group }[:lines][line_no] = { date: date, nom: nom, a_or_b.to_sym =&gt; val } else # add to the value of the line at the line_no index data.find { |x| x[:title] == group }[:lines][line_no][a_or_b.to_sym] += val end end </code></pre> <p>What are some ways I can improve this method?</p>

270322

<p>I need to write a function to count numbers of nests in an iterable. I reached my goal but wondering if there's any more neat/faster solution (maybe even a library or so?). Besides I'm afraid that my code is error prone.</p> <p>Let's analyze two examples:</p> <pre class="lang-py prettyprint-override"><code>dct_test = { &quot;a&quot;: {1: 2, 2: 3, 3: 4}, &quot;b&quot;: {&quot;x&quot;: &quot;y&quot;, &quot;z&quot;: [1, 2, 3, {7, 8}]}, &quot;c&quot;: {&quot;l&quot;: (2, 3, 5), &quot;j&quot;: {&quot;a&quot;: {&quot;k&quot;: 1, &quot;l&quot;: [1, 3, (2, 7, {&quot;x&quot;: 1})]}}}, &quot;d&quot;: [1, (2, 3)] } tpl_test = (1, [3, 4, {5, 6, 7}], {&quot;a&quot;: 5, &quot;b&quot;: [9, 8]}) </code></pre> <p>This is a visualization of what I'm trying to achieve: <a href="https://i.stack.imgur.com/sIfDZ.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/sIfDZ.png" alt="Algorithm" /></a></p> <p>Code:</p> <pre class="lang-py prettyprint-override"><code>from collections.abc import Iterable from itertools import chain # EXAMPLES dct_test = { &quot;a&quot;: {1: 2, 2: 3, 3: 4}, &quot;b&quot;: {&quot;x&quot;: &quot;y&quot;, &quot;z&quot;: [1, 2, 3, {7, 8}]}, &quot;c&quot;: {&quot;l&quot;: (2, 3, 5), &quot;j&quot;: {&quot;a&quot;: {&quot;k&quot;: 1, &quot;l&quot;: [1, 3, (2, 7, {&quot;x&quot;: 1})]}}}, &quot;d&quot;: [1, (2, 3)] } tpl_test = (1, [3, 4, {5, 6, 7}], {&quot;a&quot;: 5, &quot;b&quot;: [9, 8]}) # FUNCTIONS # checking if an argument is a 'real' iterable (list, tuple, set, dictionary) def IsRealIterable( iter: Iterable ): return True if isinstance(iter, Iterable) and not isinstance(iter, str) else False # converting an iterable to a list def ConvertIterableToList( iter: Iterable, dct_keys=False, # False returns dict.values(), True returns dict.keys() ): if IsRealIterable(iter): if isinstance(iter, tuple) or isinstance(iter, set): return list(iter) elif isinstance(iter, dict): return list(iter.keys()) if dct_keys else list(iter.values()) elif isinstance(iter, list): return iter else: raise TypeError(&quot;Given argument is not a list, tuple, set or dictionary&quot;) # returns a list of iterables extracted from an iterable def ExtractFromIterable( iter: Iterable ): if IsRealIterable(iter): return [i for i in ConvertIterableToList(iter) if IsRealIterable(i)] else: raise TypeError(&quot;Given argument is not a list, tuple, set or dictionary&quot;) # returns number of levels in an iterable def CountNestingLevels( iter: Iterable, cntr: int=0, only_sublevels: bool=True # if False then returns number of all nesting levels - not only a number of nests ): lst_to_inspect = ExtractFromIterable(iter) lst_deep = [] # empty list for nested iterables # analyzing structure # if lst_to_inspect is empty then returns already counted number of levels if not lst_to_inspect: return cntr if only_sublevels else cntr + 1 else: cntr += 1 for i in lst_to_inspect: # temporary list for iterables from each element in lst_to_inspect temp_list = ExtractFromIterable(i) # elements (only non-empty) should be added to lst_deep because otherwise ExtractFromIterable() would overwrite existing values lst_deep.append(temp_list) if temp_list else None # flattening lst_deep. it contains lists returned by ExtractFromIterable so lst_deep has structure: [[[], [], ...]] lst_deep = list(chain.from_iterable(lst_deep)) # using ExtractFromIterable in lst_deep may return the same structure as lst_to_inspect # if no - use recursion to analyze remaining elements again # if yes - finish analyzing if lst_deep != lst_to_inspect: return CountNestingLevels(lst_deep, cntr) else: return cntr if only_sublevels else cntr + 1 print(CountNestingLevels(dct_test)) # returns 6 print(CountNestingLevels(tpl_test)) # returns 2 </code></pre> <p>Do you have any tips how to improve this code?</p>

270323

<p>I have the following function that returns StaffQualifications where either the qualification is expiring or the qualification type is expiring, but this section doesn't seem to sit well with me as it splits up the SQL string... Should this be two separate functions perhaps even though 95% of the query is the same?</p> <pre><code> if ($qualification instanceof Qualification) { $sql .= &quot;AND q.id = :qualificationId &quot;; } elseif ($qualificationType instanceof QualificationType) { $sql .= &quot;AND q.qualification_type_id = :qualificationTypeId &quot;; } </code></pre> <p>The above doesn't quite feel right, but not sure how to better it.</p> <pre><code>/** * @return StaffQualification[] */ public function getStaffQualificationsExpiringOnQualificationOrQualificationType(?Qualification $qualification, ?QualificationType $qualificationType): array { if ($qualification === null &amp;&amp; $qualificationType === null) { throw new \Exception('Qualification or QualificationType must not be null'); } if ($qualification instanceof Qualification &amp;&amp; $qualificationType instanceof QualificationType) { throw new \Exception('Only one of Qualification or QualificationType can be present'); } $sql = &quot; SELECT * FROM staff_qualification AS sq &quot;; // Complicated SQL ensues that I've omitted from this SE question... if ($qualification instanceof Qualification) { $sql .= &quot;AND q.id = :qualificationId &quot;; } elseif ($qualificationType instanceof QualificationType) { $sql .= &quot;AND q.qualification_type_id = :qualificationTypeId &quot;; } $sql .= &quot; GROUP BY sq.id ORDER BY sq.end_date ; &quot;; $rsm = new ResultSetMapping(); $rsm-&gt;addEntityResult(StaffQualification::class, 'sq'); $rsm-&gt;addJoinedEntityResult(Staff::class, 's', 'sq', 'staff'); $rsm-&gt;addFieldResult('sq', 'id', 'id'); $rsm-&gt;addFieldResult('s', 'staff_id', 'id'); $query = $this-&gt;getEntityManager()-&gt;createNativeQuery($sql, $rsm); if ($qualification instanceof Qualification) { $query-&gt;setParameter('qualificationId', $qualification-&gt;getId()); } elseif ($qualificationType instanceof QualificationType) { $query-&gt;setParameter('qualificationTypeId', $qualificationType-&gt;getId()); } $result = $query-&gt;getResult(); return $result; } </code></pre>

270325

<p><strong>Let's suppose I have 2 <code>repositories</code>:</strong></p> <ul> <li>first is responsible for creating job and return <code>jobId</code></li> <li>second is responsible for creating log and take <code>jobId</code> as argument</li> </ul> <p><strong>My goal is to:</strong></p> <ul> <li>save <code>Job</code> and <code>Log</code> simultaneously</li> <li>prevent situation when in case of error only <code>Job</code> would be saved without <code>Log</code></li> </ul> <h3>What is the most recommended way to get desired result?</h3> <p>I prepared 3 cases which came to my mind but if you see better alternative please share it.</p> <ul> <li><strong>option 1 (getting result and save changes in controller)</strong></li> </ul> <pre class="lang-cs prettyprint-override"><code>public class JobRepository : IJobRepository { private readonly Context _context; public JobRepository(Context context) { _context = context; } public Guid CreateJob() { var job = new Job { Id = Guid.NewGuid() }; _context.Jobs.Add(job); return job.Id; } } // ... public class LogRepository : ILogRepository { private readonly Context _context; public LogRepository(Context context) { _context = context; } public void CreateLog(Guid id) { var log = new Log { Jobid = id }; _context.Logs.Add(log); } } // ... public class JobsController : Controller { private readonly Context _context; private readonly IJobRepository _jobRepository; private readonly ILogRepository _logRepository; public JobsController(Context context, JobRepository jobRepository, ILogRepository logRepository) { _context = context; _jobRepository = jobRepository; _logRepository = logRepository } [HttpGet] public IActionResult Create() { return View(); } [HttpPost] public IActionResult Create() { var id = _jobRepository.CreateJob(); _logRepository.CreateLog(id); _context.SaveChanges(); return RedirectToAction(&quot;Index&quot;); } } </code></pre> <ul> <li><strong>option 2 (inject one repository into another)</strong></li> </ul> <pre class="lang-cs prettyprint-override"><code>public class JobRepository : IJobRepository { private readonly Context _context; private readonly ILogRepository _logRepository; public JobRepository(Context context, ILogRepository logRepository) { _context = context; } public void CreateJob() { var job = new Job { Id = Guid.NewGuid() }; _context.Jobs.Add(job); _logRepository.CreateLog(job.Id); _context.SaveChanges(); } } // ... public class LogRepository : ILogRepository { private readonly Context _context; public LogRepository(Context context) { _context = context; } public void CreateLog(Guid id) { var log = new Log { Jobid = id }; _context.Logs.Add(log); } } // ... public class JobsController : Controller { private readonly IJobRepository _jobRepository; public JobsController(JobRepository jobRepository) { _jobRepository = jobRepository; } [HttpGet] public IActionResult Create() { return View(); } [HttpPost] public IActionResult Create() { _jobRepository.CreateJob(); return RedirectToAction(&quot;Index&quot;); } } </code></pre> <ul> <li><strong>option 3 (do not use context in controller but declare <code>Save</code> method in each repo)</strong></li> </ul> <pre class="lang-cs prettyprint-override"><code>public class JobRepository : IJobRepository { private readonly Context _context; public JobRepository(Context context) { _context = context; } public Guid CreateJob() { var job = new Job { Id = Guid.NewGuid() }; _context.Jobs.Add(job); return job.Id; } public void Save() { _context.SaveChanges(); } } // ... public class LogRepository : ILogRepository { private readonly Context _context; public LogRepository(Context context) { _context = context; } public void CreateLog(Guid id) { var log = new Log { Jobid = id }; _context.Logs.Add(log); } public void Save() { _context.SaveChanges(); } } // ... public class JobsController : Controller { private readonly IJobRepository _jobRepository; private readonly ILogRepository _logRepository; public JobsController(JobRepository jobRepository, ILogRepository logRepository) { _jobRepository = jobRepository; _logRepository = logRepository } [HttpGet] public IActionResult Create() { return View(); } [HttpPost] public IActionResult Create() { var id = _jobRepository.CreateJob(); _logRepository.CreateLog(id); return RedirectToAction(&quot;Index&quot;); } } <span class="math-container">```</span> </code></pre>

270329

<p>I wrote this script partly as an exercise in learning Bash and partly because I needed a tool to find specific versions of library files and copy them to a particular device.</p> <p>The script takes parameters that control its operation. First, it searches for the file specified by the user. Then it displays the search results, allowing the user to pick one of the files found, and (assuming a file was selected) copying it to the specified destination/path.</p> <p>I would most like feedback on whether the script could be written more clearly or perhaps whether there are better ways to approach its tasks.</p> <pre><code>#!/bin/bash # libr.sh (librarian): find the file you need, and put it where you want. #-------------------------process parameters if [ $# -eq 0 ] || [ $# -gt 3 ] then echo &quot;Usage: libr &lt;FILENAME&gt; [DESTINATION] [IP]&quot; echo &quot;The librarian will find FILENAME in the current directory or below&quot; echo &quot;and will then copy it to the DESTINATION path on the unit at IP.&quot; echo &quot;If multiple files are found, the user may choose which to copy.&quot; exit fi FILE=$1 DEST=${2:-/usr/lib/} IP=${3:-160.48.199.99} #-------------------------find the file FULLRESULTS=$(find -name $FILE 2&gt; /dev/null) echo &quot;File \&quot;$FILE\&quot; was found in the following directories:&quot; if [ -z &quot;$FULLRESULTS&quot; ] then echo &quot; None!&quot; exit fi # `find` returns the path plus filename for each file found # but we just want the directories, for ease of reading RESULTS=$(dirname $FULLRESULTS) #-------------------------display results and get the source path PS3=&quot;Which one do you want to copy ? &quot; select SRCPATH in $RESULTS do if [ ! -z &quot;$SRCPATH&quot; ] then #-----------------copy the file CMD=&quot;scp $SRCPATH/$FILE root@$IP:$DEST&quot; echo &quot;Executing: $CMD&quot; $CMD fi # we don't actually want to loop break done </code></pre>

270331

<p>I'm using (non-boost) Asio 1.18.1 and C++17. Forgive the boost tag, there wasn't a more specific one.</p> <p>I have a <code>async_connect_with_retry</code> composed asynchronous operation:</p> <pre class="lang-cpp prettyprint-override"><code>/// Calls resolver.async_resolve(...), async_connect(socket, ...), and (on /// failure) timer.async_wait(...) to start over. template &lt;typename Timer, typename Token&gt; auto async_connect_with_retry(Timer&amp; timer, asio::ip::tcp::socket&amp; socket, asio::ip::tcp::resolver&amp; resolver, std::string_view host, std::string_view service, typename Timer::duration retry_delay, Token token); </code></pre> <p>I'm struggling to turn this into a reusable and extensible <code>reconnecting_socket</code> TCP client socket class (or possibly another composed op, if its more ergonomic). This is useful for connecting to embedded systems, for instance.</p> <p>My main focus is ease of use for the person extending the class, especially for new-to-Asio users.</p> <p>I am not interested in making everything generic yet (e.g. it's fine that I use <code>ip::tcp::socket</code> and not <code>basic_socket&lt;Protocol, Executor&gt;</code>). That can come later.</p> <p>Feedback on the <code>async_</code> methods is welcome, but I'm mostly interested in <code>reconnecting_socket.h</code>.</p> <p>The biggest unsolved problems:</p> <ol> <li>How do I give the user a customization point in the <code>reconnecting_socket::handle_connect</code> method? The user could start an <code>async_read</code> loop, and maybe a <code>async_write</code> heartbeat loop. <ul> <li>Extending the class (and making <code>socket_</code> <code>protected</code>) makes using <code>shared_from_this()</code> to extend the object's lifetime <a href="https://stackoverflow.com/questions/657155/how-to-enable-shared-from-this-of-both-parent-and-derived">tricky to get right</a>.</li> <li>Providing a callback has the same lifetime issues, and now we need a getter for <code>socket_</code> if they want to write anything.</li> </ul> </li> <li>How does the &quot;reconnect&quot; get triggered? The user could call <code>close()</code> if they get an error, but then if they have a write loop and a read loop, and both fail, they'll probably call <code>close()</code> twice, which would cause problems (two <code>start_connect</code> calls, multiple closes, etc.). Plus with this scheme the user has to remember to call <code>close()</code>. Maybe that's an OK tradeoff, though.</li> </ol> <p><strong>reconnecting_socket.h</strong></p> <pre class="lang-cpp prettyprint-override"><code>#pragma once #include &lt;iostream&gt; #include &quot;asio.hpp&quot; #include &quot;async_connect_with_retry.h&quot; class reconnecting_socket : public std::enable_shared_from_this&lt;reconnecting_socket&gt; { public: using ptr = std::shared_ptr&lt;reconnecting_socket&gt;; using tcp = asio::ip::tcp; using timer = asio::high_resolution_timer; reconnecting_socket(asio::io_context&amp; io_context, timer::duration retry_delay) : io_context_(io_context), socket_(io_context_), resolver_(io_context_), reconnect_timer_(io_context_), retry_delay_(retry_delay) {} void start(std::string_view host, std::string_view service) { assert(!started_); started_ = true; std::cout &lt;&lt; &quot;starting\n&quot;; host_ = host; service_ = service; start_connect(); } void stop() { end_ = true; close(false); } private: bool started_ = false; bool end_ = false; asio::io_context&amp; io_context_; tcp::socket socket_; tcp::resolver resolver_; timer reconnect_timer_; timer::duration retry_delay_; std::string_view host_; std::string_view service_; void close(bool reconnect = true) { asio::post(io_context_, [self = shared_from_this(), reconnect] { std::error_code ignored; self-&gt;socket_.shutdown(tcp::socket::shutdown_both, ignored); self-&gt;socket_.close(ignored); if (reconnect) self-&gt;start_connect(); }); } void start_connect() { if (end_) return; async_connect_with_retry( reconnect_timer_, socket_, resolver_, host_, service_, retry_delay_, [self = shared_from_this()](std::error_code error, auto endpoint) { self-&gt;handle_connect(error, endpoint); }); } void handle_connect(std::error_code error, tcp::endpoint endpoint) { if (!error) { std::cout &lt;&lt; &quot;connected to &quot; &lt;&lt; endpoint &lt;&lt; &quot;\n&quot;; // @todo how does the user customize this connection? } } }; </code></pre> <p><strong>async_connect_with_retry.h</strong></p> <pre class="lang-cpp prettyprint-override"><code>#pragma once #include &quot;asio.hpp&quot; // @todo include what you use #include &quot;async_connect_to.h&quot; namespace detail { template &lt;typename Timer&gt; struct async_connect_with_retry_to_impl { Timer&amp; timer_; asio::ip::tcp::socket&amp; socket_; asio::ip::tcp::resolver&amp; resolver_; std::string_view host_; std::string_view service_; typename Timer::duration retry_delay_; // overload: starting template &lt;typename Self&gt; void operator()(Self&amp; self) { async_connect_to(socket_, resolver_, host_, service_, std::move(self)); } // overload: async_connect_to handler template &lt;typename Self&gt; void operator()(Self&amp; self, std::error_code error, asio::ip::tcp::endpoint endpoint) { if (error) { timer_.expires_after(retry_delay_); timer_.async_wait(std::move(self)); } else { self.complete(error, endpoint); } } // overload: async_wait handler template &lt;typename Self&gt; void operator()(Self&amp; self, std::error_code error) { if (error) { self.complete(error, {}); } else { async_connect_to(socket_, resolver_, host_, service_, std::move(self)); } } }; } // namespace detail /// Calls resolver.async_resolve(...), async_connect(socket, ...), and (on /// failure) timer.async_wait(...) to start over. template &lt;typename Timer, typename Token&gt; auto async_connect_with_retry(Timer&amp; timer, asio::ip::tcp::socket&amp; socket, asio::ip::tcp::resolver&amp; resolver, std::string_view host, std::string_view service, typename Timer::duration retry_delay, Token token) { return asio::async_compose&lt;Token, void(std::error_code, asio::ip::tcp::endpoint)&gt;( detail::async_connect_with_retry_to_impl&lt;Timer&gt;{ timer, socket, resolver, host, service, retry_delay}, token); } </code></pre> <p><strong>async_connect_to.h</strong></p> <pre class="lang-cpp prettyprint-override"><code>#pragma once #include &quot;asio.hpp&quot; // @todo include what you use namespace detail { struct async_connect_to_impl { asio::ip::tcp::socket&amp; socket_; asio::ip::tcp::resolver&amp; resolver_; std::string_view host_; std::string_view service_; // overload: starting template &lt;typename Self&gt; void operator()(Self&amp; self) { resolver_.async_resolve(host_, service_, std::move(self)); } // overload: async_resolve handler template &lt;typename Self&gt; void operator()(Self&amp; self, std::error_code error, asio::ip::tcp::resolver::results_type results) { if (error) { self.complete(error, {}); } else { asio::async_connect(socket_, results, std::move(self)); } } // overload: async_connect handler template &lt;typename Self&gt; void operator()(Self&amp; self, std::error_code error, asio::ip::tcp::endpoint endpoint) { self.complete(error, std::move(endpoint)); } }; } // namespace detail /// Connect to a given address and port. Will resolve URIs. template &lt;typename Token&gt; auto async_connect_to(asio::ip::tcp::socket&amp; socket, asio::ip::tcp::resolver&amp; resolver, std::string_view host, std::string_view service, Token&amp;&amp; token) { return asio::async_compose&lt;Token, void(std::error_code, asio::ip::tcp::endpoint)&gt;( detail::async_connect_to_impl{socket, resolver, host, service}, token); } </code></pre>

270333

<p>I'm trying to implement sum of 2 array using multi threading.</p> <p>I expected that when I use more threads it will be faster than when I use one thread, but that isn't the case.</p> <pre><code>public static int[] a = new int[100]; public static int[] b = new int[100]; public static int[] c = new int[a.Length]; public static int numberofthreads; static void Main(string[] args) { Random r = new Random(); for (int i = 0; i &lt; 100; i++) { a[i] = r.Next(5, 20); b[i] = r.Next(10, 30); } Console.WriteLine(&quot;Enter the Number of threads to use: &quot;); numberofthreads = int.Parse(Console.ReadLine()); var watch = new System.Diagnostics.Stopwatch(); watch.Start(); Thread[] threadsarray = new Thread[numberofthreads]; List&lt;Thread&gt; threads = new List&lt;Thread&gt;(); for (int i = 0; i &lt; numberofthreads; i++) { threadsarray[i] = new Thread(new ParameterizedThreadStart(myThreadMethod)); threadsarray[i].Start(i); // threadsarray[i].Join(); } watch.Stop(); Console.WriteLine(&quot;The First Array : &quot;); Console.WriteLine(string.Join(&quot;,&quot;, a)); Console.WriteLine(&quot;The Secound Array : &quot;); Console.WriteLine(string.Join(&quot;,&quot;, b)); Console.WriteLine(&quot;The Result Array : &quot;); Console.WriteLine(string.Join(&quot;,&quot;, c)); Console.WriteLine(&quot; &quot;); Console.WriteLine(watch.ElapsedMilliseconds.ToString()); } static void myThreadMethod(object threadid) { lock (threadid) { int start = a.Length; int thid = (int)threadid; for (int i = thid * a.Length / numberofthreads; i &lt; (thid + 1) * a.Length / numberofthreads; i++) { c[i] = a[i] + b[i]; } } } </code></pre>

270338

<p>I want to edit Windows <strong>hosts</strong> file in the best way for the end user, using a batch-only solution. I ended up with this script, which works fine, but since I don't have enough knowledge, the syntax is very poor. So please, may you take a look and tell me how to improve it, especially the <code>=999</code> part (for some reason I can't use there <code>=replaced</code>, and can't use <code>=0</code> as it breaks future iterations):</p> <pre><code>REM In short: REM FOR for every line of the hosts file REM FOR to check current line if it contains our hosts and replace if so REM FOR for our hosts if they not been replaced and thus shall be inserted at the end of the hosts file @echo off setlocal enabledelayedexpansion set hostspath=%SystemRoot%\System32\drivers\etc\hosts set hosts[0]=first.host.com set hosts[1]=second.host.com set ip=127.1.2.3 set hostslenght=0 :hostsLenght if defined hosts[%hostsLenght%] ( set /a &quot;hostslenght+=1&quot; GOTO :hostslenght ) &gt;&quot;%hostspath%.new&quot; ( set /a hostslenght-=1 for /f &quot;delims=: tokens=1*&quot; %%a in ('%SystemRoot%\System32\findstr.exe /n /r /c:&quot;.*&quot; &quot;%hostspath%&quot;') do ( set skipline= for /L %%h in (0,1,!hostslenght!) do ( echo %%b|find &quot;!hosts[%%h]!&quot; &gt;nul if not errorlevel 1 ( echo %ip% !hosts[%%h]! set /a hosts[%%h]=999 set skipline=true ) ) if not &quot;!skipline!&quot;==&quot;true&quot; (echo.%%b) ) for /L %%h in (0,1,!hostslenght!) do ( if not !hosts[%%h]!==999 ( echo %ip% !hosts[%%h]! ) ) ) REM move /y &quot;%hostspath%&quot; &quot;%hostspath%.bak&quot; &gt;nul || echo Can't backup %hostspath%. Try run the script as Administrator. REM move /y &quot;%hostspath%.new&quot; &quot;%hostspath%&quot; &gt;nul || echo Can't update %hostspath%. Try run the script as Administrator. endlocal echo The hosts file is updated. pause </code></pre> <p>It would be great to get rid of <code>set /a hostslenght-=1</code> (initially I wanted to decrement this in <code>for</code> loops, but it's wont decremented that way), and the last <code>for</code> as well.</p> <p><strong>Upd:</strong> Version 2. Horrible <code>=999</code> is defeated, but there is still problems with <code>hostslenght</code> (is there a way to not enumerate the hosts count?), and it will be nice to preserve original file's last line (<code>echo</code> is always leave empty line at the end, but I don't see a easy way to detect last <code>for</code> iteration)</p> <p>Before:</p> <pre><code>... set /a hosts[%%h]=999 ... if not !hosts[%%h]!==999 ( </code></pre> <p>After:</p> <pre><code>... set hosts[%%h]= ... if defined hosts[%%h] ( </code></pre>

270342

<p>I started learning classes and operator overloading in C++. To test my skills I decided to make a Fraction class with all necessary operations.</p> <p>I would appreciate improvements and suggesstions on my implementation.</p> <p>Here is the code -</p> <pre><code>#include &lt;iostream&gt; #include &lt;string&gt; #include &lt;stdexcept&gt; // throw std::invalid_argument // Function to find GCD(Greatest Common Divisor) of two numbers int gcd(int x, int y) { if (y == 0) return x; return gcd(y, x % y); } // Function to find LCM(Lowest Common Multiple) of two numbers int lcm(int x, int y) { return (x * y) / gcd(x, y); } // An immutable Fraction class class Fraction { private: int numerator; int denominator; public: // Constructor for improper fractions Fraction(int num, int deno=1) { if (deno == 0) { throw std::invalid_argument(&quot;Denominator can not be 0.&quot;); } int gcd_ = gcd(num, deno); num /= gcd_; deno /= gcd_; numerator = num; denominator = deno; if (denominator &lt; 0) { numerator *= -1; denominator *= -1; } } // Constructor for mixed fractions Fraction(int whole, int num, int deno) { if (deno == 0) { throw std::invalid_argument(&quot;Denominator can not be 0.&quot;); } int gcd_ = gcd(num, deno); num /= gcd_; deno /= gcd_; numerator = (whole * deno) + num; denominator = deno; } // Getter methods int get_numerator() {return numerator;} int get_denominator() {return denominator;} // Type casting methods operator int() {return numerator / denominator;} operator float() {return float(numerator) / denominator;} operator double() {return double(numerator) / denominator;} operator long() {return long(numerator) / denominator;} operator std::string() { std::string str_frac = std::to_string(numerator); if (denominator != 1) { str_frac += '/' + std::to_string(denominator); } return str_frac; } // Helps to print a fraction to the console friend std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, const Fraction&amp; frac) { os &lt;&lt; frac.numerator; if (frac.denominator != 1) { os &lt;&lt; '/' &lt;&lt; frac.denominator; } return os; } // Assingment operator Fraction operator=(Fraction frac2) { numerator = frac2.numerator; denominator = frac2.denominator; int gcd_ = gcd(numerator, denominator); numerator /= gcd_; denominator /= gcd_; } // Unary '-' operator, eg. -(1/2) Fraction operator-() { numerator *= -1; if (denominator &lt; 0) { numerator *= -1; denominator *= -1; } return *this; } // Binary operators - (+, -, *, /) Fraction operator+(Fraction frac2) { int lcm_ = lcm(denominator, frac2.denominator); return Fraction( (numerator * lcm_ / denominator) + (frac2.numerator * lcm_ / frac2.denominator), lcm_ ); } Fraction operator-(Fraction frac2) { int lcm_ = lcm(denominator, frac2.denominator); return Fraction( (numerator * lcm_ / denominator) - (frac2.numerator * lcm_ / frac2.denominator), lcm_ ); } Fraction operator*(Fraction frac2) { return Fraction(numerator * frac2.numerator, denominator * frac2.denominator); } Fraction operator/(Fraction frac2) { return Fraction(numerator * frac2.denominator, denominator * frac2.numerator); } // Comparision operators bool operator&lt;(Fraction frac2) { int lcm_ = lcm(denominator, frac2.denominator); return (numerator * lcm_ / denominator) &lt; (frac2.numerator * lcm_ / frac2.denominator); } bool operator&gt;(Fraction frac2) { int lcm_ = lcm(denominator, frac2.denominator); return (numerator * lcm_ / denominator) &gt; (frac2.numerator * lcm_ / frac2.denominator); } bool operator==(Fraction frac2) { int lcm_ = lcm(denominator, frac2.denominator); return (numerator * lcm_ / denominator) == (frac2.numerator * lcm_ / frac2.denominator); } bool operator&lt;=(Fraction frac2) { int lcm_ = lcm(denominator, frac2.denominator); return (numerator * lcm_ / denominator) &lt;= (frac2.numerator * lcm_ / frac2.denominator); } bool operator&gt;=(Fraction frac2) { int lcm_ = lcm(denominator, frac2.denominator); return (numerator * lcm_ / denominator) &gt;= (frac2.numerator * lcm_ / frac2.denominator); } }; int main() { Fraction frac1(-1, 2); Fraction frac2(1, -2); std::cout &lt;&lt; &quot;-1/2 * 1/-2 = &quot; &lt;&lt; frac1 * frac2 &lt;&lt; '\n'; } </code></pre> <p>Thanks for your time!</p>

270347

<p>I have a string like the one below from which I am extracting the tariff name.</p> <p><code>const url = &quot;https://any-api/supplier/tariffSelectionG_E5449168?t=randomChars&quot;</code></p> <p>So from the above string, I want text <code>tariffSelectionG_E5449168</code> and I am using the code below at the moment, which is working fine.</p> <pre><code>const supplyUrl = &quot;https://any-api/supplier/tariffSelectionG_E5449168?t=randomChars&quot; if(supplyUrl.includes('?')) { const url = supplyUrl.split('?') if(url.length &gt; 0) { const tariff = url[0].split('supplier/') return tariff[1] } } </code></pre> <p>Is there any better way to do the above extracting?</p>

270349

<p>I have tried my hand with implementing simple quadrature formulas in C++.</p> <p>Definite integral: <span class="math-container">$$\int_a^b f(x) dx$$</span> Domain of integration <span class="math-container">\$[a, b]\$</span> divided into <span class="math-container">\$n\$</span> intervals of equal length <span class="math-container">\$h = (b - a) / n\$</span>.</p> <p>Midpoint of interval <span class="math-container">\$h_i = b_i - a_i\$</span> is <span class="math-container">$$x_i = a + h / 2 + (i - 1) h$$</span> with <span class="math-container">\$i = 1, \dots, n \$</span>.</p> <p>Newton-Cotes quadrature formulas implemented in the code:</p> <ul> <li><em>Midpoint</em> rule (constant approx) <span class="math-container">$$F_M = h \sum_{i=1}^n f(x_i)$$</span></li> <li><em>Trapezoidal</em> rule (linear approx) <span class="math-container">$$F_T = \frac{h}{2} \left(f(a) + f(b) \right) + h \sum_{i=1}^{n-1} f(a_i)$$</span></li> <li><em>Simpson's</em> rule (quadratic approx) <span class="math-container">$$F_S = \frac{h}{6} \left(f(a) + f(b) \right) + \frac{h}{3} \sum_{i=1}^{n-1} f(a_i) + 2 \frac{h}{3} \sum_{i=1}^{n} f(x_i) $$</span></li> </ul> <p>I decided to go with a parametrized factory pattern that has no subclasses involved.</p> <p>I employ <span class="math-container">\$ f(x) = \sqrt{x} \exp{(-x)} \$</span> as test function, to be integrated between <span class="math-container">\$a = 1 \$</span> and <span class="math-container">\$b = 3\$</span>.</p> <p>I wonder whether the <code>#include &quot;NewtonCotesFormulas.cpp&quot;</code> at the end of the <code>NewtonCotesFormulas.h</code> header file could be somehow avoided. I used it because without I'd get linking errors.</p> <p>Here is the code.</p> <p><em>main.cpp</em>:</p> <pre><code>#include &lt;iostream&gt; #include &lt;cmath&gt; #include &quot;NewtonCotesFormulas.h&quot; #include &quot;NewtonCotesFactory.h&quot; using namespace std; double func(double x) { return sqrt(x) * exp(-x); } int main() { cout &lt;&lt; &quot;Choose method:\n&quot; &lt;&lt; &quot;Midpoint numeric quadrature -----&gt; (1)\n&quot; &lt;&lt; &quot;Trapezoidal numeric quadrature --&gt; (2)\n&quot; &lt;&lt; &quot;Simpson's numeric quadrature ----&gt; (3)\n&quot; &lt;&lt; endl; // //user input code: // int choice; // cin &gt;&gt; choice; // while (choice &lt; 1 || choice &gt; 3) { // cout &lt;&lt; &quot;Pick again a number from 1 to 3\n&quot;; // cin &gt;&gt; choice; // } NewtonCotesFactory creator; // alternative to user input, print all results at once: for (int choice : {1,2,3}) { NewtonCotesFormulas* rule = creator.createQuadrature(choice, 1, 3, 0.000001); double result = rule-&gt;printConvergenceValues(4, &amp;func); cout &lt;&lt; &quot;Final result within tolerance: &quot; &lt;&lt; result &lt;&lt; endl &lt;&lt; endl; delete rule; } return 0; } </code></pre> <p><em>NewtonCotesFormulas.h</em>:</p> <pre><code>#ifndef NEWTONCOTESFORMULAS_H_INCLUDED #define NEWTONCOTESFORMULAS_H_INCLUDED #include &lt;string&gt; class NewtonCotesFormulas { public: NewtonCotesFormulas(double, double, double, std::string); virtual ~NewtonCotesFormulas(); virtual double computeIntegral(int, double (*func)(double)) = 0; double convergeToTol(int, double (*func)(double)); double printConvergenceValues(int, double (*func)(double)); protected: double inf, sup; double tol; std::string method_name; }; class Midpoint: public NewtonCotesFormulas { public: Midpoint(double, double, double); ~Midpoint(){}; double computeIntegral(int, double (*func)(double)) override; }; class Trapezoidal: public NewtonCotesFormulas { public: Trapezoidal(double, double, double); ~Trapezoidal(){}; double computeIntegral(int, double (*func)(double)) override; }; class Simpsons: public NewtonCotesFormulas { public: Simpsons(double, double, double); ~Simpsons(){}; double computeIntegral(int, double (*func)(double)) override; }; #include &quot;NewtonCotesFormulas.cpp&quot; #endif // NEWTONCOTESFORMULAS_H_INCLUDED </code></pre> <p><em>NewtonCotesFormulas.cpp</em>:</p> <pre><code>#include &lt;iomanip&gt; #include &quot;NewtonCotesFormulas.h&quot; using namespace std; NewtonCotesFormulas::NewtonCotesFormulas(double a, double b, double inp_tol, string name): inf(a), sup(b), tol(inp_tol), method_name(name) {} NewtonCotesFormulas::~NewtonCotesFormulas() {} double NewtonCotesFormulas::convergeToTol(int intervals, double (*func)(double)) { double old_integral = this-&gt;computeIntegral(intervals, func); intervals *= 2; double new_integral = this-&gt;computeIntegral(intervals, func); double difference = abs(new_integral - old_integral); while(difference &gt; tol) { cout &lt;&lt; setprecision(8) &lt;&lt; string(9 - to_string(intervals).size(), ' ') &lt;&lt; // blank padding used to format output table intervals &lt;&lt; string(3,' ') &lt;&lt; fixed &lt;&lt; new_integral &lt;&lt; string(3,' ') &lt;&lt; scientific &lt;&lt; difference &lt;&lt; endl; old_integral = new_integral; intervals *= 2; new_integral = this-&gt;computeIntegral(intervals, func); difference = abs(new_integral - old_integral); } cout &lt;&lt; setprecision(8) &lt;&lt; fixed &lt;&lt; string(9 - to_string(intervals).size(), ' ') &lt;&lt; intervals &lt;&lt; string(3,' ') &lt;&lt; new_integral &lt;&lt; string(3,' ') &lt;&lt; scientific &lt;&lt; difference &lt;&lt; endl; return new_integral; } double NewtonCotesFormulas::printConvergenceValues(int intervals, double (*func)(double)) { cout &lt;&lt; method_name &lt;&lt; &quot; method, with tolerance &quot; &lt;&lt; tol &lt;&lt; &quot;\n&quot;; cout &lt;&lt; &quot;intervals&quot; &lt;&lt; string(5,' ') &lt;&lt; &quot;integral &quot; &lt;&lt; string(9,' ') &lt;&lt; &quot;tol\n&quot;; cout &lt;&lt; setprecision(8) &lt;&lt; string(9 - to_string(intervals).size(), ' ') &lt;&lt; intervals &lt;&lt; string(3,' ') &lt;&lt; this-&gt;computeIntegral(intervals, func) &lt;&lt; string(3,' ') &lt;&lt; fixed &lt;&lt; 0.0 &lt;&lt; endl; double result = this-&gt;convergeToTol(intervals, func); return result; } Midpoint::Midpoint(double a, double b, double inp_tol): NewtonCotesFormulas(a, b, inp_tol, &quot;Midpoint&quot;){} Trapezoidal::Trapezoidal(double a, double b, double inp_tol): NewtonCotesFormulas(a, b, inp_tol, &quot;Trapezoidal&quot;){} Simpsons::Simpsons(double a, double b, double inp_tol): NewtonCotesFormulas(a, b, inp_tol, &quot;Simpson's&quot;){} double Midpoint::computeIntegral(int intervals, double (*func)(double)) { double interval_width = (sup - inf) / intervals; double result = 0; for (int i = 1; i &lt;= intervals; ++i) result += func(inf + (i - 0.5) * interval_width); return result * interval_width; } double Trapezoidal::computeIntegral(int intervals, double (*func)(double)) { double interval_width = (sup - inf) / intervals; double result = (func(inf) + func(sup)) / 2.; for (int i = 1; i &lt;= intervals - 1; ++i) result += func(inf + i * interval_width); return result * interval_width; } double Simpsons::computeIntegral(int intervals, double (*func)(double)) { double interval_width = (sup - inf) / intervals; double result = (func(inf) + func(sup)) / 6; for (int i = 1; i &lt;= intervals - 1; ++i) result += func(inf + i * interval_width) / 3 + 2 * func(inf + (i - 0.5) * interval_width) / 3; result += 2 * func(inf + (intervals - 0.5) * interval_width) / 3; return result * interval_width; } </code></pre> <p><em>NewtonCotesFactory.h</em>:</p> <pre><code>#ifndef NEWTONCOTESFACTORY_H_INCLUDED #define NEWTONCOTESFACTORY_H_INCLUDED #include &lt;string&gt; #include &lt;stdexcept&gt; #include &quot;NewtonCotesFormulas.h&quot; class NewtonCotesFactory { // Parametrized factory, no children public: virtual NewtonCotesFormulas* createQuadrature(int choice, double a, double b, double inp_tol) const { if (choice == 1) return new Midpoint(a, b, inp_tol); else if (choice == 2) return new Trapezoidal(a, b, inp_tol); else if (choice == 3) return new Simpsons(a, b, inp_tol); else throw std::runtime_error(&quot;Pick either choice = 1, 2, or 3&quot;); return 0; // never gets here } virtual ~NewtonCotesFactory(){} }; #endif // NEWTONCOTESFACTORY_H_INCLUDED </code></pre> <p>Results look fine:</p> <pre class="lang-none prettyprint-override"><code>Choose method: Midpoint numeric quadrature -----&gt; (1) Trapezoidal numeric quadrature --&gt; (2) Simpson's numeric quadrature ----&gt; (3) Midpoint method, with tolerance 1e-06 intervals integral tol 4 0.40715731 0.00000000 8 0.40807542 9.18106750e-04 16 0.40829709 2.21674991e-04 32 0.40835199 5.49009778e-05 64 0.40836569 1.36924160e-05 128 0.40836911 3.42104469e-06 256 0.40836996 8.55132348e-07 Final result within tolerance: 4.08369962e-01 Trapezoidal method, with tolerance 1.00000000e-06 intervals integral tol 4 4.10757439e-01 0.00000000 8 0.40895737 1.80006398e-03 16 0.40851640 4.40978614e-04 32 0.40840674 1.09651812e-04 64 0.40837937 2.73754169e-05 128 0.40837253 6.84150045e-06 256 0.40837082 1.71022788e-06 512 0.40837039 4.27547766e-07 Final result within tolerance: 4.08370390e-01 Simpson's method, with tolerance 1.00000000e-06 intervals integral tol 4 4.08357353e-01 0.00000000 8 0.40836940 1.20498403e-05 16 0.40837019 7.90455982e-07 Final result within tolerance: 4.08370194e-01 Process returned 0 (0x0) execution time : 0.063 s Press any key to continue. </code></pre>

270354

<p>My Data consists of rows containing a Length/Duration in Minutes, a Begin &amp; EndTime. The precision is 1min (or larger).</p> <p>the table looks something like that:</p> <pre><code>CREATE TABLE public.&quot;TimeSeries&quot; ( &quot;Id&quot; uuid NOT NULL, &quot;BeginTime&quot; timestamptz NOT NULL, &quot;EndTime&quot; timestamptz NOT NULL DEFAULT '0001-01-01 00:00:00' :: timestamp without time zone, &quot;LengthMin&quot; int4 NOT NULL ); INSERT INTO public.&quot;TimeSeries&quot; (&quot;Id&quot;,&quot;BeginTime&quot;,&quot;LengthMin&quot;,&quot;EndTime&quot;) VALUES ('ecabcd8d-3129-4128-b126-a4e1abcd49c9'::uuid,'2021-11-16 11:45:00.000',1,'2021-11-16 11:46:00.000'), ('e5abcd70-5125-412b-9128-93ecabcdcba9'::uuid,'2021-11-16 11:46:00.000',1,'2021-11-16 11:47:00.000'), ('03abcdb8-8129-4124-b126-f5bbabcd7157'::uuid,'2021-11-16 11:47:00.000',1,'2021-11-16 11:48:00.000'), ('54abcdcc-6129-4126-912b-34b2abcde19a'::uuid,'2021-11-16 11:50:00.000',1,'2021-11-16 11:51:00.000'), ('77abcd28-212f-4122-912f-5060abcd2aa0'::uuid,'2021-11-16 11:51:00.000',1,'2021-11-16 11:52:00.000'), ('8babcdd1-f12a-4124-9128-2529abcda136'::uuid,'2021-11-16 11:52:00.000',1,'2021-11-16 11:53:00.000'), ('8aabcd94-9129-4121-b12c-1ebfabcd06b8'::uuid,'2021-11-16 12:35:00.000',1,'2021-11-16 12:36:00.000'), ('96abcd04-b12e-4122-b12b-4dc2abcdcee4'::uuid,'2021-11-16 12:40:00.000',1,'2021-11-16 12:41:00.000'), ('42abcd4a-f129-412c-9124-41b3abcd3ca3'::uuid,'2021-11-16 12:44:00.000',1,'2021-11-16 12:45:00.000'), ('beabcd8f-c12f-4126-a12b-0a37abcdd0bb'::uuid,'2021-11-16 12:49:00.000',1,'2021-11-16 12:50:00.000'), ('b8abcd79-d12c-4120-912f-754fabcdd220'::uuid,'2021-11-16 12:50:00.000',1,'2021-11-16 12:51:00.000'), ('c3abcd08-e121-4127-b125-4e70abcd5756'::uuid,'2021-11-16 12:59:00.000',1,'2021-11-16 13:00:00.000'), ('65abcdbe-7121-412a-a12c-1f68abcd94eb'::uuid,'2021-11-16 13:00:00.000',1,'2021-11-16 13:01:00.000'), ('f5abcd38-9122-412c-b12f-957fabcd79b5'::uuid,'2021-11-16 13:05:00.000',1,'2021-11-16 13:06:00.000'); </code></pre> <p>The code I came up with looks something like that: ( <a href="http://www.sqlfiddle.com/#!17/8a517/2" rel="nofollow noreferrer">http://www.sqlfiddle.com/#!17/8a517/2</a> )</p> <pre><code>SELECT u.&quot;SeriesBegin&quot;, COUNT(u.&quot;BeginTime&quot;) as cnt, min(u.&quot;BeginTime&quot;) as min, max(u.&quot;EndTime&quot;) as max, max(u.&quot;EndTime&quot;) - min(u.&quot;BeginTime&quot;) as delta FROM ( SELECT v.&quot;BeginTime&quot;, v.&quot;EndTime&quot;, v.&quot;isInSeries&quot;, v.&quot;n_in_series&quot;, lag(&quot;BeginTime&quot;, v.&quot;n_in_series&quot; :: int) OVER ( ORDER BY &quot;BeginTime&quot; ) AS &quot;SeriesBegin&quot;, grp FROM ( SELECT t.*, row_number() OVER ( partition BY t.&quot;BeginTime&quot; - grp * make_interval(mins =&gt; t.&quot;LengthMin&quot;) ORDER BY t.&quot;BeginTime&quot; ) - 1 as n_in_series FROM ( SELECT row_number() OVER ( ORDER BY &quot;BeginTime&quot; ) AS grp, &quot;BeginTime&quot; = lag(&quot;EndTime&quot;) OVER ( ORDER BY &quot;BeginTime&quot; ) AS &quot;isInSeries&quot;, * FROM &quot;TimeSeries&quot; WHERE &quot;LengthMin&quot; = 1 ) t ORDER BY t.&quot;BeginTime&quot; ) AS v ) u GROUP BY &quot;SeriesBegin&quot; ORDER BY &quot;SeriesBegin&quot; ASC </code></pre> <p>The result:</p> <pre><code> | SeriesBegin | cnt | min | max | delta | |----------------------|-----|----------------------|----------------------|------------------------------------------------| | 2021-11-16T11:45:00Z | 3 | 2021-11-16T11:45:00Z | 2021-11-16T11:48:00Z | 0 years 0 mons 0 days 0 hours 3 mins 0.00 secs | | 2021-11-16T11:50:00Z | 3 | 2021-11-16T11:50:00Z | 2021-11-16T11:53:00Z | 0 years 0 mons 0 days 0 hours 3 mins 0.00 secs | | 2021-11-16T12:35:00Z | 1 | 2021-11-16T12:35:00Z | 2021-11-16T12:36:00Z | 0 years 0 mons 0 days 0 hours 1 mins 0.00 secs | | 2021-11-16T12:40:00Z | 1 | 2021-11-16T12:40:00Z | 2021-11-16T12:41:00Z | 0 years 0 mons 0 days 0 hours 1 mins 0.00 secs | | 2021-11-16T12:44:00Z | 1 | 2021-11-16T12:44:00Z | 2021-11-16T12:45:00Z | 0 years 0 mons 0 days 0 hours 1 mins 0.00 secs | | 2021-11-16T12:49:00Z | 2 | 2021-11-16T12:49:00Z | 2021-11-16T12:51:00Z | 0 years 0 mons 0 days 0 hours 2 mins 0.00 secs | | 2021-11-16T12:59:00Z | 2 | 2021-11-16T12:59:00Z | 2021-11-16T13:01:00Z | 0 years 0 mons 0 days 0 hours 2 mins 0.00 secs | | 2021-11-16T13:05:00Z | 1 | 2021-11-16T13:05:00Z | 2021-11-16T13:06:00Z | 0 years 0 mons 0 days 0 hours 1 mins 0.00 secs | </code></pre> <p>I think this code can be optimized, on one hand 4 SELECT statements seem pretty much for me. On the other hand currently there are 2 approaches included, however one only active.</p> <p>The Approach I like more is checking if the <code>BeginTime = lag(EndTime)</code> however then I was not able to connect rows which are in the same series.</p> <p>The active approach is calculating some common value <code>t.&quot;BeginTime&quot; - grp * make_interval(mins =&gt; t.&quot;LengthMin&quot;)</code> and mapping them via the calculated position in the series <code>n_in_series</code> &amp; <code>lag(&quot;BeginTime&quot;, v.&quot;n_in_series&quot; :: int)</code> to a group.</p>

270358

<p>I'm learning Objects calisthenics and I was practicing with the typical Tic Tac Toe game, I was wondering if you could gimme feedback about my mistakes (Algorithmic problems, logic, and especially OOP following Objects calisthenics rules). Thanks in advance!</p> <ul> <li>Only One Level Of Indentation Per Method</li> <li>Don’t Use The ELSE Keyword</li> <li>Wrap All Primitives And Strings First Class Collections</li> <li>One Dot Per Line</li> <li>Don’t Abbreviate</li> <li>Keep All Entities Small</li> <li>No Classes With More Than Two Instance Variables</li> <li>No Getters/Setters/Properties</li> </ul> <h2>Player.cs</h2> <pre><code>namespace Tic_tac_toe { public class Token { // TODO: Get rid off this auto propertie. public char TokenSelected { get; } public Token(char token) =&gt; TokenSelected = token; } public class Player { private readonly Matrix _matrix = new Matrix(3, 3); public Token Token { get; } public Player(Token token) { Token = token; } public void PutTokenAt(Coords coords) { if (_matrix.IsNotEmpty(coords)) _matrix.SetToken(coords, Token); } public bool CheckIfPlayerWon() { return _matrix.CheckRow(Token) || _matrix.CheckColumn(Token) || _matrix.CheckSlashDiagonal(Token) || _matrix.CheckBackSlashDiagonal(Token); } } } </code></pre> <h2>Coords.cs</h2> <pre><code>using System.Collections.Generic; using System.Linq; namespace Tic_tac_toe { public class Coords { public Coords(int x, int y) { X = x; Y = y; } public int X { get; } public int Y { get; } } public class CoordsCollection { private readonly List&lt;Coords&gt; _coordsList; public CoordsCollection() { _coordsList = new List&lt;Coords&gt;(); } public void Add(Coords coords) { _coordsList.Add(coords); } public int Sum(int[,] magicSquare) { return _coordsList.Sum(cord =&gt; magicSquare[cord.X, cord.Y]); } } } </code></pre> <h2>Matrix.cs</h2> <pre><code>namespace Tic_tac_toe { public class Matrix { private readonly int _n; private readonly int _m; private readonly char[,] _value; private Coords _lastMove; public Matrix(int n, int m) { _n = n; _m = m; _value = new char[_n, _m]; CreateMatrix(); } private void CreateMatrix() { for (int i = 0; i &lt; _n; i++) for (int j = 0; j &lt; _m; j++) _value[i, j] = '.'; } public bool IsNotEmpty(Coords coords) { return _value[coords.X, coords.Y] == '.'; } public void SetToken(Coords coords, Token token) { _value[coords.X, coords.Y] = token.TokenSelected; _lastMove = coords; } private bool MagicSquare(CoordsCollection listCord) { // https://en.wikipedia.org/wiki/Magic_square int[,] mS = new int[3, 3]; mS[0, 0] = 2; mS[0, 1] = 7; mS[0, 2] = 6; mS[1, 0] = 9; mS[1, 1] = 5; mS[1, 2] = 1; mS[2, 0] = 4; mS[2, 1] = 3; mS[2, 2] = 8; return listCord.Sum(mS) == 15; } public bool CheckRow(Token token) { CoordsCollection rowCordList = new CoordsCollection(); for (int x = 0; x &lt; _m; x++) if (_value[x, _lastMove.Y] == token.TokenSelected) rowCordList.Add(new Coords(x, _lastMove.Y)); return MagicSquare(rowCordList); } public bool CheckColumn(Token token) { CoordsCollection columnsCordList = new CoordsCollection(); for (int y = 0; y &lt; _n; y++) if (_value[y, _lastMove.Y] == token.TokenSelected) columnsCordList.Add(new Coords(_lastMove.X, y)); return MagicSquare(columnsCordList); } public bool CheckBackSlashDiagonal(Token token) { CoordsCollection backSlashCordsList = new CoordsCollection(); for (int i = 0; i &lt; _n; i++) if (_value[i, i] == token.TokenSelected) backSlashCordsList.Add(new Coords(i, i)); return MagicSquare(backSlashCordsList); } public bool CheckSlashDiagonal(Token token) { CoordsCollection slashCordsList = new CoordsCollection(); for (int x = 0, y = _n - 1; x &lt; _m; x++, y--) if (_value[x, y] == token.TokenSelected) slashCordsList.Add(new Coords(x, y)); return MagicSquare(slashCordsList); } } } </code></pre>

270366

<p>In this code the angle between the minute and hour hands of an analog clock are found and calculated and the smaller angle between them returned. This code works perfectly and I am getting back the results I expect.</p> <p>We were told to do this and any testing if necessary.</p> <p>I got asked this in an interview question and wanted to see if there was any way to improve what I came up with.</p> <p>Is there any way you could think to do all this better and shorten this. I am not exactly sure if the validation is the best either. I put in if statements to stop anyone from putting in a random number or more digits then needed but I am not sure if there is a better or more efficient way to do that.</p> <p>I thought about maybe trying to split it individually into every digit so I could validate the time that way but i was not sure it was worth doing it that way either.</p> <p>If there is something I should be doing better to make my code look better or anything that would earn more points within an interview would be great.</p> <p>Anything is appreciated as coding in interviews is difficult and I was wondering if there was anything I could of done better.</p> <p>Example input in main method</p> <pre><code> //valid input System.out.println(calcAngle(&quot;17:00&quot;)); //should return 150 System.out.println(calcAngle(&quot;15:15&quot;)); //should return 7.5 System.out.println(calcAngle(&quot;3:15&quot;)); //should return 7.5 System.out.println(calcAngle(&quot;9:30&quot;)); //should return 105 System.out.println(calcAngle(&quot;17:59&quot;)); //should return 174.5 System.out.println(calcAngle(&quot;11:15&quot;)); //should return 112.5 System.out.println(calcAngle(&quot;23:15&quot;) + &quot;\n&quot;); //should return 112.5 //invalid input should return error message System.out.println(calcAngle(&quot;24:60&quot;)); System.out.println(calcAngle(&quot;00:-1&quot;)); System.out.println(calcAngle(&quot;:00&quot;)); System.out.println(calcAngle(&quot;:&quot;)); System.out.println(calcAngle(&quot;25:00&quot;)); System.out.println(calcAngle(&quot;11:80&quot;)); </code></pre> <pre><code>public static String calcAngle(String time) { double hour=0; double min=0; //Seperating the string hour and minute to different array value String[] sep = time.split(&quot;:&quot;); /* * Two if statements to catch any errors * Stops any incorrect formatting of time causing an error or exception */ //stops any value if time has more than 5 or less than 3 if(time.length()&gt;5 || time.length()&lt;3) { return &quot;Time &quot; + time +&quot; is not formated correctly format as hh:mm with 14:00 or 2:00&quot;; } //getting values of array to check String checkHour = sep[0]; String checkMinute= sep[1]; //does not allow values to be read if they are empty or greater than 2 if(checkHour==&quot;&quot; || checkMinute==&quot;&quot; || checkMinute.length()&gt;2 || checkHour.length()&gt;2) { return &quot;Time &quot; + time + &quot; is not formated correctly format as hh:mm with 14:00 or 2:00&quot;; } //turning strings to doubles hour = Double.parseDouble(sep[0]); min = Double.parseDouble(sep[1]); //value check if(hour&lt;0 || hour&gt;24 || min&lt;0 || min&gt;59) { return &quot;Time &quot; + time + &quot; out of bounds for a 24 hour clock&quot;; } // handle 24-hour notation hour = hour % 12; // find the position of the hour's hand double hours = (hour * 360) / 12 + (min * 360) / (12 * 60); // find the position of the minute's hand double minute = (min * 360) / (60); // calculate the angle difference double angle = Math.abs(hours - minute); // consider the shorter angle and return it if (angle &gt; 180) { angle = 360 - angle; } //returns in The answer for 17:00 is 150.0 Degrees return &quot;The answer for &quot; + time + &quot; is &quot; + angle + &quot; Degrees &quot;; } </code></pre>

270367

<p>I am currently working on a chess console app. However i feel like i got some inefficient code. For example: In order to find out whether an enemy is in check I start iteration over all pieces and all their possible moves. I am glad to get any advice regarding the structure syntax etc. on my project.</p> <p><a href="https://github.com/DerEddie/ChessConsoleApp" rel="nofollow noreferrer">https://github.com/DerEddie/ChessConsoleApp</a></p> <pre><code>sing System; using System.Security.Cryptography.X509Certificates; using Microsoft.Win32; namespace OOPChessProject { class Controller { public Field stringToField(string s) { // String to Field Methode int c = (int)(col)Enum.Parse(typeof(col), s[0].ToString()); int r = (int)(row)Enum.Parse(typeof(row), &quot;_&quot; + s[1]); Field of = new Field(r, c); return of; } public void MainGameLoop() { //Init Game with the Players var cGame = new ChessGame(&quot;Eduard&quot;, &quot;Benjamin&quot;); cGame.GameState = gameState.Running; bool isCheck; Console.ReadKey(); //Game Loop do { #region Printing the board Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine(&quot;_________________________________&quot;); Console.WriteLine(&quot;Iteration Nr.&quot; + cGame.TurnCounter); Console.WriteLine(cGame.currentChessBoard); Console.WriteLine(cGame.CurrentPlayer + &quot;'s turn!&quot;); Console.WriteLine(cGame.CurrentPlayer.Color); Console.WriteLine(&quot;_________________________________&quot;); #endregion region MyClass definition //check if there is a check //change color because we need to iter of opponents pieces isCheck = cGame.currentChessBoard.isChecked(Helper.ColorSwapper(cGame.CurrentPlayer.Color)); Console.WriteLine(&quot;Checked:&quot;); if (isCheck) { cGame.GameState = gameState.Check; Console.WriteLine(&quot;CHECK!&quot;); } if (cGame.GameState == gameState.Check) { //TODO function which returns true if mitigation of check found if (!cGame.ChessMitigationPossible()) { Console.WriteLine(&quot;Game Over!&quot;); Console.ReadKey(); } } else //if there is no check we need to see if there is a stalemate which will result in a draw { if (!cGame.movesAvailable()) { Console.WriteLine(&quot;Stalemate!&quot;); } } //Check if the check can be mitigated var OwnPieces = cGame.currentChessBoard.getAllPiecesOfColor(cGame.CurrentPlayer.Color); //Create Copy of the Board //Perform the the move and then check if the check is still there. Once Move was found we break out //var boardCopy #region Asking for 1st User Input //User Input --&gt; Another While Loop Console.WriteLine(&quot;Enter Origin Field: [A-H][1-8]&quot;); string s = Console.ReadLine(); var of = stringToField(s); #endregion #region Check for right color and if field is not empty //if the colors are not the same we need to prompt again for input, because not the right piece was chosen. if (!cGame.isPlayerAndPieceColorSame(cGame.CurrentPlayer, cGame.currentChessBoard.GetPieceFromField(of))) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(&quot;WRONG COLOR OR FIELD IS EMPTY!!!&quot;); Console.ForegroundColor = ConsoleColor.Yellow; continue; } #endregion //Lookup the possible Moves var p = cGame.currentChessBoard.GetPieceFromField(of); var listofMoves = p.getPossibleMoves(cGame.currentChessBoard); foreach (var f in listofMoves) { Console.WriteLine(f); } //Check if there is a Piece and the correct color //Get List Of Possible Moves for that Piece //cGame.currentChessBoard.GetPieceFromField(Field f); Console.WriteLine(&quot;Enter Destination Field: [A-H][1-8]&quot;); s = Console.ReadLine(); var df = stringToField(s); MovementType mtype = MovementType.moving; ; foreach (var move in listofMoves) { if (move.ToField.ToString() == df.ToString()) { mtype = move.movementType; } } //Move gets Performed cGame.currentChessBoard.MovePiece(of, df, mtype, cGame.TurnCounter); //After the move check whether this piece now attacks the enemy King //Change current Player cGame.CurrentPlayer= (cGame.CurrentPlayer == cGame.Player1) ? cGame.Player2: cGame.Player1; cGame.TurnCounter++; } while (true); } } } </code></pre>

270368

<p><a href="https://www.hackerrank.com/challenges/climbing-the-leaderboard/problem" rel="nofollow noreferrer">Climbing the Leaderboard</a></p> <blockquote> <p>An arcade game player wants to climb to the top of the leaderboard and track their ranking. The game uses Dense Ranking, so its leaderboard works like this:</p> <p>The player with the highest score is ranked number <span class="math-container">\$1\$</span> on the leaderboard. Players who have equal scores receive the same ranking number, and the next player(s) receive the immediately following ranking number.</p> <h3>Example</h3> <p><span class="math-container">\$ranked = [100, 90, 90, 80]\$</span></p> <p><span class="math-container">\$player = [70, 80, 105]\$</span></p> <p>The ranked players will have ranks 1, 2, 2, and 3, respectively. If the player's scores are 70, 80 and 105, their rankings after each game are 4^th, 3^rd and 1^st. Return <code>[4, 3, 1]</code>.</p> <h3>Function Description</h3> <p>Complete the climbingLeaderboard function in the editor below.</p> <p>climbingLeaderboard has the following parameter(s):</p> <ul> <li><code>int ranked[n]</code>: the leaderboard scores</li> <li><code>int player[m]</code>: the player's scores</li> </ul> <h3>Returns</h3> <ul> <li><code>int[m]</code>: the player's rank after each new score</li> </ul> <h3>Input Format</h3> <p>The first line contains an integer <span class="math-container">\$n\$</span>, the number of players on the leaderboard. The next line contains space-separated integers <span class="math-container">\$ranked[i]\$</span>, the leaderboard scores in decreasing order. The next line contains an integer, <span class="math-container">\$m\$</span>, the number games the player plays. The last line contains space-separated integers <span class="math-container">\$player[i]\$</span>, the game scores.</p> <h3>Constraints</h3> <ul> <li><span class="math-container">\$1 &lt;= n &lt;= 2 x 10^5\$</span></li> <li><span class="math-container">\$1 &lt;= m &lt;= 2 x 10^5\$</span></li> <li><span class="math-container">\$0 &lt;= ranked[i] &lt;= 10^9\$</span> for <span class="math-container">\$0 &lt;= i &lt; n\$</span></li> <li>The existing leaderboard, <span class="math-container">\$ranked\$</span>, is in descending order.</li> <li>The player's scores, <span class="math-container">\$scores\$</span>, are in ascending order.</li> </ul> <h3>Subtask</h3> <p>For <span class="math-container">\$60%\$</span> of the maximum score:</p> <ul> <li><span class="math-container">\$1 &lt;= n &lt;= 200\$</span></li> <li><span class="math-container">\$1 &lt;= m &lt;= 200\$</span></li> </ul> <h3>Sample Input 1</h3> <pre><code>7 100 100 50 40 40 20 10 4 5 25 50 120 </code></pre> <h3>Sample Output 1</h3> <p>6 4 2 1</p> </blockquote> <p>I keep getting timed out. I think my general logic is right but how can my code be optimized more?</p> <p>I know there are solutions using the bisect module but I've seen very simple ones without using that. From what I can think of, maybe using while loops will speed things up?</p> <pre><code>def climbingLeaderboard(ranked, player): ranked=[i for n, i in enumerate(ranked) if i not in ranked[:n]] #remove duplicates player_rank=[] ranking=len(ranked)+1 start=1 for pi,ps in enumerate(player[::-1]): for ri,r in enumerate(ranked,start=start): if ps&gt;=r: player_rank.append(ri) break else: ranked=ranked[1:] start+=1 else: player_rank.append(ranking) return player_rank[::-1] </code></pre>

270371

<p>I have implemented few functions in C language that manipulate strings. These functions are not present in the standard C library.</p> <hr /> <h2>string_library.c</h2> <pre><code> #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &quot;string_library.h&quot; /* * get_input_from_stdin_and_discard_extra_characters(char *str, long size): * * Function get_input_from_stdin_and_discard_extra_characters() reads at most * 'size - 1' characters into 'str' from stdin and then appends the NULL * character ('\0'). In all cases, reading input stops after encountering a * newline ('\n') or EOF even if 'size - 1' characters have not been read. * If a newline ('\n') or EOF is read then these are replaced by NULL character * ('\0'). If there are extra characters in input, they are read and discarded. * In all cases, str is returned. * */ char *get_input_from_stdin_and_discard_extra_characters(char *str, long size) { char c = 0; long num_chars_to_read = size - 1; long i = 0; if (!str) return NULL; if (num_chars_to_read &lt;= 0) return NULL; for (i = 0; i &lt; num_chars_to_read; i++) { c = getchar(); if ((c == '\n') || (c == EOF)) { str[i] = 0; return str; } str[i] = c; } // end of for loop str[i] = 0; // discard rest of input while ((c = getchar()) &amp;&amp; (c != '\n') &amp;&amp; (c != EOF)); return str; } // end of get_input_from_stdin_and_discard_extra_characters int is_string_empty(const char *str) { if (!str) return 1; if (*str == 0) return 1; return 0; } // end of is_string_empty int is_string_all_whitespace(const char *str) { char *temp = (char *)(str); if (is_string_empty(str)) return 1; while (*temp) { if ((*temp != ' ') &amp;&amp; (*temp != '\t')) return 0; temp++; } return 1; } // is_string_all_whitespace /* * This function fills 'str' with 'len - 1' random characters and appends a null * byte at the end and returns 'str'. */ char *get_random_string(char *str, long len) { int min_num = 32; int max_num = 126; int i = 0; for (i = 0; i &lt; (len - 1); i++) { str[i] = (random() % (max_num - min_num + 1)) + min_num; } str[len - 1] = 0; return str; } /* * str_replace_chr(char *str, const char orig, const char new): * * Function str_replace_chr() replaces all occurrences of 'orig' character in * the string 'str' with the 'new' character. If 'str' is NULL then nothing is * done. In all cases, 'str' is returned. * */ char *str_replace_chr(char *str, const char orig, const char new) { char *orig_str = (str); if (!str) return orig_str; while (*str) { if (*str == orig) *str = new; str++; } return orig_str; } // end of str_replace_chr /* * substr(const char *str, long start_index, long end_index): * * Function substr() allocates memory and returns a pointer to a string / character * array which is a substring of 'str' starting from index 'start_index' till * 'end_index' (inclusive). This substring is terminated by NULL byte at the end. * If 'str' is NULL or 'start_index' is less than 0 or 'end_index' is less than 0 * or 'end_index' is less than 'start_index' then NULL is returned. * * The returned pointer points to a memory region containing the substring and this * memory region was allocated using malloc. So, it is the user's responsibility to * free the allocated memory. * */ char *substr(const char *str, long start_index, long end_index) { char *substring = NULL; long length = 0; long i = 0; if (!str) return NULL; if ((start_index &lt; 0) || (end_index &lt; 0) || (end_index &lt; start_index)) return NULL; length = end_index - start_index + 1; substring = malloc(length + 1); // extra 1 byte for NULL byte if (!substring) return NULL; for (i = 0; i &lt; length; i++) { substring[i] = str[i + start_index]; } substring[i] = 0; return substring; } // end of substr </code></pre>

270376

<p>I have several products. A product can have 1 or more images. In each image, we have content slot. I don't want duplication per content slot in a product.</p> <p>My code works fine. I'm just wondering what will be a better way to do this or improvement on my code?</p> <p>Codesandbox is here <a href="https://codesandbox.io/s/redux-added-array-of-object-inside-another-aray-in-react-forked-uxqce?file=/src/components/MediaCard/index.js" rel="nofollow noreferrer">CLICK HERE</a></p> <pre><code> &lt;Autocomplete fullWidth size=&quot;small&quot; options={ Boolean(product.slot) &amp;&amp; product.slot.length &gt; 0 ? contentSlots.filter( (slot) =&gt; !product.slot.find((data) =&gt; data.value.id === slot.id) ) : contentSlots } renderInput={(params) =&gt; ( &lt;TextField {...params} label=&quot;Content Slots&quot; variant=&quot;outlined&quot; fullWidth /&gt; )} getOptionLabel={(option) =&gt; option.name || &quot;&quot;} disableClearable={true} onChange={(_, value) =&gt; onChangeContentSlot(value, product)} /&gt; </code></pre>

270379

<p>I'm learning rust (coming from C++) and playing around with different small algorithms to understand the ownership &amp; borrowing concepts better. Currently, I'm having difficulties finding the idiomatic way to reuse a Vector after iterating over it in a for-loop. This is the (very verbose) code I currently have:</p> <pre><code>fn build_trie(paths: &amp;Vec&lt;String&gt;) -&gt; TreeNode { let mut root = TreeNode::new('\0'); for path in paths { // start at the root node let mut current_node = &amp;mut root; for ch in path.as_bytes() { let ch = *ch as char; println!(&quot;Current char: {}&quot;, ch); let length: i32 = current_node.children.len() as i32; let mut found_child = false; // for each child of the current node, check if the current character matches for i in 0..length as usize { // found a match, descend into the tree if current_node.children[i].get_value() == ch { println!(&quot;Found matching char: {}&quot;, ch); found_child = true; // avoid adding a new child later current_node.children[i].increment_count(); current_node = &amp;mut current_node.children[i]; break; } found_child = false; } // no matching child found, add a new child // and descend into the tree if !found_child { let new_node = TreeNode::new(ch); current_node.children.push(new_node); current_node = current_node.children.last_mut().unwrap(); } } } root } </code></pre> <p>While this does seem to work, I wanted to replace the <code>for i in 0..length</code> header with <code>for child in current_node.children.iter_mut()</code>. The problem is that this does a mutable borrow of <code>current_node.children</code> which also happens in the last if-statement, which obviously isn't allowed twice. I have the feeling that I'm missing some simple detail. I did a lot of googling but couldn't find anything that answered my question.</p> <p>PS: I'm not sure if this question is for Code Review or StackOverflow. But since it might be opinion-based (and those get closed immediately...) I thought I'd try here first.</p>

270380

<p>The following is a put controller I wrote to update a document.</p> <p>What I am updating is a particular array in the Model: The <code>issues</code> array. The schema for the Model is given below.</p> <p>It works and updates the <code>issues</code> array of the document.:</p> <ol> <li><p><strong>If the array gets very big</strong>, would using the <code>updateOne</code> method be, somehow, negatively affect the performance. I feel like updating the entire document just to update an object inside an array is not necessary.</p> </li> <li><p>If there is a better way to do this.</p> </li> </ol> <pre><code>app.route('/api/issues/:project') .put(async function (req, res){ let project = req.params.project; if (!req.body._id) { return res.status(200).json({ error: 'missing _id' }) } try{ // Find if project with this name exists let existingProject = await Project.findOne({name: project}).lean(); //If project does not exist, return if (!existingProject) { return res.status(200).json({ error: 'could not update', _id: req.body._id }) } // If project exists, get the issues from array let issues = existingProject.issues; // Find index of object in array let index = issues.findIndex(obj =&gt; obj._id.toString() == req.body._id); // If issue does not exist, return if (index === -1) { return res.status(200).json({ error: 'could not update', _id: req.body._id }) } // Filter req.body to remove fields that are empty let updateObj = {...req.body} Object.keys(req.body).map(key =&gt; { if (!req.body[key]) { delete updateObj[key] } }) // If the the only thing left after filtering is the id, return if (Object.keys(updateObj).length &lt;= 1 &amp;&amp; updateObj._id) { return res.status(200).json({ error: 'no update field(s) sent', _id: req.body._id }) } // Update object issues[index] = { ...issues[index], ...updateObj }; // Save the updated object await Project.updateOne({_id: existingProject._id}, existingProject); // If Project exists, return its issue array return res.status(200).json({ result: 'successfully updated', _id: req.body._id }); } catch(err) { // Return error return res.status(500).json(err); } }) </code></pre> <p>The Schema:</p> <pre><code>const ProjectSchema = new Schema({ name: { type: String, required: [true, &quot;Path `project name` is required.&quot;] }, issues: [ { _id: Schema.Types.ObjectId, issue_title: { type: String, required: [true, &quot;required field(s) missing&quot;] }, issue_text: { type: String, required: [true, &quot;required field(s) missing&quot;] }, created_on: String, updated_on: String, created_by: { type: String, required: [true, &quot;required field(s) missing&quot;] }, assigned_to: String, open: Boolean, status_text: String } ] }) const Project = mongoose.model('Project', ProjectSchema); </code></pre>

270382

<p>This is follow-up on <a href="https://codereview.stackexchange.com/questions/220557/sql-odbc-bind-to-c-classes-row-wise">SQL (ODBC) bind to C++ classes row-wise</a></p> <p>The main idea behind this code is to minimize the number of ODBC API calls, because profiling shows significant amount of time is spent in intermediate layers (not waiting for IO). <a href="https://docs.microsoft.com/en-us/sql/odbc/reference/develop-app/row-wise-binding?view=sql-server-ver15" rel="nofollow noreferrer">ODBC supports bulk processing</a>, but it requires all buffers to be in-place (see picture at link), so I can't bind to <code>std::string</code> directly and I need to transform my domain objects to flat memory layout.</p> <p>There are 3 minor problems with this code marked with <code>// (A)</code>, <code>// (B)</code> and <code>// (C)</code>:</p> <ul> <li>(A): this two fold expressions only compiles with GCC and pre-release MSVC. Any suggestions for Clang?</li> <li>(B): I didn't find an easy way to infer this type from parameter pack.</li> <li>(C): This class exists only to differentiate between SQL parameters and SQL columns parameters pack.</li> </ul> <pre><code>namespace details { enum class bind_type { defaultType, timestamp, }; template &lt;typename T, typename V&gt; struct bind_desc { // using owner_type = V; using type = T; std::size_t size/* = 1 / 0*/; T V::* value; bind_type odbcType; }; #pragma region dto struct ts_dto { SQL_TIMESTAMP_STRUCT buf; SQLLEN len; static constexpr SQLSMALLINT sql_c_type = SQL_C_TYPE_TIMESTAMP; static constexpr SQLSMALLINT sql_type = SQL_TYPE_TIMESTAMP; std::string toValue() const { return len == sizeof buf ? TimestampToString(buf) : (_ASSERT(len == SQL_NULL_DATA), std::string{}); } void fromValue(std::string_view v) { buf = StringToTimestamp(v); if (IsNullTimestamp(buf)) len = SQL_NULL_DATA; else len = sizeof (SQL_TIMESTAMP_STRUCT); } }; struct ts_nn_dto { SQL_TIMESTAMP_STRUCT buf; static constexpr SQLSMALLINT sql_c_type = SQL_C_TYPE_TIMESTAMP; static constexpr SQLSMALLINT sql_type = SQL_TYPE_TIMESTAMP; std::string toValue() const { return TimestampToString(buf); } void fromValue(std::string_view v) { buf = StringToTimestamp(v); } }; template &lt;std::size_t col_size&gt; struct string_dto { char buf[col_size]; SQLLEN len; static constexpr SQLSMALLINT sql_c_type = SQL_C_CHAR; static constexpr SQLSMALLINT sql_type = SQL_VARCHAR; std::string toValue() const { // bufferSize &gt;= gotlength or is null _ASSERTE(col_size - 1u &gt;= std::size_t(len) || len == SQL_NULL_DATA); std::string ret; if (len != SQL_NULL_DATA) { _ASSERT(len &gt;= 0); // len - the length of the data before truncation because of the data buffer being too small ret.assign(buf, std::clamp&lt;std::size_t&gt;(len, 0, col_size - 1u)); } return ret; } void fromValue(std::string_view v) { _ASSERT(sizeof buf &gt;= v.size()); // throw? len = v.copy(buf, sizeof buf); } }; struct long_nn_dto { long buf; static constexpr SQLSMALLINT sql_c_type = SQL_C_SLONG; static constexpr SQLSMALLINT sql_type = SQL_INTEGER; long toValue() const { return buf; } void fromValue(long v) { buf = v; } }; struct long_dto { long buf; SQLLEN len; static constexpr SQLSMALLINT sql_c_type = SQL_C_SLONG; long toValue() const { return len == sizeof buf ? buf : (_ASSERT(len == SQL_NULL_DATA), 0); } }; #pragma endregion template &lt;typename T, std::size_t col_size, bind_type odbcType&gt; consteval auto to_dto() { if constexpr (std::is_same_v&lt;T, std::string&gt;) { if constexpr (odbcType == bind_type::timestamp) { if constexpr (col_size == 0) return ts_nn_dto{}; else return ts_dto{}; } else return string_dto&lt;col_size + 1&gt;{}; // + '\0' } else if constexpr (std::is_same_v&lt;T, long&gt;) { if constexpr (col_size == 0) return long_nn_dto{}; else return long_dto{}; } else static_assert(dependent_false&lt;T&gt;, &quot;implement dto for T&quot;); } template &lt;bind_desc Col&gt; using to_dto_t = decltype(to_dto&lt;typename decltype(Col)::type, Col.size, Col.odbcType&gt;()); template&lt;typename x&gt; concept has_len_member = requires { &amp;x::len; }; template &lt;typename dto&gt; bool BindCol(SQLHSTMT stmt, SQLUSMALLINT n, dto&amp; dto_column) { SQLPOINTER buf_ptr = [&amp;] { if constexpr (std::is_array_v&lt;decltype(dto_column.buf)&gt;) return dto_column.buf; else return &amp;dto_column.buf; }(); SQLLEN* len_ptr = [&amp;]() -&gt; SQLLEN* { if constexpr (details::has_len_member&lt;dto&gt;) return &amp;dto_column.len; else return nullptr; }(); const SQLRETURN rc = ::SQLBindCol(stmt, n, dto::sql_c_type, buf_ptr, sizeof dto_column.buf, len_ptr); //show_v&lt;sizeof dto_column.buf&gt;{}; return rc == SQL_SUCCESS; } ///////////////////////////////////////////////////////////// template &lt;typename T, std::size_t col_size, bind_type odbcType&gt; consteval auto to_param_dto() { if constexpr (std::is_same_v&lt;T, std::string&gt;) { if constexpr (odbcType == bind_type::timestamp) { if constexpr (col_size == 0) return ts_nn_dto{}; else return ts_dto{}; } else return string_dto&lt;col_size&gt;{}; } else if constexpr (std::is_same_v&lt;T, long&gt;) { if constexpr (col_size == 0) return long_nn_dto{}; else static_assert(dependent_false&lt;T&gt;, &quot;nullable long param not implemented&quot;); } else static_assert(dependent_false&lt;T&gt;, &quot;implement dto for T&quot;); } template &lt;bind_desc Par&gt; using to_param_dto_t = decltype(to_param_dto&lt;typename decltype(Par)::type, Par.size, Par.odbcType&gt;()); template &lt;typename dto&gt; bool BindParam(SQLHSTMT stmt, SQLUSMALLINT n, dto&amp; dto_column) { SQLPOINTER buf_ptr = [&amp;] { if constexpr (std::is_array_v&lt;decltype(dto_column.buf)&gt;) return dto_column.buf; else return &amp;dto_column.buf; }(); SQLLEN* len_ptr = [&amp;] { if constexpr (details::has_len_member&lt;dto&gt;) return &amp;dto_column.len; else return nullptr; }(); const SQLRETURN rc = ::SQLBindParameter(stmt, n, SQL_PARAM_INPUT, dto::sql_c_type, dto::sql_type, /*col_size*/sizeof dto_column.buf, /*scale*/0, buf_ptr, 0, len_ptr); return rc == SQL_SUCCESS; } } template&lt;typename V = void, details::bind_desc... Cols&gt; class OdbcBinder // (C) { template&lt;typename P, details::bind_desc... Par&gt; static auto BindParams(COdbc&amp; odbc, SQLHSTMT stmt, const std::vector&lt;P&gt;&amp; v) { using DTOProw = tuple&lt;details::to_param_dto_t&lt;Par&gt;...&gt;; static_assert(std::is_trivial_v&lt;DTOProw&gt; &amp;&amp; std::is_standard_layout_v&lt;DTOProw&gt;); std::unique_ptr&lt;DTOProw[]&gt; res = std::make_unique_for_overwrite&lt;DTOProw[]&gt;(v.size()); constexpr auto ConvertParam = []&lt;std::size_t... I&gt; (DTOProw&amp; dto, const P&amp; t, std::index_sequence&lt;I...&gt;) { ((get&lt;I&gt;(dto).fromValue(t.*(Par.value))), ...); // (A) }; constexpr auto is = std::make_index_sequence&lt;sizeof...(Par)&gt;{}; for (std::size_t i = 0; i &lt; v.size(); ++i) ConvertParam(res[i], v[i], is); SQLUSMALLINT N = 0; apply( [&amp;](auto&amp;... dto_row) { if (!(details::BindParam(stmt, ++N, dto_row) &amp;&amp; ...)) throw ODBCException(&quot;OB: SQLBindParameter&quot;, SQL_ERROR, odbc.LogLastError(stmt)); }, res[0]); return res; } static void Exec(COdbc&amp; odbc, SQLHSTMT stmt, std::string_view query) { SQLRETURN rc = ::SQLExecDirect(stmt, (SQLCHAR*)query.data(), static_cast&lt;SQLINTEGER&gt;(query.size())); if (!SQL_SUCCEEDED(rc)) { throw ODBCException(&quot;OB: SQLExecDirect&quot;, rc, odbc.LogLastError(stmt)); } } static std::vector&lt;V&gt; GetQueryResultInternal(COdbc&amp; odbc, SQLHSTMT stmt, std::string_view query, SQLULEN limit, SQLULEN batchSize) { using DTOrow = tuple&lt;details::to_dto_t&lt;Cols&gt;...&gt;; //show&lt;DTOrow&gt;{}; constexpr SQLULEN default_batch_size = 32 * 1024 / sizeof(DTOrow); // 32 kb at least if (batchSize == 0) batchSize = limit != 0 &amp;&amp; limit &lt; default_batch_size ? limit : default_batch_size; static_assert(std::is_trivial_v&lt;DTOrow&gt; &amp;&amp; std::is_standard_layout_v&lt;DTOrow&gt;); static_assert(std::is_nothrow_move_constructible_v&lt;V&gt;); // for fast std::vector reallocation SQLRETURN rc; if (limit != 0) { rc = ::SQLSetStmtAttr(stmt, SQL_ATTR_MAX_ROWS, (SQLPOINTER)limit, SQL_IS_UINTEGER); _ASSERT(rc == 0); if (rc != SQL_SUCCESS) odbc.LogLastError(stmt); } Exec(odbc, stmt, query); const std::unique_ptr&lt;DTOrow[]&gt; mem = std::make_unique_for_overwrite&lt;DTOrow[]&gt;(batchSize); //std::span&lt;DTOrow&gt; rowArray(mem.get(), batchSize); SQLULEN numRowsFetched = 0; rc = ::SQLSetStmtAttr(stmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER)batchSize, SQL_IS_UINTEGER); _ASSERT(rc == 0); rc = ::SQLSetStmtAttr(stmt, SQL_ATTR_ROW_BIND_TYPE, (SQLPOINTER)sizeof(DTOrow), SQL_IS_UINTEGER); _ASSERT(rc == 0); rc = ::SQLSetStmtAttr(stmt, SQL_ATTR_ROWS_FETCHED_PTR, &amp;numRowsFetched, SQL_IS_POINTER); _ASSERT(rc == 0); // Bind columns SQLUSMALLINT N = 0; apply( [&amp;](auto&amp;... dto_row) { if (!(details::BindCol(stmt, ++N, dto_row) &amp;&amp; ...)) throw ODBCException(&quot;OB: SQLBindCol&quot;, SQL_ERROR, odbc.LogLastError(stmt)); }, mem[0]); std::vector&lt;V&gt; results; results.reserve(batchSize); constexpr auto Convert = []&lt;std::size_t... I&gt;(const DTOrow &amp; t, std::index_sequence&lt;I...&gt;) -&gt; V { V value; ((value.*(Cols.value) = get&lt;I&gt;(t).toValue()), ...); // (A) return value; }; constexpr auto is = std::make_index_sequence&lt;sizeof...(Cols)&gt;{}; do { while (SQL_SUCCEEDED((rc = ::SQLFetch(stmt)))) { if (rc == SQL_SUCCESS_WITH_INFO) odbc.LogLastError(stmt); for (SQLUINTEGER i = 0; i &lt; numRowsFetched; ++i) { results.emplace_back(Convert(mem[i], is)); } } if (rc != SQL_NO_DATA) { throw ODBCException(&quot;OB: SQLFetch&quot;, rc, odbc.LogLastError(stmt)); } } while (SQL_SUCCEEDED((rc = ::SQLMoreResults(stmt)))); if (rc != SQL_NO_DATA) { throw ODBCException(&quot;OB: SQLMoreResults&quot;, rc, odbc.LogLastError(stmt)); } if (results.capacity() &gt; results.size() * 3) results.shrink_to_fit(); return results; } public: OdbcBinder() = delete; OdbcBinder(const OdbcBinder&amp;) = delete; OdbcBinder(OdbcBinder&amp;&amp;) = delete; template&lt;typename P, details::bind_desc... Par&gt; static void ExecuteWithParams(COdbc&amp; odbc, const std::vector&lt;P&gt;&amp; v, std::string_view query) { autoHSTMT stmt{ odbc.GetHstmt() }; auto pDto = BindParams&lt;P, Par...&gt;(odbc, stmt, v); Exec(odbc, stmt, query); SQLRETURN rc; while (SQL_SUCCEEDED((rc = ::SQLMoreResults(stmt)))) /* empty */; if (rc != SQL_NO_DATA) { throw ODBCException(&quot;OB: SQLMoreResults&quot;, rc, odbc.LogLastError(stmt)); } } template&lt;typename P, details::bind_desc... Par&gt; static std::vector&lt;V&gt; GetQueryResultWithParams(COdbc&amp; odbc, const std::vector&lt;P&gt;&amp; v, std::string_view query, SQLULEN limit = 0, SQLULEN batchSize = 0) { autoHSTMT stmt{ odbc.GetHstmt() }; auto pdto = BindParams&lt;P, Par...&gt;(odbc, stmt, v); return GetQueryResultInternal(odbc, stmt, query, limit, batchSize); } static std::vector&lt;V&gt; GetQueryResult(COdbc&amp; odbc, std::string_view query, SQLULEN limit = 0, SQLULEN batchSize = 0) { autoHSTMT stmt{ odbc.GetHstmt() }; return GetQueryResultInternal(odbc, stmt, query, limit, batchSize); } }; namespace details { template&lt;typename T&gt; concept not_varsize = std::integral&lt;T&gt; || std::floating_point&lt;T&gt; || std::same_as&lt;T, SQL_TIMESTAMP_STRUCT&gt;; } template &lt;typename V&gt; consteval auto sized(std::string V::* ptr, std::size_t col_size) { return details::bind_desc&lt;std::string, V&gt;{ col_size, ptr }; } template &lt;details::not_varsize T, typename V&gt; consteval auto not_null(T V::* ptr) { return details::bind_desc&lt;T, V&gt;{ 0, ptr }; } template &lt;details::not_varsize T, typename V&gt; consteval auto nullable(T V::* ptr) { return details::bind_desc&lt;T, V&gt;{ 1, ptr }; } template &lt;typename V&gt; consteval auto not_null_ts(std::string V::* ptr) { return details::bind_desc&lt;std::string, V&gt;{ 0, ptr, details::bind_type::timestamp }; } template &lt;typename V&gt; consteval auto nullable_ts(std::string V::* ptr) { return details::bind_desc&lt;std::string, V&gt;{ 1, ptr, details::bind_type::timestamp }; } </code></pre> <p>Usage example:</p> <pre class="lang-cpp prettyprint-override"><code>struct Incident { long id; std::string name; std::string comments; /* ... */ std::string timeSend; std::string timeClosed; long num; }; int main() { auto odbc = COdbc{}; // create connection, etc std::vector&lt;Incident&gt; vec = OdbcBinder&lt;Incident // (B) , not_null(&amp;Incident::id) , sized(&amp;Incident::name, 25) , sized(&amp;Incident::comments, 100) , not_null_ts(&amp;Incident::timeSend) , nullable_ts(&amp;Incident::timeClosed) , nullable(&amp;Incident::num) &gt;::GetQueryResult(odbc, &quot;select ID, COMMENTS, &quot; /* ... */ &quot;TIME_CLOSED from INCIDENTS&quot;); OdbcBinder&lt;&gt;::ExecuteWithParams&lt;Incident // (B) , not_null(&amp;Incident::id) , sized(&amp;Incident::name, 25) , sized(&amp;Incident::comments, 100) , not_null_ts(&amp;Incident::timeSend) , nullable_ts(&amp;Incident::timeClosed) &gt;(odbc, vec, &quot;insert into INCIDENTS values (?, ?, ?, ?, ?)&quot;); } </code></pre> <p>Full code with ODBC API stubs: <a href="https://godbolt.org/z/c9oxq7GMc" rel="nofollow noreferrer">https://godbolt.org/z/c9oxq7GMc</a></p>

270384

<p>This question is a supplement to my previous question: <a href="https://codereview.stackexchange.com/questions/270323/counting-absolute-nesting-levels-of-an-iterable">Counting 'absolute' nesting levels of an iterable</a>.</p> <p>I would like to expand functionality of counting nests in order to get values from given nest. I created 2 examples:</p> <pre class="lang-py prettyprint-override"><code>dct_test = { &quot;a&quot;: {1: 2, 2: 3, 3: 4}, &quot;b&quot;: {&quot;x&quot;: &quot;y&quot;, &quot;z&quot;: [1, 2, 3, {7, 8}]}, &quot;c&quot;: {&quot;l&quot;: (2, 3, 5), &quot;j&quot;: {&quot;a&quot;: {&quot;k&quot;: 1, &quot;l&quot;: [1, 3, (2, 7, {&quot;x&quot;: 1})]}}}, &quot;d&quot;: [1, (2, 3)], &quot;e&quot;: 5 } tpl_test = (1, [3, 4, {5, 6, 7}], {&quot;a&quot;: 5, &quot;b&quot;: [9, 8]}, 2) </code></pre> <p>Picture below shows an algorithm of counting with values that should be returned from each level: <a href="https://i.stack.imgur.com/JzWHt.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/JzWHt.png" alt="Algorithm" /></a></p> <p>Here's code:</p> <pre class="lang-py prettyprint-override"><code>from collections.abc import Iterable from itertools import chain # EXAMPLES dct_test = { &quot;a&quot;: {1: 2, 2: 3, 3: 4}, &quot;b&quot;: {&quot;x&quot;: &quot;y&quot;, &quot;z&quot;: [1, 2, 3, {7, 8}]}, &quot;c&quot;: {&quot;l&quot;: (2, 3, 5), &quot;j&quot;: {&quot;a&quot;: {&quot;k&quot;: 1, &quot;l&quot;: [1, 3, (2, 7, {&quot;x&quot;: 1})]}}}, &quot;d&quot;: [1, (2, 3)], &quot;e&quot;: 5 } tpl_test = (1, [3, 4, {5, 6, 7}], {&quot;a&quot;: 5, &quot;b&quot;: [9, 8]}, 2) # FUNCTIONS # converting a collection to a list def ConvertIterableToList( coll: Iterable, ): # check if argument is a collection if isinstance(coll, (tuple, list, set, dict)): # if the argument is a tuple or set - convert to list if isinstance(coll, (tuple, set)): return list(coll) # if the argument is a dictionary - get values of a dictionary and convert them to list elif isinstance(coll, dict): return list(coll.values()) # if the argument is a list - return collection elif isinstance(coll, list): return coll else: raise TypeError(&quot;Given argument is not a list, tuple, set or dictionary&quot;) # author: FMc # https://codereview.stackexchange.com/a/270335/252081 def GetIterDepth( coll: Iterable, ): # returning coll if it's a tuple, list or set # returning values of dictionary if coll is dict # returning None if coll is not a collection iter_to_inspect = ( coll if isinstance(coll, (tuple, list, set)) else coll.values() if isinstance(coll, dict) else None ) # # 0 means coll is not a collection at all # # 1 means coll has no nests # # 1 + max(...) means coll has nested collections # iterate over iter_to_inspect in order to get one level deeper # recursion is needed to inspect deeper nests # max() stores result for each case of a collections inside a collection # 1 is a kind incrementator/counter for looping over collections inside a collection return ( 0 if iter_to_inspect is None else 1 if not iter_to_inspect else 1 + max(GetIterDepth(i) for i in iter_to_inspect) ) # returns a list of collections extracted from a collection def PeelIter( coll: Iterable ): if isinstance(coll, (tuple, list, set, dict)): return [i for i in ConvertIterableToList(coll) if isinstance(i, (tuple, list, set, dict))] else: raise TypeError(&quot;Given argument is not a list, tuple, set or dictionary&quot;) # returns a collection from a given level def GetItersFromLevel( coll: Iterable, level: int ): # argument must be a collection - error otherwise if not isinstance(coll, (tuple, list, set, dict)): raise TypeError(&quot;Given argument is not a list, tuple, set or dictionary&quot;) # maximum number of nests (levels) inside a collection n_levels = GetIterDepth(coll) # level cannot be equal to 0 or less if level &lt; 1: raise ValueError(f&quot;Given level ({level}) is not greater or equal 1.&quot;) # level cannot be greater than maximum number of levels if level &gt; n_levels: raise ValueError(f&quot;Given level ({level}) is bigger than maximum number of levels \ in a collection ({n_levels}).&quot;) # if level is 1 - no computation is needed - simply return a collection if level == 1: # if coll is dict return only values if isinstance(coll, dict): return list(coll.values()) else: return coll # if level if greater than one else: # assuming function needs to return at least 2nd level # we have to &quot;peel&quot; a collection at start iter_to_inspect = PeelIter(coll) # looping as many times as deep is a collection # in order to avoid recursion or indefinite while loop # we can start from 2 as there's no need to inspect 1st level # we have to add 1 to n_levels because range(from, to) ends at (to - 1) for i in range(2, n_levels + 1): # if i is less than given level we have to continue peeling if i &lt; level: # peeling iter_to_inspect as well as j is needed because: # 1. peeling iter_to inspect returns list of collections inside iter_to_inspect # 2. peeling j returns collections from elements inside list of collections # # from peeled iter_to_inspect # iter_to_inspect returns list of lists containing single collections # flattening is needed because otherwise function would constantly iterate # # over the same peeled collection iter_to_inspect = \ list(chain.from_iterable([PeelIter(j) for j in PeelIter(iter_to_inspect)])) else: return iter_to_inspect print(&quot;1st level: &quot;, GetItersFromLevel(dct_test, 1)) # returns dct_test.values() so it's correct print(&quot;2nd level: &quot;, GetItersFromLevel(dct_test, 2)) print(&quot;3rd level: &quot;, GetItersFromLevel(dct_test, 3)) print(&quot;4th level: &quot;, GetItersFromLevel(dct_test, 4)) print(&quot;5th level: &quot;, GetItersFromLevel(dct_test, 5)) print(&quot;6th level: &quot;, GetItersFromLevel(dct_test, 6)) print(&quot;7th level: &quot;, GetItersFromLevel(dct_test, 7)) print(&quot;8th level: &quot;, GetItersFromLevel(dct_test, 8), &quot;\n&quot;) # error print(&quot;1st level: &quot;, GetItersFromLevel(tpl_test, 1)) print(&quot;2nd level: &quot;, GetItersFromLevel(tpl_test, 2)) print(&quot;3rd level: &quot;, GetItersFromLevel(tpl_test, 3)) print(&quot;4th level: &quot;, GetItersFromLevel(tpl_test, 4)) #error </code></pre> <p>Output:</p> <pre class="lang-py prettyprint-override"><code>1st level: [{1: 2, 2: 3, 3: 4}, {'x': 'y', 'z': [1, 2, 3, {8, 7}]}, {'l': (2, 3, 5), 'j': {'a': {'k': 1, 'l': [1, 3, (2, 7, {'x': 1})]}}}, [1, (2, 3)], 5] 2nd level: [{1: 2, 2: 3, 3: 4}, {'x': 'y', 'z': [1, 2, 3, {8, 7}]}, {'l': (2, 3, 5), 'j': {'a': {'k': 1, 'l': [1, 3, (2, 7, {'x': 1})]}}}, [1, (2, 3)]] 3rd level: [[1, 2, 3, {8, 7}], (2, 3, 5), {'a': {'k': 1, 'l': [1, 3, (2, 7, {'x': 1})]}}, (2, 3)] 4th level: [{8, 7}, {'k': 1, 'l': [1, 3, (2, 7, {'x': 1})]}] 5th level: [[1, 3, (2, 7, {'x': 1})]] 6th level: [(2, 7, {'x': 1})] 7th level: [{'x': 1}] Traceback (most recent call last): (...) ValueError: Given level (8) is bigger than maximum number of levels in a collection (7). 1st level: (1, [3, 4, {5, 6, 7}], {'a': 5, 'b': [9, 8]}, 2) 2nd level: [[3, 4, {5, 6, 7}], {'a': 5, 'b': [9, 8]}] 3rd level: [{5, 6, 7}, [9, 8]] Traceback (most recent call last): (...) ValueError: Given level (4) is bigger than maximum number of levels in a collection (3). </code></pre> <p>So, I reached my goal but I think this code, like code for counting nests, can be more neat (@FMc - big thanks). I would be grateful for any tips because I'm rather a beginner. Do you have any?</p>

270386

<p>I am new to react and I tried to implement a TODO application using react state and props. I need somebody to just review the code and suggest improvements in the code. Currently I have not added any CSS to it, I am focusing more on react practices. code sandbox link- <a href="https://codesandbox.io/s/adoring-archimedes-se4vm" rel="nofollow noreferrer">https://codesandbox.io/s/adoring-archimedes-se4vm</a></p> <p>App.jsx</p> <pre><code>import './App.css'; import InputForm from './InputForm'; import ShowTODO from './ShowTODO' import Choices from './Choices'; import {useState} from 'react' function App(props) { const [todoList, setTODOList] = useState([]); const [filterName, setFilterName] = useState(&quot;active&quot;); const addTODO = (event, todoInput) =&gt; { // if you do not do this then if form submit is clicked // then page will refresh and everything will go event.preventDefault(); var currentTODO = {&quot;state&quot;: &quot;active&quot;, &quot;data&quot;: todoInput}; var previousTODOList = [...todoList]; previousTODOList.push(currentTODO); setTODOList(previousTODOList); } const updateFilterName = (event) =&gt; { let newFilterName = event.target.value; setFilterName(newFilterName); console.log(todoList); } const updateTODOStatus = (index, newState) =&gt; { let previousTODOList = [...todoList]; previousTODOList[index][&quot;state&quot;] = newState; setTODOList(previousTODOList); } return ( &lt;div className=&quot;App&quot;&gt; &lt;InputForm onSubmit={addTODO}/&gt; &lt;Choices filterName={filterName} onChange={(e) =&gt; updateFilterName(e)}/&gt; &lt;p&gt; {filterName} &lt;/p&gt; &lt;ShowTODO filterName={filterName} todoList={todoList} updateStatus={updateTODOStatus}/&gt; &lt;/div&gt; ); } export default App; </code></pre> <p>Choices.jsx</p> <pre><code>function Choices(props) { return ( &lt;div&gt; &lt;select value={props.filterName} onChange={(event)=&gt;props.onChange(event)}&gt; &lt;option value=&quot;active&quot;&gt; Show active to do &lt;/option&gt; &lt;option value=&quot;completed&quot;&gt; Show completed to do &lt;/option&gt; &lt;option value=&quot;all&quot;&gt; Show all to do &lt;/option&gt; &lt;/select&gt; &lt;/div&gt; ); } export default Choices; </code></pre> <p>InputForm.jsx</p> <pre><code>import './App.css'; import {useState} from 'react' function InputForm(props) { const [todoInput, setTODOInput] = useState(&quot;&quot;); const addTODO = (event)=&gt;{ props.onSubmit(event, todoInput); } const updateInputValue = (event) =&gt; { setTODOInput(event.target.value); } return ( &lt;div className=&quot;InputForm&quot;&gt; &lt;form onSubmit={addTODO}&gt; &lt;input type=&quot;text&quot; name=&quot;todo-input&quot; id=&quot;todo-input&quot; value={todoInput} onChange={(event)=&gt;updateInputValue(event)} /&gt; &lt;button&gt; Add To Do &lt;/button&gt; &lt;/form&gt; &lt;/div&gt; ); } export default InputForm; </code></pre> <p>ShowTODO.jsx</p> <pre><code>function ShowTODO(props) { return ( &lt;div&gt; { props.todoList.map((todo, index) =&gt; { return ( &lt;div key={index}&gt; {todo.state === &quot;active&quot; &amp;&amp; props.filterName === &quot;active&quot; &amp;&amp; &lt;span&gt; {todo.data} Mark as complete &lt;input type=&quot;checkbox&quot; onClick={()=&gt;props.updateStatus(index, &quot;completed&quot;)}/&gt; &lt;/span&gt; } {todo.state === &quot;completed&quot; &amp;&amp; props.filterName === &quot;completed&quot; &amp;&amp; &lt;span&gt; {todo.data} Mark as active &lt;input type=&quot;checkbox&quot; onClick={()=&gt;props.updateStatus(index, &quot;active&quot;)}/&gt; &lt;/span&gt;} {props.filterName === &quot;all&quot; &amp;&amp; &lt;span&gt; {todo.data} &lt;/span&gt;} &lt;/div&gt; ); }) } &lt;/div&gt; ); } export default ShowTODO; </code></pre>

270392

<p>I'm implementing some simple algorithms (e.g. two-sum) in OCaml and I am unsure why my OCaml solution is running much slower than the equivalent Python version.</p> <p>My OCaml version:</p> <pre class="lang-ml prettyprint-override"><code>open Base let two_sum_hash lst target = let rec loop tbl counter = function | [] -&gt; failwith &quot;No sum found&quot; | x :: xs -&gt; match Hashtbl.find tbl x with | None -&gt; Hashtbl.set tbl ~key:(target - x) ~data:counter; loop tbl (counter+1) xs | Some index -&gt; [index; counter] in loop (Hashtbl.create (module Int)) 0 lst </code></pre> <p>and the Python solution</p> <blockquote> <pre class="lang-py prettyprint-override"><code> def two_sum(lst, target): d = {} for i, x in enumerate(lst): if x in d: return [d[x], i] d[target - x] = I </code></pre> </blockquote> <p>The OCaml version runs in ~2.16 seconds and the Python solution runs in ~1.15 seconds for large inputs (e.g. list of 10⁷ elements).</p> <p>What is the reason for OCaml running slower? Am I doing something wrong in my OCaml solution?</p> <p>I know that dicts are heavily optimised in Python - I wonder how/whether can I make the OCaml code more performant.</p>

270395

<p><a href="https://i.stack.imgur.com/HEF6e.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/HEF6e.png" alt="example" /></a></p> <p>given a number and two dimensional array the method will check if the number is in the array the array is quadratic circular size n x n and each quarter of the array contains bigger numbers that the previous quarter(picture added)</p> <p>the code i wrote:</p> <pre><code> public static boolean search(int matrix[][], int key) { int start = 0; int ROWS = matrix.length; int COLS = matrix[0].length; int mid, row, col, value; int end = ROWS * COLS - 1; while (start &lt;= end) { mid = start + (end - start) / 2; row = mid / COLS; col = mid % COLS; value = matrix[row][col]; if (value == key) return true; if (value &gt; key) end = mid - 1; else start = mid + 1; } return false; } </code></pre> <p>my goal is to make this code as efficient as possible in terms of time complexity,can you help me to improve it? and what time complexity is it right now? (o)log n^2?</p>

270396

<p>take an array of two numbers who are not necessarily in order, and then add not just those numbers but any numbers in between. For example, [3,1] will be the same as 1+2+3 and not just 3+1.</p> <pre><code>function sumAll(arr) { let start = arr[0]; let end = arr[1]; if (start &gt; end) { let temp = start; start = end; end = temp; } return getSum(start, end); } function getSum(start, end) { if (start === end) return start; return end + getSum(start, end-1); } </code></pre>

270400

<p>This is my first real personal application and I'm just looking for some outside feedback. Completely built in Python, this is a Pokédex for the Pokémon Mystery Dungeon series. I hope to eventually publish to the Android app store. If you choose to check it out... don't be nice. Tell me how bad it is, (just make sure you tell me how to fix it too).</p> <pre><code>import os, json from assets.utilities.pokeapi import api from assets.data.models.pokemon import Pokemon class Version: def __init__(dex, name): dex.basepath = &quot;assets/data/storage/json/&quot; dex.name = name dex.version = dex.getversion() dex.pokemon = dex.version['pokemon'] dex.pokedex = [] def getversion(dex): versionpath = f&quot;{dex.basepath}versions/{dex.name}.json&quot; if os.path.exists(versionpath): with open(versionpath) as file: file = file.read() version = json.loads(file) return version def getpokemon(dex): count = 1 for pokemon in dex.pokemon: dexid = pokemon['dexid'] species = pokemon['species'] path = f&quot;{dex.basepath}pokemon/{species}.json&quot; with open(path) as file: file = file.read() pokemon = json.loads(file) try: typing = pokemon['typing'] abilities = pokemon['abilities'] moveset = pokemon['moveset'] except: stop = len(dex.pokemon) # stop = 9 if count &lt;= stop: data = api.pokemon(dexid, species) print(f'requesting {count} of {stop}') typing = data.typing() abilities = data.abilities() moveset = data.moveset() pokemon.update({'typing': typing, 'abilities': abilities, 'moveset': moveset}) pokemon = json.dumps(pokemon) with open(path, 'w') as file: file.write(pokemon) count += 1 else: break else: pokemon = Pokemon(pokemon) dex.pokedex.append(pokemon) return </code></pre> <p>The rest is GitHub repo: <a href="https://github.com/austenc-id/MysteonDex/tree/b30729041fc2d73df76fc4c574ab653c0ce46e34" rel="nofollow noreferrer">https://github.com/austenc-id/MysteonDex/</a></p>

270403

<p>So to check my Python knowledge I am building a cricket scoreboard in Python. My scoreboard could be able to can be used to store previous matches ' scores. A work in progress as of now. But as of now, it is a 50/50 success. I might have done 50% of the work already, but I am can't move forward. I have my code on GitLab @ <a href="https://gitlab.com/AnantGupta/cricket-scoreboard" rel="nofollow noreferrer">https://gitlab.com/AnantGupta/cricket-scoreboard</a> where there is a python file named <code>main.py</code>. I have added what I have done in <code>README.md</code> and what I am aiming to do in the cricket scoreboard. I am adding comments for you all for having less problem in finding which code does what. Here is what I have done as of now</p> <pre><code>Start a game Can do toss Can calculate runs/wickets/extras/run rate Will store/read every previous score Can remove all the previous score </code></pre> <p>And here is what I am aiming to do</p> <pre><code>Adding batsman's name Add runs and bowls to the batsman Adding bowler name Add runs and wickets to the bowlers Change strike on even runs (1s, 3s, 5s, etc) Change strike after over ends (if the bowl is either dot ball, double, four, six, etc) </code></pre> <p>As of now, I am looking for hints on how I can do to accomplish this stuff. Also, you can look at the code, where you can improve my code. If I like the suggestion I will implement it in my code (You can check my commits on my GitLab).</p> <p>Also english is not my first language so please don't kill me :P</p>

270404

<p>My boss asked me, a <strong>Polar researcher</strong> whose major is biology (surprise!), to do a coding work which I am NOT really good at, for our satelite data processing module. (I'm not even sure why he asked me to do this in the first place...sigh...corporate culture)</p> <p>He said</p> <ol> <li><p>his codes have methods but no class so he'd appreciate if I &quot;assemble&quot; it under a class named nc_methods. (class nc_methods():)</p> </li> <li><p>He also asked me to add &quot; __ str __&quot; (what is this?)</p> </li> <li><p>He asked me finally to add &quot;try~except&quot; just like the first method.</p> </li> </ol> <p>I should finish this work by today but I still have no idea where to start.. Please help</p> <pre><code>import netCDF4 as nc import numpy as np # --- Read DAta modules def Read_NC4(filename, var): try: ds_set = nc.Dataset(filename) except IOError: print(' ...&gt; Fatal Error: unavailable file\n ', filename) dat = -1 else: dat = np.squeeze(ds_set.variables[var][:]) ds_set.close() return dat # Functions def read_nc(ifnm, ds_name): nc_file = nc.Dataset(ifnm, 'r') dat = nc_file.variables[ds_name][:] nc_file.close() return dat def nc_get_dtype(FILE, var): nc_file = nc.Dataset(FILE, 'r') Dat_Type = nc_file.variables[var].dtype nc_file.close() return Dat_Type def nc_variables_meta(FILE, verbose=False): try: nc_file = nc.Dataset(FILE) except OSError as e: print( e.errno ) return -1 # fmt = ' {:&lt;10} {:&lt;15} {:&lt;8} {}' dat_vars = [] for item in nc_file.variables.keys(): var = nc_file.variables[item] if verbose: print(fmt.format(item, str(var.shape), str(var.dtype), var.long_name)) if var.ndim == 3: dat_vars.append(item) # nc_file.close() return dat_vars def nc_dimensions(FILE): nc_file = nc.Dataset(FILE, 'r') dims = nc_file.dimensions #.keys() #size = [ nc_file.dimensions[key].size for key in keys ] out = {}.fromkeys(dims.keys()) for key in dims.keys(): out[key] = dims[key].size nc_file.close() return out def nc_attrs(FILE, var): nc_ds = nc.Dataset(FILE, 'r') attr = {} if var not in nc_ds.variables.keys(): for item in nc_ds.ncattrs(): #print(item, nc_ds.getncattr(item)) attr[item] = nc_ds.getncattr(item) else: for item in nc_ds[var].ncattrs(): attr[item] = getattr(nc_ds[var], item) #attr_keys = nc_ds[var].ncattrs() #target = nc_ds[var] # #attr = {} #for item in attr_keys: # attr[item] = getattr(target, item) nc_ds.close() return attr #def nc_append(var, attr, output): def nc_append(output, var_name, DAT, ATTR): try: dims = ('time','latitude','longitude') nc_ds = nc.Dataset(output, 'r+') N_var = nc_ds.createVariable(var_name, DAT.dtype, dims) N_var.setncatts(ATTR) N_var[:] = DAT nc_ds.close() return True except: return False </code></pre>

270405

<p>I have implemented a library which makes Java Swing programming easier. I am just posting the library. There is a program that uses this library to implement examples of many Swing components but I cannot include that program here because the total size will become more than the allowed limit of 65K characters. I will the examples program in another question.</p> <p>Can someone please do the code review.</p> <p>The code is below:</p> <hr /> <h2>SwingLibrary.java</h2> <pre><code> class SwingLibrary { // if width is 0 then the frame is maximized horizontally // if height is 0 then the frame is maximized vertically public static JFrame setupJFrameAndGet(String title, int width, int height) { int state = 0; JFrame tmpJF = new JFrame(title); if (width == 0) { state = state | JFrame.MAXIMIZED_HORIZ; } if (height == 0) { state = state | JFrame.MAXIMIZED_VERT; } if ((width != 0) || (height != 0)) { tmpJF.setSize(width, height); } tmpJF.setExtendedState(tmpJF.getExtendedState() | state); tmpJF.setLocationRelativeTo(null); tmpJF.setLayout(null); tmpJF.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); return tmpJF; } // end of setupJFrameAndGet // width and height are the preferred width and height of JPanel public static ArrayList&lt;Object&gt; setupScrollableJFrameAndGetFrameAndPanel(String title, int width, int height) { JFrame tmpJF = new JFrame(title); tmpJF.setExtendedState(tmpJF.getExtendedState() | JFrame.MAXIMIZED_BOTH); tmpJF.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //tmpJF.setLayout(null); JPanel tmpJP = new JPanel(); //tmpJP.setBounds(xpos, ypos, width + 1000, height + 1000); tmpJP.setPreferredSize(new Dimension(width, height)); tmpJP.setLayout(null); JScrollPane tmpJSPFrame = new JScrollPane(tmpJP, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS); tmpJSPFrame.getHorizontalScrollBar().setUnitIncrement(10); tmpJSPFrame.getVerticalScrollBar().setUnitIncrement(10); tmpJF.add(tmpJSPFrame); ArrayList&lt;Object&gt; tmpA = new ArrayList&lt;&gt;(); tmpA.add((Object) (tmpJF)); tmpA.add((Object) (tmpJP)); return tmpA; } // end of setupScrollableJFrameAndGetFrameAndPanel // actLisObj: object which implements action listener public static JButton setupJButtonAndGet(String text, Object actLisObj, boolean setBoundsFlag, int xpos, int ypos, int width, int height) { JButton tmpJB = new JButton(text); if (setBoundsFlag == true) { tmpJB.setBounds(xpos, ypos, width, height); } tmpJB.addActionListener((ActionListener) actLisObj); return tmpJB; } // end of setupJButtonAndGet // halign: horizontal alignment of text, valign: vertical alignment of text public static JLabel setupJLabelAndGet(String text, boolean opaque, Color bg, int halign, int valign, boolean setBoundsFlag, int xpos, int ypos, int width, int height) { JLabel tmpJL = new JLabel(text); if (setBoundsFlag == true) { tmpJL.setBounds(xpos, ypos, width, height); } tmpJL.setOpaque(opaque); if (bg != null) { tmpJL.setBackground(bg); } tmpJL.setHorizontalAlignment(halign); tmpJL.setVerticalAlignment(valign); return tmpJL; } // end of setupJlabelAndGet public static JTextField setupJTextFieldAndGet(int xpos, int ypos, int width, int height) { JTextField tmpJTF = new JTextField(); tmpJTF.setBounds(xpos, ypos, width, height); return tmpJTF; } // end of setupJTextFieldAndGet public static JFormattedTextField setupJFormattedTextFieldAndGet(Format fmt, Object initialVal, Object propertyChangeLis, String propertyToListenFor, int xpos, int ypos, int width, int height) { JFormattedTextField tmpJFTF = new JFormattedTextField(fmt); tmpJFTF.setValue(initialVal); tmpJFTF.addPropertyChangeListener(propertyToListenFor, (PropertyChangeListener) propertyChangeLis); tmpJFTF.setBounds(xpos, ypos, width, height); return tmpJFTF; } // end of setupJFormattedTextFieldAndGet // itemLisObj: object which implements item listener public static JCheckBox setupJCheckBoxAndGet(String text, boolean state, Object itemLisObj, int xpos, int ypos, int width, int height) { JCheckBox tmpJCB = new JCheckBox(text, state); tmpJCB.setBounds(xpos, ypos, width, height); tmpJCB.addItemListener((ItemListener) itemLisObj); return tmpJCB; } // end of setupJCheckBoxAndGet // actLisObj: object which implements action listener public static JRadioButton setupJRadioButtonAndGet(String text, boolean state, Object actLisObj, int xpos, int ypos, int width, int height) { JRadioButton tmpJRB = new JRadioButton(text, state); tmpJRB.setBounds(xpos, ypos, width, height); tmpJRB.addActionListener((ActionListener) actLisObj); return tmpJRB; } // end of setupJRadioButtonAndGet public static ButtonGroup setupButtonGroupAndGet() { ButtonGroup tmpBG = new ButtonGroup(); return tmpBG; } // end of setupButtonGroupAndGet public static JPasswordField setupJPasswordFieldAndGet(int xpos, int ypos, int width, int height) { JPasswordField tmpJPF = new JPasswordField(); tmpJPF.setBounds(xpos, ypos, width, height); return tmpJPF; } // end of setupJPasswordFieldAndGet public static JTextArea setupJTextAreaAndGet(String text, int rows, int columns, boolean setEditableFlag, boolean setLineWrapFlag, boolean setWrapStyleWordFlag, boolean setBoundsFlag, int xpos, int ypos, int width, int height) { JTextArea tmpJTA = new JTextArea(text, rows, columns); tmpJTA.setEditable(setEditableFlag); tmpJTA.setLineWrap(setLineWrapFlag); tmpJTA.setWrapStyleWord(setWrapStyleWordFlag); if (setBoundsFlag == true) { tmpJTA.setBounds(xpos, ypos, width, height); } return tmpJTA; } // end of setupJTextAreaAndGet public static JScrollPane setupScrollableJTextAreaAndGet(JTextArea jta, int xpos, int ypos, int width, int height) { JScrollPane tmpJSP = new JScrollPane(jta); tmpJSP.setBounds(xpos, ypos, width, height); return tmpJSP; } // end of setupScrollableJTextAreaAndGet public static JList&lt;String&gt; setupJListAndGet(ListModel&lt;String&gt; lm, int selectionMode, int visibleRowCount, int initialSelectedIndex, Object listSelLisObj, boolean setBoundsFlag, int xpos, int ypos, int width, int height) { JList&lt;String&gt; tmpJList = new JList&lt;String&gt;(lm); tmpJList.setSelectionMode(selectionMode); tmpJList.setVisibleRowCount(visibleRowCount); if (initialSelectedIndex &gt;= 0) { tmpJList.setSelectedIndex(initialSelectedIndex); } tmpJList.addListSelectionListener((ListSelectionListener) listSelLisObj); if (setBoundsFlag == true) { tmpJList.setBounds(xpos, ypos, width, height); } return tmpJList; } // end of setupJListAndGet public static JScrollPane setupScrollableJListAndGet(JList jlist, int xpos, int ypos, int width, int height) { JScrollPane tmpJSP = new JScrollPane(jlist); tmpJSP.setBounds(xpos, ypos, width, height); return tmpJSP; } // end of setupScrollableJListAndGet public static JComboBox&lt;String&gt; setupJComboBoxAndGet(ComboBoxModel&lt;String&gt; cbm, int initialSelectedIndex, Object actLisObj, boolean setBoundsFlag, int xpos, int ypos, int width, int height) { JComboBox&lt;String&gt; tmpJComboBox = new JComboBox&lt;String&gt;(cbm); if (initialSelectedIndex &gt;= 0) { tmpJComboBox.setSelectedIndex(initialSelectedIndex); } tmpJComboBox.addActionListener((ActionListener) actLisObj); if (setBoundsFlag == true) { tmpJComboBox.setBounds(xpos, ypos, width, height); } return tmpJComboBox; } // end of setupJComboBoxAndGet public static JProgressBar setupJProgressBarAndGet(int orientation, int min, int max, int initialVal, boolean borderPaintedFlag, boolean stringPaintedFlag, boolean setBoundsFlag, int xpos, int ypos, int width, int height) { JProgressBar tmpJPB = new JProgressBar(orientation, min, max); tmpJPB.setValue(initialVal); tmpJPB.setBorderPainted(borderPaintedFlag); tmpJPB.setStringPainted(stringPaintedFlag); if (setBoundsFlag == true) { tmpJPB.setBounds(xpos, ypos, width, height); } return tmpJPB; } // end of setupJProgressBarAndGet public static JSlider setupJSliderAndGet(int orientation, int min, int max, int initialVal, int minorTickSpacing, int majorTickSpacing, boolean paintTicksFlag, boolean paintLabelsFlag, Object changeLisObj, boolean setBoundsFlag, int xpos, int ypos, int width, int height) { JSlider tmpJS = new JSlider(orientation, min, max, initialVal); tmpJS.setMinorTickSpacing(minorTickSpacing); tmpJS.setMajorTickSpacing(majorTickSpacing); tmpJS.setPaintTicks(paintTicksFlag); tmpJS.setPaintLabels(paintLabelsFlag); tmpJS.addChangeListener((ChangeListener) changeLisObj); if (setBoundsFlag == true) { tmpJS.setBounds(xpos, ypos, width, height); } return tmpJS; } // end of setupJSliderAndGet public static JTree setupJTreeAndGet(DefaultMutableTreeNode rootNode, int selectionMode, Object treeSelLisObj, boolean setBoundsFlag, int xpos, int ypos, int width, int height) { JTree tmpJTree = new JTree(rootNode); tmpJTree.getSelectionModel().setSelectionMode(selectionMode); tmpJTree.addTreeSelectionListener((TreeSelectionListener) treeSelLisObj); if (setBoundsFlag == true) { tmpJTree.setBounds(xpos, ypos, width, height); } return tmpJTree; } // end of setupJTreeAndGet public static JScrollPane setupScrollableJTreeAndGet(JTree jtree, int xpos, int ypos, int width, int height) { JScrollPane tmpJSP = new JScrollPane(jtree); tmpJSP.setBounds(xpos, ypos, width, height); return tmpJSP; } // end of setupScrollableJTreeAndGet public static JSpinner setupJSpinnerAndGet(SpinnerModel sm, boolean editableFlag, Object spinnerChangeLisObj, int xpos, int ypos, int width, int height) { JSpinner tmpJSPN = new JSpinner(sm); tmpJSPN.addChangeListener((ChangeListener) spinnerChangeLisObj); if (editableFlag == false) { JComponent editor = tmpJSPN.getEditor(); if (editor instanceof JSpinner.DefaultEditor) { ((JSpinner.DefaultEditor) editor).getTextField().setEditable(editableFlag); } else { System.out.println(&quot;Error: Could not set editableFlag for JSpinner.&quot;); } } tmpJSPN.setBounds(xpos, ypos, width, height); return tmpJSPN; } // end of setupJSpinnerAndGet public static JColorChooser setupJColorChooserAndGet(Color initialColor, boolean borderTitleFlag, String borderTitle, Object colorChooserChangeLisObj, int xpos, int ypos, int width, int height) { JColorChooser tmpJCC = new JColorChooser(initialColor); tmpJCC.getSelectionModel().addChangeListener((ChangeListener) colorChooserChangeLisObj); if (borderTitleFlag == true) { tmpJCC.setBorder(BorderFactory.createTitledBorder(borderTitle)); } tmpJCC.setBounds(xpos, ypos, width, height); return tmpJCC; } // end of setupJColorChooserAndGet public static JDialog setupJDialogAndGet(Frame owner, String title, boolean modal, int width, int height) { JDialog tmpJD = new JDialog(owner, title, modal); tmpJD.setSize(width, height); tmpJD.setLocationRelativeTo(null); tmpJD.setLayout(null); tmpJD.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE); return tmpJD; } // end of setupJDialogAndGet public static ArrayList&lt;Object&gt; setupScrollableJDialogAndGetDialogAndPanel(Frame owner, String title, boolean modal, int dialogWidth, int dialogHeight, int panelWidth, int panelHeight) { JDialog tmpJD = new JDialog(owner, title, modal); tmpJD.setSize(dialogWidth, dialogHeight); tmpJD.setLocationRelativeTo(null); tmpJD.setLayout(null); tmpJD.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE); JPanel tmpJP = new JPanel(); tmpJP.setPreferredSize(new Dimension(panelWidth, panelHeight)); tmpJP.setLayout(null); ScrollPane sp = new ScrollPane(ScrollPane.SCROLLBARS_ALWAYS); sp.getHAdjustable().setUnitIncrement(10); sp.getVAdjustable().setUnitIncrement(10); sp.add(tmpJP); tmpJD.getRootPane().setContentPane(sp); ArrayList&lt;Object&gt; tmpA = new ArrayList&lt;&gt;(); tmpA.add((Object) (tmpJD)); tmpA.add((Object) (tmpJP)); return tmpA; } // end of setupScrollableJDialogAndGetDialogAndPanel public static JToggleButton setupJToggleButtonAndGet(String text, Object itemLisObj, boolean opaque, Color bgcolor, boolean setBoundsFlag, int xpos, int ypos, int width, int height) { JToggleButton tmpJTB = new JToggleButton(text); if (setBoundsFlag == true) { tmpJTB.setBounds(xpos, ypos, width, height); } tmpJTB.addItemListener((ItemListener) itemLisObj); tmpJTB.setOpaque(opaque); tmpJTB.setBackground(bgcolor); return tmpJTB; } // end of setupJToggleButtonAndGet public static JSeparator setupJSeparatorAndGet(int orientation, Color bgcolor, boolean setBoundsFlag, int xpos, int ypos, int width, int height) { JSeparator tmpJS = new JSeparator(orientation); tmpJS.setBackground(bgcolor); if (setBoundsFlag == true) { tmpJS.setBounds(xpos, ypos, width, height); } return tmpJS; } // end of setupJSeparatorAndGet public static JMenuBar setupJMenuBarAndGet(Color fgcolor, Color bgcolor) { JMenuBar tmpJMB = new JMenuBar(); tmpJMB.setOpaque(true); tmpJMB.setForeground(fgcolor); tmpJMB.setBackground(bgcolor); return tmpJMB; } // end of setupJMenuBarAndGet public static JMenu setupJMenuAndGet(String text, Color fgcolor, Color bgcolor) { JMenu tmpJM = new JMenu(text); tmpJM.setOpaque(true); tmpJM.setForeground(fgcolor); tmpJM.setBackground(bgcolor); return tmpJM; } // end of setupJMenuAndGet public static JMenuItem setupJMenuItemAndGet(String text, Object actLisObj, KeyStroke k, Color fgcolor, Color bgcolor) { JMenuItem tmpJMI = new JMenuItem(text); tmpJMI.setOpaque(true); tmpJMI.setForeground(fgcolor); tmpJMI.setBackground(bgcolor); tmpJMI.setAccelerator(k); if (actLisObj != null) { tmpJMI.addActionListener((ActionListener) actLisObj); } return tmpJMI; } // end of setupJMenuItemAndGet } // end of SwingLibrary </code></pre>

270406

<p>This is in continuation of my previous post for code review of Java Swing Library: <a href="https://codereview.stackexchange.com/questions/270406/java-swing-library">Java Swing Library</a></p> <p>Since the limit on total number of characters is 65K, I split my program in two parts. The first was Java Swing Library and the second one is this one.</p> <p>I have implemented a program that uses my Java Swing Library to show examples of many Swing components.</p> <p>You can use code from this program in your code.</p> <p>Where applicable, appropriate listeners are also implemented.</p> <p>The code of the program is below:</p> <hr /> <h2>Examples_Of_Many_Swing_Components_In_One_Program.java</h2> <pre><code> import java.io.*; import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.util.*; import java.util.List; import java.beans.PropertyChangeListener; import java.beans.PropertyChangeEvent; import java.text.*; import javax.swing.tree.*; import java.time.*; import java.time.format.*; public class Examples_Of_Many_Swing_Components_In_One_Program extends MouseAdapter implements ActionListener, ItemListener, ListSelectionListener, ChangeListener, PropertyChangeListener, TreeSelectionListener { Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); int screenWidth = screenSize.width; int screenHeight = screenSize.height; int midScreenWidth = screenWidth / 2; int midScreenHeight = screenHeight / 2; int xMargin = screenWidth/10; int vGap = 25; // vertical gap between components int hGap = 15; // horizontal gap between components int lineLabelHeight = 10; int currentYPos = 0; int componentHeight = 25; int buttonWidth = 100; Color lightBlue = new Color(173, 216, 230); JFrame jf = null; JPanel jp = null; JButton jbButtonExample = null; JTextField jtfTextFieldExample = null; JButton jbTextFieldExample = null; JFormattedTextField jftfFormattedTextFieldExample = null; JButton jbFormattedTextFieldExample = null; JCheckBox jcb1CheckBoxExample = null; JCheckBox jcb2CheckBoxExample = null; JCheckBox jcb3CheckBoxExample = null; JCheckBox jcb4CheckBoxExample = null; JLabel jlCheckBoxExample = null; JRadioButton jrb1RadioButtonExample = null; JRadioButton jrb2RadioButtonExample = null; JRadioButton jrb3RadioButtonExample = null; JRadioButton jrb4RadioButtonExample = null; JLabel jlRadioButtonExample = null; JButton jbFileChooserExample = null; JTextField jtfFileChooserExample = null; JTextField jpfPasswordFieldExample = null; JButton jbPasswordFieldExample = null; JTextArea jtaTextAreaExample = null; JScrollPane jspScrollableTextAreaExample = null; JButton jbScrollableTextAreaExample = null; JList&lt;String&gt; jlistScrollableListExample = null; JScrollPane jspScrollableListExample = null; JLabel jlScrollableListExample = null; JComboBox&lt;String&gt; jcbComboBoxExample = null; JLabel jlComboBoxExample = null; JProgressBar jpbProgressBarExample = null; JButton jbProgressBarExample = null; JLabel jlProgressBarExample = null; boolean stopThreadProgressBarExample = false; JSlider jsSliderExample = null; JLabel jlSliderExample = null; JTree jtreeScrollableTreeExample = null; JScrollPane jspScrollableTreeExample = null; JLabel jlScrollableTreeExample = null; JSpinner jsSpinnerExample = null; JLabel jlSpinnerExample = null; JColorChooser jccColorChooserExample = null; JLabel jlColorChooserExample = null; JButton jbOptionPaneExamplesMessage = null; JButton jbOptionPaneExamplesInput = null; JButton jbOptionPaneExamplesConfirm = null; JButton jbOptionPaneExamplesOption = null; JDialog jdDialogExample = null; JComboBox jcbDialogExample = null; JFormattedTextField jftfDialogExample = null; JList jlistDialogExample = null; JButton jbDialogExample1 = null; JButton jbDialogExample2 = null; JDialog jdScrollableDialogExample = null; JPanel jpScrollableDialogPanel = null; JButton jbDisplayScrollableDialog = null; JButton jbCloseScrollableDialog = null; JPopupMenu jpmPopupMenuExample = null; JMenuItem jmiPopupMenuExample1 = null; JMenuItem jmiPopupMenuExample2 = null; JToggleButton jtbToggleButtonExample = null; JButton jbToolBarExample = null; JComboBox jcbToolBarExample = null; JMenuBar jmb = null; JMenu jm = null; JMenu jmSubMenu = null; JMenuItem jmiMenuItemExample = null; JCheckBoxMenuItem jcbmiCheckBoxMenuItemExample = null; JRadioButtonMenuItem jrbmiRadioButtonMenuItem1 = null; JRadioButtonMenuItem jrbmiRadioButtonMenuItem2 = null; public void actionPerformed(ActionEvent ae) { Object source = ae.getSource(); if (source == jbButtonExample) { JOptionPane.showMessageDialog(jf, &quot;You clicked the button!&quot;, &quot;Info&quot;, JOptionPane.INFORMATION_MESSAGE); } else if (source == jbTextFieldExample) { String text = &quot;You entered: &quot; + jtfTextFieldExample.getText(); JOptionPane.showMessageDialog(jf, text, &quot;Info&quot;, JOptionPane.INFORMATION_MESSAGE); } else if ((source == jrb1RadioButtonExample) || (source == jrb2RadioButtonExample) || (source == jrb3RadioButtonExample) || (source == jrb4RadioButtonExample)) { String text = &quot;You selected &quot; + &quot;\&quot;&quot; + ((JRadioButton)source).getText() + &quot;\&quot;.&quot;; jlRadioButtonExample.setText(text); } else if (source == jbFileChooserExample) { JFileChooser jfc = new JFileChooser(); if ((jfc.showOpenDialog(jf)) == JFileChooser.APPROVE_OPTION) { File selectedFile = jfc.getSelectedFile(); jtfFileChooserExample.setText(selectedFile.getAbsolutePath()); } } else if (source == jbPasswordFieldExample) { String text = &quot;You entered: &quot; + jpfPasswordFieldExample.getText(); JOptionPane.showMessageDialog(jf, text, &quot;Info&quot;, JOptionPane.INFORMATION_MESSAGE); } else if (source == jbScrollableTextAreaExample) { String text = &quot;You wrote: &quot; + jtaTextAreaExample.getText(); JOptionPane.showMessageDialog(jf, text, &quot;Info&quot;, JOptionPane.INFORMATION_MESSAGE); } else if (source == jcbComboBoxExample) { // source is used here to show that selected item can be gotten from source // instead of using jcbComboBoxExample. String text = (String)(((JComboBox)source).getSelectedItem()); if (text.isBlank() == true) { jlComboBoxExample.setText(text); } else { text = &quot;You selected \&quot;&quot; + text + &quot;\&quot;.&quot;; jlComboBoxExample.setText(text); } } else if (source == jbProgressBarExample) { String buttonText = jbProgressBarExample.getText(); if ((buttonText.equals(&quot;Start Task&quot;) == true) || (buttonText.equals(&quot;Start Task Again&quot;) == true)) { // example of anonymous subclass Thread thread = new Thread() { public void run() { int progress = 10; while (progress &lt;= 100) { if (stopThreadProgressBarExample == true) { stopThreadProgressBarExample = false; jpbProgressBarExample.setValue(0); jbProgressBarExample.setText(&quot;Start Task Again&quot;); jlProgressBarExample.setText(&quot;Task cancelled.&quot;); return; } // end of if stopThreadProgressBarExample jlProgressBarExample.setText(&quot;Task is running..&quot;); jpbProgressBarExample.setValue(progress); if (progress == 100) { break; } try { Thread.sleep(1000); } catch (Exception e) {} progress = progress + 10; } // end of while jbProgressBarExample.setText(&quot;Start Task Again&quot;); jlProgressBarExample.setText(&quot;Task completed.&quot;); } }; // end of new thread thread.start(); jbProgressBarExample.setText(&quot;Cancel Task&quot;); } else if (buttonText.equals(&quot;Cancel Task&quot;) == true) { stopThreadProgressBarExample = true; } // end of if else (comparing strings) } else if (source == jbToolBarExample) { JOptionPane.showMessageDialog(jf, &quot;You clicked Button 1.&quot;, &quot;Info&quot;, JOptionPane.INFORMATION_MESSAGE); } else if (source == jcbToolBarExample) { // source is used here to show that selected item can be gotten from source // instead of using jcbToolBarExample. String text = (String)(((JComboBox)source).getSelectedItem()); if (text.isBlank() == false) { text = &quot;You selected \&quot;&quot; + text + &quot;\&quot;.&quot;; JOptionPane.showMessageDialog(jf, text, &quot;Info&quot;, JOptionPane.INFORMATION_MESSAGE); } } else if (source == jmiMenuItemExample) { String text = &quot;This one program implements examples of many swing components.&quot;; JOptionPane.showMessageDialog(jf, text, &quot;Info&quot;, JOptionPane.INFORMATION_MESSAGE); } else if (source == jcbmiCheckBoxMenuItemExample) { if (jcbmiCheckBoxMenuItemExample.isSelected() == true) { JOptionPane.showMessageDialog(jf, &quot;You have selected check box menu item&quot;, &quot;Info&quot;, JOptionPane.INFORMATION_MESSAGE); } else { JOptionPane.showMessageDialog(jf, &quot;You have unselected check box menu item&quot;, &quot;Info&quot;, JOptionPane.INFORMATION_MESSAGE); } } else if (source == jrbmiRadioButtonMenuItem1) { jp.setBackground(Color.WHITE); } else if (source == jrbmiRadioButtonMenuItem2) { jp.setBackground(null); } else if (source == jmiPopupMenuExample1) { LocalTime time = LocalTime.now(); DateTimeFormatter formatter = DateTimeFormatter.ofPattern(&quot;hh:mm a&quot;); String text = time.format(formatter); JOptionPane.showMessageDialog(jf, text, &quot;Current Time&quot;, JOptionPane.INFORMATION_MESSAGE); } else if (source == jmiPopupMenuExample2) { LocalDate date = LocalDate.now(); DateTimeFormatter formatter = DateTimeFormatter.ofPattern(&quot;dd-LLL-yyyy&quot;); String text = date.format(formatter); JOptionPane.showMessageDialog(jf, text, &quot;Today's Date&quot;, JOptionPane.INFORMATION_MESSAGE); } else if (source == jbDialogExample2) { jcbDialogExample.setSelectedIndex(0); jftfDialogExample.setText(&quot;&quot;); jlistDialogExample.clearSelection(); jdDialogExample.setVisible(true); } else if (source == jbDialogExample1) { String text = &quot;&quot;; boolean error = false; String textMonth = &quot;&quot;; String textYear = &quot;&quot;; String textCountry = &quot;&quot;; textMonth = (String)(jcbDialogExample.getSelectedItem()); if (jftfDialogExample.getValue() != null) { textYear = jftfDialogExample.getText(); } if (jlistDialogExample.getSelectedValue() != null) { textCountry = (String)(jlistDialogExample.getSelectedValue()); } if (textMonth.isBlank() == true) { error = true; text = &quot;Please select your month of birth.\n&quot;; } if (textYear.isBlank() == true) { error = true; text = text + &quot;Please enter your year of birth.\n&quot;; } else if (Integer.valueOf(textYear) &lt;= 0) { error = true; text = text + &quot;Please enter a valid year of birth.\n&quot;; } if (textCountry.isBlank() == true) { error = true; text = text + &quot;Please select your country of birth.\n&quot;; } if (error == true) { JOptionPane.showMessageDialog(jf, text, &quot;Error&quot;, JOptionPane.ERROR_MESSAGE); } else { text = &quot;&quot;; text = &quot;Your month of birth is: &quot; + textMonth + &quot;\n&quot;; text = text + &quot;Your year of birth is: &quot; + textYear + &quot;\n&quot;; text = text + &quot;Your counry of birth is: &quot; + textCountry + &quot;\n&quot;; JOptionPane.showMessageDialog(jf, text, &quot;Your deatils&quot;, JOptionPane.INFORMATION_MESSAGE); } } else if (source == jbDisplayScrollableDialog) { jdScrollableDialogExample.setVisible(true); } else if (source == jbCloseScrollableDialog) { jdScrollableDialogExample.dispose(); } else if (source == jbOptionPaneExamplesMessage) { JOptionPane.showMessageDialog(jf, &quot;This is a Message Dialog Box.&quot;, &quot;Message Dialog Box&quot;, JOptionPane.INFORMATION_MESSAGE); } else if (source == jbOptionPaneExamplesInput) { String text = &quot;You entered: &quot;; String input = JOptionPane.showInputDialog(jf, &quot;Please input some text below:&quot;, &quot;Input Dialog Box&quot;, JOptionPane.PLAIN_MESSAGE); if (input != null) { text = text + input; JOptionPane.showMessageDialog(jf, text, &quot;Text you entered&quot;, JOptionPane.INFORMATION_MESSAGE); } } else if (source == jbOptionPaneExamplesConfirm) { JPasswordField jpf = new JPasswordField(); int result = JOptionPane.showConfirmDialog(jf, jpf, &quot;Please input your password&quot;, JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE); if (result == JOptionPane.OK_OPTION) { String text = &quot;Your password is: &quot; + new String(jpf.getPassword()); JOptionPane.showMessageDialog(jf, text, &quot;Your password&quot;, JOptionPane.INFORMATION_MESSAGE); } } else if (source == jbOptionPaneExamplesOption) { /* JRadioButton jrb1 = new JRadioButton(&quot;Proceed&quot;); JRadioButton jrb2 = new JRadioButton(&quot;Do not proceed, stop here&quot;); JRadioButton jrb3 = new JRadioButton(&quot;Do not proceed, revert back&quot;); Object[] objs = {jrb1, jrb2, jrb3, &quot;Submit&quot;}; */ Object[] objs = new Object[4]; objs[0] = new JRadioButton(&quot;Proceed&quot;); objs[1] = new JRadioButton(&quot;Do not proceed, stop here&quot;); objs[2] = new JRadioButton(&quot;Do not proceed, revert back&quot;); objs[3] = &quot;Submit&quot;; ButtonGroup bg = new ButtonGroup(); bg.add((JRadioButton)(objs[0])); bg.add((JRadioButton)(objs[1])); bg.add((JRadioButton)(objs[2])); int result = JOptionPane.showOptionDialog(jf, &quot;Please select a radio button&quot;, &quot;Option Dialog Box&quot;, JOptionPane.DEFAULT_OPTION, JOptionPane.PLAIN_MESSAGE, null, objs, null); if (result == 3) { // 3 is the index of &quot;Submit&quot; String text = &quot;&quot;; // if-else-if should be used but I am using ifs only to see that whether // more than one radio button gets selected or not or whether something // wrong is happening in UI. if ((((JRadioButton)(objs[0]))).isSelected() == true) { text = text + &quot;You selected: \&quot;Proceed\&quot;.&quot;; } if ((((JRadioButton)(objs[1]))).isSelected() == true) { text = text + &quot;You selected: \&quot;Do not proceed, stop here\&quot;.&quot;; } if ((((JRadioButton)(objs[2]))).isSelected() == true) { text = text + &quot;You selected: \&quot;Do not proceed, revert back\&quot;.&quot;; } if (text.isBlank() == true) { text = &quot;Nothing selected.&quot;; } JOptionPane.showMessageDialog(jf, text, &quot;Your selected choice&quot;, JOptionPane.INFORMATION_MESSAGE); } //String text = &quot;Result is: &quot; + result; //JOptionPane.showMessageDialog(jf, text, &quot;Info&quot;, JOptionPane.INFORMATION_MESSAGE); } } // end of actionPerformed // for JCheckBox and JToggleButton public void itemStateChanged(ItemEvent ie) { String text = &quot;&quot;; Object source = ie.getItemSelectable(); if ((source == jcb1CheckBoxExample) || (source == jcb2CheckBoxExample) || (source == jcb3CheckBoxExample) || (source == jcb4CheckBoxExample)) { if (ie.getStateChange() == ItemEvent.SELECTED) { text = &quot;You selected &quot;; } else { text = &quot;You unselected &quot;; } text = text + &quot;\&quot;&quot; + ((JCheckBox)source).getText() + &quot;\&quot;.&quot;; jlCheckBoxExample.setText(text); } else if (source == jtbToggleButtonExample) { if (jtbToggleButtonExample.isSelected() == true) { jtbToggleButtonExample.setText(&quot;ON&quot;); jtbToggleButtonExample.setOpaque(true); jtbToggleButtonExample.setBackground(Color.GREEN); } else { jtbToggleButtonExample.setText(&quot;OFF&quot;); jtbToggleButtonExample.setOpaque(true); jtbToggleButtonExample.setBackground(Color.YELLOW); } } } // end of itemStateChanged // for JList public void valueChanged(ListSelectionEvent lse) { String text = &quot;&quot;; Object source = lse.getSource(); if (source == jlistScrollableListExample) { List&lt;String&gt; lst = jlistScrollableListExample.getSelectedValuesList(); if (lst.size() &lt;= 0) { jlScrollableListExample.setText(text); } else { text = &quot;Your selected items are: &quot;; boolean first = true; for (String str : lst) { if (first == false) { text = text + &quot;, &quot;; } text = text + str; first = false; } // end of for loop text = text + &quot;.&quot;; jlScrollableListExample.setText(text); } // end of if else } // end of if source } // end of valueChanged // for JSlider, JSpinner, and JColorChooser public void stateChanged(ChangeEvent ce) { String text = &quot;&quot;; Object source = ce.getSource(); if (source == jsSliderExample) { JSlider jsSource = (JSlider)source; if (!jsSource.getValueIsAdjusting()) { int value = (int)(jsSource.getValue()); text = &quot;The current value from slider is: &quot; + value; jlSliderExample.setText(text); } } else if (source == jsSpinnerExample) { JSpinner jspnSource = (JSpinner)source; SpinnerModel sm = jspnSource.getModel(); if (sm instanceof SpinnerNumberModel) { text = &quot;The current value from spinner is: &quot; + ((SpinnerNumberModel)(sm)).getNumber().intValue(); jlSpinnerExample.setText(text); } else { text = &quot;Something went wrong.&quot;; jlSpinnerExample.setText(text); } } else if (source == jccColorChooserExample.getSelectionModel()) { Color newColor = jccColorChooserExample.getColor(); jlColorChooserExample.setBackground(newColor); } } // end of stateChanged // for JFormattedTextField public void propertyChange(PropertyChangeEvent pce) { Object source = pce.getSource(); if (source == jftfFormattedTextFieldExample) { double amount = ((Number)(jftfFormattedTextFieldExample.getValue())).doubleValue(); String text = &quot;You entered amount: &quot; + amount; JOptionPane.showMessageDialog(jf, text, &quot;Info&quot;, JOptionPane.INFORMATION_MESSAGE); } } // end of propertyChange // for JTree public void valueChanged(TreeSelectionEvent tse) { String text = &quot;&quot;; Object source = tse.getSource(); if (source == jtreeScrollableTreeExample) { DefaultMutableTreeNode node = (DefaultMutableTreeNode)(((JTree)source).getLastSelectedPathComponent()); if (node == null) { jlScrollableTreeExample.setText(text); } else { text = &quot;You selected: &quot; + node.getUserObject().toString(); jlScrollableTreeExample.setText(text); } } } // end of valueChanged // for JPopupMenu to show up public void mousePressed(MouseEvent e) { //JOptionPane.showMessageDialog(jf, &quot;Mouse Pressed&quot;, &quot;Info&quot;, JOptionPane.INFORMATION_MESSAGE); if (e.isPopupTrigger()) { jpmPopupMenuExample.show(e.getComponent(), e.getX(), e.getY()); } } // end of mousePressed // for JPopupMenu to show up public void mouseReleased(MouseEvent e) { //JOptionPane.showMessageDialog(jf, &quot;Mouse Released&quot;, &quot;Info&quot;, JOptionPane.INFORMATION_MESSAGE); if (e.isPopupTrigger()) { jpmPopupMenuExample.show(e.getComponent(), e.getX(), e.getY()); } } // end of mouseReleased //void createJFrameExample() { //jf = SwingLibrary.setupJFrameAndGet(&quot;Learn Java Swing GUI Programming By Examples&quot;, screenWidth, screenHeight); //jf = SwingLibrary.setupJFrameAndGet(&quot;Learn Java Swing GUI Programming By Examples&quot;, 0, 0); //jf.setVisible(true); //} // end of addJFrameExample void createScrollableJFrameExample() { ArrayList&lt;Object&gt; a = SwingLibrary.setupScrollableJFrameAndGetFrameAndPanel(&quot;Learn Java Swing GUI Programming By Examples&quot;, screenWidth, screenHeight + 4500); jf = (JFrame)(a.get(0)); jp = (JPanel)(a.get(1)); } // end of addScrollableJFrameExample void addJButtonExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Button Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; jbButtonExample = SwingLibrary.setupJButtonAndGet(&quot;Click Me!&quot;, this, true, midScreenWidth - 50, currentYPos, buttonWidth, componentHeight); jp.add(jbButtonExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJButtonExample void addJLabelExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Label Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;This is a label!&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jl); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJLabelExample void addToolTipExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Tool Tip Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;Hover the mouse over me to see the tool tip!&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 150, currentYPos, 300, componentHeight); jl.setToolTipText(&quot;This is a tool tip!&quot;); // show tool tip immediately ToolTipManager.sharedInstance().setInitialDelay(0); // keep tool tip showing ToolTipManager.sharedInstance().setDismissDelay(Integer.MAX_VALUE); jp.add(jl); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addToolTipExample void addJTextFieldExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Text Field Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;Enter some text in below field:&quot;, false, null, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jl); currentYPos = currentYPos + componentHeight; jtfTextFieldExample = SwingLibrary.setupJTextFieldAndGet(xMargin, currentYPos, screenWidth - (xMargin*2), componentHeight); jp.add(jtfTextFieldExample); currentYPos = currentYPos + componentHeight + vGap; jbTextFieldExample = SwingLibrary.setupJButtonAndGet(&quot;Submit&quot;, this, true, midScreenWidth - 50, currentYPos, buttonWidth, componentHeight); jp.add(jbTextFieldExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJTextFieldExample void addJFormattedTextFieldExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Formatted Text Field Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;Enter some number in below formatted field (it accepts numbers only):&quot;, false, null, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 200, currentYPos, 400, componentHeight); jp.add(jl); currentYPos = currentYPos + componentHeight; jftfFormattedTextFieldExample = SwingLibrary.setupJFormattedTextFieldAndGet(NumberFormat.getNumberInstance(), 1000, this, &quot;value&quot;, xMargin, currentYPos, screenWidth - (xMargin*2), componentHeight); jp.add(jftfFormattedTextFieldExample); currentYPos = currentYPos + componentHeight + vGap; jbFormattedTextFieldExample = SwingLibrary.setupJButtonAndGet(&quot;Click to shift focus away from formatted field&quot;, this, true, midScreenWidth - 200, currentYPos, 400, componentHeight); jp.add(jbFormattedTextFieldExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJFormattedTextFieldExample void addJCheckBoxExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Check Box Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;Select/Unselect a checkbox&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jl); currentYPos = currentYPos + componentHeight; jcb1CheckBoxExample = SwingLibrary.setupJCheckBoxAndGet(&quot;One&quot;, false, this, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jcb1CheckBoxExample); currentYPos = currentYPos + componentHeight; jcb2CheckBoxExample = SwingLibrary.setupJCheckBoxAndGet(&quot;Two&quot;, false, this, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jcb2CheckBoxExample); currentYPos = currentYPos + componentHeight; jcb3CheckBoxExample = SwingLibrary.setupJCheckBoxAndGet(&quot;Three&quot;, false, this, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jcb3CheckBoxExample); currentYPos = currentYPos + componentHeight; jcb4CheckBoxExample = SwingLibrary.setupJCheckBoxAndGet(&quot;Four&quot;, false, this, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jcb4CheckBoxExample); currentYPos = currentYPos + componentHeight; jlCheckBoxExample = SwingLibrary.setupJLabelAndGet(&quot;&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jlCheckBoxExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJCheckBoxExample void addJRadioButtonExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Radio Button Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;Select a radio button&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jl); currentYPos = currentYPos + componentHeight; jrb1RadioButtonExample = SwingLibrary.setupJRadioButtonAndGet(&quot;A&quot;, false, this, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jrb1RadioButtonExample); currentYPos = currentYPos + componentHeight; jrb2RadioButtonExample = SwingLibrary.setupJRadioButtonAndGet(&quot;B&quot;, false, this, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jrb2RadioButtonExample); currentYPos = currentYPos + componentHeight; jrb3RadioButtonExample = SwingLibrary.setupJRadioButtonAndGet(&quot;C&quot;, false, this, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jrb3RadioButtonExample); currentYPos = currentYPos + componentHeight; jrb4RadioButtonExample = SwingLibrary.setupJRadioButtonAndGet(&quot;D&quot;, false, this, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jrb4RadioButtonExample); // add all radio buttons to a button group so that only one radio button // can be selected at a time ButtonGroup bg = SwingLibrary.setupButtonGroupAndGet(); bg.add(jrb1RadioButtonExample); bg.add(jrb2RadioButtonExample); bg.add(jrb3RadioButtonExample); bg.add(jrb4RadioButtonExample); currentYPos = currentYPos + componentHeight; jlRadioButtonExample = SwingLibrary.setupJLabelAndGet(&quot;&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jlRadioButtonExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJRadioButtonExample void addJFileChooserExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;File Chooser Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;Select a file by clicking Browse button below:&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 150, currentYPos, 300, componentHeight); jp.add(jl); currentYPos = currentYPos + componentHeight + 4; jbFileChooserExample = SwingLibrary.setupJButtonAndGet(&quot;Browse&quot;, this, true, midScreenWidth - 50, currentYPos, buttonWidth, componentHeight); jp.add(jbFileChooserExample); currentYPos = currentYPos + componentHeight + vGap; jl = SwingLibrary.setupJLabelAndGet(&quot;The path to file that you choose will appear below:&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 150, currentYPos, 300, componentHeight); jp.add(jl); currentYPos = currentYPos + componentHeight + 4; jtfFileChooserExample = SwingLibrary.setupJTextFieldAndGet(xMargin, currentYPos, screenWidth - (xMargin*2), componentHeight); jp.add(jtfFileChooserExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJFileChooserExample void addJPasswordFieldExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Password Field Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;Enter some text (password) in below field:&quot;, false, null, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 150, currentYPos, 300, componentHeight); jp.add(jl); currentYPos = currentYPos + componentHeight; jpfPasswordFieldExample = SwingLibrary.setupJPasswordFieldAndGet(xMargin, currentYPos, screenWidth - (xMargin*2), componentHeight); jp.add(jpfPasswordFieldExample); currentYPos = currentYPos + componentHeight + vGap; jbPasswordFieldExample = SwingLibrary.setupJButtonAndGet(&quot;Submit&quot;, this, true, midScreenWidth - 50, currentYPos, buttonWidth, componentHeight); jp.add(jbPasswordFieldExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJPasswordFieldExample void addScrollableJTextAreaExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Scrollable Text Area Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;Write something in Text Area below:&quot;, false, null, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 150, currentYPos, 300, componentHeight); jp.add(jl); currentYPos = currentYPos + componentHeight; jtaTextAreaExample = SwingLibrary.setupJTextAreaAndGet(&quot;&quot;, 10, 100, true, true, true, false, 0, 0, 0, 0); jspScrollableTextAreaExample = SwingLibrary.setupScrollableJTextAreaAndGet(jtaTextAreaExample, (xMargin*5)/2, currentYPos, screenWidth - (xMargin*5), componentHeight*4); jp.add(jspScrollableTextAreaExample); currentYPos = currentYPos + componentHeight*4 + vGap; jbScrollableTextAreaExample = SwingLibrary.setupJButtonAndGet(&quot;Submit&quot;, this, true, midScreenWidth - 50, currentYPos, buttonWidth, componentHeight); jp.add(jbScrollableTextAreaExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addScrollableJTextAreaExample void addScrollableJListExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Scrollable List Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;Select/Unselect item(s) from list&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jl); currentYPos = currentYPos + componentHeight + 4; // add items to default list model DefaultListModel&lt;String&gt; dlm = new DefaultListModel&lt;String&gt;(); dlm.addElement(&quot;One&quot;); dlm.addElement(&quot;Two&quot;); dlm.addElement(&quot;Three&quot;); dlm.addElement(&quot;Four&quot;); dlm.addElement(&quot;Five&quot;); dlm.addElement(&quot;Six&quot;); dlm.addElement(&quot;Seven&quot;); dlm.addElement(&quot;Eight&quot;); dlm.addElement(&quot;Nine&quot;); dlm.addElement(&quot;Ten&quot;); jlistScrollableListExample = SwingLibrary.setupJListAndGet(dlm, ListSelectionModel.MULTIPLE_INTERVAL_SELECTION, 3, -1, this, false, 0, 0, 0, 0); jspScrollableListExample = SwingLibrary.setupScrollableJListAndGet(jlistScrollableListExample, xMargin*4, currentYPos, screenWidth - (xMargin*8), componentHeight*4); jp.add(jspScrollableListExample); currentYPos = currentYPos + componentHeight*4 + vGap; jlScrollableListExample = SwingLibrary.setupJLabelAndGet(&quot;&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, xMargin, currentYPos, screenWidth - (xMargin*2), componentHeight); jp.add(jlScrollableListExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addScrollableJListExample void addJComboBoxExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Combo Box Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;Select an item from combo box&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jl); currentYPos = currentYPos + componentHeight + 4; // add items to default list model DefaultComboBoxModel&lt;String&gt; dcbm = new DefaultComboBoxModel&lt;String&gt;(); dcbm.addElement(&quot;&quot;); dcbm.addElement(&quot;A&quot;); dcbm.addElement(&quot;B&quot;); dcbm.addElement(&quot;C&quot;); dcbm.addElement(&quot;D&quot;); dcbm.addElement(&quot;E&quot;); dcbm.addElement(&quot;V&quot;); dcbm.addElement(&quot;W&quot;); dcbm.addElement(&quot;X&quot;); dcbm.addElement(&quot;Y&quot;); dcbm.addElement(&quot;Z&quot;); jcbComboBoxExample = SwingLibrary.setupJComboBoxAndGet(dcbm, 0, this, true, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jcbComboBoxExample); currentYPos = currentYPos + componentHeight*4 + vGap; jlComboBoxExample = SwingLibrary.setupJLabelAndGet(&quot;&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jlComboBoxExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJComboBoxExample void addJProgressBarExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Progress Bar Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; jlProgressBarExample = SwingLibrary.setupJLabelAndGet(&quot;Task not started.&quot;, false, null, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jlProgressBarExample); currentYPos = currentYPos + componentHeight; jpbProgressBarExample = SwingLibrary.setupJProgressBarAndGet(SwingConstants.HORIZONTAL, 0, 100, 0, true, true, true, xMargin, currentYPos, screenWidth - (xMargin*2), componentHeight); jp.add(jpbProgressBarExample); currentYPos = currentYPos + componentHeight + vGap; jbProgressBarExample = SwingLibrary.setupJButtonAndGet(&quot;Start Task&quot;, this, true, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jbProgressBarExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJProgressBarExample void addJSliderExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Slider Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; jsSliderExample = SwingLibrary.setupJSliderAndGet(SwingConstants.HORIZONTAL, 0, 100, 20, 1, 10, true, true, this, true, xMargin, currentYPos, screenWidth - (xMargin*2), componentHeight*2); jp.add(jsSliderExample); currentYPos = currentYPos + componentHeight*2 + vGap; jlSliderExample = SwingLibrary.setupJLabelAndGet(&quot;The current value from slider is: 20&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 110, currentYPos, 220, componentHeight); jp.add(jlSliderExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJSliderExample void addScrollableJTreeExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Scrollable Tree Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;You can select any node in the tree.&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 110, currentYPos, 220, componentHeight); jp.add(jl); currentYPos = currentYPos + componentHeight + 4; // create tree nodes DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode(&quot;Names&quot;); DefaultMutableTreeNode j = new DefaultMutableTreeNode(&quot;J&quot;); DefaultMutableTreeNode james = new DefaultMutableTreeNode(&quot;James&quot;); DefaultMutableTreeNode jerrod = new DefaultMutableTreeNode(&quot;Jerrod&quot;); j.add(james); j.add(jerrod); rootNode.add(j); DefaultMutableTreeNode n = new DefaultMutableTreeNode(&quot;N&quot;); DefaultMutableTreeNode nathan = new DefaultMutableTreeNode(&quot;Nathan&quot;); DefaultMutableTreeNode nicholas = new DefaultMutableTreeNode(&quot;Nicholas&quot;); n.add(nathan); n.add(nicholas); rootNode.add(n); DefaultMutableTreeNode v = new DefaultMutableTreeNode(&quot;V&quot;); DefaultMutableTreeNode vincent = new DefaultMutableTreeNode(&quot;Vincent&quot;); v.add(vincent); rootNode.add(v); jtreeScrollableTreeExample = SwingLibrary.setupJTreeAndGet(rootNode, TreeSelectionModel.SINGLE_TREE_SELECTION, this, false, 0, 0, 0, 0); jspScrollableTreeExample = SwingLibrary.setupScrollableJTreeAndGet(jtreeScrollableTreeExample, xMargin*4, currentYPos, screenWidth - (xMargin*8), componentHeight*4); jp.add(jspScrollableTreeExample); currentYPos = currentYPos + componentHeight*4 + vGap; jlScrollableTreeExample = SwingLibrary.setupJLabelAndGet(&quot;&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 110, currentYPos, 220, componentHeight); jp.add(jlScrollableTreeExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addScrollableJTree example void addJSpinnerExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Spinner Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;Click on up arrow or down arrow of the spinner to set a value.&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 200, currentYPos, 400, componentHeight); jp.add(jl); currentYPos = currentYPos + componentHeight*2; SpinnerNumberModel snm = new SpinnerNumberModel(20, 1, null, 1); jsSpinnerExample = SwingLibrary.setupJSpinnerAndGet(snm, false, this, xMargin*4, currentYPos, screenWidth - (xMargin*8), componentHeight); jp.add(jsSpinnerExample); currentYPos = currentYPos + componentHeight + vGap; jlSpinnerExample = SwingLibrary.setupJLabelAndGet(&quot;The current value from spinner is: 20&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 150, currentYPos, 300, componentHeight); jp.add(jlSpinnerExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJSpinnerExample void addJColorChooserExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Color Chooser Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; jlColorChooserExample = SwingLibrary.setupJLabelAndGet(&quot;Select a color and the background of this label will change to that color.&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 250, currentYPos, 500, componentHeight); jp.add(jlColorChooserExample); currentYPos = currentYPos + componentHeight*2; jccColorChooserExample = SwingLibrary.setupJColorChooserAndGet(Color.GREEN, true, &quot;Choose a color&quot;, this, xMargin*2, currentYPos, screenWidth - (xMargin*4), componentHeight*12); jp.add(jccColorChooserExample); currentYPos = currentYPos + componentHeight*12 + vGap; addLineLabel(currentYPos); } // end of addJColorChooserExample void addJOptionPaneExamples() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Option Pane Examples&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; jbOptionPaneExamplesMessage = SwingLibrary.setupJButtonAndGet(&quot;Click to see the Message Dialog Box&quot;, this, true, midScreenWidth - 150, currentYPos, 300, componentHeight); jp.add(jbOptionPaneExamplesMessage); currentYPos = currentYPos + componentHeight + vGap; jbOptionPaneExamplesInput = SwingLibrary.setupJButtonAndGet(&quot;Click to see the Input Dialog Box&quot;, this, true, midScreenWidth - 150, currentYPos, 300, componentHeight); jp.add(jbOptionPaneExamplesInput); currentYPos = currentYPos + componentHeight + vGap; jbOptionPaneExamplesConfirm = SwingLibrary.setupJButtonAndGet(&quot;Click to see the Confirm Dialog Box&quot;, this, true, midScreenWidth - 150, currentYPos, 300, componentHeight); jp.add(jbOptionPaneExamplesConfirm); currentYPos = currentYPos + componentHeight + vGap; jbOptionPaneExamplesOption = SwingLibrary.setupJButtonAndGet(&quot;Click to see the Option Dialog Box&quot;, this, true, midScreenWidth - 150, currentYPos, 300, componentHeight); jp.add(jbOptionPaneExamplesOption); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJOptionPaneExample void addJDialogExample() { int dialogWidth = 336; int dialogHeight = 350; int midDialogWidth = dialogWidth/2; int jdXPos = 10; int jdYPos = 10; currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Dialog Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + vGap; jdDialogExample = SwingLibrary.setupJDialogAndGet(jf, &quot;Details&quot;, true, dialogWidth, dialogHeight); JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;Select your month of birth from combo box:&quot;, false, null, SwingConstants.LEFT, SwingConstants.CENTER, true, jdXPos, jdYPos, 300, componentHeight); jdDialogExample.add(jl); DefaultComboBoxModel&lt;String&gt; dcbm = new DefaultComboBoxModel&lt;String&gt;(); dcbm.addElement(&quot;&quot;); dcbm.addElement(&quot;Jan&quot;); dcbm.addElement(&quot;Feb&quot;); dcbm.addElement(&quot;Mar&quot;); dcbm.addElement(&quot;Apr&quot;); dcbm.addElement(&quot;May&quot;); dcbm.addElement(&quot;Jun&quot;); dcbm.addElement(&quot;Jul&quot;); dcbm.addElement(&quot;Aug&quot;); dcbm.addElement(&quot;Sep&quot;); dcbm.addElement(&quot;Oct&quot;); dcbm.addElement(&quot;Nov&quot;); dcbm.addElement(&quot;Dec&quot;); jdYPos = jdYPos + componentHeight; jcbDialogExample = SwingLibrary.setupJComboBoxAndGet(dcbm, 0, null, true, jdXPos, jdYPos, 300, componentHeight); jdDialogExample.add(jcbDialogExample); jdYPos = jdYPos + componentHeight*2; jl = SwingLibrary.setupJLabelAndGet(&quot;Enter your year of birth in text field (4 digits):&quot;, false, null, SwingConstants.LEFT, SwingConstants.CENTER, true, jdXPos, jdYPos, 300, componentHeight); jdDialogExample.add(jl); jdYPos = jdYPos + componentHeight; NumberFormat format = NumberFormat.getIntegerInstance(); format.setGroupingUsed(false); format.setMinimumIntegerDigits(0); format.setMaximumIntegerDigits(4); jftfDialogExample = SwingLibrary.setupJFormattedTextFieldAndGet(format, null, null, null, jdXPos, jdYPos, 300, componentHeight); jdDialogExample.add(jftfDialogExample); jdYPos = jdYPos + componentHeight*2; jl = SwingLibrary.setupJLabelAndGet(&quot;Select your country of birth from list:&quot;, false, null, SwingConstants.LEFT, SwingConstants.CENTER, true, jdXPos, jdYPos, 300, componentHeight); jdDialogExample.add(jl); DefaultListModel&lt;String&gt; dlm = new DefaultListModel&lt;String&gt;(); dlm.addElement(&quot;USA&quot;); dlm.addElement(&quot;Outside USA&quot;); jdYPos = jdYPos + componentHeight; jlistDialogExample = SwingLibrary.setupJListAndGet(dlm, ListSelectionModel.SINGLE_SELECTION, 2, -1, null, true, jdXPos, jdYPos, 300, componentHeight*2 - 14); jdDialogExample.add(jlistDialogExample); jdYPos = jdYPos + componentHeight*3; jbDialogExample1 = SwingLibrary.setupJButtonAndGet(&quot;Submit&quot;, this, true, midDialogWidth - 50, jdYPos, 100, componentHeight); jdDialogExample.add(jbDialogExample1); currentYPos = currentYPos + componentHeight; jbDialogExample2 = SwingLibrary.setupJButtonAndGet(&quot;Click to see the dialog box&quot;, this, true, midScreenWidth - 150, currentYPos, buttonWidth*3, componentHeight); jp.add(jbDialogExample2); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJDialogExample void addScrollableJDialogExample() { int dialogWidth = 400; int dialogHeight = 400; int midDialogWidth = dialogWidth/2; int panelWidth = 420; int panelHeight = 570; int jdYPos = 10; currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Scrollable Dialog Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + vGap; ArrayList&lt;Object&gt; a = SwingLibrary.setupScrollableJDialogAndGetDialogAndPanel(jf, &quot;List of Labels&quot;, true, dialogWidth, dialogHeight, panelWidth, panelHeight); jdScrollableDialogExample = (JDialog)(a.get(0)); jpScrollableDialogPanel = (JPanel)(a.get(1)); JLabel jl = null; String text = null; for (int i = 0; i &lt; 15; i++) { text = &quot;This is label &quot; + (i + 1); jl = SwingLibrary.setupJLabelAndGet(text, true, Color.BLACK, SwingConstants.LEFT, SwingConstants.CENTER, true, 10, jdYPos, 400, componentHeight); jl.setForeground(Color.WHITE); jdYPos = jdYPos + 35; jpScrollableDialogPanel.add(jl); } jbCloseScrollableDialog = SwingLibrary.setupJButtonAndGet(&quot;Close&quot;, this, true, midDialogWidth - 50, jdYPos, 100, componentHeight); jpScrollableDialogPanel.add(jbCloseScrollableDialog); currentYPos = currentYPos + componentHeight; jbDisplayScrollableDialog = SwingLibrary.setupJButtonAndGet(&quot;Click to see the scrollable dialog box&quot;, this, true, midScreenWidth - 150, currentYPos, buttonWidth*3, componentHeight); jp.add(jbDisplayScrollableDialog); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addScrollableJDialogExample void addJPopupMenuExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Popup Menu Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jlPopupMenuExample = SwingLibrary.setupJLabelAndGet(&quot;Right click anywhere in the frame to the see the popup menu.&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 250, currentYPos, 500, componentHeight); jp.add(jlPopupMenuExample); jpmPopupMenuExample = new JPopupMenu(&quot;Popup Menu&quot;); jmiPopupMenuExample1 = SwingLibrary.setupJMenuItemAndGet(&quot;Show current time&quot;, this, null, null, null); jpmPopupMenuExample.add(jmiPopupMenuExample1); jpmPopupMenuExample.addSeparator(); jmiPopupMenuExample2 = SwingLibrary.setupJMenuItemAndGet(&quot;Show today's date&quot;, this, null, null, null); jpmPopupMenuExample.add(jmiPopupMenuExample2); // Add mouse listener on JPanel so that clicking anywhere on JPanel will bring up the popup menu. jp.addMouseListener(this); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJPopupMenuExample void addJToggleButtonExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Toggle Button Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; jtbToggleButtonExample = SwingLibrary.setupJToggleButtonAndGet(&quot;OFF&quot;, this, true, Color.YELLOW, true, midScreenWidth - 50, currentYPos, buttonWidth, componentHeight); jp.add(jtbToggleButtonExample); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJToggleButtonExample void addJSeparatorExample() { currentYPos = currentYPos + vGap; addHeadingLabel(&quot;Separator Example&quot;, 0, currentYPos, screenWidth, componentHeight); currentYPos = currentYPos + componentHeight + vGap; JLabel jlSeparatorExample = SwingLibrary.setupJLabelAndGet(&quot;Below are the separators.&quot;, true, Color.GREEN, SwingConstants.CENTER, SwingConstants.CENTER, true, midScreenWidth - 100, currentYPos, 200, componentHeight); jp.add(jlSeparatorExample); currentYPos = currentYPos + componentHeight + vGap; JSeparator sep1 = SwingLibrary.setupJSeparatorAndGet(SwingConstants.HORIZONTAL, Color.YELLOW, true, xMargin*2, currentYPos, screenWidth - (xMargin*4), componentHeight); jp.add(sep1); currentYPos = currentYPos + componentHeight + vGap; JSeparator sep2 = SwingLibrary.setupJSeparatorAndGet(SwingConstants.HORIZONTAL, Color.GREEN, true, xMargin*2, currentYPos, screenWidth - (xMargin*4), componentHeight); jp.add(sep2); currentYPos = currentYPos + componentHeight + vGap; addLineLabel(currentYPos); } // end of addJSeparatorExample void addJToolBarExample() { JToolBar jtbToolBarExample = new JToolBar(&quot;Tool Bar&quot;, SwingConstants.HORIZONTAL); jbToolBarExample = SwingLibrary.setupJButtonAndGet(&quot;Button 1&quot;, this, false, 0, 0, 0, 0); jtbToolBarExample.add(jbToolBarExample); jtbToolBarExample.addSeparator(); // Now, add a combo box to tool bar DefaultComboBoxModel&lt;String&gt; dcbm = new DefaultComboBoxModel&lt;String&gt;(); dcbm.addElement(&quot;&quot;); dcbm.addElement(&quot;Item 1&quot;); dcbm.addElement(&quot;Item 2&quot;); dcbm.addElement(&quot;Item 3&quot;); dcbm.addElement(&quot;Item 4&quot;); jcbToolBarExample = SwingLibrary.setupJComboBoxAndGet(dcbm, 0, this, false, 0, 0, 0, 0); jtbToolBarExample.add(jcbToolBarExample); //jtbToolBarExample.setBorderPainted(true); jf.add(jtbToolBarExample, BorderLayout.NORTH); } // end of addJToolBarExample void addJMenuItemsExample() { KeyStroke k = KeyStroke.getKeyStroke(KeyEvent.VK_I, InputEvent.CTRL_DOWN_MASK); jmb = SwingLibrary.setupJMenuBarAndGet(null, Color.GREEN); jm = SwingLibrary.setupJMenuAndGet(&quot;Help&quot;, Color.BLACK, Color.YELLOW); jmSubMenu = SwingLibrary.setupJMenuAndGet(&quot;More Help&quot;, Color.BLUE, Color.YELLOW); jmiMenuItemExample = SwingLibrary.setupJMenuItemAndGet(&quot;About&quot;, this, k, null, Color.WHITE); jcbmiCheckBoxMenuItemExample = new JCheckBoxMenuItem(&quot;Show a message dialog box&quot;); jcbmiCheckBoxMenuItemExample.addActionListener(this); jrbmiRadioButtonMenuItem1 = new JRadioButtonMenuItem(&quot;Change background color to white&quot;); jrbmiRadioButtonMenuItem1.addActionListener(this); jrbmiRadioButtonMenuItem2 = new JRadioButtonMenuItem(&quot;Change background color to default&quot;); jrbmiRadioButtonMenuItem2.addActionListener(this); ButtonGroup bg = SwingLibrary.setupButtonGroupAndGet(); bg.add(jrbmiRadioButtonMenuItem1); bg.add(jrbmiRadioButtonMenuItem2); jmSubMenu.add(jmiMenuItemExample); jmSubMenu.addSeparator(); jmSubMenu.add(jcbmiCheckBoxMenuItemExample); jmSubMenu.addSeparator(); jmSubMenu.add(jrbmiRadioButtonMenuItem1); jmSubMenu.add(jrbmiRadioButtonMenuItem2); jm.add(jmSubMenu); jmb.add(jm); jf.setJMenuBar(jmb); } // end of addJMenuItemsExample void createAndShowSwingGUIExamples() { //createJFrameExample(); createScrollableJFrameExample(); addJButtonExample(); addJLabelExample(); addToolTipExample(); addJTextFieldExample(); addJFormattedTextFieldExample(); addJCheckBoxExample(); addJRadioButtonExample(); addJFileChooserExample(); addJPasswordFieldExample(); addScrollableJTextAreaExample(); addScrollableJListExample(); addJComboBoxExample(); addJProgressBarExample(); addJSliderExample(); addScrollableJTreeExample(); addJSpinnerExample(); addJColorChooserExample(); addJOptionPaneExamples(); addJDialogExample(); addScrollableJDialogExample(); addJPopupMenuExample(); addJToggleButtonExample(); addJSeparatorExample(); addJToolBarExample(); addJMenuItemsExample(); // Frame has been created, all examples have been added, now show the frame jf.setVisible(true); } // end of createAndShowSwingExamples void addHeadingLabel(String text, int xpos, int ypos, int width, int height) { //JLabel jl = SwingLibrary.setupJLabelAndGet(text, true, Color.YELLOW, SwingConstants.CENTER, SwingConstants.CENTER, true, xpos, ypos, width, height); JLabel jl = SwingLibrary.setupJLabelAndGet(text, true, lightBlue, SwingConstants.CENTER, SwingConstants.CENTER, true, xpos, ypos, width, height); jp.add(jl); } // end of addHeadingLabel void addLineLabel(int ypos) { JLabel jl = SwingLibrary.setupJLabelAndGet(&quot;&quot;, true, Color.BLACK, SwingConstants.CENTER, SwingConstants.CENTER, true, 0, ypos, screenWidth, lineLabelHeight); jp.add(jl); currentYPos = currentYPos + lineLabelHeight; } // end of addLineLabel public static void main(String[] args) { Examples_Of_Many_Swing_Components_In_One_Program eomsciop = new Examples_Of_Many_Swing_Components_In_One_Program(); eomsciop.createAndShowSwingGUIExamples(); } // end of main } // end of Examples_Of_Many_Swing_Components_In_One_Program </code></pre> <p>The components whose examples are given in the code are:</p> <ul> <li>JButton</li> <li>JLabel</li> <li>ToolTip</li> <li>JTextField</li> <li>JFormattedTextField</li> <li>JCheckBox</li> <li>JRadioButton</li> <li>JFileChooser</li> <li>JPasswordField</li> <li>Scrollable JTextArea</li> <li>Scrollable JList</li> <li>JComboBox</li> <li>JProgressBar</li> <li>JSlider</li> <li>Scrollable JTree</li> <li>JSpinner</li> <li>JColorChooser</li> <li>JOptionPane</li> <li>JDialog</li> <li>Scrollable JDialog</li> <li>JPopupMenu</li> <li>JToggleButton</li> <li>JSeparator</li> <li>JToolBar</li> <li>JMenuBar</li> <li>JMenu</li> <li>JMenuItem</li> <li>JCheckBoxMenuItem</li> <li>JRadioButtonMenuItem</li> </ul>

270408

<p>Background:</p> <p>Hello, I'm a student (since 2 months) and I've created a small MVP of a weather application. So now I'm refactoring my code because it looks hideous and it is hard to work with.</p> <p>The problem:</p> <p>In the snippet I will provide you will see that I repeat code for a .map(), which I know is not the best practice. But I need help to know in which way I could combine the two loops to one, and still render the same result from my component.</p> <p>This is probably a simple problem, but I struggle right now with the nesting. I think it's actually more about the html table rather than the .js itself. But I just keep bashing my head here.</p> <p>What my code does:</p> <p>This is a html Table from a component that formats and renders weather data fetched from a public API, in 3 columns per row, date, time of day and weather data values.</p> <p>The loops themselves maps through a weather json object so I can render the timestamps and the weather data I want to show to the user.</p> <pre><code>&lt;table&gt; &lt;tbody&gt; &lt;tr&gt; &lt;th className=&quot;date&quot;&gt;Date&lt;/th&gt; &lt;th className=&quot;time&quot;&gt;Time&lt;/th&gt; &lt;th className=&quot;values&quot;&gt;Value/Unit&lt;/th&gt; &lt;/tr&gt; {dates.map((weatherDate, index) =&gt; { if ( index === 0 || weather[weatherDate].length &lt; 4 ) { return null; } return weather[weatherDate] &amp;&amp; weather[weatherDate].length !== 0 ? ( &lt;React.Fragment key={&quot;thisWeek-&quot; + index}&gt; &lt;tr className=&quot;tr-content&quot;&gt; &lt;td className=&quot;date&quot;&gt;{weatherDate}&lt;/td&gt; &lt;td className=&quot;time&quot;&gt; {weather[weatherDate].map((weatherData, _index) =&gt; { const time = weatherData.validTime.slice( weatherData.validTime.indexOf(&quot;T&quot;) + 1, weatherData.validTime.length - 4 ); if (TIMES_TO_SHOW.indexOf(time) === -1) return null; return ( &lt;p key={&quot;weather-data-&quot; + _index}&gt; {time} &lt;/p&gt; ); })} &lt;/td&gt; &lt;td className=&quot;values&quot;&gt; {weather[weatherDate].map((weatherTime, index_) =&gt; { const time = weatherTime.validTime.slice( weatherTime.validTime.indexOf(&quot;T&quot;) + 1, weatherTime.validTime.length - 4 ); if (TIMES_TO_SHOW.indexOf(time) === -1) return null; return ( &lt;React.Fragment key={index_}&gt; Temperature: {weatherTime.parameters.t.values}° Windspeed: {weatherTime.parameters.ws.values} m/s Gusts: {weatherTime.parameters.gust.values} m/s Vind direction: {weatherTime.parameters.wd.values}° &lt;/React.Fragment&gt; ); })} &lt;/td&gt; &lt;/tr&gt; &lt;/React.Fragment&gt; ) : null; })} &lt;/tbody&gt; &lt;/table&gt; </code></pre> <p>I am aware of other problems in my code, feel free to adress them as well, but I'm mainly here for help with combining my loops :)</p>

270411

<p>As already written in the title I want to count the numbers in the range (x+1, y) where x and y are integers, in which the sum of the digits in odd places have the same parity of the ones in even places. I made this code:</p> <pre><code>def findIntegers(x, y): count = 0 for k in range(int(x)+1, int(y)+1): odd_sum = 0 even_sum = 0 k = str(k) odd_sum += sum([int(k[i]) for i in range(1, len(k), 2) if i % 2 == 1]) even_sum += sum([int(k[i]) for i in range(0, len(k), 2) if i % 2 == 0]) if (odd_sum % 2) == (even_sum % 2): count += 1 return count </code></pre> <p>The code works but for very big range it's very slow. How can I improve my code?</p>

270414

<p>For a program I'm writing, it requires a lot of printing and receiving user input. I've found it cumbersome to keep specifying the type strings in <code>printf</code>, and having to write another <code>printf</code> before using <code>scanf</code> to receive input. I've decided to write two macros, <code>print</code> and <code>input</code>, that achieve exactly what I want. A simplified function call that prints the types I need to print, and an input macro that allows me to pass a prompt and a variable to the same function.</p> <p>Another concept I've included in the header file is pythons module-like structure. With specific defines, I can decide which functions I want to compile/use at a certain time. While there hasn't been a significant difference in compile speed when importing one function vs the entire file, my project will get exponentially large, so this might provide some time save. Is this something I should continue to implement? Or is the speed increase negligible to the point where it's a waste of time to write?</p> <p>I would like to know if this is the best way to go about this. Having more experience in <code>C++</code>, I've learned to appreciate the nuances of <code>C</code>. Some of it looks convoluted, but I've trying to cover all my bases to avoid duplicate declarations of macros and writing the safest code possible. Any and all input and recommendations are appreciated and considered.</p> <p><strong>IO.h</strong></p> <pre><code>#ifndef IO_H #define IO_H #ifdef IO_IMPORT_ALL #define PRINT #define INPUT #define TYPE_FINDER #endif #ifdef PRINT #include &lt;tgmath.h&gt; #include &lt;stdio.h&gt; #if !defined(TYPE_FINDER) || !defined(INPUT) #define TYPE_FINDER #endif #ifdef PRINT_NEWLINE #define print(value) do { \ printf(type_finder(value), value); \ printf(&quot;\n&quot;); \ } while (0) #else #define print(value) printf(type_finder(value), value) #endif #endif #ifdef INPUT #include &lt;stdio.h&gt; #include &lt;tgmath.h&gt; #if !defined(TYPE_FINDER) || !defined(PRINT) #define TYPE_FINDER #endif #define input(prompt, variable) do { \ printf(&quot;%s&quot;, prompt); \ scanf(type_finder(variable), &amp;variable); \ } while (0) #endif #ifdef TYPE_FINDER #define type_finder(type) _Generic((type), \ char: &quot;%c&quot;, \ int: &quot;%d&quot;, \ float: &quot;%f&quot;, \ unsigned int: &quot;%u&quot;, \ char*: &quot;%s&quot;, \ void*: &quot;%p&quot; \ ) #endif #endif // IO_H </code></pre> <p><strong>main.c</strong></p> <pre><code>#define IO_IMPORT_ALL #define PRINT_NEWLINE #include &quot;IO.h&quot; void PrintTest(void) { print((char)'c'); print(10); print(24.7f); print((unsigned int)24); print(&quot;test&quot;); print((void*)&quot;abcde&quot;); } void InputTest(void) { int number; input(&quot;Enter a number: &quot;, number); print(number); } int main() { PrintTest(); InputTest(); return 0; } </code></pre> <p>I'm specifically tagging <code>C11</code> because I need to use <code>_Generic</code> to distinguish the types passed to the macros.</p> <p>If you want to run this code, here's my <code>run.sh</code></p> <pre><code>gcc main.c -o main ./main rm main </code></pre>

270416

<p>Modules for FPGAs for generating a pseudo-random bit sequence are presented. The first module generates a bit sequence. The third module speeds up the generation by transferring the bus to, for example, a multiplexer which is controlled by a faster device. Hence this bus is serialized into a bit sequence.</p> <p>prbs.sv</p> <pre><code>`timescale 1ns / 1ps module prbs # ( parameter integer PN = 7 //3, 4, 5, 6, 7, 9, 11, 15, 17, 23, 31, 32, 36, 41 ) ( input logic i_clk, input logic i_s_rst_n, input logic i_en, output logic o_prbs, output logic o_prbs_n ); localparam integer TAP_1 = (PN == 3) ? 2 : (PN == 4) ? 3 : (PN == 5) ? 4 : (PN == 6) ? 5 : (PN == 7) ? 6 : (PN == 9) ? 7 : (PN == 11) ? 10 : (PN == 15) ? 14 : (PN == 17) ? 16 : (PN == 23) ? 22 : (PN == 31) ? 30 : (PN == 32) ? 31 : (PN == 36) ? 35 : (PN == 41) ? 40 : 0; localparam integer TAP_0 = (PN == 3) ? 0 : (PN == 4) ? 2 : (PN == 5) ? 2 : (PN == 6) ? 4 : (PN == 7) ? 0 : (PN == 9) ? 4 : (PN == 11) ? 8 : (PN == 15) ? 0 : (PN == 17) ? 2 : (PN == 23) ? 17 : (PN == 31) ? 27 : (PN == 32) ? 21 : (PN == 36) ? 24 : (PN == 41) ? 37 : 0; logic [PN - 1 : 0] lfsr; always_comb begin o_prbs = lfsr[PN - 1]; o_prbs_n = ~lfsr[PN - 1]; end always_ff @ (posedge i_clk) begin if (i_s_rst_n == 1'h0) begin lfsr &lt;= '1; end else if (i_en == 1'h1) begin lfsr &lt;= {lfsr[PN - 2 : 0], lfsr[TAP_1] ^ lfsr[TAP_0]}; end end endmodule </code></pre> <p>prbs_tb.sv</p> <pre><code>`timescale 1ns / 1ps module prbs_tb; localparam integer PN = 7; //3, 4, 5, 6, 7, 9, 11, 15, 17, 23, 31, 32, 36, 41 localparam integer PERIOD = 2 ** PN; localparam integer CLOCK_PERIOD = 100; localparam integer TEST_ITERATION = 1000; localparam integer CHANGE_EN_VAL = 100; logic clk = '0; logic s_rst_n = '0; logic en = '0; logic prbs = '0; logic prbs_n = '0; integer tick = 0; prbs # ( .PN (PN) ) prbs_dut ( .i_clk (clk ), .i_s_rst_n (s_rst_n), .i_en (en ), .o_prbs (prbs ), .o_prbs_n (prbs_n ) ); initial begin forever begin #( CLOCK_PERIOD / 2 ) clk = !clk; end end initial begin s_rst_n &lt;= '0; @(posedge clk); s_rst_n &lt;= '1; en &lt;= '1; @(posedge clk); for(int i = 0; i &lt; TEST_ITERATION; i++) begin if ((i % PERIOD) == (PERIOD - 1)) begin en &lt;= ~en; tick = 0; end else begin tick++; end @(posedge clk); end $finish; end endmodule </code></pre> <p>prbs_wide.sv</p> <pre><code> `timescale 1ns / 1ps module prbs_wide # ( parameter integer PN = 7, //3, 4, 5, 6, 7, 9, 11, 15, 17, 23, 31, 32, 36, 41 parameter integer WIDTH = 16 ) ( input logic i_clk, input logic i_s_rst_n, input logic i_en, output logic [WIDTH - 1 : 0] o_prbs, output logic [WIDTH - 1 : 0] o_prbs_n ); localparam integer TAP_1 = (PN == 3) ? 2 : (PN == 4) ? 3 : (PN == 5) ? 4 : (PN == 6) ? 5 : (PN == 7) ? 6 : (PN == 9) ? 7 : (PN == 11) ? 10 : (PN == 15) ? 14 : (PN == 17) ? 16 : (PN == 23) ? 22 : (PN == 31) ? 30 : (PN == 32) ? 31 : (PN == 36) ? 35 : (PN == 41) ? 40 : 0; localparam integer TAP_0 = (PN == 3) ? 0 : (PN == 4) ? 2 : (PN == 5) ? 2 : (PN == 6) ? 4 : (PN == 7) ? 0 : (PN == 9) ? 4 : (PN == 11) ? 8 : (PN == 15) ? 0 : (PN == 17) ? 2 : (PN == 23) ? 17 : (PN == 31) ? 27 : (PN == 32) ? 21 : (PN == 36) ? 24 : (PN == 41) ? 37 : 0; logic [PN - 1 : 0] lfsr; logic [PN - 1 : 0] r_lfsr; logic [WIDTH - 1 : 0] tmp; always_comb begin lfsr = r_lfsr; for (int i = WIDTH - 1; i &gt;= 0; i = i - 1) begin lfsr = {lfsr[PN - 2 : 0], lfsr[TAP_1] ^ lfsr[TAP_0]}; tmp[i] = lfsr[TAP_1] ^ lfsr[TAP_0]; end end always_ff @ (posedge i_clk) begin if (i_s_rst_n == 1'h0) begin r_lfsr &lt;= '1; o_prbs &lt;= '0; o_prbs_n &lt;= '1; end else if (i_en == 1'h1) begin r_lfsr &lt;= lfsr; o_prbs &lt;= tmp; o_prbs_n &lt;= ~tmp; end end endmodule </code></pre> <p>prbs_wide_tb.sv</p> <pre><code>`timescale 1ns / 1ps module prbs_wide_tb; localparam integer PN = 7; localparam integer PERIOD = 2 ** PN - 1; localparam integer WIDTH = 128; localparam integer CLOCK_PERIOD = 100; localparam integer TEST_ITERATION = 1000; localparam integer CHANGE_EN_VAL = 100; logic clk = '0; logic s_rst_n = '0; logic en = '0; logic [WIDTH - 1 : 0] prbs = '0; logic [WIDTH - 1 : 0] prbs_n = '0; prbs_wide # ( .PN (PN ), .WIDTH (WIDTH) ) prbs_wide_dut ( .i_clk (clk ), .i_s_rst_n (s_rst_n), .i_en (en ), .o_prbs (prbs ), .o_prbs_n (prbs_n ) ); initial begin forever begin #( CLOCK_PERIOD / 2 ) clk = !clk; end end initial begin s_rst_n &lt;= '0; @(posedge clk); s_rst_n &lt;= '1; en &lt;= '1; @(posedge clk); for(int i = 0; i &lt; TEST_ITERATION; i++) begin if ((i % PERIOD) == PERIOD - 1) begin en &lt;= ~en; end @(posedge clk); end $finish; end endmodule </code></pre>

270417

<p>I want to simplify some code I have written but not sure how to go about doing it. When my workbook opens it checks the current date and compares it to dates I have on a sheet. If the current date is &lt;= date on sheet it writes the date range to a cell. My issue is I have 13 If statements and would like to simply/neaten it up.</p> <p>I know there is a better way to go about if/then statements I just can't remember what it is or how to implement it.</p> <p>Here is my code:</p> <pre><code>Private Sub Workbook_Open() If ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C15&quot;).Value &lt; Date Then ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C3&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C15&quot;) + 28 End If If Date &lt;= ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C15&quot;).Value Then ActiveWorkbook.Sheets(&quot;North Reading&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B15&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C15&quot;).Value ActiveWorkbook.Sheets(&quot;Chelmsford St&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B15&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C15&quot;).Value End If If Date &lt;= ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C14&quot;).Value Then ActiveWorkbook.Sheets(&quot;North Reading&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B14&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C14&quot;).Value ActiveWorkbook.Sheets(&quot;Chelmsford St&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B14&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C14&quot;).Value End If If Date &lt;= ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C13&quot;).Value Then ActiveWorkbook.Sheets(&quot;North Reading&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B13&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C13&quot;).Value ActiveWorkbook.Sheets(&quot;Chelmsford St&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B13&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C13&quot;).Value End If If Date &lt;= ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C12&quot;).Value Then ActiveWorkbook.Sheets(&quot;North Reading&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B12&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C12&quot;).Value ActiveWorkbook.Sheets(&quot;Chelmsford St&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B12&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C12&quot;).Value End If If Date &lt;= ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C11&quot;).Value Then ActiveWorkbook.Sheets(&quot;North Reading&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B11&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C11&quot;).Value ActiveWorkbook.Sheets(&quot;Chelmsford St&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B11&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C11&quot;).Value End If If Date &lt;= ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C10&quot;).Value Then ActiveWorkbook.Sheets(&quot;North Reading&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B10&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C10&quot;).Value ActiveWorkbook.Sheets(&quot;Chelmsford St&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B10&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C10&quot;).Value End If If Date &lt;= ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C09&quot;).Value Then ActiveWorkbook.Sheets(&quot;North Reading&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B09&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C09&quot;).Value ActiveWorkbook.Sheets(&quot;Chelmsford St&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B09&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C09&quot;).Value End If If Date &lt;= ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C08&quot;).Value Then ActiveWorkbook.Sheets(&quot;North Reading&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B08&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C08&quot;).Value ActiveWorkbook.Sheets(&quot;Chelmsford St&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B08&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C08&quot;).Value End If If Date &lt;= ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C07&quot;).Value Then ActiveWorkbook.Sheets(&quot;North Reading&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B07&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C07&quot;).Value ActiveWorkbook.Sheets(&quot;Chelmsford St&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B07&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C07&quot;).Value End If If Date &lt;= ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C06&quot;).Value Then ActiveWorkbook.Sheets(&quot;North Reading&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B06&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C06&quot;).Value ActiveWorkbook.Sheets(&quot;Chelmsford St&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B06&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C06&quot;).Value End If If Date &lt;= ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C05&quot;).Value Then ActiveWorkbook.Sheets(&quot;North Reading&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B05&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C05&quot;).Value ActiveWorkbook.Sheets(&quot;Chelmsford St&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B05&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C05&quot;).Value End If If Date &lt;= ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C04&quot;).Value Then ActiveWorkbook.Sheets(&quot;North Reading&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B04&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C04&quot;).Value ActiveWorkbook.Sheets(&quot;Chelmsford St&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B04&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C04&quot;).Value End If If Date &lt;= ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C03&quot;).Value Then ActiveWorkbook.Sheets(&quot;North Reading&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B03&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C03&quot;).Value ActiveWorkbook.Sheets(&quot;Chelmsford St&quot;).Range(&quot;B2&quot;).Value = ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;B03&quot;).Value &amp; &quot; - &quot; &amp; ActiveWorkbook.Sheets(&quot;Period Dates&quot;).Range(&quot;C03&quot;).Value End If End Sub </code></pre>

270421

<p>Is this the correct way to calculate leap years in a range of [y,x) ?</p> <pre><code>def bis(y1,y2): mas = max(y1,y2) mini = min(y1,y2) k=0 for i in range(mini,mas): if i % 4 == 0 and i % 100 != 0: if i % 400 != 0: k=k+1 return k print(bis(1904,1957)) </code></pre>

270425

<p>This project is based off the shunting yard algorithm and has additional features such as negative value parsing. It's like a scientific calculator. I am looking to improve this project by getting rid of potential errors and optimizing code. I have tried many cases and have fixed the broken ones I've seen. However, although this works, I am aware that the code is quite messy and may potentially have bugs</p> <pre><code>#include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;vector&gt; #include &lt;stack&gt; #include &lt;queue&gt; #include &lt;map&gt; #include &lt;cmath&gt; #include &lt;functional&gt; #include &lt;complex&gt; using std::cout; using std::string; using std::getline; using std::complex; using std::abs; using std::vector; using std::stack; using std::queue; using std::transform; using std::invalid_argument; using std::map; using std::function; using namespace std::literals; using std::isinf; using std::isnan; using std::cin; using std::exception; typedef complex&lt;double&gt; cmpd; constexpr unsigned int str2int(const char* str, int h = 0) //string to int conversion for switch case purposes { return !str[h] ? 5381 : (str2int(str, h + 1) * 33) ^ str[h]; } bool isNumber(const string&amp; s) //check if a string is a number { if(s.empty() || ::isspace(s[0]) || isalpha(s[0])) { return false; } char *p; strtod(s.c_str(), &amp;p); return (*p == 0); } cmpd operation(string s, cmpd v1, cmpd v2 = 0, bool deg = false) //operations { switch (str2int(s.c_str())) { case str2int(&quot;+&quot;): return v1 + v2; case str2int(&quot;-&quot;): return v1 - v2; case str2int(&quot;*&quot;): return v1 * v2; case str2int(&quot;#&quot;): //for negative powers return v1 * v2; case str2int(&quot;/&quot;): return v1 / v2; case str2int(&quot;^&quot;): return pow(v1, v2); default: return tgamma(v1.real() + 1); //factorial, technically it is a function but it is conveninent to treat it as an operator here } } cmpd func(string s, cmpd v, cmpd v2 = 0, bool deg = false) //functions, radians { double toRad = acos(-1) / 180.0; double toDeg = 180.0 / acos(-1); if (deg) { switch (str2int(s.c_str())) { case str2int(&quot;sin&quot;): return sin(v * toRad); case str2int(&quot;cos&quot;): return cos(v * toRad); case str2int(&quot;tan&quot;): return tan(v * toRad); case str2int(&quot;sec&quot;): return 1.0 / cos(v * toRad); case str2int(&quot;csc&quot;): return 1.0 / sin(v * toRad); case str2int(&quot;cot&quot;): return 1.0 / tan(v * toRad); case str2int(&quot;asin&quot;): return asin(v) * toDeg; case str2int(&quot;acos&quot;): return acos(v) * toDeg; case str2int(&quot;atan&quot;): return atan(v) * toDeg; case str2int(&quot;asec&quot;): return acos(1.0 / v) * toDeg; case str2int(&quot;acsc&quot;): return asin(1.0 / v) * toDeg; default: //acot return atan(1.0 / v) * toDeg; } } switch (str2int(s.c_str())) { case str2int(&quot;sin&quot;): return sin(v); case str2int(&quot;cos&quot;): return cos(v); case str2int(&quot;tan&quot;): return tan(v); case str2int(&quot;sec&quot;): return 1 / cos(v.real()); case str2int(&quot;csc&quot;): return 1 / sin(v.real()); case str2int(&quot;cot&quot;): return 1 / tan(v.real()); case str2int(&quot;ln&quot;): if (v.real() &lt; 0) { return log(-1 * v.real()) + 3.142i; } if (v.real() == 0) { return INFINITY; //returning INFINITY for domain errors } return log(v); case str2int(&quot;log10&quot;): if (v.real() &lt; 0) { return (3.142i + log(-1 * v.real())) / log(10); } if (v.real() == 0) { return INFINITY; } return log10(v); case str2int(&quot;log&quot;): if (v.real() == 0 || v.real() == 1 || v2.real() == 0) { return INFINITY; } if (v.real() &lt; 0) { if (v2.real() &lt; 0) { return (log(-1 * v2.real()) + 3.142i) / (log(-1 * v.real()) + 3.142i); } return log(v2.real()) / (log(-1 * v.real()) + 3.142i); } if (v2.real() &lt; 0) { return (log(-1 * v2.real()) + 3.142i) / log(v); } return log(v2) / log(v); case str2int(&quot;exp&quot;): return exp(v); case str2int(&quot;sqrt&quot;): return sqrt(v); case str2int(&quot;cbrt&quot;): return pow(v, 1.0 / 3); case str2int(&quot;root&quot;): if (v == 0.0) { return INFINITY; } return pow(v2, 1.0 / v); case str2int(&quot;abs&quot;): return abs(v); case str2int(&quot;asin&quot;): return asin(v); case str2int(&quot;acos&quot;): return acos(v); case str2int(&quot;atan&quot;): return atan(v); case str2int(&quot;asec&quot;): return acos(1.0 / v); case str2int(&quot;acsc&quot;): return asin(1.0 / v); default: //acot return atan(1.0 / v); } } bool isOperator(string s) //checks if string is operator { vector&lt;string&gt; v {&quot;+&quot;, &quot;-&quot;, &quot;*&quot;, &quot;/&quot;, &quot;^&quot;, &quot;#&quot;, &quot;!&quot;}; return find(v.begin(), v.end(), s) != v.end(); } bool isFunction(string s) //checks if string is function { vector&lt;string&gt; v {&quot;sin&quot;, &quot;cos&quot;, &quot;tan&quot;, &quot;sec&quot;, &quot;csc&quot;, &quot;cot&quot;, &quot;ln&quot;, &quot;log10&quot;, &quot;exp&quot;, &quot;sqrt&quot;, &quot;!&quot;, &quot;cbrt&quot;, &quot;abs&quot;, &quot;asin&quot;, &quot;acos&quot;, &quot;atan&quot;, &quot;asec&quot;, &quot;acsc&quot;, &quot;acot&quot;, &quot;log&quot;, &quot;root&quot;}; return find(v.begin(), v.end(), s) != v.end(); } int paramamnt(string s) //checks parameter amount of a function { vector&lt;string&gt; v1 {&quot;sin&quot;, &quot;cos&quot;, &quot;tan&quot;, &quot;sec&quot;, &quot;csc&quot;, &quot;cot&quot;, &quot;ln&quot;, &quot;log10&quot;, &quot;exp&quot;, &quot;sqrt&quot;, &quot;cbrt&quot;, &quot;abs&quot;, &quot;asin&quot;, &quot;acos&quot;, &quot;atan&quot;, &quot;asec&quot;, &quot;acsc&quot;, &quot;acot&quot;}; vector&lt;string&gt; v2 {&quot;log&quot;, &quot;root&quot;}; return find(v1.begin(), v1.end(), s) != v1.end() ? 1 : 2; } void newval(int n, stack&lt;cmpd&gt; &amp;s, queue&lt;string&gt; &amp;q, function&lt;cmpd(string o, cmpd a, cmpd b, bool deg)&gt; func, bool isdeg) //evaluates using either the operate or the func function { if (s.size() &lt; n) { throw invalid_argument(&quot;Error: invalid expression&quot;); } cmpd a = s.top(); s.pop(); if (n == 1) { s.push(func(q.front(), a, 0, isdeg)); } else { cmpd b = s.top(); s.pop(); s.push(func(q.front(), b, a, isdeg)); } q.pop(); } cmpd evaluate(queue&lt;string&gt; q, bool isdeg) //evaluates reverse polish notation given by parse function { stack&lt;cmpd&gt; valstack; const int qsize = q.size(); for (int i = 0; i &lt; qsize; ++i) { if (isNumber(q.front())) { if (q.front() == &quot;3.142&quot;) { valstack.push(acos(-1)); } else if (q.front() == &quot;2.718&quot;) { valstack.push(exp(1)); } else { valstack.push(stod(q.front())); } q.pop(); } else if (isOperator(q.front())) { q.front() == &quot;!&quot; ? newval(1, valstack, q, operation, isdeg) : newval(2, valstack, q, operation, isdeg); } else if (isFunction(q.front())) { paramamnt(q.front()) == 1 ? newval(1, valstack, q, func, isdeg) : newval(2, valstack, q, func, isdeg); } } return valstack.top(); } queue&lt;string&gt; parse(vector&lt;string&gt; tokens) //converts vector of tokens to reverse polish notation { map&lt;string, int&gt; m {{&quot;+&quot;, 1}, {&quot;-&quot;, 1}, {&quot;*&quot;, 2}, {&quot;/&quot;, 2}, {&quot;^&quot;, 3}, {&quot;!&quot;, 4}, {&quot;#&quot;, 5}}; //operator precedence map&lt;string, char&gt; assoc {{&quot;+&quot;, 'l'}, {&quot;-&quot;, 'l'}, {&quot;*&quot;, 'l'}, {&quot;/&quot;, 'l'}, {&quot;^&quot;, 'r'}, {&quot;!&quot;, 'r'}, {&quot;(&quot;, 'l'}, {&quot;)&quot;, 'l'}}; //operator and parenthesis associativity stack&lt;string&gt; operate; queue&lt;string&gt; que; for (int i = 0; i &lt; tokens.size(); ++i) { //checking the vector of tokens cout &lt;&lt; &quot;\&quot;&quot; &lt;&lt; tokens[i] &lt;&lt; &quot;\&quot; &quot;; } for (int i = 0; i &lt; tokens.size(); ++i) { string s = tokens[i]; if (isNumber(s)) { que.push(s); } else if (isFunction(s) || s == &quot;(&quot;) { operate.push(s); } else if (isOperator(s)) { while (operate.size() != 0 &amp;&amp; operate.top() != &quot;(&quot; &amp;&amp; (m[operate.top()] &gt; m[s] || (m[s] == m[operate.top()] &amp;&amp; assoc[s] == 'l'))) { que.push(operate.top()); operate.pop(); } operate.push(s); } else if (s == &quot;)&quot;) { if (operate.size() &lt; 1) { throw invalid_argument(&quot;Error: right parenthesis at start of expression&quot;); } while (operate.top() != &quot;(&quot;) { que.push(operate.top()); operate.pop(); } operate.pop(); if (isFunction(operate.top())) { que.push(operate.top()); operate.pop(); } } else { throw invalid_argument(&quot;Error: invalid token&quot;); } } const int osize = operate.size(); for (int i = 0; i &lt; osize; ++i) { que.push(operate.top()); operate.pop(); } cout &lt;&lt; &quot;\n&quot;; queue&lt;string&gt; q2 = que; const int q2size = q2.size(); for (int i = 0; i &lt; q2size; ++i) { //checking queue here cout &lt;&lt; q2.front() &lt;&lt; &quot; &quot;; q2.pop(); } return que; } vector&lt;string&gt; lex(string input) //tokenizes input { for (int i = 0; i &lt; input.length() - 1; ++i) { //checks if a number is next to a function in order to multiply them if (isdigit(input[i]) &amp;&amp; isalpha(input[i + 1])) { input = input.substr(0, i + 1) + &quot;*&quot; + input.substr(i + 1); } } string buffer = &quot;&quot;; vector&lt;string&gt; output {&quot;0&quot;, &quot;+&quot;}; for (int i = 0; i &lt; input.length(); ++i) { if (input[i] == '-') { output.push_back(buffer); if (output.size() != 0 &amp;&amp; (output[output.size() - 1] == &quot;)&quot; || isNumber(output[output.size() - 1]))) { //subtraction output.push_back(input.substr(i, 1)); } else { //negative val string a = &quot;&quot;; if (output.size() &gt;= 2) { string a = output[output.size() - 2]; } output.push_back(&quot;-1&quot;); if (a == &quot;^&quot;) { output.push_back(&quot;#&quot;); } else { output.push_back(&quot;*&quot;); } } buffer = &quot;&quot;; } else if (isOperator(input.substr(i, 1)) || input[i] == '(' || input[i] == ')') { //operator or parenthesis output.push_back(buffer); output.push_back(input.substr(i, 1)); buffer = &quot;&quot;; } else if (input[i] == ',') { //comma output.push_back(buffer); output.push_back(&quot;,&quot;); buffer = &quot;&quot;; } else if (input[i] == 'e' &amp;&amp; (input[i + 1] != 'x' &amp;&amp; input[i + 1] != 'c' || i == input.length() - 1)) { //e output.push_back(&quot;2.718&quot;); } else if (input[i] == 'p' &amp;&amp; input[i + 1] == 'i') { //pi input = input.substr(0, i) + input.substr(i + 1); output.push_back(&quot;3.142&quot;); } else if (input[i] == 'i' &amp;&amp; (i == 0 || input[i - 1] != 's')) { output.push_back(&quot;sqrt&quot;); output.push_back(&quot;(&quot;); output.push_back(&quot;-1&quot;); output.push_back(&quot;)&quot;); } else { //number or function buffer += input.substr(i, 1); } } output.push_back(buffer); output.erase(remove(output.begin(), output.end(), &quot;&quot;), output.end()); if (count(output.begin(), output.end(), &quot;(&quot;) != count(output.begin(), output.end(), &quot;)&quot;)) { throw invalid_argument(&quot;Error: mismatched parentheses&quot;); } for (int i = 1; i &lt; output.size(); ++i) { if (output[i] == &quot;(&quot; &amp;&amp; (isNumber(output[i - 1]) || output[i - 1] == &quot;)&quot; || output[i - 1] == &quot;!&quot;)) { output.insert(output.begin() + i, &quot;*&quot;); } else if (output[i] == &quot;)&quot; &amp;&amp; isNumber(output[i + 1])) { output.insert(output.begin() + i + 1, &quot;*&quot;); ++i; } else if (isNumber(output[i]) &amp;&amp; (isNumber(output[i - 1]))) { output.insert(output.begin() + i, &quot;*&quot;); ++i; } } output.erase(remove(output.begin(), output.end(), &quot;,&quot;), output.end()); return output; } int main() { cout &lt;&lt; &quot;This calculator has experimental support with complex numbers.\n&quot;; cout &lt;&lt; &quot;3.142 and 2.718 are assumed as pi and e respectively (type 3.1420 for example if you want 3.142 instead of pi).\n&quot;; cout &lt;&lt; &quot;If the absolute value of a number is &lt;= 0.0001, it will be rounded to 0.\n&quot;; cout &lt;&lt; &quot;\nRadians or Degrees? Enter rad or deg. (default is radians): &quot;; string measure; cin &gt;&gt; measure; transform(measure.begin(), measure.end(), measure.begin(), ::tolower); if (measure != &quot;rad&quot; &amp;&amp; measure != &quot;deg&quot;) { cout &lt;&lt; &quot;defaulting to rad...\n&quot;; measure = &quot;rad&quot;; } bool isdeg = measure != &quot;rad&quot;; cin.ignore(); cout &lt;&lt; &quot;\nEnter (use parenthesis for functions like ln()): \n&quot;; string input; getline(cin, input); input.erase(remove_if(input.begin(), input.end(), ::isspace), input.end()); //removes spaces from input cmpd val; try { val = evaluate(parse(lex(input)), isdeg); } catch (const exception&amp; e) { cout &lt;&lt; e.what(); return 1; } cout.precision(16); cout &lt;&lt; &quot;\nanswer: \n&quot;; if (isnan(val.real()) || isinf(val.real())) { cout &lt;&lt; &quot;undefined&quot;; } else { if (abs(val.real()) &lt;= 0.0001) { //used a tolerance value here because for some reason sqrt(-1)^2 evaluated into -1 + a very small constant times i so... if (abs(val.imag()) &lt;= 0.0001) { //lots of if statements for formatting purposes cout &lt;&lt; 0; } else { if (val.imag() == 1) { cout &lt;&lt; &quot;i&quot;; } else if (val.imag() == -1) { cout &lt;&lt; &quot;-i&quot;; } else { cout &lt;&lt; val.imag() &lt;&lt; &quot;i&quot;; } } } else if (abs(val.imag()) &lt;= 0.0001) { cout &lt;&lt; val.real(); } else { cout &lt;&lt; val.real() &lt;&lt; &quot; + &quot; &lt;&lt; val.imag() &lt;&lt; &quot;i&quot;; } } } </code></pre> <p>How would you improve this program?</p>

270433

<p>All 3 ids are basically the same button but different divs, but I had to rename them to accomplish what I was looking for. Is there a way to write this better? Any help is much appreciated.</p> <pre><code>$(document).ready(function(){ $(&quot;#open_iptvbasic&quot;).click(function(){ $(&quot;#iptv-channel-slideout_skinny&quot;).toggleClass(&quot;expand&quot;); $(&quot;.letju&quot;).css(&quot;opacity&quot;, &quot;1&quot;); $(&quot;.letju&quot;).css(&quot;display&quot;, &quot;block&quot;); }); $(&quot;#open_iptvloaded&quot;).click(function(){ $(&quot;#iptv-channel-slideout_loaded&quot;).toggleClass(&quot;expand&quot;); $(&quot;.letju&quot;).css(&quot;opacity&quot;, &quot;1&quot;); $(&quot;.letju&quot;).css(&quot;display&quot;, &quot;block&quot;); }); $(&quot;#open_iptvfully&quot;).click(function(){ $(&quot;#iptv-channel-slideout_fully-loaded&quot;).toggleClass(&quot;expand&quot;); $(&quot;.letju&quot;).css(&quot;opacity&quot;, &quot;1&quot;); $(&quot;.letju&quot;).css(&quot;display&quot;, &quot;block&quot;); }); $(&quot;#tv-channel-close, .letju&quot;).click(function(){ $(&quot;#iptv-channel-slideout_skinny, #iptv-channel-slideout_loaded, #iptv-channel-slideout_fully-loaded&quot;).removeClass(&quot;expand&quot;); $(&quot;.letju&quot;).fadeOut(); }); }); </code></pre> <p><a href="https://i.stack.imgur.com/PDZJv.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/PDZJv.png" alt="these are the services boxes" /></a></p> <p><a href="https://i.stack.imgur.com/T5OcR.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/T5OcR.png" alt="this is the modal that shows the respective channels" /></a></p>

270434

<p>I'm developing a REST API using Azure Functions with .NET 5 (Isolated) and I want to add an OpenAPI spec for each route. But it looks like this:</p> <pre class="lang-csharp prettyprint-override"><code>namespace AzureFunctionsREST.API.Functions { public class ReporterFunction : BaseFunction { private readonly IReporterRepository _reporterRepository; public ReporterFunction(IReporterRepository reporterRepository) { this._reporterRepository = reporterRepository; } [Function(&quot;ReporterList&quot;)] [OpenApiOperation(tags: new[] { &quot;reporter&quot; }, Summary = &quot;Retrieve all reporters&quot;)] [OpenApiSecurity(&quot;function_key&quot;, SecuritySchemeType.ApiKey, Name = &quot;code&quot;, In = OpenApiSecurityLocationType.Query)] [OpenApiResponseWithBody(statusCode: HttpStatusCode.OK, contentType: &quot;application/json&quot;, bodyType: typeof(Reporter[]), Description = &quot;All reporters&quot;)] public async Task&lt;HttpResponseData&gt; List([HttpTrigger(AuthorizationLevel.Function, &quot;get&quot;, Route = &quot;reporter&quot;)] HttpRequestData req, FunctionContext executionContext) { // List reporters } [Function(&quot;ReporterGet&quot;)] [OpenApiOperation(tags: new[] { &quot;reporter&quot; }, Summary = &quot;Retrieve reporter&quot;)] [OpenApiSecurity(&quot;function_key&quot;, SecuritySchemeType.ApiKey, Name = &quot;code&quot;, In = OpenApiSecurityLocationType.Query)] [OpenApiParameter(name: &quot;reporterId&quot;, In = ParameterLocation.Path, Required = true, Type = typeof(string))] [OpenApiResponseWithBody(statusCode: HttpStatusCode.OK, contentType: &quot;application/json&quot;, bodyType: typeof(Reporter), Description = &quot;Reporter&quot;)] public async Task&lt;HttpResponseData&gt; Get([HttpTrigger(AuthorizationLevel.Function, &quot;get&quot;, Route = &quot;reporter/{reporterId:required}&quot;)] HttpRequestData req, FunctionContext executionContext) { // Get reporter } [Function(&quot;ReporterPost&quot;)] [OpenApiOperation(tags: new[] { &quot;reporter&quot; }, Summary = &quot;Create a new reporter&quot;)] [OpenApiSecurity(&quot;function_key&quot;, SecuritySchemeType.ApiKey, Name = &quot;code&quot;, In = OpenApiSecurityLocationType.Query)] [OpenApiRequestBody(contentType: &quot;application/json&quot;, bodyType: typeof(ReporterRequest))] [OpenApiResponseWithBody(statusCode: HttpStatusCode.OK, contentType: &quot;application/json&quot;, bodyType: typeof(Reporter), Description = &quot;Created reporter&quot;)] public async Task&lt;HttpResponseData&gt; Post([HttpTrigger(AuthorizationLevel.Function, &quot;post&quot;, Route = &quot;reporter&quot;)] HttpRequestData req, FunctionContext executionContext) { // Create reporter } [Function(&quot;ReporterPut&quot;)] [OpenApiOperation(tags: new[] { &quot;reporter&quot; }, Summary = &quot;Update a reporter&quot;)] [OpenApiSecurity(&quot;function_key&quot;, SecuritySchemeType.ApiKey, Name = &quot;code&quot;, In = OpenApiSecurityLocationType.Query)] [OpenApiParameter(name: &quot;reporterId&quot;, In = ParameterLocation.Path, Required = true, Type = typeof(string))] [OpenApiRequestBody(contentType: &quot;application/json&quot;, bodyType: typeof(ReporterRequest))] [OpenApiResponseWithBody(statusCode: HttpStatusCode.OK, contentType: &quot;application/json&quot;, bodyType: typeof(Reporter), Description = &quot;Updated reporter&quot;)] public async Task&lt;HttpResponseData&gt; Put([HttpTrigger(AuthorizationLevel.Function, &quot;put&quot;, Route = &quot;reporter/{reporterId:required}&quot;)] HttpRequestData req, FunctionContext executionContext) { // Update reporter } [Function(&quot;ReporterDelete&quot;)] [OpenApiOperation(tags: new[] { &quot;reporter&quot; }, Summary = &quot;Delete a reporter&quot;)] [OpenApiParameter(name: &quot;reporterId&quot;, In = ParameterLocation.Path, Required = true, Type = typeof(string))] [OpenApiSecurity(&quot;function_key&quot;, SecuritySchemeType.ApiKey, Name = &quot;code&quot;, In = OpenApiSecurityLocationType.Query)] [OpenApiResponseWithBody(statusCode: HttpStatusCode.OK, contentType: &quot;application/json&quot;, bodyType: typeof(Reporter), Description = &quot;Deleted reporter&quot;)] public async Task&lt;HttpResponseData&gt; Delete([HttpTrigger(AuthorizationLevel.Function, &quot;delete&quot;, Route = &quot;reporter/{reporterId:required}&quot;)] HttpRequestData req, FunctionContext executionContext) { // Delete reporter } } } </code></pre> <p>All five methods are just routes for simple CRUD operations. As you can see these lines are duplicated in every function (route):</p> <pre class="lang-csharp prettyprint-override"><code>[OpenApiOperation(tags: new[] { &quot;reporter&quot; }, Summary = &quot;Retrieve all reporters&quot;)] [OpenApiSecurity(&quot;function_key&quot;, SecuritySchemeType.ApiKey, Name = &quot;code&quot;, In = OpenApiSecurityLocationType.Query)] [OpenApiResponseWithBody(statusCode: HttpStatusCode.OK, contentType: &quot;application/json&quot;, bodyType: typeof(Reporter[]), Description = &quot;All reporters&quot;)] </code></pre> <p>I'm using a single class for interaction with each model (e.g. 10 models = 10 classes) so in each class:</p> <ul> <li>Tags will all be the same</li> <li>Security will be the same</li> <li>Response body will all be the same (except <code>[GET] /api/reporter</code> which will return as an array)</li> </ul> <p>And also parameter name is also duplicated (see <code>reporterId</code>):</p> <pre class="lang-csharp prettyprint-override"><code>[OpenApiParameter(name: &quot;reporterId&quot;, In = ParameterLocation.Path, Required = true, Type = typeof(string))] public async Task&lt;HttpResponseData&gt; Put([HttpTrigger(AuthorizationLevel.Function, &quot;put&quot;, Route = &quot;reporter/{reporterId:required}&quot;)] HttpRequestData req, FunctionContext executionContext) { } </code></pre> <p>I've tried something like putting values in a variable and using it in the attributes (<a href="https://stackoverflow.com/a/2827821/7405706">which is not possible</a>). So, I'm wondering is there a way to refactor this so these lines won't get duplicated all over?</p> <hr /> <p>Additional Info:</p> <ul> <li>GitHub - <a href="https://github.com/phwt/azure-functions-rest/tree/feature/mongo" rel="nofollow noreferrer">https://github.com/phwt/azure-functions-rest/tree/feature/mongo</a> <ul> <li>The functions will be inside <code>AzureFunctionsREST.API/Functions</code></li> <li>This project is a PoC for REST API + OpenAPI + MongoDB + repository pattern on Azure Functions. So, there might be a lot of unrelated codes.</li> </ul> </li> <li>Related documentations on OpenAPI with Azure Functions <ul> <li><a href="https://github.com/Azure/azure-functions-openapi-extension/blob/main/docs/openapi-core.md" rel="nofollow noreferrer">https://github.com/Azure/azure-functions-openapi-extension/blob/main/docs/openapi-core.md</a></li> <li><a href="https://docs.microsoft.com/en-us/azure/azure-functions/openapi-apim-integrate-visual-studio" rel="nofollow noreferrer">https://docs.microsoft.com/en-us/azure/azure-functions/openapi-apim-integrate-visual-studio</a></li> </ul> </li> </ul> <hr /> <p>The updated version is available <a href="https://gist.github.com/phwt/7728bab1483bc4cf8cfb5d10ad3bdc51" rel="nofollow noreferrer">here</a></p>

270437

<p>I needed to pass a const reference to part of a <code>std::vector</code> without copy. I posted the previous version in my <a href="https://codereview.stackexchange.com/questions/270271/custom-implementation-to-provide-an-immutable-range-of-a-vector-without-copying">earlier question</a>, thank you for the great support! As far as I know this version supports not only <code>std::vector</code>s but any kind of iterator based continuous containers!</p> <p>Some research, particularly <a href="//stackoverflow.com/q/30469063">this SO question</a>, suggested that it is not something supported by default(at least in pre-c++20 std), so I created my own code for it:</p> <pre class="lang-cpp prettyprint-override"><code>#include &lt;iterator&gt; #include &lt;vector&gt; template &lt;typename Iterator = std::vector&lt;double&gt;::const_iterator&gt; class ConstVectorSubrange{ public: using T = typename Iterator::value_type; ConstVectorSubrange(Iterator start_, std::size_t size_) : start(start_) , range_size(size_) { } ConstVectorSubrange(Iterator begin_, Iterator end_) : start(begin_) , range_size(std::distance(start, end_)) { } const T&amp; operator[](std::size_t index) const{ assert(index &lt; range_size); return *std::next(start, index); } const T&amp; front() const{ return *begin(); } const T&amp; back() const{ return *std::next(end(), -1); } std::size_t size() const{ return range_size; } Iterator begin() const{ return start; } Iterator end() const{ return std::next(start, range_size); } private: const Iterator start; const std::size_t range_size; }; </code></pre> <p>In C++20 the functionality is available in <code>std::span</code>, so I am trying to achieve this with c++17 latest. Target for my code is c++11, but c++17 features are also present in the project I am using this in. I'm not sure I would go up to c++20 as I'm still not sure how widespread it is yet, but I'm still open to it.</p> <p>An example of using this would be a member function where not the whole array is visible, although copies are to be avoided:</p> <pre class="lang-cpp prettyprint-override"><code>#include &lt;vector&gt; class BigData{ std::vector&lt;int&gt; big_array = vector&lt;int&gt;(10000); public: ConstVectorSubrange get_last_five_thousand_elements(){ return{(big_array.end()-5000), big_array.end()}; } }; </code></pre> <p>How can this code be improved? I tried to remove the dependent typename, but I could only do that with C++20 <code>std::iter_reference_t</code>. Is there no other way to deduce <code>T</code> explicitly?</p>

270439

<p>I have created a simple abstract class called <code>expr_node</code> which will serve as a base class for any expression-related nodes.</p> <p>My goal is to create a simple deleter that can delete the allocated memory from the derived class in which would be recursive in some cases.</p> <p>Rules and constraints (NOTE: for practice purposes only):</p> <ul> <li>Will not rely on smart pointers (<code>std::unique_ptr</code> and <code>std::shared_ptr</code>)</li> <li>Will not rely on <code>std::variant</code> or <code>std::any</code></li> <li>Not using <code>std::visit</code></li> <li>Apply dynamic dispatch</li> <li>Only use inheritance</li> <li>(i'm also aware that I use recursion very often here just for the sake of traversing each)</li> </ul> <p>Important enumerations:</p> <pre class="lang-cpp prettyprint-override"><code>/// enum class: node_kinds enum class node_kinds { number_atom, unary_op, binary_op }; /// enum class: unary_op_kinds enum class unary_op_kinds { plus, minus }; /// enum class: binary_op_kinds enum class binary_op_kinds { plus, minus, multiplies, divides, modulus }; </code></pre> <p>Abstract class:</p> <pre class="lang-cpp prettyprint-override"><code>/// abstract class: expr_node struct expr_node { virtual ~expr_node() = default; virtual node_kinds node_kind() const = 0; }; </code></pre> <p>Derived classes from <code>expr_node</code>:</p> <pre class="lang-cpp prettyprint-override"><code>/// number_node struct number_node : expr_node { std::int64_t value; number_node(std::int64_t value) : value(value) {} node_kinds node_kind() const override { return node_kinds::number_atom; } }; /// unary_op_node struct unary_op_node : expr_node { unary_op_kinds kind; expr_node* operand; unary_op_node(unary_op_kinds kind, expr_node* operand = nullptr) : kind(kind), operand(operand) {} node_kinds node_kind() const override { return node_kinds::unary_op; } }; /// binary_op_node struct binary_op_node : expr_node { binary_op_kinds kind; expr_node* left; expr_node* right; binary_op_node(binary_op_kinds kind, expr_node* left = nullptr, expr_node* right = nullptr) : kind(kind), left(left), right(right) {} node_kinds node_kind() const override { return node_kinds::binary_op; } }; </code></pre> <p>Main Highlight: Deleter</p> <pre class="lang-cpp prettyprint-override"><code>void delete_nodes(expr_node* node) { if (node != nullptr) { switch (node-&gt;node_kind()) { case node_kinds::number_atom: if (auto temp = dynamic_cast&lt;number_node*&gt;(node); temp != nullptr) { delete temp; temp = nullptr; } break; case node_kinds::unary_op: if (auto temp = dynamic_cast&lt;unary_op_node*&gt;(node); temp != nullptr) { delete_nodes(temp-&gt;operand); delete temp; temp = nullptr; } break; case node_kinds::binary_op: if (auto temp = dynamic_cast&lt;binary_op_node*&gt;(node); temp != nullptr) { delete_nodes(temp-&gt;left); delete_nodes(temp-&gt;right); delete temp; temp = nullptr; } break; } node = nullptr; } } </code></pre> <p>Utilities for printing a tree:</p> <pre class="lang-cpp prettyprint-override"><code>std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, unary_op_kinds kind) { switch (kind) { using enum unary_op_kinds; case plus: return os &lt;&lt; '+'; case minus: return os &lt;&lt; '-'; } return os; } std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, binary_op_kinds kind) { switch (kind) { using enum binary_op_kinds; case plus: return os &lt;&lt; '+'; case minus: return os &lt;&lt; '-'; case multiplies: return os &lt;&lt; '*'; case divides: return os &lt;&lt; '/'; case modulus: return os &lt;&lt; '%'; } return os; } void display_nodes(expr_node* node, std::size_t level = 0) { if (node != nullptr) { switch (node-&gt;node_kind()) { case node_kinds::number_atom: if (auto temp_node = dynamic_cast&lt;number_node*&gt;(node); temp_node != nullptr) { std::cout &lt;&lt; std::string(level, ' ') &lt;&lt; &quot;number(&quot; &lt;&lt; temp_node-&gt;value &lt;&lt; &quot;)\n&quot;; } break; case node_kinds::unary_op: if (auto temp_node = dynamic_cast&lt;unary_op_node*&gt;(node); temp_node != nullptr) { std::cout &lt;&lt; std::string(level, ' ') &lt;&lt; &quot;unary_op(&quot; &lt;&lt; temp_node-&gt;kind &lt;&lt; &quot;)\n&quot;; display_nodes(temp_node-&gt;operand, level + 1); } break; case node_kinds::binary_op: if (auto temp_node = dynamic_cast&lt;binary_op_node*&gt;(node); temp_node != nullptr) { std::cout &lt;&lt; std::string(level, ' ') &lt;&lt; &quot;binary_op(&quot; &lt;&lt; temp_node-&gt;kind &lt;&lt; &quot;)\n&quot;; display_nodes(temp_node-&gt;left, level + 1); display_nodes(temp_node-&gt;right, level + 1); } break; } } } </code></pre> <p>Sample:</p> <pre class="lang-cpp prettyprint-override"><code>// 1 + (2 + (3 * (-4))) expr_node* nodes = new binary_op_node(binary_op_kinds::plus, new number_node(1), new binary_op_node(binary_op_kinds::plus, new number_node(2), new binary_op_node(binary_op_kinds::multiplies, new number_node(3), new unary_op_node(unary_op_kinds::minus, new number_node(4) ) ) ) ); display_nodes(nodes); delete_nodes(nodes); </code></pre> <p>Output:</p> <pre class="lang-cpp prettyprint-override"><code>binary_op(+) number(1) binary_op(+) number(2) binary_op(*) number(3) unary_op(-) number(4) </code></pre> <p>If we focus primarily on the deleter function <code>delete_nodes</code>, is it enough to be called a &quot;proper&quot; or is it properly deleting? Will there be undefined behavior happen?</p>

270443

<blockquote> <p>Given an array <span class="math-container">\$a\$</span> of integers, find minimum sum obtained after performing <span class="math-container">\$K\$</span> <em>operation</em>s. In this context <em>operation</em> involves choosing an element <em>a[i]</em>, multiply it by <span class="math-container">\$2\$</span>, at the same time, choose another element and divide by <span class="math-container">\$2\$</span>.</p> </blockquote> <p>My approach is able to find the minimum sum by carrying out the following operation.<br /> But it's not able to find the minimum sum after performing <span class="math-container">\$K\$</span> operations.</p> <pre><code>def minSum(arr, n, x=2): Sum = 0 # To store the largest element # from the array which is # divisible by x largestDivisible, minimum = -1, arr[0] for i in range(0, n): # Sum of array elements before # performing any operation Sum += arr[i] # If current element is divisible by x # and it is maximum so far if(arr[i] % x == 0 and largestDivisible &lt; arr[i]): largestDivisible = arr[i] # Update the minimum element if arr[i] &lt; minimum: minimum = arr[i] # If no element can be reduced then there's # no point in performing the operation as # we will end up increasing the sum when an # element is multiplied by x if largestDivisible == -1: return Sum # Subtract the chosen elements from the # sum and then add their updated values sumAfterOperation = (Sum - minimum - largestDivisible + (x * minimum) + (largestDivisible // x)) # Return the minimized sum return min(Sum, sumAfterOperation) </code></pre> <p>Any idea on what I can do to extend this approach to handle the concept of doing <span class="math-container">\$K\$</span> operations?</p>

270444

<p>I wrote a program with Python that converts decimal positive numbers to binary and puts the result in a list. I have a problem with decimal 0 because the result I get is <code>[]</code> instead of <code>[0]</code>. It works just fine with every number except for 0. How can I improve it to make it work with 0 too?</p> <p>This is my code:</p> <pre><code>def dec2bin(number): binary_number = [] final_quotient = 0 while (number != 0): rem = number % 2 binary_number.append(rem) number = number // 2 binary_number.reverse() print(binary_number) return binary_number </code></pre>

270445

<p>Here is my A* algorithm. I tried hard to implement it generically, but come up only with one idea to use lambdas for heuristic and next nodes (neighbours / successors) functions. I know that using good heuristic function is the key to speed up, but here i'm trying to squeeze everything from current implementation not taking into account any external factors.</p> <pre><code> /** * @brief generic a* algorithm * * @tparam T any type with operator&lt; and operator== * @tparam Heuristic function, returns uint32_t * @tparam Mutator function returns iterable of all next states of node * @param initial initial state of node * @param expected expected state of node * @param heuristic function like manhattan or euclidean distance * @param next next mutator * @return std::vector&lt;T&gt; representing path from expected to initial */ template &lt;class T, class Heuristic, class Mutator&gt; std::vector&lt;T&gt; path(const T&amp; initial, const T&amp; expected, Heuristic heuristic, Mutator next) { struct Node { using ref = std::shared_ptr&lt;Node&gt;; explicit Node(const T&amp; data, ref parent, uint32_t g, uint32_t h) : data(data), parent(parent), g(g), h(h), f(g + h) {} const T data; // actual data const ref parent{}; // pointer to parent // scores const uint32_t g, h, f; }; static auto path = [](auto n) { std::vector&lt;T&gt; result; for (; n; n = n-&gt;parent) result.push_back(n-&gt;data); return result; }; // comparator for nodes::ref's to make heap static auto comp = [](auto&amp;&amp; lhs, auto&amp;&amp; rhs) { return lhs-&gt;f &gt; rhs-&gt;f; }; // std::vector&lt;T&gt; closed; std::set&lt;T&gt; closed; // &lt;- required operator&lt; // vector will be used as priority_queue std::vector&lt;typename Node::ref&gt; opened; // initial state with g score = 0 opened.push_back(std::make_shared&lt;Node&gt;(initial, nullptr, 0, heuristic(initial, expected))); while (not opened.empty()) { // pop opened into curr const auto curr = opened.front(); // if goal found if (curr-&gt;data == expected) return path(curr); // poping priority queue std::pop_heap(opened.begin(), opened.end(), comp); opened.pop_back(); // foreach node in successors for (auto&amp;&amp; child : next(curr-&gt;data)) { // if was in closed if (!closed.insert(child).second) continue; // setting up child node const auto node = std::make_shared&lt;Node&gt;(child, curr, curr-&gt;g + 1, heuristic(child, expected)); // find the node with the same data as child auto it = std::find_if(opened.begin(), opened.end(), [&amp;child](auto&amp;&amp; node) { return node-&gt;data == child; }); // if opened does not contains child data push and continue if (it == opened.end()) { opened.push_back(std::move(node)); std::push_heap(opened.begin(), opened.end(), comp); continue; } // if current child node is better than found node // replace previos node with current if (node-&gt;f &lt; (*it)-&gt;f) *it = node; } } return {}; // impossible to reach } </code></pre> <p>Is there any way to improve performance?</p>

270452

<p>I have a base view model which implements an Mode View View model pattern.</p> <pre><code> public interface IBaseViewModel&lt;T&gt; { #region public properties BaseViewModelProperties BaseVMProps { get; set; } T Model { get; set; } #endregion #region public methods Task Init(); Task Init(Guid Id); Task Init(string Id); Task Init(string type, Guid Id); Task Create(); Task Get(Guid Id); Task&lt;T&gt; Get(string Id); Task&lt;IEnumerable&lt;T&gt;&gt; GetList(); Task&lt;IEnumerable&lt;T&gt;&gt; GetList(Guid Id); Task&lt;IEnumerable&lt;T&gt;&gt; GetList(string Id); Task Insert(T t); Task Insert(string type, T t); Task Update(Guid Id, T t); Task Update(string type, Guid Id, T t); Task Delete(Guid Id); Task Delete(string type, Guid Id); void Dispose(); #endregion } public abstract class BaseViewModel&lt;T&gt; : IBaseViewModel&lt;T&gt;, IDisposable { public BaseViewModelProperties BaseVMProps { get; set; } = new BaseViewModelProperties(); public T Model { get; set; } #region Init public virtual Task Init() { return Task.FromResult&lt;T&gt;(default); } public virtual Task Init(Guid Id) { return Task.FromResult&lt;T&gt;(default); } public virtual Task Init(string Id) { return Task.FromResult&lt;T&gt;(default); } public virtual Task Init(string type, Guid Id) { return Task.FromResult&lt;T&gt;(default); } #endregion public virtual Task Create() { return Task.FromResult&lt;T&gt;(default); } #region Get public virtual Task Get(Guid Id) { return Task.FromResult&lt;T&gt;(default); } public virtual Task&lt;T&gt; Get(string Id) { return Task.FromResult&lt;T&gt;(default); } public virtual Task Get(string type, Guid Id) { return Task.FromResult&lt;T&gt;(default); } public virtual Task&lt;IEnumerable&lt;T&gt;&gt; GetList() { return Task.FromResult&lt;IEnumerable&lt;T&gt;&gt;(default); } public virtual Task&lt;IEnumerable&lt;T&gt;&gt; GetList(Guid Id) { return Task.FromResult&lt;IEnumerable&lt;T&gt;&gt;(default); } public virtual Task&lt;IEnumerable&lt;T&gt;&gt; GetList(string Id) { return Task.FromResult&lt;IEnumerable&lt;T&gt;&gt;(default); } #endregion #region Insert public virtual Task Insert(T t) { return Task.FromResult&lt;T&gt;(default); } public virtual Task Insert(string type, T t) { return Task.FromResult&lt;T&gt;(default); } #endregion #region Update public virtual Task Update(Guid Id, T t) { return Task.FromResult&lt;T&gt;(default); } public virtual Task Update(string type, Guid Id, T t) { return Task.FromResult&lt;T&gt;(default); } #endregion #region Delete public virtual Task Delete(Guid Id) { return Task.FromResult&lt;T&gt;(default); } public virtual Task Delete(string type, Guid Id) { return Task.FromResult&lt;T&gt;(default); } #endregion public virtual void ProcessDto(T t) { } public virtual void Dispose() { } </code></pre> <p>Below is a sample implementation of this base view model</p> <pre><code> public class AccountBillViewModel : BaseViewModel&lt;AccountBillGroup&gt;, IAccountBillViewModel { public Guid AccountId { get; set; } public string AccountQDSId { get; set; } public AccountBillGroup SelectedAccountBillGroup { get; set; } public IEnumerable&lt;AccountBillGroup&gt; AccountBillGroupList { get; set; } private IAccountBillDataService accountBillDataService { get; set; } public AccountBillViewModel(IAccountBillDataService accountBillDataService) { this.accountBillDataService = accountBillDataService; AccountBillGroupList = Enumerable.Empty&lt;AccountBillGroup&gt;(); } #region Get collection of account bills by account id - Api call public async override Task&lt;IEnumerable&lt;AccountBillGroup&gt;&gt; GetList(Guid accountId) { try { OperationResult&lt;IEnumerable&lt;AccountBillGroup&gt;&gt; opResult = await accountBillDataService.GetAccountBillsByAccountId(accountId).ConfigureAwait(false); AccountBillGroupList = OperationResultHelper&lt;IEnumerable&lt;AccountBillGroup&gt;&gt;. ProcessOperationResult(opResult, BaseVMProps, &quot;GetAccountBillsByAccountId&quot;, &quot;Get&quot;); return AccountBillGroupList; } catch (Exception ex) { //ToDo: call audit service to log error UtilityHelper.ProcessException(BaseVMProps); throw; } } #endregion } </code></pre> <p>The sample implementation uses a subset of the abstract base class. Does this violate the Interface Segregation Principle? Would it be better to break this base view model down into a set of smaller interfaces and then implement only those interfaces that will be used in each class? Or is the current implementation acceptable?</p>

270454

<p>So I tried implementing a easily extendable solution for <a href="https://www.geeksforgeeks.org/sqrt-square-root-decomposition-technique-set-1-introduction/" rel="nofollow noreferrer">Sqrt decompostion</a>, I deduced that only identity value, operation and block update logic change and rest of the code is same. So i created 3 functions</p> <ul> <li><code>T identity()</code></li> <li><code>T operation(const T&amp;a, const T&amp;b)</code></li> <li><code>T block_update_calc(const T old_block_value, const T, const T &amp;old_data_value)</code></li> </ul> <p>I earlier tried inheritance, where these were <strong>pure virtual functions</strong> in base class and these are implemented in derived classes. But I then found out that we can't call virtual functions of derived class in constructor of base class which can be mitigated at cost of syntax.</p> <p>Current solution is template based and <code>AdditionSqrtDecomposition</code> and <code>MultiplicationSqrtDecomposition</code> <strong>behave exactly like I want</strong>, but code looks bit messy, how can I improve this code?</p> <p>Usage:</p> <pre class="lang-cpp prettyprint-override"><code>vector&lt;int&gt; nums(N); AdditionSqrtDecomposition&lt;int&gt; sd_addition(nums); MultiplicationSqrtDecomposition&lt;int&gt; sd_multiplication(nums); </code></pre> <p>Implementation</p> <pre class="lang-cpp prettyprint-override"><code>#ifndef SQRT_DECOMPOSITION_HPP #define SQRT_DECOMPOSITION_HPP #include &lt;cmath&gt; #include &lt;vector&gt; template &lt;typename T, class Core&gt; class SqrtDecomposition { public: std::vector&lt;T&gt; _data, _decomp; int _block_size; // constructors, asssignment, destructor explicit SqrtDecomposition(const std::vector&lt;T&gt; &amp;data) : _data(data), _decomp(ceil(sqrt(data.size())), Core::identitiy()), _block_size(::sqrt(data.size())) { int curr_block = -1; for (int i = 0; i &lt; _data.size(); ++i) { if (i % _block_size == 0) { curr_block++; } auto &amp;d = _decomp[curr_block]; d = Core::operation(d, _data[i]); } } T query(int l, int r) { T result = Core::identitiy(); // identitiy for (; l &lt;= r and l % _block_size != 0; l++) { // individuals before a block result = Core::operation(result, _data[l]); } for (int i = l / _block_size; l + _block_size &lt;= r; ++i, l += _block_size) { // block representatives result = Core::operation(result, _decomp[i]); } for (; l &lt;= r; ++l) { // individuals after a block result = Core::operation(result, _data[l]); } return result; } void update(int index, T value) { int representating_block = index / _block_size; _decomp[representating_block] = Core::block_update_calc( _decomp[representating_block], value, _data[index]); _data[index] = value; } }; // interface template &lt;typename T&gt; class OperationCore { public: static T identitiy() = 0; static T operation(const T &amp;a, const T &amp;b) = 0; static T block_update_calc(const T old_block_value, const T new_data_value, const T &amp;old_data_value) = 0; }; template &lt;typename T&gt; class AdditionCore { public: static T identitiy() { return 0; } static T operation(const T &amp;a, const T &amp;b) { return a + b; } static T block_update_calc(const T old_block_value, const T new_data_value, const T &amp;old_data_value) { return old_block_value + new_data_value - old_data_value; } }; template &lt;typename T&gt; class MultiplicationCore { public: static T identitiy() { return 1; } static T operation(const T &amp;a, const T &amp;b) { return a * b; } static T block_update_calc(const T old_block_value, const T new_data_value, const T &amp;old_data_value) { return (old_block_value * new_data_value) / old_block_value; } }; template &lt;typename T&gt; class AdditionSqrtDecomposition : public SqrtDecomposition&lt;T, AdditionCore&lt;T&gt;&gt; { using SqrtDecomposition&lt;T, AdditionCore&lt;T&gt;&gt;::SqrtDecomposition; }; template &lt;typename T&gt; class MultiplicationSqrtDecomposition : public SqrtDecomposition&lt;T, MultiplicationCore&lt;T&gt;&gt; { using SqrtDecomposition&lt;T, MultiplicationCore&lt;T&gt;&gt;::SqrtDecomposition; }; #endif // SQRT_DECOMPOSITION_HPP </code></pre>

270455