Datasets:

introvoyz041
/

Dwsim

﻿#region Copyright © 2009 Jose Antonio De Santiago-Castillo.

//Copyright © 2009 Jose Antonio De Santiago-Castillo. 
//E-mail:JAntonioDeSantiago@gmail.com
//Web: www.DotNumerics.com
//
#endregion

using System;
using System.Collections.Generic;
using System.Text;

namespace DotNumerics.FortranLibrary
{
    public class Characters
    {
        #region Borrar

        //#region Fields

        //private char[] _CharArray = new char[0];
        //private int _Offset = 1;
        //private int _Length = 0;

        //#endregion

        //#region Constructor

        //public Characters(int length)
        //{
        //    if (length < 0) length = 0;
        //    this._Length = length; 
        //    this._CharArray = new char[length];

        //    for (int i = 0; i < this._CharArray.Length; i++)
        //    {
        //        this._CharArray[i] = ' '; 
        //    }
        //}

        //public Characters(char[] sourceChars)
        //{
        //    if (sourceChars == null)
        //    {
        //        return;
        //    }
        //    this._CharArray = sourceChars;
        //    this._Length = sourceChars.Length;            
        //}

        //public Characters(char[] sourceChars, int offset)
        //{
        //    if (sourceChars == null)
        //    {
        //        return;
        //    }
        //    this._CharArray = sourceChars;
        //    this._Length = sourceChars.Length - offset + 1;
        //    this._Offset = offset;
        //}

        //public Characters(char[] sourceChars, int offset, int length)
        //{
        //    if (sourceChars == null)
        //    {
        //        return;
        //    }
        //    this._CharArray = sourceChars;
        //    this._Length = length;
        //    this._Offset = offset;
        //}


        //#endregion

        //#region Properties

        //public char[] CharArray
        //{
        //    get { return this._CharArray; }
        //}

        //public int Offset
        //{
        //    get { return _Offset; }
        //    set { _Offset = value; }
        //}

        //public int Length
        //{
        //    get { return _Length; }
        //    set { _Length = value; }
        //}


        //public char this[int index]
        //{
        //    get
        //    {
        //        return this._CharArray[index - this._Offset];
        //    }
        //    set
        //    {
        //        this._CharArray[index - this._Offset] = value;
        //    }
        //}




        //#endregion

        #endregion

        #region Fields

        private char[] _CharArray = new char[0];

        #endregion

        #region Constructor

        public Characters(int length)
        {
            if (length < 0) length = 0;
            this._CharArray = new char[length];

            for (int i = 0; i < this._CharArray.Length; i++)
            {
                this._CharArray[i] = ' ';
            }
        }

        public Characters(char[] sourceChars, bool copy)
        {
            if (sourceChars == null)
            {
                return;
            }
            if (copy == true)
            {
                this._CharArray = new char[sourceChars.Length];
                Array.Copy(sourceChars, this._CharArray, this._CharArray.Length);
            }
            else
            {
                this._CharArray = sourceChars;
            }
        }

        public Characters(string s) : this(s.ToCharArray(), false) { }

        public Characters(string s, int length)
            : this(length)
        {
            this.Copy(s);
        }


        #endregion

        #region Properties

        public char[] CharArray
        {
            get { return this._CharArray; }
        }

        public int Length
        {
            get { return this._CharArray.Length; }
        }



        #endregion


        #region Methods


        public void Copy(int startIndex, int lastIndex, char[] sourceCharArray)
        {
            if (lastIndex > this.Length) lastIndex = this.Length;
            int length = lastIndex - startIndex + 1;
            length = Math.Min(length, sourceCharArray.Length);

            startIndex--; //C# index

            Array.Copy(sourceCharArray, 0, this._CharArray, startIndex, length);

            //for (int i = 0; i < length; i++)
            //{
            //    this._CharArray[startIndex + i] = sourceCharArray[i];
            //}          
        }

        public void Copy(int startIndex, char[] sourceCharArray)
        {
            this.Copy(startIndex, this.Length, sourceCharArray);
        }

        public void Copy(char[] sourceCharArray)
        {
            this.Copy(1, sourceCharArray);
        }

