コード例 #1
0
        private modnode ConvertToAON(modnode m) //Исключает штрих Шеффера, стрелку Пирса, импликацию, эквивалентность и сложение по модулю 2.
        {
            modnode tl, tr;

            if (m.right != null)
            {
                m.right = ConvertToAON(m.right);
            }
            if (m.left != null)
            {
                m.left = ConvertToAON(m.left);
            }
            if (m.data == "/")
            {
                m.data = "V";
                m.Addl("!");
                m.Addr("!");
                return(m);
            }
            if (m.data == "|")
            {
                m.data = "&";
                m.Addl("!");
                m.Addr("!");
                return(m);
            }
            if (m.data == ">")
            {
                m.data = "V";
                m.Addl("!");
                return(m);
            }
            if (m.data == "=") //(x = y) == (!y V x) & (!x V y)
            {
                tl     = m.left.Copy();
                tr     = m.right.Copy();
                m.data = "&";
                m.Addl("V");
                m.left.left = tr;
                m.left.Addl("!");
                m.Addr("V");
                m.right.left = tl;
                m.right.Addl("!");
                return(m);
            }
            if (m.data == "+") //(x + y) == (y V x) & (!x V !y)
            {
                tl     = m.left.Copy();
                tr     = m.right.Copy();
                m.data = "&";
                m.Addl("V");
                m.left.left = tr;
                m.Addr("V");
                m.right.Addr("!");
                m.right.left = tl;
                m.right.Addl("!");
                return(m);
            }
            return(m);
        }
コード例 #2
0
 private void button1_Click(object sender, EventArgs e)
 {
     F = textBox_input.Text;
     if (F != "")
     {
         F         = F.Replace(" ", "");
         tree      = new modnode();
         perems    = new ArrayList();
         kvants    = new ArrayList();
         tree.data = F;
         correct   = true;
         tree      = Pars(tree);
         if (correct)
         {
             tree = ConvertToAON(tree);
             tree = NotDown(tree);
             tree = RenameKvants(tree);
             tree = ConvertToPNF(tree);
             tree = ConvertToKNF(tree);
             textBox_output.Text = tree.ToString();
         }
         else
         {
             textBox_output.Text = "Bad";
         }
         tree.Del();
         tree   = null;
         perems = null;
         kvants = null;
     }
 }
コード例 #3
0
        private modnode ConvertToKNF(modnode m)//Приводит к коньюнктивной нормальной форме. Работает только с формулами приведёнными к ПНФ.
        {
            modnode t0, t1;

            if (m.right != null && m.right.right != null)
            {
                m.right = ConvertToKNF(m.right);
            }
            if (m.left != null && m.left.right != null)
            {
                m.left = ConvertToKNF(m.left);
            }
            if (m.data == "V")
            {
                t0 = new modnode();
                if (m.right.data == "&")
                {
                    t0.data        = "&";
                    t0.left        = new modnode();
                    t0.left.data   = "V";
                    t0.left.left   = m.left;
                    t0.left.right  = m.right.left;
                    t0.right       = new modnode();
                    t0.right.data  = "V";
                    t1             = m.left.Copy();
                    t0.right.left  = t1;
                    t0.right.right = m.right.right;
                    m       = t0;
                    m.right = ConvertToKNF(m.right);
                    m.left  = ConvertToKNF(m.left);
                    return(m);
                }
                if (m.left.data == "&")
                {
                    t0.data        = "&";
                    t0.left        = new modnode();
                    t0.left.data   = "V";
                    t0.left.left   = m.left.left;
                    t0.left.right  = m.right;
                    t0.right       = new modnode();
                    t0.right.data  = "V";
                    t1             = m.right.Copy();
                    t0.right.left  = m.left.right;
                    t0.right.right = t1;
                    m       = t0;
                    m.right = ConvertToKNF(m.right);
                    m.left  = ConvertToKNF(m.left);
                    return(m);
                }
            }
            return(m);
        }
コード例 #4
0
 public void Del()
 {
     if (right != null)
     {
         right.Del();
         right = null;
     }
     if (left != null)
     {
         left.Del();
         left = null;
     }
 }
