POC 1 functional version

codes/counter.asm

@@ -0,0 +1,8 @@
+define:
+    0 [ABC][DE]
+    1 [AB][CDE]
+
+data:
+    0001111
+
+instructions:

dnasimd

@@ -0,0 +1 @@
+src/main.py

src/SIMDDNA/__init__.py

@@ -1,3 +1,3 @@
-import ascii as ascii
+from . import ascii as ascii
-import molecule as molecule
+from . import molecule as molecule
-import register as register
+from . import register as register

src/SIMDDNA/ascii.py

@@ -3,8 +3,8 @@
 # @autor Lukáš Plevač <xpleva07@vutbr.cz>
 # @brief defines function from print structions in ASCII reprezentation
 
-from molecule import isComplementary
+from .molecule import isComplementary
-from molecule import nothing
+from .molecule import nothing
 
 ##
 # Return number of bases to bind with main chain 0

src/SIMDDNA/assembly.py

@@ -1,9 +1,100 @@
+import re
+from . import molecule
+
 class Assembly:
     def __init__(self, asm):
-        # remove whitespaces
-        asm = asm.strip()
         # load macros from file
         self.macros = self.parseMacros(asm)
+        self.data   = self.parseData(asm)
+        self.ins    = self.parseInstructions(asm)
+
+    def getMacros(self):
+        return self.macros
+
+    def getData(self):
+        return self.data
+    
+    def getInstructions(self):
+        return self.ins
 
     def parseMacros(self, asm):
+        asm = asm.splitlines()
+
+        is_in = False
+        macros = []
+        for ins in asm:
+            ins = re.sub("\s+" , " ", ins.strip()) # remove whitespaces
+            ins = ins.split("#")[0] # remove comments
+            
+            if "define:" in ins:
+                is_in = True
+            elif ":" in ins and is_in:
+                break
+            elif is_in:
+                name = ins.split(" ")[0]
+
+                if not name.isspace() and len(name) > 0:
+                    val = ins.split(" ")[1]
+
+                    macros.append([name, val])
+
+        return macros
+
+    def useMacros(self, text):
+        for macro in self.macros:
+            text = text.replace(macro[0], macro[1])
+
+        return text
+    
+    def parseData(self, asm):
+        asm = asm.splitlines()
+
+        is_in = False
+        datas = []
+        for ins in asm:
+            ins = re.sub("\s+" , " ", ins.strip()) # remove whitespaces
+            ins = ins.split("#")[0] # remove comments
+            
+            if "data:" in ins:
+                is_in = True
+            elif ":" in ins and is_in:
+                break
+            elif is_in:
+                reg = ins.split(" ")
+
+                if len(reg) > 1:
+                    print("WARNING: ASM parsing data molecule with space. All after space is ignored!")
+
+                reg = reg[0]
+
+                if not reg.isspace() and len(reg) > 0:
+                    datas.append(molecule.parse(self.useMacros(reg)))
+
+        return datas        
+
+    def parseInstructions(self, asm):
+        asm = asm.splitlines()
+
+        is_in = False
+        gins = []
+        for ins in asm:
+            ins = re.sub("\s+" , " ", ins.strip()) # remove whitespaces
+            ins = ins.split("#")[0] # remove comments
+            
+            if "instructions:" in ins:
+                is_in = True
+            elif ":" in ins and is_in:
+                break
+            elif is_in:
+                DNAins = ins.split(" ")
+
+                DNAInsArray = []
+                for DNAin in DNAins:
+                    if not DNAin.isspace() and len(DNAin) > 0:
+                        DNAInsArray.append(molecule.parse(self.useMacros(DNAin)))
+
+                if len(DNAInsArray) > 0:
+                    gins.append(DNAInsArray)
+
+        return gins     
 

src/SIMDDNA/register.py

@@ -3,8 +3,8 @@
 # @autor Lukáš Plevač <xpleva07@vutbr.cz>
 # @brief implments REGISTER from SIMD|DNA
 
-import molecule
+from . import molecule
-import ascii
+from . import ascii
 
 class Register:
     ##
@@ -125,11 +125,11 @@ class Register:
                 for pos in range(len(self.mol)):
                     if molecule.isComplementary(self.mol.getBase(chainI, pos), self.mol.getBase(0, pos)) and self.mol.bindedCountAt(pos) == 1: # binde minimaly once
                         bindScore += 1
-                    else:
+                    elif not molecule.isComplementary(self.mol.getBase(chainI, pos), self.mol.getBase(0, pos)):
+                        finalBindScore = max(bindScore, finalBindScore)
                         bindScore      = 0
-                        finalBindScore = max(finalBindScore, bindScore)
 
-                if finalBindScore < 2:
+                if max(bindScore, finalBindScore) < 2:
                     self.mol.removeChain(chainI)
                     done = False
                     break

src/main.py

@@ -1,48 +1,72 @@
+#!/usr/bin/env python3
 
 from SIMDDNA.register import Register
-from SIMDDNA          import molecule
 from SIMDDNA.assembly import Assembly
+from SIMDDNA.ascii    import showMolecule
+import argparse
 
-asm = Assembly(
+parser = argparse.ArgumentParser(description='DNA|SIMD python simulator POC1')
-"""
+parser.add_argument('assembly')
-define:
+parser.add_argument('-s', '--spaceing', default=" ", help='space sentense between ascii char of DNA strands')
-    0 [ABC][DE]
+parser.add_argument('-v', '--verbose', help='show simulation step by step not only final', action='store_true', default=False)
-    1 {A}[BCDE]
+parser.add_argument('-d', '--decode', help='use macros to decode final result', action='store_true', default=False)
 
-data:
+args = parser.parse_args()
-    1001111010
 
-instructions:
+# Open a file
-    {D*E*A*F*}      # mark 01
+file = open(args.assembly, mode='r')
-    {D*E*A*B*C*G*}  # mark 11
+asm = file.read()
-    {DEABCG}        # remove mark 11
+file.close()
-    {A*B*C*} {D*E*} # write 0
+
-    {DEAF}          # remove mark 01
+asm = Assembly(asm)
-    {B*C*D*E*}      # write 1
-"""
-)
 
 print("=================================")
 print("|         Inital state          |")
 print("=================================")
-print("\n")
+print("")
 
 regs = []
 
 for data in asm.getData():
-    regs.append(Register(molecule.parse(data)))
+    regs.append(Register(data))
-    regs[-1].asciiShow(spaceing = " ")
+    regs[-1].asciiShow(spaceing = args.spaceing)
 
 
 iId = 0
 for ins in asm.getInstructions():
+
+    if args.verbose:
+        print("")
         print("=================================")
         print(f"|        Instruction {iId}         |")
         print("=================================")
-    print("\n")
+        print()
+
+        for insc in ins:
+            insc.rawPrint()
+
+        print()
+        print("Registers")
+        print("--------------------------------")
+        print()
 
     for reg in regs:
         reg.instruction(ins)
-        reg.asciiShow(spaceing = " ")
+        
+        if args.verbose:
+            reg.asciiShow(spaceing = args.spaceing)
 
     iId += 1
+
+print("")
+print("=================================")
+print("|          FINAL state          |")
+print("=================================")
+print("")
+
+for reg in regs:
+    reg.asciiShow(spaceing = args.spaceing)
+
+if args.decode:
+    # todo: implement it
+    pass