Merge branch '2024_sem2' into khai/progressbar

Author: tuankhainguy

.idea/.name

@@ -66,13 +66,13 @@
     "denque": "^2.0.1",
     "framer-motion": "^4.0.0",
     "lodash": "^4.17.21",
-    "prop-types": "^15.7.2",
+    "prop-types": "^15.8.1",
     "react": "^17.0.2",
     "react-dom": "^17.0.2",
     "react-markdown": "^5.0.0",
     "react-resize-detector": "^6.6.0",
     "react-router-dom": "^5.2.0",
-    "react-scripts": "^4.0",
+    "react-scripts": "^5.0.1",
     "react-table": "^7.5.0",
     "reactjs-popup": "^2.0.5",
     "remark-gfm": "^1.0.0",
@@ -83,7 +83,7 @@
   },
   "devDependencies": {
     "@babel/plugin-proposal-private-property-in-object": "^7.21.11",
-    "electron": "^15.0.0",
+    "electron": "^31.4.0",
     "enzyme": "^3.11.0",
     "eslint": "^7.11.0",
     "eslint-plugin-import": "^2.28.1",
@@ -96,4 +96,3 @@
     "run-script-os": "^1.1.6"
   }
 }
-

.idea/workspace.xml

@@ -347,6 +347,7 @@ export default {
   },
 
   run(chunker, { nodes }) {
+
     if (nodes === null || nodes.length === 0) return;
     let { node: tree, id: newID } = this.createNodeAndIncrement(null);
 

docs/URL-Code-Implementation-Guideline-20241004.pdf

@@ -7,8 +7,9 @@
 // #define QUICKSORT // some version of quicksort
 // #define MERGE_TD // top-down merge sort
 // #define MERGE_BUP // bottom-up merge sort
+#define MERGE_NAT // natural merge sort
 // #define MSD_RADIX // radix exchange sort
-#define MERGE_TD_LA // top-down merge sort for lists imp as arrays
+// #define MERGE_TD_LA // top-down merge sort for lists imp as arrays
 // XXX should do top-down merge sort for lists imp with pointers - main code
 // should be identical - just need to write init code for list and change
 // some macro definitions
@@ -59,6 +60,10 @@ List mergesort_td_la(int L, int len);
 void mergesort_bup(int A[], int size);
 #endif // MERGE_BUP
 
+#ifdef MERGE_NAT
+void mergesort_nat(int A[], int size);
+#endif // MERGE_NAT
+
 #ifdef MSD_RADIX
 int radix_partition(int *A, int left, int right, int mask);
 void msd_radix_sort(int A[], int left, int right, int mask);
@@ -102,6 +107,9 @@ main() {
 #ifdef MERGE_BUP
         mergesort_bup(A, Size-1);
 #endif // MERGE_BUP
+#ifdef MERGE_NAT
+        mergesort_nat(A, Size-1);
+#endif // MERGE_NAT
         for (i=1; i < Size; i++) printf("%d ", A[i]); printf("\n");
 }
 
@@ -323,7 +331,7 @@ mergesort_td(int A[], int left, int right) {
 List
 mergesort_td_la(int L, int len) {
         int i, mid;
-        List Lmid, R, M, E;
+        List Lmid, R, M, Mlast;
 
         if (len > 1) {
                 // determine Lmid, the mid point of L
@@ -362,23 +370,23 @@ mergesort_td_la(int L, int len) {
                     R = tail(R);
                 }
                 // scan through adding elements to the end of M
-                E = M;
+                Mlast = M;
                 while (L != Null && R != Null) {
                     if (head(L) <= head(R)) {
-                        tail(E) = L;
-                        E = L;
+                        tail(Mlast) = L;
+                        Mlast = L;
                         L = tail(L);
                     } else {
-                        tail(E) = R;
-                        E = R;
+                        tail(Mlast) = R;
+                        Mlast = R;
                         R = tail(R);
                     }
                 }
                 // add any elements not scanned to the end of M
                 if (L == Null)
-                    tail(E) = R;
+                    tail(Mlast) = R;
                 else
-                    tail(E) = L;
+                    tail(Mlast) = L;
             printf("Merged: ");
             for (Lmid = M; Lmid != Null; Lmid = tail(Lmid))
                 printf(" %d", head(Lmid));
@@ -397,7 +405,7 @@ mergesort_td_la(int L, int len) {
 #endif // MERGE_TD_LA
 
 #ifdef MERGE_BUP
-// XXX could reduce duplication with MERGE_TD
+// XXX could reduce duplication with MERGE_TD and MERGE_NAT
 int B[Size];
 
 int
@@ -460,3 +468,77 @@ printf("Merging %d %d %d - %d\n", left, mid, right, runlength);
 }
 
 #endif // MERGE_BUP
+
+#ifdef MERGE_NAT
+// XXX could reduce duplication with MERGE_TD and MERGE_BUP
+int B[Size];
+
+int
+minimum(int i, int j) {
+        if (i <= j)
+                return i;
+        else
+                return j;
+}
+
+// Sort array A[1]..A[size] in ascending order
+void
+mergesort_nat(int A[], int size) {
+        int runcount, left, mid, right;
+        int ap1, ap1max, ap2, ap2max, bp;
+
+        do {
+                runcount = 0;
+                left = 1;
+                do {
+                        // find the first run, A[left..mid]
+                        mid = left;
+                        while (mid < size && A[mid] <= A[mid+1])
+                            mid++;
+                        // find the second run, A[mid+1..right]
+                        right = mid+1;
+                        while (right < size && A[right] <= A[right+1])
+                            right++;
+                        if (mid < size) {
+                        // merge A[left..mid] and A[mid+1..right], with the result in A
+printf("Merging %d %d %d \n", left, mid, right);
+                                ap1 = left;
+                                ap1max = mid;
+                                ap2 = mid+1;
+                                ap2max = right;
+                                bp = left;
+                                while (ap1 <= ap1max && ap2 <= ap2max)
+                                        if (A[ap1] < A[ap2]) {
+                                                B[bp] = A[ap1];
+                                                ap1 = ap1+1;
+                                                bp = bp+1;
+                                        } else {
+                                                B[bp] = A[ap2];
+                                                ap2 = ap2+1;
+                                                bp = bp+1;
+                                        }
+                                while (ap1 <= ap1max) {
+                                        B[bp] = A[ap1];
+                                        ap1 = ap1+1;
+                                        bp = bp+1;
+                                }
+                                while (ap2 <= ap2max) {
+                                        B[bp] = A[ap2];
+                                        ap2 = ap2+1;
+                                        bp = bp+1;
+                                }
+                                for (bp = left; bp <= right; bp++)
+                                        A[bp] = B[bp];
+                        }
+                        runcount++;
+                        left = right + 1;
+                } while (left < size);
+        } while (runcount > 1);
+// if (left < right-1) { // for testing/debugging
+// int i1;
+// printf("Ret from ms(%d, %d): ", left, right);
+// for (i1=1; i1 < Size; i1++) printf("%d ", A[i1]); printf("\n");
+// }
+}
+
+#endif // MERGE_NAT

package-lock.json

@@ -19,7 +19,8 @@ export default {
   initVisualisers() {
     return {
       graph: {
-        instance: new GraphTracer('key', null, 'Transitive Closure'),
+        // instance: new GraphTracer('key', null, 'Transitive Closure'),
+        instance: new GraphTracer('key', null, 'Graph view'),
         order: 0
       },
       // create a separate component for displaying the matrix as a 2D array
@@ -42,22 +43,25 @@ export default {
     return out;
   },
 
-  run(chunker, { matrix, size }) {
+  run(chunker, { edgeValueMatrix, coordsMatrix, startNode, endNodes, moveNode}) {
     // eslint-disable-next-line no-unused-expressions
+    const matrix = edgeValueMatrix;
+    const size = matrix.length;
     const numOfNodes = size;
     const nodes = new Array(numOfNodes);
     let prevI = 0;
     let prevJ = 0;
     let prevK = 0;
-    chunker.add(1, (g) => {
+    chunker.add(1, (g, edgeArray, coordsArray) => {
       // show kth tag when step back
       setKthVisible(true);
       g.array.set([...matrix], 'tc');
-      g.graph.set([...matrix], Array.from({ length: matrix.length }, (v, k) => (k + 1)));
-      g.graph.layoutCircle();
+      g.graph.set(edgeArray, Array.from({ length: matrix.length }, (v, k) => (k + 1)),coordsArray);
+      // g.graph.layoutCircle();
       // initialise the matrix in the 'Matrix' component
       g.graph.setIstc();
-    }, [this.graph], [this.array]);
+      g.graph.moveNodeFn(moveNode);
+    }, [[...edgeValueMatrix], [...coordsMatrix]]);
 
     for (let i = 0; i < numOfNodes; i++) {
       nodes[i] = this.copyArr([...matrix]);

package.json

@@ -22,9 +22,6 @@ import * as Instructions from './instructions';
  src/context/actions.js had better be deployed!
  XXX Design of noDeploy stuff was done with the aim of minimal code change
  and could be re-thought when there are fewer merges going on.
- XXX we could export and use allalgs in key places in the system,
- eg src/context/actions.js so we can still access them via the URL, but
- not have them appear in the index.
 
  Each imported algorithm is expected to be an object of the form:
  { pseudocode: String, explanation: String, run: Function }
@@ -182,7 +179,6 @@ const allalgs = {
     },
   },
   'BFS': {
-    
     name: 'Breadth First Search',
     category: 'Graph',
     param: <Param.BFSParam/>,
@@ -351,7 +347,13 @@ const algorithms =
  * Get the first mode of an algorithm
  * @param {string} key algorithm's name
  */
-const getDefaultMode = (key) => Object.keys(algorithms[key].pseudocode)[0];
+export const getDefaultMode = (key) => Object.keys(algorithms[key].pseudocode)[0];
+
+/**
+ * Get the category of an algorithm
+ * @param {string} key algorithm's name
+ */
+export const getCategory = (key) => algorithms[key].category;
 
 // This function generates a list of algorithms classed by categories
 const generateAlgorithmCategoryList = () => {

src/algorithms/controllers/TTFTreeInsertion.js

@@ -3,6 +3,8 @@ import React, { useState } from 'react';
 import MatrixParam from './helpers/MatrixParam';
 import '../../styles/Param.scss';
 import EuclideanMatrixParams from './helpers/EuclideanMatrixParams';
+import PropTypes from 'prop-types'; // Import this for URL Param
+import { withAlgorithmParams } from './helpers/urlHelpers' // Import this for URL Param
 
 // Note: 'A* Algorithm' currently used in EuclideanMatrixParams.js -
 // change both or neither!
@@ -30,23 +32,30 @@ const GRAPH_EGS = [ // XXX think up better examples?
           edges:
 '1-2-10,1-4-4,2-3-6,3-4-10,3-5-5,4-7-3,5-6-7,6-7-8,7-8-2,7-9,8-9-3,9-10-5,9-11-7, 10-11-7,11-13-4,12-13-8,12-14-6,13-14-7,13-15-7,14-16-6,15-16-2,15-17-5,16-17-2'
         }];
-function ASTParam() {
+function ASTParam( { mode, xyCoords, edgeWeights, size, start, end, heuristic, min, max } ) {
   const [message, setMessage] = useState(null);
+  const graph_egs = [
+      { name: 'URL Input Graph',
+        size: size || GRAPH_EGS[0].size,
+        coords: xyCoords || GRAPH_EGS[0].coords,
+        edges: edgeWeights || GRAPH_EGS[0].edges
+      }
+      ]
 
   return (
     <>
       {/* Matrix input */}
       <EuclideanMatrixParams
         name="aStar"
         mode="find"
-        defaultSize={DEFAULT_SIZE}
-        defaultStart={DEFAULT_START}
-        defaultEnd={DEFAULT_END}
-        heuristic = {DEFAULT_HEUR}
-        min={1}
-        max={49}
+        defaultSize={ size || DEFAULT_SIZE }
+        defaultStart={ start || DEFAULT_START }
+        defaultEnd={ end || DEFAULT_END }
+        heuristic = { heuristic || DEFAULT_HEUR }
+        min={ min || 1 }
+        max={ max || 49 }
         symmetric
-        graphEgs={GRAPH_EGS}
+        graphEgs={ graph_egs || GRAPH_EGS }
         ALGORITHM_NAME={ASTAR}
         EXAMPLE={ASTAR_EXAMPLE}
         EXAMPLE2={ASTAR_EXAMPLE2}
@@ -60,4 +69,32 @@ function ASTParam() {
   );
 }
 
-export default ASTParam;
+// Define the prop types for URL Params
+ASTParam.propTypes = {
+  alg: PropTypes.string.isRequired,
+  mode: PropTypes.string.isRequired,
+  size: PropTypes.string.isRequired,
+  start: PropTypes.string.isRequired,
+  end: PropTypes.string.isRequired,
+  heuristic: PropTypes.string.isRequired,
+  xyCoords: PropTypes.string.isRequired,
+  edgeWeights: PropTypes.string.isRequired,
+  min: PropTypes.string.isRequired,
+  max: PropTypes.string.isRequired,
+};
+// ASTParam.propTypes = {
+//   alg: PropTypes.string.isRequired,
+//   mode: PropTypes.string.isRequired,
+//   size: PropTypes.number.isRequired,
+//   start: PropTypes.arrayOf(PropTypes.number),
+//   end: PropTypes.arrayOf(PropTypes.number),
+//   heuristic: PropTypes.number.isRequired,
+//   xyCoords: PropTypes.string,
+//   edgeWeights: PropTypes.string,
+//   min: PropTypes.number,
+//   max: PropTypes.number
+// };
+
+export default withAlgorithmParams(ASTParam); // Export with the wrapper for URL Params
+
+