C# BitArray.And方法代码示例

 public static void And_EmptyArray()
 {
     BitArray bitArray1 = new BitArray(0);
     BitArray bitArray2 = new BitArray(0);
     
     Assert.Equal(0, bitArray1.And(bitArray2).Length);
 }

        public static void And_Operator(bool[] l, bool[] r, bool[] expected)
        {
            BitArray left = new BitArray(l);
            BitArray right = new BitArray(r);

            BitArray actual = left.And(right);
            Assert.Same(left, actual);
            Assert.Equal(actual.Length, expected.Length);

            for (int i = 0; i < expected.Length; i++)
            {
                Assert.Equal(expected[i], actual[i]);
            }
        }

 public virtual bool runTest()
 {
     Console.Out.WriteLine( "Plain\\System_NewCollections\\BitArray\\Co1550And.cs  runTest() started." );
     int iCountErrors = 0;
     int iCountTestcases = 0;
     BitArray ba2 = null;
     BitArray ba3 = null;
     BitArray ba4 = null;
     ba2 = new BitArray( 6 ,false );
     ba3 = new BitArray( 6 ,false );
     ba2.Set( 0 ,true ); 
     ba2.Set( 1 ,true ); 
     ba3.Set( 1 ,true ); 
     ba3.Set( 2 ,true ); 
     ba4 = ba2.And( ba3 );
     ++iCountTestcases;
     if ( ba4.Get( 0 ) )
     {
         ++iCountErrors;
         Console.Error.WriteLine(  "POINTTOBREAK: find error E_09pv (Co1550And)"  );
         Console.Error.WriteLine(  "EXTENDEDINFO: 1 & 0 (E_09pv ,Co1550And)"  );
     }
     ++iCountTestcases;
     if ( ! ba4.Get( 1 ) )
     {
         ++iCountErrors;
         Console.Error.WriteLine(  "POINTTOBREAK: find error E_96hf (Co1550And)"  );
     }
     ++iCountTestcases;
     if ( ba4.Get( 2 ) )
     {
         ++iCountErrors;
         Console.Error.WriteLine(  "POINTTOBREAK: find error E_84si (Co1550And)"  );
     }
     ++iCountTestcases;
     if ( ba4.Get( 4 ) )
     {
         ++iCountErrors;
         Console.Error.WriteLine(  "POINTTOBREAK: find error E_79kn (Co1550And)"  );
     }
     ba2 = new BitArray( 0x1000F ,false );
     ba3 = new BitArray( 0x1000F ,false );
     ba2.Set( 0x10000 ,true );
     ba2.Set( 0x10001 ,true );
     ba3.Set( 0x10001 ,true );
     ba3.Set( 0x10002 ,true );
     ba4 = ba2.And( ba3 );
     ++iCountTestcases;
     if ( ba4.Get( 0x10000 ) )
     {
         ++iCountErrors;
         Console.Error.WriteLine(  "POINTTOBREAK: find error E_61ah (Co1550And)"  );
     }
     ++iCountTestcases;
     if ( ! ba4.Get( 0x10001 ) )
     {
         ++iCountErrors;
         Console.Error.WriteLine(  "POINTTOBREAK: find error E_52xd (Co1550And)"  );
     }
     ++iCountTestcases;
     if ( ba4.Get( 0x10002 ) )
     {
         ++iCountErrors;
         Console.Error.WriteLine(  "POINTTOBREAK: find error E_47op (Co1550And)"  );
     }
     ++iCountTestcases;
     if ( ba4.Get( 0x10004 ) )
     {
         ++iCountErrors;
         Console.Error.WriteLine(  "POINTTOBREAK: find error E_54ja (Co1550And)"  );
     }
     try
     {
         BitArray b1 = new BitArray( 0 );
         BitArray b2 = new BitArray( 0 );
         b1.And( b2 );
     }
     catch ( Exception exc )
     {
         ++iCountErrors;
         Console.WriteLine( "Err_001, Exception was not expected " + exc );
     }
     ba2 = new BitArray( 11 ,false );
     ba3 = new BitArray( 6 ,false );
     try
     {
         ++iCountTestcases;
         ba4 = ba2.And( ba3 );
         ++iCountErrors;
         Console.Error.WriteLine(  "POINTTOBREAK: find error E_66vc (Co1550And)"  );
     }
     catch ( ArgumentException ) {}
     catch ( Exception )  
     {
         ++iCountErrors;
         Console.Error.WriteLine(  "POINTTOBREAK: find error E_58jq (Co1550And)"  );
     }
     ba2 = new BitArray( 6 ,false );
     ba3 = new BitArray( 11 ,false );
     try
//.........这里部分代码省略.........

        public static void And_Invalid()
        {
            BitArray bitArray1 = new BitArray(11, false);
            BitArray bitArray2 = new BitArray(6, false);

            // Different lengths
            Assert.Throws<ArgumentException>(null, () => bitArray1.And(bitArray2));
            Assert.Throws<ArgumentException>(null, () => bitArray2.And(bitArray1));

            Assert.Throws<ArgumentNullException>("value", () => bitArray1.And(null));
        }

        public static void OperatorTest(Operator op)
        {
            BitArray bitArray1 = new BitArray(6, false);
            BitArray bitArray2 = new BitArray(6, false);
            BitArray result;

            bitArray1.Set(0, true);
            bitArray1.Set(1, true);

            bitArray2.Set(1, true);
            bitArray2.Set(2, true);

            switch (op)
            {
                case Operator.Xor:
                    result = bitArray1.Xor(bitArray2);
                    Assert.Same(bitArray1, result);
                    Assert.True(result.Get(0));
                    Assert.False(result.Get(1));
                    Assert.True(result.Get(2));
                    Assert.False(result.Get(4));
                    break;

                case Operator.And:
                    result = bitArray1.And(bitArray2);
                    Assert.Same(bitArray1, result);
                    Assert.False(result.Get(0));
                    Assert.True(result.Get(1));
                    Assert.False(result.Get(2));
                    Assert.False(result.Get(4));
                    break;

                case Operator.Or:
                    result = bitArray1.Or(bitArray2);
                    Assert.Same(bitArray1, result);
                    Assert.True(result.Get(0));
                    Assert.True(result.Get(1));
                    Assert.True(result.Get(2));
                    Assert.False(result.Get(4));
                    break;
            }
            
            // Size stress cases.
            bitArray1 = new BitArray(0x1000F, false);
            bitArray2 = new BitArray(0x1000F, false);

            bitArray1.Set(0x10000, true); // The bit for 1 (2^0).
            bitArray1.Set(0x10001, true); // The bit for 2 (2^1).

            bitArray2.Set(0x10001, true); // The bit for 2 (2^1).

            switch (op)
            {
                case Operator.Xor:
                    result = bitArray1.Xor(bitArray2);
                    Assert.Same(bitArray1, result);
                    Assert.True(result.Get(0x10000));
                    Assert.False(result.Get(0x10001));
                    Assert.False(result.Get(0x10002));
                    Assert.False(result.Get(0x10004));
                    break;

                case Operator.And:
                    result = bitArray1.And(bitArray2);
                    Assert.Same(bitArray1, result);
                    Assert.False(result.Get(0x10000));
                    Assert.True(result.Get(0x10001));
                    Assert.False(result.Get(0x10002));
                    Assert.False(result.Get(0x10004));
                    break;

                case Operator.Or:
                    result = bitArray1.Or(bitArray2);
                    Assert.Same(bitArray1, result);
                    Assert.True(result.Get(0x10000));
                    Assert.True(result.Get(0x10001));
                    Assert.False(result.Get(0x10002));
                    Assert.False(result.Get(0x10004));
                    break;
            }
        }

    // 隣接判定、ノードごとの処理
    public void NodeCheckAction(NodeController.NodeLinkTaskChecker Tc, _eLinkDir Link)
    {
        NodeDebugLog += "NodeCheckAction. CheckerID : " + Tc.ID + "\n";
        // チェック済みでスキップ
        if (bChecked) { Tc.Branch--; return; }

        // 各種変数定義
        bool bBranch = false;
        bChecked = true;
        Tc.SumNode++;
        bChain = false;

        // お隣さんを更新
        UpdateNegibor();

        // 状態表示
        Tc += (ToString() + "Action \n     Link : " + bitLink.ToStringEx() + "\nNegibor : " + Negibor.ToStringEx());
        Tc += Tc.NotFin + " : " + Tc.Branch.ToString();

        // チェックスタート
        // 接地判定（根本のみ）
        if (Link == _eLinkDir.NONE)     // 根本か確認
        {
            if (!bitLink[(int)_eLinkDir.RD] && !bitLink[(int)_eLinkDir.LD]) // 下方向チェック
            {
                Tc.Branch--;
                Tc.SumNode--;
                bChecked = false;
                return;                 // 繋がってないなら未チェックとして処理終了
            }
            // 繋がっている
            Tc += ("Ground");
        }

        // この時点で枝が繋がっている事が確定
        bChain = true;
        Tc.NodeList.Add(this);  // チェッカに自身を登録しておく

        // 終端ノードであれば、周囲チェック飛ばす
        var TempBit = new BitArray(6);
        // 除外方向設定
        TempBit.SetAll(false);
        if (Link == _eLinkDir.NONE)
        {
            TempBit.Set((int)_eLinkDir.RD, true);
            TempBit.Set((int)_eLinkDir.LD, true);
        }
        else {
            TempBit.Set((int)Link, true);
        }
        TempBit.And(bitLink).Xor(bitLink);    // 自身の道とAND後、自身の道とXOR。
        if (TempBit.isZero())                  // 比較して一致なら除外方向以外に道がない = XOR後に全0なら終端
        {
            Tc.Branch--;                      // 終端ノードであればそこで終了
            return;
        }

        // 周囲のチェック
        // この時点で、TempBitは先が壁の道を除いた自分の道を示している。
        Tc += "ExcludeFrom MyWay : " + TempBit.ToStringEx();

        for (int n = 0; n < (int)_eLinkDir.MAX; n++)
        {
            var TempBit2 = new BitArray(6);
            // 隣接ノードのうち、道が無い場所に自分の道が伸びてたらそこは途切れている。
            TempBit2 = TempBit.retAnd(Negibor.retNot());
            // ノード繋がってない
            if (TempBit2[n])
            {
                nodeControllerScript.unChainController.AddObj(this, (_eLinkDir)n);
                Tc.NotFin = true;                               // 隣と繋がってないので、枝未完成として登録
            }
        }

        Tc += ("Negibor : " + Negibor.ToStringEx());
        TempBit.And(Negibor);                       // 隣接ノードと繋がっている場所を特定
        Tc += "Linked : " + TempBit.ToStringEx();
        for (int n = 0; n < (int)_eLinkDir.MAX; n++)
        {
            if (!TempBit[n]) { continue; }          // ビット立ってないならスキップ

            // お隣さんと繋がっているので、処理引き渡しの準備
            bChain = true;

            // デバック表示
            Tc += ("Linked [" + LinkDirToString(n) + "]");

            // 接続先がおかしいならノーカンで
            Vec2Int Target = nodeControllerScript.GetDirNode(nodeID, (_eLinkDir)n);
            if (Target.x == -1) { continue; }

            // 分岐を検出してカウント
            if (!bBranch)
            {
                bBranch = true;     // 一回目ならノーカン
            }
            else {
                Tc.Branch++;        // 二回目以降は分岐なので、枝カウンタを+1
            }
//.........这里部分代码省略.........

    // returns a bitboard of a pump station that exists on the specified coordinates,
    // or return empty if no pump station exists on the specified coordinates
    public static BitArray GetPumpStation(BitArray pumpStations, int x, int y)
    {
        // check to see if specified unit is on one of our pump stations
        BitArray test = new BitArray(length, false).Or(pumpStations);
        test.And(position[x][y]);
        if (Equal(test, empty))
        {
          return empty;
        }

        // create bitboard representing pump station the unit is standing on
        BitArray pumpStation = new BitArray(length, false).Or(position[x][y]);
        if (x - 1 >= 0)
        {
          pumpStation.Or(position[x - 1][y]);
          if (y - 1 >= 0)
          {
        pumpStation.Or(position[x - 1][y - 1]);
          }
          if (y + 1 < height)
          {
        pumpStation.Or(position[x - 1][y + 1]);
          }
        }
        if (x + 1 < width)
        {
          pumpStation.Or(position[x + 1][y]);
          if (y - 1 >= 0)
          {
        pumpStation.Or(position[x + 1][y - 1]);
          }
          if (y + 1 < height)
          {
        pumpStation.Or(position[x + 1][y + 1]);
          }
        }
        if (y - 1 >= 0)
        {
          pumpStation.Or(position[x][y - 1]);
        }
        if (y + 1 < height)
        {
          pumpStation.Or(position[x][y + 1]);
        }
        return pumpStation.And(pumpStations);
    }