        public void Copy(int startIndex, int lastIndex, string sourceString)
        {
            this.Copy(startIndex, lastIndex, sourceString.ToCharArray());
        }

        public void Copy(int startIndex, string sourceString)
        {
            this.Copy(startIndex, sourceString.ToCharArray());
        }

        public void Copy(string sourceString)
        {
            this.Copy(sourceString.ToCharArray());
        }


        public void Replace(char[] source)
        {
            this.ToBlanks();
            this.Copy(source);
        }

        public void Replace(Characters source)
        {
            this.Replace(source.CharArray);
        }

        public void Replace(string source)
        {
            this.Replace(source.ToCharArray());
        }



        public Characters Substring(int startIndex, int lastIndex)
        {
            int length = lastIndex - startIndex + 1;
            Characters sub = new Characters(length);

            startIndex--; //C# index
            Array.Copy(this._CharArray, startIndex, sub.CharArray, 0, length);

            return sub;

        }

        public Characters Substring(int startIndex)
        {
            return Substring(startIndex, this.Length);
        }


        public void ToUpper()
        {
            for (int i = 0; i < this._CharArray.Length; i++)
            {
                this._CharArray[i] = Char.ToUpper(this._CharArray[i]);
            }
        }

        public void ToLower()
        {
            for (int i = 0; i < this._CharArray.Length; i++)
            {
                this._CharArray[i] = Char.ToLower(this._CharArray[i]);
            }
        }

        public void ToBlanks()
        {
            for (int i = 0; i < this._CharArray.Length; i++)
            {
                this._CharArray[i] = ' ';
            }
        }

        public void ToBlanks(int start, int last)
        {
            start--;
            int max = Math.Min(last, this._CharArray.Length);
            for (int i = start; i < max; i++)
            {
                this._CharArray[i] = ' ';
            }
        }

        public void ToBlanks(int length)
        {
            this.ToBlanks(1, length + 1);
        }

        public int ToInt32()
        {
            if (this.LenTrim() == 0) return 0;
            string s = new string(this._CharArray);
            int val = Convert.ToInt32(s);
            return val;
        }

        public string Trim()
        {
            string s = new string(this._CharArray);
            return s.TrimEnd(new char[] { ' ' });
        }

        public void AdjustLeft()
        {
            int numLeftBlanks = 0;
            for (int i = 0; i < this._CharArray.Length; i++)
            {
                if (this._CharArray[i] == ' ')
                {
                    numLeftBlanks++;
                }
                else
                {
                    break;
                }
            }

            if (numLeftBlanks == 0) return;
            else
            {
                int lastIndex = this._CharArray.Length - numLeftBlanks;
                for (int i = 0; i < this._CharArray.Length; i++)
                {
                    if (i < lastIndex)
                    {
                        this._CharArray[i] = this._CharArray[numLeftBlanks + i];
                    }
                    else
                    {
                        this._CharArray[i] = ' ';
                    }
                }

            }
        }

        public void AdjustRight()
        {
            Array.Reverse(this._CharArray);
            this.AdjustLeft();
            Array.Reverse(this._CharArray);

        }

        public int LenTrim()
        {
            int lentrim = this._CharArray.Length;
            char blank = ' ';

            for (int i = this._CharArray.Length - 1; i > -1; i--)
            {
                if (this._CharArray[i] == blank)
                {
                    lentrim--;
                }
                else
                {
                    break;
                }
            }
            return lentrim;
        }


        #endregion


        #region Operators

        #region operator +

        public static Characters operator +(Characters c1, Characters c2)
        {
            return Characters.Add(c1.CharArray, c2.CharArray);
        }

        public static Characters operator +(string s, Characters c2)
        {
            return Characters.Add(s.ToCharArray(), c2.CharArray);
        }

        public static Characters operator +(Characters c1, string s)
        {
            return Characters.Add(c1.CharArray, s.ToCharArray());
        }

        public static Characters Add(char[] c1, char[] c2)
        {
            Characters newCharacters = new Characters(c1.Length + c2.Length);

            Array.Copy(c1, newCharacters.CharArray, c1.Length);

            Array.Copy(c2, 0, newCharacters.CharArray, c1.Length, c2.Length);

            return newCharacters;

        }

