Utility.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
 
namespace MyCaffe.basecode
{
    public interface IBinaryPersist
    {
        void Save(BinaryWriter bw);
        object Load(BinaryReader br, bool bNewInstance = true);
    }
 
    public class Utility
    {
        public Utility()
        {
        }
 
        public static int CanonicalAxisIndex(int nIdx, int nNumAxes)
        {
            if (nIdx < 0)
                return nIdx + nNumAxes;
            else
                return nIdx;
        }
 
        public static int GetSpatialDim(List<int> rg, int nStartIdx = 0)
        {
            int nDim = 1;
 
            for (int i = nStartIdx; i < rg.Count; i++)
            {
                nDim *= rg[i];
            }
 
            return nDim;
        }
 
        public static int Count(List<int> rgShape, int nStartIdx = 0, int nEndIdx = -1)
        {
            int nCount = 1;
 
            if (nEndIdx == -1)
                nEndIdx = rgShape.Count;
 
            for (int i = nStartIdx; i < nEndIdx; i++)
            {
                nCount *= rgShape[i];
            }
 
            return nCount;
        }
 
        public static int Count(int[] rgShape, int nStartIdx = 0, int nEndIdx = -1)
        {
            int nCount = 1;
            
            if (nEndIdx == -1)
                nEndIdx = rgShape.Length;
 
            for (int i = nStartIdx; i < nEndIdx; i++)
            {
                nCount *= rgShape[i];
            }
 
            return nCount;
        }
 
        public static void Save<T>(BinaryWriter bw, List<T> rg)
        {
            int nCount = (rg != null) ? rg.Count : 0;
 
            bw.Write(nCount);
 
            if (nCount == 0)
                return;
 
            if (typeof(T) == typeof(string))
            {
                foreach (T t in rg)
                {
                    bw.Write(t.ToString());
                }
 
                return;
            }
 
            if (typeof(T) == typeof(double))
            {
                foreach (T t in rg)
                {
                    bw.Write((double)Convert.ChangeType(t, typeof(double)));
                }
 
                return;
            }
 
            if (typeof(T) == typeof(float))
            {
                foreach (T t in rg)
                {
                    bw.Write((float)Convert.ChangeType(t, typeof(float)));
                }
 
                return;
            }
 
            if (typeof(T) == typeof(int))
            {
                foreach (T t in rg)
                {
                    bw.Write((int)Convert.ChangeType(t, typeof(int)));
                }
 
                return;
            }
 
            if (typeof(T) == typeof(long))
            {
                foreach (T t in rg)
                {
                    bw.Write((long)Convert.ChangeType(t, typeof(long)));
                }
 
                return;
            }
 
            if (typeof(T) == typeof(uint))
            {
                foreach (T t in rg)
                {
                    bw.Write((uint)Convert.ChangeType(t, typeof(uint)));
                }
 
                return;
            }
 
            if (typeof(T) == typeof(bool))
            {
                foreach (T t in rg)
                {
                    bw.Write((bool)Convert.ChangeType(t, typeof(bool)));
                }
 
                return;
            }
 
            bool bSaved = true;
 
            foreach (T t in rg)
            {
                IBinaryPersist p = t as IBinaryPersist;
 
                if (p != null)
                {
                    p.Save(bw);
                    bSaved = true;
                }
 
                return;
            }
 
            if (!bSaved)
                throw new Exception("Persistance for type " + (typeof(T)).ToString() + " is not supported!");
        }
 
