From 270e2170402b17f3bdfc50acbe81c6c3823f9564 Mon Sep 17 00:00:00 2001 From: emile Date: Sat, 25 May 2019 18:22:08 +0200 Subject: [PATCH] initial --- Classes.cs | 219 +++++++++++++++++++++++++++++++++++++++++++++++++++++ Program.cs | 31 ++++++++ program.py | 69 +++++++++++++++++ 3 files changed, 319 insertions(+) create mode 100644 Classes.cs create mode 100644 Program.cs create mode 100644 program.py diff --git a/Classes.cs b/Classes.cs new file mode 100644 index 0000000..8723966 --- /dev/null +++ b/Classes.cs @@ -0,0 +1,219 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace LogiksProject +{ + //alternatywa, konjunkcja, równaważność, implikacja, negacja, lewy nawias, prawy nawias, zmienna, jakieś cudo + + enum Signs { Alterantive, Conjuction, Equality, Implication, Negation, LeftBracket, RightBracket, Var, Unknown }; + //enum Brackets { LeftBracket, RightBracket}; + + + class LogicVar //Najprostsza klasa dla przechowywania zmiennych + { + public char Name { get; set; } + } + + class LogicRelation //(NIE UŻYWANE) + { //Prawdopodobnie można użyć przy wprowadzaniu nawiasów + LogicVar v1; + LogicVar v2; + + Signs rel; + + public void SetVarOne(LogicVar v1) + { + this.v1 = v1; + } + + public void SetVars(LogicVar v1, LogicVar v2) + { + this.v1 = v1; + this.v2 = v2; + } + + LogicRelation(LogicVar l, Signs s) + { + v1 = l; + rel = s; + } + + LogicRelation(LogicVar l1, LogicVar l2, Signs s) + { + v1 = l1; + v2 = l2; + rel = s; + } + + } + class LogicString // Najważniejsza klasa, która przyjmuje ciąq danych + { // i przetwarza dla sprawdzenia, czy wpisana formuła + string input; // jest poprawna logicznie. W danym przypadku nie są uwzględniane nawiasy, + // więc można przyjąć, że konjunkcja i alternatywa mają różne priorytety + //LogicRelation rel; + LogicVar[] vars; // <- Tablica zmiennych logicznych + int[] StringRelVar; // <- tablica przechowująca informację o ciągu znaków (1 dla zmiennej, 0 dla funkcji, 2 - koniec ciągu), używana przy sprawdzaniu + Signs [] sTab; // <- tablica zmiennych i funkcji logicznych, używana przy sprawdzaniu + //Brackets [] bTab; // <- (NIE UŻYWANE) tablica nawiasów + + public void GetInputString() // <- metoda GetInputString pryzjmuje wejście do zmienney typu string + { + Console.WriteLine("Please, input your string and press enter(with no spaces)"); + input = Console.ReadLine(); + } + + public void AnalizeString() // <- metoda AnalizeString "przetwarza" dane z wejścia i "tłumaczy" je na zmienne i funkcje logiczne, które są później zapisywane w LogicVar[] vars, int[] StringRelVar i Signs[] sTab + { + sTab = new Signs [100]; // toporny sposób na tworzenie nowej tablicy + vars = new LogicVar[100]; // to samo + for (int j = 0; j < 100; j++) // cuda na kiju, ze aż wstyd + { + vars[j] = new LogicVar(); + } + StringRelVar = new int[100]; + //bTab = new Brackets [100]; + for(int i = 0; i < input.Length; i++) // "chodzenie" po stringu input i "tłumaczenie" zmiennych i funkcji + { + if(input[i] == '=') // '=' równoważność + { + //Console.WriteLine("equality"); + sTab[i] = Signs.Equality; + StringRelVar[i] = 0; // funkcja logiczna rozpoznawana jako "0" + } + else if(input[i] == '>') // '>' implikacja + { + //Console.WriteLine("implication"); + sTab[i] = Signs.Implication; + StringRelVar[i] = 0; + } + else if(input[i] == '|') // '|' alternatywa + { + //Console.WriteLine("alternative"); + sTab[i] = Signs.Alterantive; + StringRelVar[i] = 0; + } + else if(input[i] == '&') // '&' koniunkcja + { + //Console.WriteLine("conjuction"); + sTab[i] = Signs.Conjuction; + StringRelVar[i] = 0; + } + else if(input[i] == '!') // '!' negacja + { + //Console.WriteLine("negation"); + sTab[i] = Signs.Negation; + StringRelVar[i] = 0; + } + /*else if(input[i] == '(') // nawiasy + { + //Console.WriteLine("left bracket"); + sTab[i] = Signs.LeftBracket; + StringRelVar[i] = 0; + } + else if(input[i] == ')') + { + //Console.WriteLine("right bracket"); + sTab[i] = Signs.RightBracket; + StringRelVar[i] = 0; + }*/ + else + { + //Console.WriteLine($"there is a variable called {input[i]}"); + vars[i].Name = input[i]; // (zbędne bez używania nawiasów) "rozpoznawanie" zmiennych i wpisywanie do tablicy, + sTab[i] = Signs.Var; + //Console.WriteLine($"there is a variable called {vars[i].Name}"); + //vars[i].SetName(input[i]); + StringRelVar[i] = 1; // Zmienna oznaczana jako "1" + } + if(input[i] == ' ') + { + Console.WriteLine("You can't put spaces"); + } + if(i == input.Length - 1) + { + StringRelVar[i+1] = 2; + } + } + + + + } + + public bool ErrSearch() // metoda ErrSearch sprawdza czy formuła jest poprawna + { + int count = 0; // używane przy "chodzeniu" po StringRelVar + int zeroCount = 0; // używane przy podliczaniu funkcji logicznych, występujacych pod rząd + int oneCount = 0; // to samo przy podliczaniu zmiennych logicznych + + + + while(StringRelVar[count] != 2) + { + //Console.Write(StringRelVar[count]); + if(StringRelVar[count] == 1) + { + if (oneCount == 1) // nie można umieszczać obok siebie zmienne logiczne + { + Console.WriteLine("formula nie jest poprawna"); + return false; + } + if (oneCount == 0) + { + zeroCount = 0; + oneCount++; + } + + } + if(StringRelVar[count] == 0) + { + if (zeroCount > 0) + { + if (sTab[count] == Signs.Negation) + { + if ((sTab[count + 1] != Signs.Var)&&(sTab[count+1] != Signs.Negation)) //tylko negacja może się powtarzać wielokrotnie, przy tym negacja nie może się znajdować przed funkcją logiczną + { + Console.WriteLine("formula nie jest porpawna"); + return false; + } + } + else + { + Console.WriteLine("formula nie jest poprawna"); + return false; + } + } + if (zeroCount == 0) + { + oneCount = 0; + zeroCount++; + } + + } + count++; + } + Console.WriteLine("formula jest poprawna"); + return true; + + + } + + public void ShowVerRel() //zestaw zer i jedynek z dwójką na końcu, dokładnie jak historia z wejściówkami na logice + { + int count = 0; + while(StringRelVar[count] != 2) + { + Console.Write(StringRelVar[count]); + count++; + } + } + + + } + + + + +} //koniec diff --git a/Program.cs b/Program.cs new file mode 100644 index 0000000..b45e6ce --- /dev/null +++ b/Program.cs @@ -0,0 +1,31 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace LogiksProject +{ + class Program + { + static void Main(string[] args) + { + LogicString s1 = new LogicString(); + + // program przyjmuje ciąg znaków(bez spacji) + // = równoważnośc + // > implikacja + // | alternatywa + // & koniunkja + // ! negacja + // pozostałe znaki, w tym spacja są traktowane jako "odmiany kaligraficzne" zmiennych logicznych + + s1.GetInputString(); + s1.AnalizeString(); + s1.ErrSearch(); + + + Console.ReadLine(); + } + } +} diff --git a/program.py b/program.py new file mode 100644 index 0000000..ac3d8ae --- /dev/null +++ b/program.py @@ -0,0 +1,69 @@ +import sys +#TODO: dodać parentices +class AbstractInterpreter: + def __init__(self): + pass + def isValid(formula:str)->bool: + raise NotImplementedError +class SimpleInterpreter(AbstractInterpreter): + def __init__(self): + pass + def isValid(self,formula)->bool: + print("is valid?") + variables = {} + f=[] + def isBlacklisted(char): + return char in ['\n', '\t', ' '] + def isSign(char): + logic_signs = ['=', '>', '&', '|', '!', '(', ')'] + return char in logic_signs + def isVariable(char): + return not isSign(char) + def isNegation(char): + return char == '!' + #print(vars(formula)) + for i,char in enumerate(formula.s): + if isBlacklisted(char): return False + print(char) + prev = formula.s[i-1] if i>0 else None #None, gdy jesteśmy na pierwszym znaku + if isSign(char): + if (not isNegation(char)): + if isSign(prev) and not isNegation(prev): # tylko negacje mogą się powtarzać po innym znaku + return False + else: + if isVariable(prev): # obrona przed a!>b + return False + else: + #if current char is a variable + if isVariable(prev) and prev is not None: #Obrona abc>d + print("previous is also a variable"); + return False + return True +class Formula: + def __init__(self, formula_string:str, interpreter:AbstractInterpreter): + self.s = formula_string + self.__i = interpreter + if not self.isValid(self.__i): + assert "formula in invalid!" + else: + print("given formula is valid") + def isValid(self, interpreter)->bool: + + return interpreter.isValid(self) + + +i = SimpleInterpreter() +print(sys.argv) +if sys.argv[1] == '-f': + #open from file + print("opening from file") + g = open(sys.argv[1], 'r') + u = g.readlines() + for l in u: + Formula(l,i) +else: + Formula( sys.argv[1],i) + + + +