        #endregion

        #region Operators == and !=

        public static bool operator ==(Characters c1, Characters c2)
        {
            return Characters.AreEqual(c1.CharArray, c2.CharArray);
        }

        public static bool operator ==(string s, Characters c2)
        {
            return Characters.AreEqual(s.ToCharArray(), c2.CharArray);
        }

        public static bool operator ==(Characters c1, string s)
        {
            return Characters.AreEqual(c1.CharArray, s.ToCharArray());
        }


        public static bool operator !=(Characters c1, Characters c2)
        {
            return !Characters.AreEqual(c1.CharArray, c2.CharArray);
        }

        public static bool operator !=(string s, Characters c2)
        {
            return !Characters.AreEqual(s.ToCharArray(), c2.CharArray);
        }

        public static bool operator !=(Characters c1, string s)
        {
            return !Characters.AreEqual(c1.CharArray, s.ToCharArray());
        }


        public static bool AreEqual(char[] left, char[] right)
        {

            int maxLength = Math.Max(left.Length, right.Length);
            char[] c1 = Characters.GetCharArray(left, maxLength);
            char[] c2 = Characters.GetCharArray(right, maxLength);

            if (c1.Length != c2.Length) return false;

            bool areEqual = true;

            for (int i = 0; i < c1.Length; i++)
            {
                if (c1[i] != c2[i])
                {
                    areEqual = false;
                    break;
                }
            }
            return areEqual;
        }