コード例 #5
0
        public void Addl()
        {
            modnode temp;

            if (left == null)
            {
                left = new modnode();
            }
            else
            {
                temp       = left;
                left       = new modnode();
                left.right = temp;
            }
        }
コード例 #6
0
        public void Addr()
        {
            modnode temp;

            if (right == null)
            {
                right = new modnode();
            }
            else
            {
                temp        = right;
                right       = new modnode();
                right.right = temp;
            }
        }
コード例 #7
0
        public void Addl(string s)
        {
            modnode temp;

            if (left == null)
            {
                left      = new modnode();
                left.data = s;
            }
            else
            {
                temp       = left;
                left       = new modnode();
                left.right = temp;
                left.data  = s;
            }
        }
コード例 #8
0
        public void Addr(string s)
        {
            modnode temp;

            if (right == null)
            {
                right      = new modnode();
                right.data = s;
            }
            else
            {
                temp        = right;
                right       = new modnode();
                right.right = temp;
                right.data  = s;
            }
        }
コード例 #9
0
        public modnode Copy()
        {
            modnode r, l, t;

            t      = new modnode();
            t.data = data;
            if (right != null)
            {
                r       = right.Copy();
                t.right = r;
            }
            if (left != null)
            {
                l      = left.Copy();
                t.left = l;
            }
            return(t);
        }
コード例 #10
0
        private modnode ExchangePerem(modnode m, string o, string n)//Замена переменной "o" на "n" в дереве "m".
        {
            int i = 0, j;

            if ((m.data[0] == '#' || m.data[0] == '$') && m.data.Substring(1, m.data.Length - 1) == o)
            {
                m.data = m.data[0] + n;
            }
            if (pred(m.data))
            {
                while (m.data[i] != '(')
                {
                    i++;
                }
                i++;
                while (i != m.data.Length)
                {
                    j = i;
                    while (m.data[j] != ',' && m.data[j] != ')')
                    {
                        j++;
                    }
                    if (m.data.Substring(i, j - i) == o)
                    {
                        m.data = m.data.Substring(0, i) + n + m.data.Substring(j, m.data.Length - j);
                    }
                    i = j + 1;
                }
            }
            if (perem(m.data) && m.data == o)
            {
                m.data = n;
            }
            if (m.right != null)
            {
                m.right = ExchangePerem(m.right, o, n);
            }
            if (m.left != null)
            {
                m.left = ExchangePerem(m.left, o, n);
            }
            return(m);
        }
コード例 #11
0
        private modnode RenameKvants(modnode m)//Переименовывает связанные переменные.
        {
            int    l, i;
            string x, xn;

            if (m.data[0] == '#' || m.data[0] == '$')
            {
                l = m.data.Length;
                x = m.data.Substring(1, l - 1);
                if (kvants.IndexOf(x) == -1)
                {
                    kvants.Add(x);
                }
                else
                {
                    if (l > 2)
                    {
                        i = Convert.ToInt32(x.Substring(1, l - 2)) + 1;
                    }
                    else
                    {
                        i = 1;
                    }
                    while (perems.IndexOf(x[0] + i.ToString()) != -1)
                    {
                        i++;
                    }
                    xn = x[0] + i.ToString();
                    perems.Add(xn);
                    kvants.Add(xn);
                    m = ExchangePerem(m, x, xn);
                }
            }
            if (m.right != null && m.right.right != null)
            {
                m.right = RenameKvants(m.right);
            }
            if (m.left != null && m.left.right != null)
            {
                m.left = RenameKvants(m.left);
            }
            return(m);
        }
