Пример #1
0
        /// <summary>
        /// And function for FDD's.
        /// </summary>
        /// <param name="u1">left side of the expression</param>
        /// <param name="u2">right side of the expression</param>
        /// <returns>a new BDD where u1 and u2 are bitwise and'ed</returns>
        public static Bdd And(Fdd u1, Fdd u2)
        {
            int u1Size  = Size(u1);
            int u2Size  = Size(u2);
            int MinSize = Min(u1Size, u2Size);
            Bdd result  = new Bdd(false);

            for (int i = 0; i < MinSize; i++)
            {
                result = Kernel.Or(result, Kernel.And(new Bdd(u1.Var + i), new Bdd(u2.Var + i)));
            }

            if (u1Size != u2Size)
            {
                if (u1Size > u2Size)        //you reach this state when 2 Fdds does not have the same number
                {                           //of bits. What happens is then the smallest get buffered with 0's
                    for (int i = MinSize; i < u1Size; i++)
                    {
                        result = Kernel.Or(result, Kernel.And(new Bdd(u1.Var + i), new Bdd(false)));
                    }
                }
                else
                {
                    for (int i = MinSize; i < u2Size; i++)
                    {
                        result = Kernel.Or(result, Kernel.And(new Bdd(false), new Bdd(u2.Var + i)));
                    }
                }
            }

            return(result);
        }
Пример #2
0
        /// <summary>
        /// restricts an FDD out of an expression, by giving it an integer value.
        /// </summary>
        /// <param name="root">the root of the tree the Fdd is a part of</param>
        /// <param name="fdd">the Fdd to restrict</param>
        /// <param name="restrictValue">the given ristrict value, must be between 0 and maxvalue of the Fdd.</param>
        /// <returns>the restricted Bdd</returns>
        public static Bdd Restrict(Bdd root, Fdd fdd, int restrictValue)
        {
            bool[] B = ToBitPattern(restrictValue);

            for (int i = 0; i < B.Length; i++)
            {
                root = Kernel.Restrict(root, fdd.Var + i, B[i]);
            }

            RestrictDictionary.Add(fdd.Var, restrictValue);

            return(root);
        }
Пример #3
0
        /// <summary>
        /// Enforces maxvalues by disallowing values normally room for with the size of bits in an fdd
        /// Value is normally expected to be the same as used in the constructor of the fdd.
        /// Note: (powers of 2) -1) does not need to be constrained: 7, 255 etc.
        /// </summary>
        /// <param name="fdd">The fdd to constrain</param>
        /// <param name="value">The values to enforce</param>
        public static Bdd EnforceMaxValue(Fdd fdd, int value)
        {
            Bdd result;

            //Always allow all bits where most significant bit isn't set
            result = Kernel.Not(new Bdd(fdd.Var));

            int start = (int)Math.Pow(2, Size(fdd) - 1);      //lowest number with most significant bit set

            for (int i = start; i <= value; i++)
            {
                result = Kernel.Or(result, Equal(fdd, i));
            }
            return(result);
        }
Пример #4
0
        /// <summary>
        /// Creates a hard binding sort of like an fdd restrict.
        /// Difference is that the binding will persist no matter
        /// what changes is later added.
        /// </summary>
        /// <param name="fdd">the Fdd to create a binding on</param>
        /// <param name="value">the constant number that is assigned to the Fdd.</param>
        /// <returns></returns>
        public static Bdd Equal(Fdd fdd, int value)
        {
            if (Log2(value) > FddDictionary[fdd.Var])      //value larger than fdd can hold.
            {
                return(new Bdd(false));
            }

            bool[] b = ToBitPattern(value, Size(fdd));

            Bdd result = new Bdd(true);

            for (int i = 0; i < b.Length; i++)
            {
                if (b[i])
                {
                    result = Kernel.And(result, new Bdd(fdd.Var + i));
                }
                else
                {
                    result = Kernel.And(result, Kernel.Not(new Bdd(fdd.Var + i)));
                }
            }
            return(result);
        }
Пример #5
0
 /// <summary>
 /// returns the bit-size of a given FDD.
 /// </summary>
 /// <param name="fdd">The FDD to get the size of</param>
 /// <returns></returns>
 public static int Size(Fdd fdd)
 {
     return(FddDictionary[fdd.Var]);
 }
Пример #6
0
 /// <summary>
 /// Compares Fdd's based on their position in the FDD array
 /// </summary>
 /// <param name="fdd">The FDD to compare the current FDD to</param>
 /// <returns>true if the FDD's have the same index, else false</returns>
 public bool Equals(Fdd fdd)
 {
     return(this.GetHashCode() == fdd.GetHashCode());       //GetHashCode is unique
 }