        public override bool Equals(System.Object obj)
        {
            // If parameter is null return false.
            if (obj == null)
            {
                return false;
            }

            // If parameter cannot be cast to Characters return false.
            Characters c = obj as Characters;
            if ((System.Object)c == null)
            {
                return false;
            }

            // Return true if the fields match:
            return Characters.AreEqual(c.CharArray, this.CharArray);
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        #endregion

        #region operator Large Than (> ,>=)


        public static bool operator >(Characters c1, Characters c2)
        {
            return Characters.LargeThan(c1.CharArray, c2.CharArray);
        }

        public static bool operator >(string s, Characters c2)
        {
            return Characters.LargeThan(s.ToCharArray(), c2.CharArray);
        }

        public static bool operator >(Characters c1, string s)
        {
            return Characters.LargeThan(c1.CharArray, s.ToCharArray());
        }


        public static bool operator >=(Characters c1, Characters c2)
        {
            bool isLE = Characters.AreEqual(c1.CharArray, c2.CharArray) || Characters.LargeThan(c1.CharArray, c2.CharArray);
            return isLE;
        }

        public static bool operator >=(string s, Characters c2)
        {
            bool isLE = Characters.AreEqual(s.ToCharArray(), c2.CharArray) || Characters.LargeThan(s.ToCharArray(), c2.CharArray);
            return isLE;
        }

        public static bool operator >=(Characters c1, string s)
        {
            bool isLE = Characters.AreEqual(c1.CharArray, s.ToCharArray()) || Characters.LargeThan(c1.CharArray, s.ToCharArray());
            return isLE;
        }


        public static bool LargeThan(char[] left, char[] right)
        {
            //For all relational operators, the collating sequence is used to interpret a
            //character relational expression. The character expression whose value is lower
            //in the collating sequence is less than the other expression. The character
            //expressions are evaluated one character at a time from left to right. You can
            //also use the intrinsic functions (LGE, LLT, and LLT) to compare character
            //strings in the order specified by the ASCII collating sequence. For all
            //relational operators, if the operands are of unequal length, the shorter is
            //extended on the right with blanks. If both char_expr1 and char_expr2 are of
            //zero length, they are evaluated as equal.

            int maxLength = Math.Max(left.Length, right.Length);
            char[] leftCharArray = Characters.GetCharArray(left, maxLength);
            char[] rightCharArray = Characters.GetCharArray(right, maxLength);

            bool isLargeThan = false;

            for (int i = 0; i < leftCharArray.Length; i++)
            {
                if (leftCharArray[i] != rightCharArray[i])
                {
                    if (leftCharArray[i] > rightCharArray[i])
                    {
                        isLargeThan = true;
                        break;
                    }
                    else if (leftCharArray[i] < rightCharArray[i])
                    {
                        isLargeThan = false;
                        break;
                    }
                }
            }
            return isLargeThan;
        }



        #endregion


        #region operator Large Than (< ,<=)

        public static bool operator <(Characters c1, Characters c2)
        {
            return Characters.LeastThan(c1.CharArray, c2.CharArray);
        }

        public static bool operator <(string s, Characters c2)
        {
            return Characters.LeastThan(s.ToCharArray(), c2.CharArray);
        }

        public static bool operator <(Characters c1, string s)
        {
            return Characters.LeastThan(c1.CharArray, s.ToCharArray());
        }

        public static bool operator <=(Characters c1, Characters c2)
        {
            bool isLE = Characters.AreEqual(c1.CharArray, c2.CharArray) || Characters.LeastThan(c1.CharArray, c2.CharArray);
            return isLE;
        }

        public static bool operator <=(string s, Characters c2)
        {
            bool isLE = Characters.AreEqual(s.ToCharArray(), c2.CharArray) || Characters.LeastThan(s.ToCharArray(), c2.CharArray);
            return isLE;
        }

        public static bool operator <=(Characters c1, string s)
        {
            bool isLE = Characters.AreEqual(c1.CharArray, s.ToCharArray()) || Characters.LeastThan(c1.CharArray, s.ToCharArray());
            return isLE;
        }


        public static bool LeastThan(char[] left, char[] right)
        {
            //For all relational operators, the collating sequence is used to interpret a
            //character relational expression. The character expression whose value is lower
            //in the collating sequence is less than the other expression. The character
            //expressions are evaluated one character at a time from left to right. You can
            //also use the intrinsic functions (LGE, LLT, and LLT) to compare character
            //strings in the order specified by the ASCII collating sequence. For all
            //relational operators, if the operands are of unequal length, the shorter is
            //extended on the right with blanks. If both char_expr1 and char_expr2 are of
            //zero length, they are evaluated as equal.

            int maxLength = Math.Max(left.Length, right.Length);
            char[] leftCharArray = Characters.GetCharArray(left, maxLength);
            char[] rightCharArray = Characters.GetCharArray(right, maxLength);

            bool isLeastThan = false;

            for (int i = 0; i < leftCharArray.Length; i++)
            {
                if (leftCharArray[i] != rightCharArray[i])
                {
                    if (leftCharArray[i] < rightCharArray[i])
                    {
                        isLeastThan = true;
                        break;
                    }
                    else if (leftCharArray[i] > rightCharArray[i])
                    {
                        isLeastThan = false;
                        break;
                    }
                }
            }
            return isLeastThan;
        }

        #endregion


        private static char[] GetCharArray(char[] source, int length)
        {
            if (source.Length == length) return source;
            char[] newCharArray = new char[length];
            int sourceLength = Math.Min(source.Length, length);

            for (int i = 0; i < sourceLength; i++)
            {
                newCharArray[i] = source[i];
            }

            for (int i = sourceLength; i < newCharArray.Length; i++)
            {
                newCharArray[i] = ' ';
            }

            return newCharArray;
        }


        //public static void NormalizeSize(ref char[] c1, ref char[] c2)
        //{
        //    if (c1.Length != c2.Length)
        //    {
        //        if (c1.Length > c2.Length)
        //        {
        //            char[] c = new char[c1.Length];
        //            Array.Copy(c2, c, c2.Length);
        //            for (int i = c2.Length; i < c.Length; i++)
        //            {
        //                c[i] = ' ';
        //            }
        //            c2 = c;
        //        }
        //        else if (c1.Length < c2.Length)
        //        {
        //            char[] c = new char[c2.Length];
        //            Array.Copy(c1, c, c1.Length);
        //            for (int i = c1.Length; i < c.Length; i++)
        //            {
        //                c[i] = ' ';
        //            }
        //            c1 = c;
        //        }
        //    }

        //}



        #region implicit Operators

        public static implicit operator Characters(string s)  // implicit string to Characters conversion operator
        {
            Characters TheChararacters = new Characters(s);
            return TheChararacters;
        }

        #endregion


        #endregion

        public override string ToString()
        {
            return new String(this._CharArray);
        }

    }
}