        public static List<T> Load<T>(BinaryReader br)
        {
            int nCount = br.ReadInt32();
            List<T> rg = new List<T>(nCount);
 
            if (nCount == 0)
                return rg;
 
            if (typeof(T) == typeof(string))
            {
                for (int i = 0; i < nCount; i++)
                {
                    string val = br.ReadString();
                    rg.Add((T)Convert.ChangeType(val, typeof(T)));
                }
 
                return rg;
            }
 
            if (typeof(T) == typeof(double))
            {
                for (int i = 0; i < nCount; i++)
                {
                    double val = br.ReadDouble();
                    rg.Add((T)Convert.ChangeType(val, typeof(T)));
                }
 
                return rg;
            }
 
            if (typeof(T) == typeof(float))
            {
                for (int i = 0; i < nCount; i++)
                {
                    float val = br.ReadSingle();
                    rg.Add((T)Convert.ChangeType(val, typeof(T)));
                }
 
                return rg;
            }
 
            if (typeof(T) == typeof(int))
            {
                for (int i = 0; i < nCount; i++)
                {
                    int val = br.ReadInt32();
                    rg.Add((T)Convert.ChangeType(val, typeof(T)));
                }
 
                return rg;
            }
 
            if (typeof(T) == typeof(long))
            {
                for (int i = 0; i < nCount; i++)
                {
                    long val = br.ReadInt64();
                    rg.Add((T)Convert.ChangeType(val, typeof(T)));
                }
 
                return rg;
            }
 
            if (typeof(T) == typeof(uint))
            {
                for (int i = 0; i < nCount; i++)
                {
                    uint val = br.ReadUInt32();
                    rg.Add((T)Convert.ChangeType(val, typeof(T)));
                }
 
                return rg;
            }
 
            if (typeof(T) == typeof(bool))
            {
                for (int i = 0; i < nCount; i++)
                {
                    bool val = br.ReadBoolean();
                    rg.Add((T)Convert.ChangeType(val, typeof(T)));
                }
 
                return rg;
            }
 
            object obj = Activator.CreateInstance(typeof(T));
            IBinaryPersist p = obj as IBinaryPersist;
 
            if (p != null)
            {
                for (int i = 0; i < nCount; i++)
                {
                    object val = p.Load(br);
                    rg.Add((T)Convert.ChangeType(val, typeof(T)));
                }
 
                return rg;
            }
 
            throw new Exception("Persistance for type " + (typeof(T)).ToString() + " is not supported!");
        }
 
        public static void Save(BinaryWriter bw, List<double> rg)
        {
            bw.Write(rg.Count);
 
            for (int i=0; i<rg.Count; i++)
            {
                bw.Write(rg[i]);
            }
        }
 
        public static List<double> LoadDouble(BinaryReader br)
        {
            List<double> rg = new List<double>();
            int nCount = br.ReadInt32();
 
            for (int i = 0; i < nCount; i++)
            {
                rg.Add(br.ReadDouble());
            }
 
            return rg;
        }
 
        public static void Save(BinaryWriter bw, List<float> rg)
        {
            bw.Write(rg.Count);
 
            for (int i = 0; i < rg.Count; i++)
            {
                bw.Write(rg[i]);
            }
        }
 
        public static List<float> LoadFloat(BinaryReader br)
        {
            List<float> rg = new List<float>();
            int nCount = br.ReadInt32();
 
            for (int i = 0; i < nCount; i++)
            {
                rg.Add(br.ReadSingle());
            }
 
            return rg;
        }
 
        public static void Save(BinaryWriter bw, int? nVal)
        {
            bw.Write(nVal.HasValue);
 
            if (nVal.HasValue)
                bw.Write(nVal.Value);
        }
 
        public static int? LoadInt(BinaryReader br)
        {
            bool bHasVal = br.ReadBoolean();
 
            if (!bHasVal)
                return null;
 
            return br.ReadInt32();
        }
 
        public static int BaseTypeSize<T>()
        {
            if (typeof(T) == typeof(float))
                return sizeof(float);
 
            return sizeof(double);
        }
 
        public static double ConvertVal<T>(T fVal)
        {
            return (double)Convert.ChangeType(fVal, typeof(double));
        }
 
        public static float ConvertValF<T>(T fVal)
        {
            return (float)Convert.ChangeType(fVal, typeof(float));
        }
 
