Esempio n. 1
0
        /// <summary>
        /// this -=overThere b
        ///
        /// この集合から、指定の要素を全て削除した結果を返します。
        ///
        /// この集合自身は変更しません。
        ///
        /// 順序はないが、Minus無印と同じではない☆
        /// 最初の1個(原点)は削除してはいけない☆
        /// </summary>
        /// <param name="targetMasus"></param>
        /// <returns></returns>
        public void MinusMe_Opened(SySet <T1> b, DLGT_SyElement_BynaryOperate dlgt_equals)
        {
            // このセットの中にある、スーパーセット1つ1つにも、Minus_OverThere をします。
            foreach (SySet <T1> superset2 in this.Supersets)
            {
                superset2.MinusMe_Opened(b, dlgt_equals);
            }

            if (b is SySet_Ordered <T1> )
            {
                // 方向をもつ集合で 引こうとした場合だけ有効です。

                // 要素の削除
                {
                    int index = 0;
                    foreach (T1 element in b.Elements)
                    {
                        if (index == 0)
                        {
                            // 最初の要素は、削除しません。
                            goto gt_Next;
                        }

                        this.Minus_Closed(element, dlgt_equals);

gt_Next:
                        index++;
                    }
                }
            }
            // 方向を持っていない集合では、Minus_OverThere は無効とします。
        }
Esempio n. 2
0
        /// <summary>
        /// もし順序があるならば、「a = 1→2→3→4」のときに
        /// 「a RemoveElement_OverThere( 2 )」とすれば、
        /// 答えは「3→4」
        /// となる操作がこれです。
        ///
        /// bを含めず、それより後ろを切る、という操作です。
        /// 順序がなければ、RemoveElementと同等です。
        /// </summary>
        /// <param name="masuHandle"></param>
        public void Minus_Opened(T1 b, DLGT_SyElement_BynaryOperate dlgt_equals)
        {
            // 削除する要素を検索します。
            int index = this.elements_.IndexOf(b);

            if (-1 == index)
            {
                goto gt_Supersets;
            }

            if (this.elements_.Count <= index + 1)
            {
                goto gt_Supersets;
            }

            // 削除したい要素を含めず、それより後ろを丸ごと削除
            this.elements_.RemoveRange(index + 1, this.elements_.Count - (index + 1));

gt_Supersets:

            // 親集合から削除
            foreach (SySet <T1> thisSuperset in this.supersets_)
            {
                thisSuperset.Minus_Closed(b, dlgt_equals);
            }
        }
Esempio n. 3
0
        /// <summary>
        /// this - b = this
        ///
        /// 要素を仲間から外します。
        /// </summary>
        /// <param name="bElement"></param>
        public void Minus_Closed(T1 bElement, DLGT_SyElement_BynaryOperate dlgt_equals)
        {
            // 要素から削除
            this.elements_.Remove(bElement);

            // 親集合から削除
            foreach (SySet <T1> thisSuperset in this.supersets_)
            {
                thisSuperset.Minus_Closed(bElement, dlgt_equals);
            }
        }
Esempio n. 4
0
        /// <summary>
        /// this - b = c
        ///
        /// この集合から、指定の要素を全て削除した結果を返します。
        ///
        /// この集合自身は変更しません。
        /// </summary>
        /// <param name="b"></param>
        /// <returns></returns>
        public SySet <T1> Minus_Closed(SySet <T1> b, DLGT_SyElement_BynaryOperate dlgt_equals)
        {
            // クローンを作成します。
            SySet <T1> c = this.Clone();

            // 要素の削除
            foreach (T1 bElement in b.Elements)
            {
                c.Minus_Closed(bElement, dlgt_equals);
            }

            return(c);
        }
Esempio n. 5
0
        /// <summary>
        /// this -= b
        /// </summary>
        /// <param name="b"></param>
        /// <returns></returns>
        public void MinusMe_Opened(SySet <T1> b, DLGT_SyElement_BynaryOperate dlgt_equals)
        {
            // このセットの中にある、スーパーセット1つ1つにも、Minus_OverThere をします。
            foreach (SySet <T1> superset2 in this.Supersets)
            {
                superset2.MinusMe_Opened(b, dlgt_equals);
            }

            foreach (T1 bElement in b.Elements)
            {
                // bを含まない、それより後ろの要素を丸ごと削除します。
                this.Minus_Opened(bElement, dlgt_equals);
            }
        }
Esempio n. 6
0
        /// <summary>
        /// this - b = c
        ///
        /// この集合のメンバーから、指定の集合のメンバーを削除します。
        /// </summary>
        /// <param name="b"></param>
        /// <returns></returns>
        public SySet <T1> Minus_Closed(SySet <T1> b, DLGT_SyElement_BynaryOperate dlgt_equals)
        {
            // クローンを作成します。
            SySet <T1> c = this.Clone();

            // 指定の要素が含まれているかどうか1つ1つ調べます。
            foreach (T1 bElement in b.Elements)
            {
                // 要素を1つ1つ削除していきます。
                c.Minus_Closed(bElement, dlgt_equals);
            }

            return(c);
        }
Esempio n. 7
0
        /// <summary>
        /// this - b = this
        ///
        /// 要素が含まれていれば、切ります。
        ///
        /// 例えば、「10→40→30→20→50」という順番で数字を持っているとき、
        /// 「30」がリムーブされれば、
        /// 「10→40」が残ります。
        /// </summary>
        /// <param name="b"></param>
        public void Minus_Closed(T1 b, DLGT_SyElement_BynaryOperate dlgt_equals)
        {
            int i = 0;

            foreach (T1 thisElement in this.orderedItems)
            {
                if (dlgt_equals(thisElement, b))
                {
                    // b 以降を切り捨てます。
                    this.orderedItems.RemoveRange(i, this.orderedItems.Count - i);
                    break;
                }

                i++;
            }
        }
Esempio n. 8
0
        /// <summary>
        /// もし順序があるならば、「a = 1→2→3→4」のときに
        /// 「a RemoveElement_OverThere( 2 )」とすれば、
        /// 答えは「3→4」
        /// となる操作がこれです。
        ///
        /// bを含めず、それより後ろを切る、という操作です。
        /// 順序がなければ、RemoveElementと同等です。
        /// </summary>
        /// <param name="masuHandle"></param>
        public void Minus_Opened(T1 b, DLGT_SyElement_BynaryOperate dlgt_equals)
        {
            int i = 0;

            foreach (T1 thisElement in this.orderedItems)
            {
                if (dlgt_equals(thisElement, b))
                {
                    // この次で切ります。

                    if (this.orderedItems.Count <= i + 1)
                    {
                        break;
                    }
                    this.orderedItems.RemoveRange(i + 1, this.orderedItems.Count - (i + 1));

                    break;
                }

                i++;
            }
        }
Esempio n. 9
0
 /// <summary>
 /// もし順序があるならば、「a = 1→2→3→4」のときに
 /// 「a RemoveElement_OverThere( 2 )」とすれば、
 /// 答えは「3→4」
 /// となる操作がこれです。
 ///
 /// bを含めず、それより後ろを切る、という操作です。
 /// 順序がなければ、RemoveElementと同等です。
 /// </summary>
 /// <param name="masuHandle"></param>
 public void Minus_Opened(T1 bElement, DLGT_SyElement_BynaryOperate dlgt_equals)
 {
     this.Minus_Closed(bElement, dlgt_equals);
 }