	#region Copyright © 2009 Jose Antonio De Santiago-Castillo.

	//Copyright © 2009 Jose Antonio De Santiago-Castillo.
	//E-mail:JAntonioDeSantiago@gmail.com
	//Web: www.DotNumerics.com
	//
	#endregion

	using System;
	using System.Collections.Generic;
	using System.Text;

	namespace DotNumerics.FortranLibrary
	{
	public class Characters
	{
	#region Borrar

	//#region Fields

	//private char[] _CharArray = new char[0];
	//private int _Offset = 1;
	//private int _Length = 0;

	//#endregion

	//#region Constructor

	//public Characters(int length)
	//{
	// if (length < 0) length = 0;
	// this._Length = length;
	// this._CharArray = new char[length];

	// for (int i = 0; i < this._CharArray.Length; i++)
	// {
	// this._CharArray[i] = ' ';
	// }
	//}

	//public Characters(char[] sourceChars)
	//{
	// if (sourceChars == null)
	// {
	// return;
	// }
	// this._CharArray = sourceChars;
	// this._Length = sourceChars.Length;
	//}

	//public Characters(char[] sourceChars, int offset)
	//{
	// if (sourceChars == null)
	// {
	// return;
	// }
	// this._CharArray = sourceChars;
	// this._Length = sourceChars.Length - offset + 1;
	// this._Offset = offset;
	//}

	//public Characters(char[] sourceChars, int offset, int length)
	//{
	// if (sourceChars == null)
	// {
	// return;
	// }
	// this._CharArray = sourceChars;
	// this._Length = length;
	// this._Offset = offset;
	//}


	//#endregion

	//#region Properties

	//public char[] CharArray
	//{
	// get { return this._CharArray; }
	//}

	//public int Offset
	//{
	// get { return _Offset; }
	// set { _Offset = value; }
	//}

	//public int Length
	//{
	// get { return _Length; }
	// set { _Length = value; }
	//}


	//public char this[int index]
	//{
	// get
	// {
	// return this._CharArray[index - this._Offset];
	// }
	// set
	// {
	// this._CharArray[index - this._Offset] = value;
	// }
	//}




	//#endregion

	#endregion

	#region Fields

	private char[] _CharArray = new char[0];

	#endregion

	#region Constructor

	public Characters(int length)
	{
	if (length < 0) length = 0;
	this._CharArray = new char[length];

	for (int i = 0; i < this._CharArray.Length; i++)
	{
	this._CharArray[i] = ' ';
	}
	}

	public Characters(char[] sourceChars, bool copy)
	{
	if (sourceChars == null)
	{
	return;
	}
	if (copy == true)
	{
	this._CharArray = new char[sourceChars.Length];
	Array.Copy(sourceChars, this._CharArray, this._CharArray.Length);
	}
	else
	{
	this._CharArray = sourceChars;
	}
	}

	public Characters(string s) : this(s.ToCharArray(), false) { }

	public Characters(string s, int length)
	: this(length)
	{
	this.Copy(s);
	}


	#endregion

	#region Properties

	public char[] CharArray
	{
	get { return this._CharArray; }
	}

	public int Length
	{
	get { return this._CharArray.Length; }
	}



	#endregion


	#region Methods


	public void Copy(int startIndex, int lastIndex, char[] sourceCharArray)
	{
	if (lastIndex > this.Length) lastIndex = this.Length;
	int length = lastIndex - startIndex + 1;
	length = Math.Min(length, sourceCharArray.Length);

	startIndex--; //C# index

	Array.Copy(sourceCharArray, 0, this._CharArray, startIndex, length);

	//for (int i = 0; i < length; i++)
	//{
	// this._CharArray[startIndex + i] = sourceCharArray[i];
	//}
	}

	public void Copy(int startIndex, char[] sourceCharArray)
	{
	this.Copy(startIndex, this.Length, sourceCharArray);
	}

	public void Copy(char[] sourceCharArray)
	{
	this.Copy(1, sourceCharArray);
	}

	public void Copy(int startIndex, int lastIndex, string sourceString)
	{
	this.Copy(startIndex, lastIndex, sourceString.ToCharArray());
	}