        public static T ConvertVal<T>(double dfVal)
        {
            return (T)Convert.ChangeType(dfVal, typeof(T));
        }
 
        public static double[] ConvertVec<T>(T[] rg)
        {
            if (typeof(T) == typeof(double))
                return (double[])Convert.ChangeType(rg, typeof(double[]));
 
            double[] rgdf = new double[rg.Length];
            Array.Copy(rg, rgdf, rg.Length);
 
            return rgdf;
        }
 
        public static float[] ConvertVecF<T>(T[] rg, int nStart = 0)
        {
            if (typeof(T) == typeof(float) && nStart == 0)
                return (float[])Convert.ChangeType(rg, typeof(float[]));
 
            float[] rgf = new float[rg.Length - nStart];
            Array.Copy(Array.ConvertAll(rg, p => Convert.ToSingle(p)), nStart, rgf, 0, rgf.Length);
 
            return rgf;
        }
 
        public static T[] ConvertVec<T>(double[] rgdf)
        {
            if (typeof(T) == typeof(double))
                return (T[])Convert.ChangeType(rgdf, typeof(T[]));
 
            T[] rgt = new T[rgdf.Length];
 
            if (typeof(T) == typeof(float))
                Array.Copy(Array.ConvertAll(rgdf, p => Convert.ToSingle(p)), rgt, rgdf.Length);
            else
                Array.Copy(rgdf, rgt, rgdf.Length);
 
            return rgt;
        }
 
        public static T[] ConvertVec<T>(float[] rgf)
        {
            if (typeof(T) == typeof(float))
                return (T[])Convert.ChangeType(rgf, typeof(T[]));
 
            T[] rgt = new T[rgf.Length];
            Array.Copy(rgf, rgt, rgf.Length);
 
            return rgt;
        }
 
        public static double[] ConvertVec(float[] rgf)
        {
            double[] rgt = new double[rgf.Length];
            Array.Copy(rgf, rgt, rgf.Length);
            
            return rgt;
        }
 
        public static void Resize<T>(ref List<T> rg, int nCount, T tDefault)
        {
            if (rg == null)
                rg = new List<T>();
 
            while (rg.Count < nCount)
            {
                rg.Add(tDefault);
            }
 
            while (rg.Count > nCount)
            {
                rg.RemoveAt(rg.Count - 1);
            }
        }
 
        public static T[] Clone<T>(T[] rg)
        {
            if (rg == null)
                return null;
 
            T[] rg1 = new T[rg.Length];
            Array.Copy(rg, rg1, rg.Length);
 
            return rg1;
        }
 
        public static List<T> Clone<T>(List<T> rg, int nMaxCount = int.MaxValue)
        {
            if (rg == null)
                return null;
 
            List<T> rg1 = new List<T>();
 
            for (int i=0; i<rg.Count && i<nMaxCount; i++)
            {
                ICloneable cloneable = rg[i] as ICloneable;
 
                if (cloneable != null)
                    rg1.Add((T)Convert.ChangeType(cloneable.Clone(), typeof(T)));
                else
                    rg1.Add(rg[i]);
            }
 
            return rg1;
        }
 
        public static List<T> Clone<T>(T[] rg, int nMaxCount = int.MaxValue)
        {
            List<T> rg1 = new List<T>();
 
            for (int i = 0; i < rg.Length && i < nMaxCount; i++)
            {
                ICloneable cloneable = rg[i] as ICloneable;
 
                if (cloneable != null)
                    rg1.Add((T)Convert.ChangeType(cloneable.Clone(), typeof(T)));
                else
                    rg1.Add(rg[i]);
            }
 
            return rg1;
        }
 
