Utils.cs

Go to the documentation of this file.

using System;

namespace FFT
{

   ///
   /// Collection of general purpose functions.
   ///
   class Utils
   {
      ///
      /// Copies the contents of an array. 
      ///
      /// \param src the source array.
      /// \param dst the target array. 
      /// 
      /// \returns <tt>dst</tt>.
      /// This method assumes that both <tt>src</tt> and <tt>dst</tt> are not <tt>null</tt>. 
      /// The arrays do not have to be of the same length. If the <tt>src</tt> 
      /// array is shorter than <tt>dst</tt>, then the remining elements of <tt>dst</tt> 
      /// are unchanged. If <tt>src</tt> is not longer than <tt>dst</tt>, then the remaining 
      /// elements of <tt>src</tt> are not copied. 
      ///
      public static T[] copy<T>(T[] src, T[] dst)
      {
         for (int i = 0; i < src.Length && i < dst.Length; i++) {
            dst[i] = src[i];
         }
         
         return dst;
      }

      ///
      /// Computes the Euclidean distance between two vectors. 
      ///
      /// The input vectors do not have to be of equal length. 
      /// The distance is calculated on the length of the shorter vector. 
      ///
      public static double dist(Complex[] a, Complex[] b)
      {
         double norm = 0;
         int n = Math.Min(a.Length,b.Length);
         
         for (int i = 0; i < n; i++) {
            norm += Math.Pow((a[i]-b[i]).Modulus,2);
         }
         
         return Math.Sqrt(norm);
      }

      ///
      /// Calculates the minimal number of bits necessary to store 
      /// numbers \f$\{0,\ldots,n-1\}\f$. 
      /// It returns \f$ \log_2(n) + 1\f$ if \f$n\f$ is a power of 2 and 
      /// \f$\lceil \log_2(n)\rceil\f$ otherwise. 
      /// For <tt>n <= 0</tt>, the method returs <tt>0</tt>.
      ///
      public static int Log2(int n)
      {
         if (n <= 0) {
            return 0;
         } else {
            int i = 0;
            int m = n; // copy of n
            while (m > 0) {
               m >>= 1;
               i++;
            }
            
            return (IsPowerOf2(n)) ? (i-1) : (i);
         }
      }

      ///
      /// Computes \f$2^n\f$.
      ///
      public static int Exp2(int n)
      {
         return 1 << n;
      }
      
      ///
      /// Checks that the number is a power of 2.
      ///
      public static bool IsPowerOf2(int n)
      {
         return (n & (n - 1)) == 0;
      }

      ///
      /// Pretty-prints the contents of an array.
      ///
      /// \param t    an array whose content is to be printed.
      /// \param name an optional name for the array.      
      ///
      public static void PrintArray<T>(T[] t, params string[] name)
      {
         if (t != null) {
            Console.Write(t.GetType().GetElementType().Name);
         } else {
            Console.Write("unknown");
         }

         Console.Write(" [] ");

         if (name.Length != 0) {
            Console.Write(name[0]);
         }

         Console.Write(" = ");
         
         if (t == null) {
            Console.Write("null\n");
            return;
         }
         
         Console.Write("[");
         for (int i = 0; i < t.Length; i++) {
            Console.Write(t[i]);
            if (i < t.Length - 1) {
               Console.Write(",");
            }
         } 
         Console.Write("]\n");
         
      }//PrintArray
   }
}

---