C# ILArray.CreateIterator方法代码示例

 /// <summary>
 /// real part of complex array
 /// </summary>
 /// <param name="X">complex input array</param>
 /// <returns>real part of complex array</returns>
 public static /*!HC:outCls1*/ ILArray<double> real (/*!HC:inCls1*/ ILArray<complex> X) {
     int nrX = X.m_dimensions.NumberOfElements; 
     /*!HC:outArr1*/ double [] retArr = new /*!HC:outArr1*/ double [nrX]; 
     /*!HC:outCls1*/ ILArray<double> ret = new /*!HC:outCls1*/ ILArray<double> (retArr,X.m_dimensions); 
     ILIterator</*!HC:inArr1*/ complex > it = X.CreateIterator(ILIteratorPositions.ILEnd,0); 
     for (int i= 0; i < nrX; i++) {
         retArr[i] = it.Increment().real; 
     }
     return ret; 
 }

 private bool isSorted(ILArray<double> input, int dim, bool descending) {
     if (input.IsEmpty || input.IsScalar) return true; 
     ILIterator<double> it = input.CreateIterator(ILIteratorPositions.ILStart,dim); 
     double tmpold = it.Value;
     double tmpnew = it.Increment(); 
     int dimpos = 1; 
     while (!it.IsAtStart()) {
         if (++dimpos % input.Dimensions[dim] != 1) {
             if (descending) {
                 if (tmpnew > tmpold) return false; 
             } else {
                 if (tmpnew < tmpold) return false; 
             }
         }
         tmpold = tmpnew; 
         tmpnew = it.Increment(); 
     }
     return true; 
 }

 /// <summary>
 /// operate on elements of both storages by the given function -> relational operations 
 /// </summary>
 /// <param name="inArray1">First storage array</param>
 /// <param name="inArray2">Second storage array</param>
 /// <param name="operation">operation to apply to the elements of inArray. This
 /// acts like a function pointer.</param>
 /// <returns>new ILLogicalArray with result of operation for corresponding 
 /// elements of both arrays.</returns>
 /// <remarks>The values of inArray2 nor inArray2 will not be altered.The dimensions 
 /// of both arrays must match.</remarks>
 private static ILArray<double> DoubleBinaryDoubleOperator(ILArray<double> inArray1, ILArray<double> inArray2,
                                              ILApplyDouble_DoubleDouble operation) {
     ILDimension inDim = inArray1.Dimensions;
     if (!inDim.IsSameSize(inArray2.Dimensions))
         throw new Exception("Array dimensions must match.");
     double[] retBoolArr;
     // build ILDimension
     int newLength = inDim.NumberOfElements;
     retBoolArr = new double[newLength];
     int leadDim = 0;
     int leadDimLen = inDim[0];
     if (inArray1.IsReference || inArray2.IsReference) {
         // this will most probably be not very fast, but .... :|
         #region Reference storage
         // walk along the longest dimension (for performance reasons)
         for (int i = 1; i < inDim.NumberOfDimensions; i++) {
             if (leadDimLen < inDim[i]) {
                 leadDimLen = inDim[i];
                 leadDim = i;
             }
         }
         ILIterator<double> it1 = inArray1.CreateIterator(ILIteratorPositions.ILEnd, leadDim);
         ILIterator<double> it2 = inArray2.CreateIterator(ILIteratorPositions.ILEnd, leadDim);
         unsafe {
             fixed (double* pOutArr = retBoolArr) {
                 double* poutarr = pOutArr;
                 double* outEnd = poutarr + newLength;
                 while (poutarr < outEnd) {
                     *poutarr++ = operation(it1.Increment(), it2.Increment());
                 }
             }
         }
         // ==============================================================
         #endregion
     } else {
         // physical -> pointer arithmetic
         #region physical storage
         unsafe {
             fixed (double* pInArr1 = inArray1.m_data,
                     pInArr2 = inArray2.m_data) {
                 fixed (double* pOutArr = retBoolArr) {
                     double* poutarr = pOutArr;
                     double* poutend = poutarr + newLength;
                     double* pIn1 = pInArr1;
                     double* pIn2 = pInArr2;
                     while (poutarr < poutend)
                         *poutarr++ = operation(*pIn1++, *pIn2++);
                 }
             }
         }
         #endregion
     }
     return new ILArray<double>(retBoolArr, inDim.ToIntArray());
 }

	   	public void Test_setrange() {
			int errorCode = 0;
			// success? 
			try {
				object[] data = new object[120];
				for (int i = 120; i-- > 0; )
					data[i] = (double)i;
				ILArray<object> A = new ILArray<object>(data, 5, 4, 1, 3, 2, 1);
				//ILFullArray A = B.CreateReference(new ILRange("0:2,4;1,3;0;2,1,0,1"), 3);
				errorCode = 1;
				// new values
				double[] vals = new double[12] { 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 
												 110, 111 };
				object[] valso = new object[12];
				for (int i = 0; i < 12; i++)
					valso[i] = vals[i];
				ILArray<object> C = new ILArray<object>(valso, 2, 2, 3);
				// should replace missing trailing dimension by 0
				// inner singleton dimensions should be ok! 
				A["1,3;0,2;0;0,1,2"] = C;
				errorCode = 2;
				
				double[] results = new double[120] {0,100,  2,101,  4,  5,  6,  7,  8,  9, 10,
					102, 12,103, 14, 15, 16, 17, 18, 19, 20,104, 22,105, 24, 25, 26, 27, 28, 
					29, 30,106, 32,107, 34, 35, 36, 37, 38, 39, 40,108, 42,109, 44, 45, 46, 
					47, 48, 49, 50, 110, 52, 111, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 
					65, 66, 67, 68, 69, 70, 71,  72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 
					83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,
					101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119};
				ILIterator<object> I = A.CreateIterator(ILIteratorPositions.ILStart, 0);
				int count = 0;
				do
				{
					if (((Double)I.Value).CompareTo(results[count++]) != 0)
						throw new Exception();
					I.Increment();
				} while (!I.IsAtStart());
				// complain if dimensions do not match
				errorCode = 3;
				ILArray<object> D = new ILArray<object>(new object[4] { 1, 1, 1, 1 }, 1, 2, 2);
				try {
					A["0,1,0,0:2"] = D;
                    throw new Exception("setrange should complain if dimensions do not match!"); 
				} catch (ILArgumentException) {
					
				}
				errorCode = 4; 
				Success("Test_setrange successful.");
			}
			catch (Exception e) {
				Error("Test_setrange failed at step: " + errorCode + " Msg: " + e.Message);
			}
		}

        public void Test_tmpPerfCount() {
            double [] data = new double[1000*1000*10];
            ILArray<double> A = new ILArray<double>(data, 1000, 1000, 10);
            ILPerformer p = new ILPerformer(); 
                        
            p.Tic();
            for (int i = 0; i < 10000000; i++) {
                A.getBaseIndex(i); 
            }
            p.Toc();
            Info("1000x1000x10: dense GetBaseIndex needed: " + p.Duration + " ms");

            ILIterator<double> it = A.CreateIterator();
            p.Tic();
            do {
                it.Increment(); 
            } while(!it.IsAtStart());
            p.Toc();
            Info("1000x1000x10: dense Iterator needed: " + p.Duration + " ms");
            
            A = (ILArray<double>)A[1,""];
            p.Tic();
            for (int i = 0; i < 10000000; i++) {
                A.getBaseIndex(i);
            }
            p.Toc();
            Info("1000x1000x10: ref. GetBaseIndex needed: " + p.Duration + " ms");

            it = A.CreateIterator();
            p.Tic();
            do {
                it.Increment();
            } while (!it.IsAtStart());
            p.Toc();
            Info("1000x1000x10: ref Iterator needed: " + p.Duration + " ms");
            p.Tic(); 
        }

        public void Test_Deserialize() {
            int errorCode = 0;
            try {
                {
                    String[] data = new String[1000];
                    String filename = "ILFullArray_SerializeTest1.ils";
                    for (int i = 0; i < data.Length; i++)
                        data[i] = "Datum Nr." + i;

                    ILArray<String> A = new ILArray<String>(data, 10, 20, 5);
                    // full storage, was: A 
                    BinaryFormatter bf = new BinaryFormatter();
                    FileStream fs = new FileStream(filename, FileMode.Open);
                    ILArray<String> ADS = (ILArray<String>)bf.Deserialize(fs);
                    fs.Close();
                    
                    if (ADS.Dimensions.NumberOfElements != 1000)
                        throw new Exception("Object has wrong size! Expected: 1000, Found: " + ADS.Dimensions.NumberOfElements);
                    ILIterator<String> I1 = A.CreateIterator(ILIteratorPositions.ILStart,0 );
                    ILIterator<String> I2 = ADS.CreateIterator(ILIteratorPositions.ILStart,0 );
                    for (int i = 0; i < A.Dimensions.NumberOfElements; i++) {
                        if (((String)I1.Value).CompareTo((String)I2.Value) != 0)
                            throw new Exception("Values did not match! ");
                    }

                    // reference storage, was : AR1
                    filename = "ILFullArray_SerializeTest2.ils";
                    fs = new FileStream(filename, FileMode.Open);
                    ILArray<String> AR1DS = (ILArray<String>)bf.Deserialize(fs);
                    fs.Close();
                    ILArray<String> AR1 = (ILArray<String>)A["0:8;3:18;0:end"];

                    if (AR1DS.Dimensions.NumberOfElements != AR1.Dimensions.NumberOfElements)
                        throw new Exception("Object has wrong size! Expected: " 
                            + AR1.Dimensions.NumberOfElements + ", Found: " 
                            + AR1DS.Dimensions.NumberOfElements);
                    I1 = AR1.CreateIterator(ILIteratorPositions.ILStart, 0);
                    I2 = AR1DS.CreateIterator(ILIteratorPositions.ILStart, 0);
                    for (int i = 0; i < AR1.Dimensions.NumberOfElements; i++) {
                        if (((String)I1.Value).CompareTo((String)I2.Value) != 0)
                            throw new Exception("Values did not match! ");
                    }

                    // if reference storage saved effective memory - keep it as reference
                    errorCode = 3;
                    filename = "ILFullArray_SerializeTest3.ils";
                    fs = new FileStream(filename, FileMode.Open);
                    ILArray<String> AR2DS = (ILArray<String>)bf.Deserialize(fs);
                    fs.Close();
                    ILArray<String> AR2 = (ILArray<String>)A["0:end,0:end;0:end,0:end;0:end"];
                    if (AR2DS.Dimensions.NumberOfElements != AR2.Dimensions.NumberOfElements)
                        throw new Exception("Object has wrong size! Expected: "
                            + AR2.Dimensions.NumberOfElements + ", Found: "
                            + AR2DS.Dimensions.NumberOfElements);
                    I1 = AR2.CreateIterator(ILIteratorPositions.ILStart, 0);
                    I2 = AR2DS.CreateIterator(ILIteratorPositions.ILStart, 0);
                    for (int i = 0; i < AR2.Dimensions.NumberOfElements; i++) {
                        if (((String)I1.Value).CompareTo((String)I2.Value) != 0)
                            throw new Exception("Values did not match! ");
                    }

                    // test if small reference would NOT store full data array
                    errorCode = 4;
                    filename = "ILFullArray_SerializeTest4.ils";
                    fs = new FileStream(filename, FileMode.Open);
                    ILArray<String> AR3DS = (ILArray<String>)bf.Deserialize(fs);
                    fs.Close();
                    ILArray<String> AR3 = A[3,3,1];
                    if (AR3DS.m_data.Length != 1 || ((String)AR3DS.m_data[0]).CompareTo("Datum Nr.233") != 0)
                        throw new Exception("Unvalid deserialized scalar storage!");
                    errorCode = 5;
                    // clean up . delete all test files 
                    File.Delete("ILFullArray_SerializeTest1.ils");
                    File.Delete("ILFullArray_SerializeTest2.ils");
                    File.Delete("ILFullArray_SerializeTest3.ils");
                    File.Delete("ILFullArray_SerializeTest4.ils"); 
                }
                Success("Test_Deserialize successfull");
            } catch (SerializationException e) {
                Error("Test_Deserialize failed at errorCode: " + errorCode + " due: " + e.Message);
            } catch (Exception e) {
                Error("Test_Deserialize failed at errorCode: " + errorCode + " due: " + e.Message);
            }
        }

        public void Test_Iterator_Performance() {
            int errorCode = 0;
            // success? 
            try {
				double[] data = new double[4 * 3 * 2] {0, 1,2,3,4,5,6,7,8,9,10
										,11,12,13,14,15,16,17,18,19,20,21,22,23 };
				ILArray<double> A = new ILArray<double>(data, 4,3,2);
				ILArray<double> Ar = (ILArray<double>)A.GetShifted(2); 
				ILPerformer p = new ILPerformer();
				int counter = 0; 
				ILIterator<double> it = A.CreateIterator(ILIteratorPositions.ILEnd, 0);
				ILIterator<double> it1 = Ar.CreateIterator(ILIteratorPositions.ILEnd, 2);
				double val = 0.0; 
				do {
					if (it.Increment() != counter++)
						throw new Exception("invalid iterator value!"); 
				} while (!it.IsAtEnd());
				// shifted (1) physical
				errorCode = 1; 
				double[] results = new double[24] {0,4,8,12,16,20,1,5,9,13,17,21
										,2,6,10,14,18,22,3,7,11,15,19,23};
				it = A.CreateIterator(ILIteratorPositions.ILEnd, 1);
				counter = 0; 
				do {
					if (it.Increment() != results[counter])
						throw new Exception("invalid phy iterator value!");
					if (it1.Increment() != results[counter++])
						throw new Exception("invalid ref iterator value!");
				} while (!it.IsAtEnd());
				results = new double[24] {0,4,8,12,16,20,1,5,9,13,17,21
										,2,6,10,14,18,22,3,7,11,15,19,23};

				data = new double[1000 * 1000 * 10];
				A = new ILArray<double>(data, 1000, 1000, 10);
                //// test the IEnumerable way of doing this
                //errorCode = 1;
				
                //p.Tic();
                //foreach (double v in A) {
                //    val = v;
                //}
                //p.Toc();
                //Info("[1000 x 1000 x 10] IEnumarable 'foreach' Iterator: " + p.ToString());

				errorCode = 2; 
				// iterate the classic way: 
                val = 2.23;
				double dura = 0.0, dura1= 0.0;
				double itIncCounter = 0.0;
				it = A.CreateIterator(ILIteratorPositions.ILStart, 0);
				it1 = A.CreateIterator(ILIteratorPositions.ILStart, 1);
				ILPerformer p1 = new ILPerformer();
				do {
					p1.Tic();
					val = it1.Increment();
					p1.Toc();
					dura1 += p1.Duration; // outer time needed 
					
					p.Tic();
					val = it.Increment();
					p.Toc();
					//dummy += Environment.TickCount - it.Dummy;  // internal time needed 
					dura += p.Duration; // outer time needed 
					itIncCounter++;
				} while (itIncCounter < data.Length);
				Info("[1000 x 1000 x 10] ILIterator Phys leadDim: 0 ->" 
					+ dura.ToString() + " leadDim: 1 ->" + dura1.ToString() 
					+ " incCount:" + itIncCounter);

				errorCode = 3;
				ILArray<double> B = (ILArray<double>)A.T;
				p.Tic();
				it = B.CreateIterator(ILIteratorPositions.ILStart, 0);
				it1 = B.CreateIterator(ILIteratorPositions.ILStart, 1);
                dura = 0.0; dura1 = 0.0; itIncCounter = 0; 
				do {
					p1.Tic();
					val = it1.Increment();
					p1.Toc();
					dura1 += p1.Duration; // outer time needed 

					p.Tic();
					val = it.Increment();
					p.Toc();
					//dummy += Environment.TickCount - it.Dummy;  // internal time needed 
					dura += p.Duration; // outer time needed 
					itIncCounter++;
				} while (itIncCounter < data.Length);
				p.Toc();
				Info("[1000 x 1000 x 10] ILIterator - Ref. leadDim: 0 ->"
					+ dura.ToString() + " leadDim: 1 ->" + dura1.ToString()
					+ " incCount:" + itIncCounter);


				Success("Test_Iterator_Performance successful.");
            } catch (Exception e) {
                Error("Test_Iterator_Performance failed at step: " + errorCode + " Msg: " + e.Message);
            }
        }