        public static bool Compare<T>(List<T> rg1, List<T> rg2, bool bExact = true)
        {
            if (rg1.Count != rg2.Count)
            {
                if (bExact)
                    return false;
 
                if (Math.Abs(rg1.Count - rg2.Count) > 1)
                    return false;
 
                T tOne = (T)Convert.ChangeType(1, typeof(T));
 
                if (rg1.Count > rg2.Count && !rg1[rg1.Count - 1].Equals(tOne))
                    return false;
 
                if (rg2.Count > rg1.Count && !rg2[rg2.Count - 1].Equals(tOne))
                    return false;                
            }
 
            for (int i = 0; i < rg1.Count && i < rg2.Count; i++)
            {
                IComparable compare1 = rg1[i] as IComparable;
 
                if (compare1 != null)
                {
                    if (compare1.CompareTo((object)Convert.ChangeType(rg2[i], typeof(object))) != 0)
                        return false;
                }
                else
                {
                    if (rg1[i].ToString() != rg2[i].ToString())
                        return false;
                }
            }
 
            return true;
        }
 
        public static List<T> Create<T>(int nCount, T fDefault)
        {
            List<T> rg = new List<T>();
 
            for (int i = 0; i < nCount; i++)
            {
                rg.Add(fDefault);
            }
 
            return rg;
        }
 
        public static List<int> Create(int nCount, int nStart, int nInc)
        {
            List<int> rg = new List<int>();
            int nVal = nStart;
 
            for (int i = 0; i < nCount; i++)
            {
                rg.Add(nVal);
                nVal += nInc;
            }
 
            return rg;
        }
 
        public static void Set<T>(List<T> rg, T fVal)
        {
            for (int i = 0; i < rg.Count; i++)
            {
                rg[i] = fVal;
            }
        }
 
        public static void Set<T>(T[] rg, T fVal)
        {
            for (int i = 0; i < rg.Length; i++)
            {
                rg[i] = fVal;
            }
        }
 
        public static string ToString<T>(List<T> rg, int nDecimals = -1, int nIdxHighight = -1, string strStart = "{", string strEnd = "}")
        {
            string strOut = strStart;
 
            for (int i = 0; i < rg.Count; i++)
            {
                if (nIdxHighight >= 0 && i == nIdxHighight)
                    strOut += "[*";
 
                if (nDecimals >= 0)
                {
                    if (typeof(T) == typeof(float))
                    {
                        float f = (float)Convert.ChangeType(rg[i], typeof(float));
                        strOut += f.ToString("N" + nDecimals.ToString());
                    }
                    else if (typeof(T) == typeof(double))
                    {
                        double f = (double)Convert.ChangeType(rg[i], typeof(double));
                        strOut += f.ToString("N" + nDecimals.ToString());
                    }
                    else
                    {
                        strOut += rg[i].ToString();
                    }
                }
                else
                    strOut += rg[i].ToString();
 
                if (nIdxHighight >= 0 && i == nIdxHighight)
                    strOut += "*]";
 
                strOut += ",";
            }
 
            strOut = strOut.TrimEnd(',');
            strOut += strEnd;
 
            return strOut;
        }
 
        public static List<int> ParseListToInt(string str)
        {
            string[] rg = str.Split(',');
            List<int> rgVal = new List<int>();
 
            foreach (string str1 in rg)
            {
                rgVal.Add(int.Parse(str1));
            }
 
            return rgVal;
        }
 
        public static int GetNumber(string str)
        {
            if (str == null || str.Length == 0)
                return 0;
 
            if (!char.IsNumber(str[str.Length - 1]))
                return 0;
 
            for (int i = str.Length - 1; i > 0; i--)
            {
                if (!char.IsNumber(str[str.Length - 1]))
                {
                    string strNum = str.Substring(i);
                    return int.Parse(strNum);
                }
            }
 
            return 0;
        }
 
        public static string Replace(string str, char ch1, char ch2)
        {
            if (str == null)
                return null;
 
            string strOut = "";
 
            foreach (char ch in str)
            {
                if (ch == ch1)
                    strOut += ch2;
                else
                    strOut += ch;
            }
 
            return strOut;
        }
 