	public void Copy(int startIndex, string sourceString)
	{
	this.Copy(startIndex, sourceString.ToCharArray());
	}

	public void Copy(string sourceString)
	{
	this.Copy(sourceString.ToCharArray());
	}


	public void Replace(char[] source)
	{
	this.ToBlanks();
	this.Copy(source);
	}

	public void Replace(Characters source)
	{
	this.Replace(source.CharArray);
	}

	public void Replace(string source)
	{
	this.Replace(source.ToCharArray());
	}



	public Characters Substring(int startIndex, int lastIndex)
	{
	int length = lastIndex - startIndex + 1;
	Characters sub = new Characters(length);

	startIndex--; //C# index
	Array.Copy(this._CharArray, startIndex, sub.CharArray, 0, length);

	return sub;

	}

	public Characters Substring(int startIndex)
	{
	return Substring(startIndex, this.Length);
	}


	public void ToUpper()
	{
	for (int i = 0; i < this._CharArray.Length; i++)
	{
	this._CharArray[i] = Char.ToUpper(this._CharArray[i]);
	}
	}

	public void ToLower()
	{
	for (int i = 0; i < this._CharArray.Length; i++)
	{
	this._CharArray[i] = Char.ToLower(this._CharArray[i]);
	}
	}

	public void ToBlanks()
	{
	for (int i = 0; i < this._CharArray.Length; i++)
	{
	this._CharArray[i] = ' ';
	}
	}

	public void ToBlanks(int start, int last)
	{
	start--;
	int max = Math.Min(last, this._CharArray.Length);
	for (int i = start; i < max; i++)
	{
	this._CharArray[i] = ' ';
	}
	}

	public void ToBlanks(int length)
	{
	this.ToBlanks(1, length + 1);
	}

	public int ToInt32()
	{
	if (this.LenTrim() == 0) return 0;
	string s = new string(this._CharArray);
	int val = Convert.ToInt32(s);
	return val;
	}

	public string Trim()
	{
	string s = new string(this._CharArray);
	return s.TrimEnd(new char[] { ' ' });
	}

	public void AdjustLeft()
	{
	int numLeftBlanks = 0;
	for (int i = 0; i < this._CharArray.Length; i++)
	{
	if (this._CharArray[i] == ' ')
	{
	numLeftBlanks++;
	}
	else
	{
	break;
	}
	}

	if (numLeftBlanks == 0) return;
	else
	{
	int lastIndex = this._CharArray.Length - numLeftBlanks;
	for (int i = 0; i < this._CharArray.Length; i++)
	{
	if (i < lastIndex)
	{
	this._CharArray[i] = this._CharArray[numLeftBlanks + i];
	}
	else
	{
	this._CharArray[i] = ' ';
	}
	}

	}
	}

	public void AdjustRight()
	{
	Array.Reverse(this._CharArray);
	this.AdjustLeft();
	Array.Reverse(this._CharArray);

	}

	public int LenTrim()
	{
	int lentrim = this._CharArray.Length;
	char blank = ' ';

	for (int i = this._CharArray.Length - 1; i > -1; i--)
	{
	if (this._CharArray[i] == blank)
	{
	lentrim--;
	}
	else
	{
	break;
	}
	}
	return lentrim;
	}


	#endregion


	#region Operators

	#region operator +

	public static Characters operator +(Characters c1, Characters c2)
	{
	return Characters.Add(c1.CharArray, c2.CharArray);
	}

	public static Characters operator +(string s, Characters c2)
	{
	return Characters.Add(s.ToCharArray(), c2.CharArray);
	}

	public static Characters operator +(Characters c1, string s)
	{
	return Characters.Add(c1.CharArray, s.ToCharArray());
	}

	public static Characters Add(char[] c1, char[] c2)
	{
	Characters newCharacters = new Characters(c1.Length + c2.Length);

	Array.Copy(c1, newCharacters.CharArray, c1.Length);

	Array.Copy(c2, 0, newCharacters.CharArray, c1.Length, c2.Length);

	return newCharacters;

	}

	#endregion

	#region Operators == and !=