コード例 #12
0
        private modnode ConvertToPNF(modnode m)//Приводит к пренексной нормальной форме. Работает только с формулами приведёнными к базису и-или-не, в которых отрицания продвинуты до атомов и переименованы связаные переменные.
        {
            modnode r, l, t0 = new modnode(), t1;

            if (m.right != null && m.right.right != null)
            {
                m.right = ConvertToPNF(m.right);
            }
            if (m.left != null && m.left.right != null)
            {
                m.left = ConvertToPNF(m.left);
            }
            if (m.data == "V" || m.data == "&")
            {
                l = m.left; t1 = t0;
                while (l.data[0] == '#' || l.data[0] == '$')
                {
                    t1.data  = l.data;
                    t1.right = new modnode();
                    t1       = t1.right;
                    l        = l.right;
                }
                r = m.right;
                while (r.data[0] == '#' || r.data[0] == '$')
                {
                    t1.data  = r.data;
                    t1.right = new modnode();
                    t1       = t1.right;
                    r        = r.right;
                }
                t1.data  = m.data;
                t1.right = r;
                t1.left  = l;
                return(t0);
            }
            return(m);
        }
コード例 #13
0
 public void Addl(modnode m)
 {
     left = m;
 }
コード例 #14
0
 public void Addr(modnode m)
 {
     right = m;
 }
コード例 #15
0
        private modnode Pars(modnode m) //Разбивает логическое выражение на атомы.
        {
            int sk = 0, j, k;

            char[] pr3 = { '/', '|' };
            int    p3  = m.data.IndexOfAny(pr3);

            if (p3 != -1)
            {
                for (int i = m.data.Length - 1; i >= 0; i--)
                {
                    if (sk == 0)
                    {
                        switch (m.data[i])
                        {
                        case '/':
                        {
                            m.Addl(m.data.Substring(0, i));
                            m.Addr(m.data.Substring(i + 1, m.data.Length - i - 1));
                            m.data  = "/";
                            m.left  = Pars(m.left);
                            m.right = Pars(m.right);
                            return(m);
                        }

                        case '|':
                        {
                            m.Addl(m.data.Substring(0, i));
                            m.Addr(m.data.Substring(i + 1, m.data.Length - i - 1));
                            m.data  = "|";
                            m.left  = Pars(m.left);
                            m.right = Pars(m.right);
                            return(m);
                        }
                        }
                    }
                    if (m.data[i] == ')')
                    {
                        sk++;
                    }
                    if (m.data[i] == '(')
                    {
                        sk--;
                    }
                }
            }
            if (m.data.Contains('='))
            {
                sk = 0;
                for (int i = m.data.Length - 1; i >= 0; i--)
                {
                    if ((sk == 0) && (m.data[i] == '='))
                    {
                        m.Addl(m.data.Substring(0, i));
                        m.Addr(m.data.Substring(i + 1, m.data.Length - i - 1));
                        m.data  = "=";
                        m.left  = Pars(m.left);
                        m.right = Pars(m.right);
                        return(m);
                    }
                    if (m.data[i] == ')')
                    {
                        sk++;
                    }
                    if (m.data[i] == '(')
                    {
                        sk--;
                    }
                }
            }
            if (m.data.Contains('>'))
            {
                sk = 0;
                for (int i = m.data.Length - 1; i >= 0; i--)
                {
                    if ((sk == 0) && (m.data[i] == '>'))
                    {
                        m.Addl(m.data.Substring(0, i));
                        m.Addr(m.data.Substring(i + 1, m.data.Length - i - 1));
                        m.data  = ">";
                        m.left  = Pars(m.left);
                        m.right = Pars(m.right);
                        return(m);
                    }
                    if (m.data[i] == ')')
                    {
                        sk++;
                    }
                    if (m.data[i] == '(')
                    {
                        sk--;
                    }
                }
            }
            char[] pr4 = { 'V', '+' };
            int    p4  = m.data.IndexOfAny(pr4);

            if (p4 != -1)
            {
                sk = 0;
                for (int i = m.data.Length - 1; i >= 0; i--)
                {
                    if (sk == 0)
                    {
                        switch (m.data[i])
                        {
                        case '+':
                        {
                            m.Addl(m.data.Substring(0, i));
                            m.Addr(m.data.Substring(i + 1, m.data.Length - i - 1));
                            m.data  = "+";
                            m.left  = Pars(m.left);
                            m.right = Pars(m.right);
                            return(m);
                        }

                        case 'V':
                        {
                            m.Addl(m.data.Substring(0, i));
                            m.Addr(m.data.Substring(i + 1, m.data.Length - i - 1));
                            m.data  = "V";
                            m.left  = Pars(m.left);
                            m.right = Pars(m.right);
                            return(m);
                        }
                        }
                    }
                    if (m.data[i] == ')')
                    {
                        sk++;
                    }
                    if (m.data[i] == '(')
                    {
                        sk--;
                    }
                }
            }
            if (m.data.Contains('&'))
            {
                sk = 0;
                for (int i = m.data.Length - 1; i >= 0; i--)
                {
                    if ((sk == 0) && (m.data[i] == '&'))
                    {
                        m.Addl(m.data.Substring(0, i));
                        m.Addr(m.data.Substring(i + 1, m.data.Length - i - 1));
                        m.data  = "&";
                        m.left  = Pars(m.left);
                        m.right = Pars(m.right);
                        return(m);
                    }
                    if (m.data[i] == ')')
                    {
                        sk++;
                    }
                    if (m.data[i] == '(')
                    {
                        sk--;
                    }
                }
            }
            if (m.data.StartsWith("!"))
            {
                m.Addr(m.data.Substring(1));
                m.data  = "!";
                m.right = Pars(m.right);
                return(m);
            }
            if (m.data.StartsWith("(") && m.data.EndsWith(")"))
            {
                m.data = m.data.Substring(1, m.data.Length - 2);
                m      = Pars(m);
                return(m);
            }
            if (m.data.StartsWith("$") || m.data.StartsWith("#"))
            {
                j = 2;
                if (m.data[1] >= 'a' && m.data[1] <= 'z')
                {
                    while (j < m.data.Length && m.data[j] >= '0' && m.data[j] <= '9')
                    {
                        j++;
                    }
                    m.Addr(m.data.Substring(j, m.data.Length - j));
                    m.data  = m.data.Substring(0, j);
                    m.right = Pars(m.right);
                }
                else
                {
                    correct = false;
                }
                return(m);
            }
            if (pred(m.data))
            {
                k = 1;
                string x;
                while (m.data[k] != '(')
                {
                    k++;
                }
                k++;
                while (k != m.data.Length)
                {
                    j = k;
                    while (m.data[j] != ',' && m.data[j] != ')')
                    {
                        j++;
                    }
                    x = m.data.Substring(k, j - k);
                    if (perems.IndexOf(x) == -1)
                    {
                        perems.Add(x);
                    }
                    k = j + 1;
                }
                return(m);
            }
            if (perem(m.data))
            {
                if (perems.IndexOf(m.data) == -1)
                {
                    perems.Add(m.data);
                }
                return(m);
            }
            correct = false;
            return(m);
        }
