s444440/Logic-Formulae-Validator-dla-ubogich
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

initial

Browse Source
This commit is contained in:
emile 2019-05-25 18:22:08 +02:00
commit 270e217040
3 changed files with 319 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

219
Classes.cs Normal file
View File

@ -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

31
Program.cs Normal file
View File

@ -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();
}
}
}

69
program.py Normal file
View File

@ -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)