	public static bool operator ==(Characters c1, Characters c2)
	{
	return Characters.AreEqual(c1.CharArray, c2.CharArray);
	}

	public static bool operator ==(string s, Characters c2)
	{
	return Characters.AreEqual(s.ToCharArray(), c2.CharArray);
	}

	public static bool operator ==(Characters c1, string s)
	{
	return Characters.AreEqual(c1.CharArray, s.ToCharArray());
	}


	public static bool operator !=(Characters c1, Characters c2)
	{
	return !Characters.AreEqual(c1.CharArray, c2.CharArray);
	}

	public static bool operator !=(string s, Characters c2)
	{
	return !Characters.AreEqual(s.ToCharArray(), c2.CharArray);
	}

	public static bool operator !=(Characters c1, string s)
	{
	return !Characters.AreEqual(c1.CharArray, s.ToCharArray());
	}


	public static bool AreEqual(char[] left, char[] right)
	{

	int maxLength = Math.Max(left.Length, right.Length);
	char[] c1 = Characters.GetCharArray(left, maxLength);
	char[] c2 = Characters.GetCharArray(right, maxLength);

	if (c1.Length != c2.Length) return false;

	bool areEqual = true;

	for (int i = 0; i < c1.Length; i++)
	{
	if (c1[i] != c2[i])
	{
	areEqual = false;
	break;
	}
	}
	return areEqual;
	}


	public override bool Equals(System.Object obj)
	{
	// If parameter is null return false.
	if (obj == null)
	{
	return false;
	}

	// If parameter cannot be cast to Characters return false.
	Characters c = obj as Characters;
	if ((System.Object)c == null)
	{
	return false;
	}

	// Return true if the fields match:
	return Characters.AreEqual(c.CharArray, this.CharArray);
	}

	public override int GetHashCode()
	{
	return base.GetHashCode();
	}

	#endregion

	#region operator Large Than (> ,>=)


	public static bool operator >(Characters c1, Characters c2)
	{
	return Characters.LargeThan(c1.CharArray, c2.CharArray);
	}

	public static bool operator >(string s, Characters c2)
	{
	return Characters.LargeThan(s.ToCharArray(), c2.CharArray);
	}

	public static bool operator >(Characters c1, string s)
	{
	return Characters.LargeThan(c1.CharArray, s.ToCharArray());
	}


	public static bool operator >=(Characters c1, Characters c2)
	{
	bool isLE = Characters.AreEqual(c1.CharArray, c2.CharArray) \|\| Characters.LargeThan(c1.CharArray, c2.CharArray);
	return isLE;
	}

	public static bool operator >=(string s, Characters c2)
	{
	bool isLE = Characters.AreEqual(s.ToCharArray(), c2.CharArray) \|\| Characters.LargeThan(s.ToCharArray(), c2.CharArray);
	return isLE;
	}

	public static bool operator >=(Characters c1, string s)
	{
	bool isLE = Characters.AreEqual(c1.CharArray, s.ToCharArray()) \|\| Characters.LargeThan(c1.CharArray, s.ToCharArray());
	return isLE;
	}


	public static bool LargeThan(char[] left, char[] right)
	{
	//For all relational operators, the collating sequence is used to interpret a
	//character relational expression. The character expression whose value is lower
	//in the collating sequence is less than the other expression. The character
	//expressions are evaluated one character at a time from left to right. You can
	//also use the intrinsic functions (LGE, LLT, and LLT) to compare character
	//strings in the order specified by the ASCII collating sequence. For all
	//relational operators, if the operands are of unequal length, the shorter is
	//extended on the right with blanks. If both char_expr1 and char_expr2 are of
	//zero length, they are evaluated as equal.

	int maxLength = Math.Max(left.Length, right.Length);
	char[] leftCharArray = Characters.GetCharArray(left, maxLength);
	char[] rightCharArray = Characters.GetCharArray(right, maxLength);

	bool isLargeThan = false;

	for (int i = 0; i < leftCharArray.Length; i++)
	{
	if (leftCharArray[i] != rightCharArray[i])
	{
	if (leftCharArray[i] > rightCharArray[i])
	{
	isLargeThan = true;
	break;
	}
	else if (leftCharArray[i] < rightCharArray[i])
	{
	isLargeThan = false;
	break;
	}
	}
	}
	return isLargeThan;
	}