コード例 #16
0
        private modnode NotDown(modnode m)//Продвижение отрацаний до атомов. Работает только с формулами приведёнными к базису и-или-не.
        {
            if (m.right == null)
            {
                return(m);
            }
            if (m.data == "!")
            {
                switch (m.right.data[0])
                {
                case '#':
                {
                    m.data       = "$" + m.right.data.Substring(1, m.right.data.Length - 1);
                    m.right.data = "!";
                    m.right      = NotDown(m.right);
                    return(m);
                }

                case '$':
                {
                    m.data       = "#" + m.right.data.Substring(1, m.right.data.Length - 1);
                    m.right.data = "!";
                    m.right      = NotDown(m.right);
                    return(m);
                }

                case 'V':
                {
                    m.data  = "&";
                    m.left  = m.right.left;
                    m.right = m.right.right;
                    m.Addl("!");
                    m.Addr("!");
                    m.right = NotDown(m.right);
                    m.left  = NotDown(m.left);
                    return(m);
                }

                case '&':
                {
                    m.data  = "V";
                    m.left  = m.right.left;
                    m.right = m.right.right;
                    m.Addl("!");
                    m.Addr("!");
                    m.right = NotDown(m.right);
                    m.left  = NotDown(m.left);
                    return(m);
                }

                case '!':
                {
                    return(m.right.right);
                }
                }
            }
            if (m.right != null)
            {
                m.right = NotDown(m.right);
            }
            if (m.left != null)
            {
                m.left = NotDown(m.left);
            }
            return(m);
        }