        public static string Replace(string str, char ch1, string str2)
        {
            if (str == null)
                return null;
 
            string strOut = "";
 
            foreach (char ch in str)
            {
                if (ch == ch1)
                    strOut += str2;
                else
                    strOut += ch;
            }
 
            return strOut;
        }
 
        public static string Replace(string str, string str1, char ch2)
        {
            if (str == null)
                return null;
 
            string strOut = "";
 
            while (str.Length > 0)
            {
                int nPos = str.IndexOf(str1);
                if (nPos >= 0)
                {
                    strOut += str.Substring(0, nPos);
                    strOut += ch2;
                    str = str.Substring(nPos + str1.Length);
                }
                else
                {
                    strOut += str;
                    str = "";
                }
            }
 
            return strOut;
        }
 
        public static string ReplaceMacro(string strRaw, string strMacroName, string strReplacement)
        {
            int nPos = 0;
            string strOut = "";
 
            while (strRaw.Length > 0)
            {
                nPos = strRaw.IndexOf(strMacroName);
 
                if (nPos >= 0)
                {
                    strOut += strRaw.Substring(0, nPos);
                    strOut += strReplacement;
                    strRaw = strRaw.Substring(nPos + strMacroName.Length);
                }
                else
                {
                    strOut += strRaw;
                    strRaw = "";
                }
            }
 
            return strOut;
        }
 
        public static string ReplaceMacros(string strRaw, List<KeyValuePair<string, string>> rgMacros)
        {
            string strOut = strRaw;
 
            foreach (KeyValuePair<string, string> kv in rgMacros)
            {
                strOut = ReplaceMacro(strOut, kv.Key, kv.Value);
            }
 
            return strOut;
        }
 
 
        public static double ConvertTimeToMinutes(DateTime dt)
        {
            DateTime dt1 = new DateTime(1980, 1, 1);
            TimeSpan ts = dt - dt1;
            return ts.TotalMinutes;
        }
 
        public static DateTime ConvertTimeFromMinutes(double dfMin)
        {
            DateTime dt1 = new DateTime(1980, 1, 1);
            TimeSpan ts = TimeSpan.FromMinutes(dfMin);
            return dt1 + ts;
        }
 
        public static List<int> RandomShuffle(List<int> rg, int? nSeed = null)
        {
            if (!nSeed.HasValue)
                nSeed = (int)DateTime.Now.Ticks;
 
            Random random = new Random(nSeed.Value);
            List<int> rg1 = new List<int>();
 
            while (rg.Count > 0)
            {
                if (rg.Count == 1)
                {
                    rg1.Add(rg[0]);
                    rg.Clear();
                }
                else
                {
                    int nIdx = random.Next(rg.Count);
                    rg1.Add(rg[nIdx]);
                    rg.RemoveAt(nIdx);
                }
            }
 
            return rg1;
        }
 
        public static List<string> LoadTextLines(string strFile, Log log = null, bool bPrependPath = true)
        {
            List<string> rgstr = new List<string>();
 
            try
            {
                string strPath = Path.GetDirectoryName(strFile);
 
                using (StreamReader sr = new StreamReader(strFile))
                {
                    string strLine = sr.ReadLine();
 
                    while (strLine != null)
                    {
                        if (strLine.Length > 0)
                        {
                            if (strLine[0] == '.' && bPrependPath)
                            {
                                int nPos = strLine.LastIndexOf('/');
                                if (nPos < 0)
                                    nPos = strLine.LastIndexOf('\\');
 
                                if (nPos >= 0)
                                    strLine = strLine.Substring(nPos + 1);
 
                                strLine = strPath + "\\" + Replace(strLine, '/', '\\');
                            }
 
                            rgstr.Add(strLine);
                        }
 
                        strLine = sr.ReadLine();
                    }
                }
            }
            catch (Exception excpt)
            {
                if (log != null)
                    log.FAIL("Failed to load '" + strFile + "'!  Error: " + excpt.Message);
                else
                    throw excpt;
            }
 
            return rgstr;
        }
    }
}