	#endregion


	#region operator Large Than (< ,<=)

	public static bool operator <(Characters c1, Characters c2)
	{
	return Characters.LeastThan(c1.CharArray, c2.CharArray);
	}

	public static bool operator <(string s, Characters c2)
	{
	return Characters.LeastThan(s.ToCharArray(), c2.CharArray);
	}

	public static bool operator <(Characters c1, string s)
	{
	return Characters.LeastThan(c1.CharArray, s.ToCharArray());
	}

	public static bool operator <=(Characters c1, Characters c2)
	{
	bool isLE = Characters.AreEqual(c1.CharArray, c2.CharArray) \|\| Characters.LeastThan(c1.CharArray, c2.CharArray);
	return isLE;
	}

	public static bool operator <=(string s, Characters c2)
	{
	bool isLE = Characters.AreEqual(s.ToCharArray(), c2.CharArray) \|\| Characters.LeastThan(s.ToCharArray(), c2.CharArray);
	return isLE;
	}

	public static bool operator <=(Characters c1, string s)
	{
	bool isLE = Characters.AreEqual(c1.CharArray, s.ToCharArray()) \|\| Characters.LeastThan(c1.CharArray, s.ToCharArray());
	return isLE;
	}


	public static bool LeastThan(char[] left, char[] right)
	{
	//For all relational operators, the collating sequence is used to interpret a
	//character relational expression. The character expression whose value is lower
	//in the collating sequence is less than the other expression. The character
	//expressions are evaluated one character at a time from left to right. You can
	//also use the intrinsic functions (LGE, LLT, and LLT) to compare character
	//strings in the order specified by the ASCII collating sequence. For all
	//relational operators, if the operands are of unequal length, the shorter is
	//extended on the right with blanks. If both char_expr1 and char_expr2 are of
	//zero length, they are evaluated as equal.

	int maxLength = Math.Max(left.Length, right.Length);
	char[] leftCharArray = Characters.GetCharArray(left, maxLength);
	char[] rightCharArray = Characters.GetCharArray(right, maxLength);

	bool isLeastThan = false;

	for (int i = 0; i < leftCharArray.Length; i++)
	{
	if (leftCharArray[i] != rightCharArray[i])
	{
	if (leftCharArray[i] < rightCharArray[i])
	{
	isLeastThan = true;
	break;
	}
	else if (leftCharArray[i] > rightCharArray[i])
	{
	isLeastThan = false;
	break;
	}
	}
	}
	return isLeastThan;
	}

	#endregion


	private static char[] GetCharArray(char[] source, int length)
	{
	if (source.Length == length) return source;
	char[] newCharArray = new char[length];
	int sourceLength = Math.Min(source.Length, length);

	for (int i = 0; i < sourceLength; i++)
	{
	newCharArray[i] = source[i];
	}

	for (int i = sourceLength; i < newCharArray.Length; i++)
	{
	newCharArray[i] = ' ';
	}

	return newCharArray;
	}


	//public static void NormalizeSize(ref char[] c1, ref char[] c2)
	//{
	// if (c1.Length != c2.Length)
	// {
	// if (c1.Length > c2.Length)
	// {
	// char[] c = new char[c1.Length];
	// Array.Copy(c2, c, c2.Length);
	// for (int i = c2.Length; i < c.Length; i++)
	// {
	// c[i] = ' ';
	// }
	// c2 = c;
	// }
	// else if (c1.Length < c2.Length)
	// {
	// char[] c = new char[c2.Length];
	// Array.Copy(c1, c, c1.Length);
	// for (int i = c1.Length; i < c.Length; i++)
	// {
	// c[i] = ' ';
	// }
	// c1 = c;
	// }
	// }

	//}



	#region implicit Operators

	public static implicit operator Characters(string s) // implicit string to Characters conversion operator
	{
	Characters TheChararacters = new Characters(s);
	return TheChararacters;
	}

	#endregion


	#endregion

	public override string ToString()
	{
	return new String(this._CharArray);
	}

	}
	}