public static Poset operator -(Poset a, Poset b)
    {
        var result = new Poset(a.Size);

        for (int i = 0; i < a.Size; ++i)
        {
            for (int j = 0; j < a.Size; ++j)
            {
                result[i, j] = a[i, j];
            }
        }
        for (int i = 0; i < Math.Min(result.Size, b.Size); ++i)
        {
            for (int j = 0; j < Math.Min(result.Size, b.Size); ++j)
            {
                if (b[i, j])
                {
                    result[i, j] = false;
                }
            }
        }
        for (int i = 0; i < result.Size; ++i)
        {
            result[i, i] = true;
        }
        result = result.TrancitiveClosure();
        return(result);
    }
    public static Poset operator +(Poset a, Poset b)
    {
        var result = new Poset(Math.Max(a.Size, b.Size));

        for (int i = 0; i < a.Size; ++i)
        {
            for (int j = 0; j < a.Size; ++j)
            {
                result[i, j] = a[i, j];
            }
        }
        for (int i = 0; i < b.Size; ++i)
        {
            for (int j = 0; j < b.Size; ++j)
            {
                if (b._state[i, j])
                {
                    result[i, j] = b[i, j];
                }
            }
        }
        result = result.TrancitiveClosure();
        if (!result.IsValid())
        {
            throw new ArithmeticException();
        }

        return(result);
    }
    public static Poset operator --(Poset poset)
    {
        var result = new Poset(poset.Size - 1);

        for (int i = 0; i < result.Size; ++i)
        {
            for (int j = 0; j < result.Size; ++j)
            {
                result[i, j] = poset[i, j];
            }
        }
        return(result);
    }
    public object Clone()
    {
        var result = new Poset(Size);

        for (int i = 0; i < Size; ++i)
        {
            for (int j = 0; j < Size; ++j)
            {
                result[i, j] = _state[i, j];
            }
        }
        return(result);
    }
Exemple #5
0
 static void Main()
 {
     {
         Poset p = new Poset(2);
         Poset q = new Poset(2);
         p.add(0, 1);
         q.add(0, 1);
         Console.Write(p * q);
     }
     Console.WriteLine();
     {
         Poset p = new Poset(2);
         Poset q = new Poset(4);
         p.add(0, 1);
         q.add(2, 3);
         Console.Write(p + q);
     }
     Console.WriteLine();
     {
         Poset p = new Poset(2);
         Poset q = new Poset(3);
         p.add(0, 1);
         q.add(1, 2);
         Console.Write(p + q);
     }
     Console.WriteLine();
     {
         Poset p = new Poset(2);
         Poset q = new Poset(3);
         p.add(0, 1);
         q.add(1, 0);
         try
         {
             Console.Write(p + q);
         }
         catch (ArithmeticException)
         {
             Console.WriteLine("Error");
         }
     }
     Console.WriteLine();
     {
         Poset ww = new Poset(3);
         Console.Write(ww);
         ww.add(0, 1);
         Console.Write(ww);
         ww.add(1, 2);
         Console.Write(ww);
     }
     Console.ReadKey();
 }
    public static Poset operator ~(Poset poset)
    {
        var result = new Poset(poset.Size);

        for (int i = 0; i < poset.Size; ++i)
        {
            for (int j = 0; j < poset.Size; ++j)
            {
                if (poset[i, j])
                {
                    result[j, i] = true;
                }
            }
        }
        return(result);
    }
    public static Poset operator ++(Poset poset)
    {
        var result = new Poset(poset.Size + 1);

        for (int i = 0; i < poset.Size; ++i)
        {
            for (int j = 0; j < poset.Size; ++j)
            {
                result[i, j] = poset[i, j];
            }
        }
        for (int i = 0; i < poset.Size; ++i)
        {
            result[i, poset.Size] = true;
        }
        return(result);
    }
    public static Poset operator *(Poset a, Poset b)
    {
        int size   = a.Size * b.Size;
        var result = new Poset(size);

        for (int i = 0; i < size; ++i)
        {
            for (int j = 0; j < size; ++j)
            {
                if (a[i % a.Size, j % a.Size] && b[i / a.Size, j / a.Size])
                {
                    result[i, j] = true;
                }
            }
        }
        return(result);
    }