694 lines
18 KiB
C#
694 lines
18 KiB
C#
using System;
|
|
using System.Collections;
|
|
using Nerd_STF.Mathematics;
|
|
|
|
namespace Nerd_STF.Lists
|
|
{
|
|
public class Matrix<T>
|
|
{
|
|
internal List<List<T>> lists;
|
|
|
|
public Vector2 Length
|
|
{
|
|
get
|
|
{
|
|
return new(lists.Get(0).Length, lists.Length);
|
|
}
|
|
}
|
|
public int LengthX
|
|
{
|
|
get
|
|
{
|
|
return lists.Get(0).Length;
|
|
}
|
|
}
|
|
public int LengthY
|
|
{
|
|
get
|
|
{
|
|
return lists.Length;
|
|
}
|
|
}
|
|
|
|
public static Matrix<T> Empty
|
|
{
|
|
get
|
|
{
|
|
return new Matrix<T> { lists = List<List<T>>.Empty };
|
|
}
|
|
}
|
|
|
|
public Matrix()
|
|
{
|
|
lists = new List<List<T>>(1, new List<T>(1, default));
|
|
}
|
|
public Matrix(int lengthX, int lengthY)
|
|
{
|
|
if (lengthX < 1) throw new ArgumentOutOfRangeException(nameof(lengthX), "Do not include a length of less than 1");
|
|
if (lengthY < 1) throw new ArgumentOutOfRangeException(nameof(lengthY), "Do not include a width of less than 1");
|
|
lists = new List<List<T>>(lengthY, new List<T>(lengthX));
|
|
}
|
|
public Matrix(int lengthX, int lengthY, T inputAll)
|
|
{
|
|
if (lengthX < 1) throw new ArgumentOutOfRangeException(nameof(lengthX), "Do not include a length of less than 1");
|
|
if (lengthY < 1) throw new ArgumentOutOfRangeException(nameof(lengthY), "Do not include a width of less than 1");
|
|
lists = new List<List<T>>(lengthY, new List<T>(lengthX, inputAll));
|
|
}
|
|
public T this[int indexX, int indexY]
|
|
{
|
|
get
|
|
{
|
|
return Get(indexX, indexY);
|
|
}
|
|
|
|
set
|
|
{
|
|
Set(indexX, indexY, value);
|
|
}
|
|
}
|
|
|
|
public void Add(Matrix<T> input, DirectionType addDir)
|
|
{
|
|
if (addDir == DirectionType.y)
|
|
{
|
|
foreach (List<T> list in input.lists)
|
|
{
|
|
AddY(list);
|
|
}
|
|
return;
|
|
}
|
|
|
|
foreach (List<T> list in input.lists)
|
|
{
|
|
AddX(list);
|
|
}
|
|
}
|
|
public void AddX()
|
|
{
|
|
foreach (List<T> list in lists)
|
|
{
|
|
list.Add();
|
|
}
|
|
}
|
|
public void AddX(T input)
|
|
{
|
|
foreach (List<T> list in lists)
|
|
{
|
|
list.Add(input);
|
|
}
|
|
}
|
|
public void AddX(T[] input)
|
|
{
|
|
foreach (T t in input)
|
|
{
|
|
AddX(t);
|
|
}
|
|
}
|
|
public void AddX(List<T> input)
|
|
{
|
|
foreach (T t in input)
|
|
{
|
|
AddX(t);
|
|
}
|
|
}
|
|
public void AddY()
|
|
{
|
|
lists.Add(new List<T>(lists.Get(0).Length));
|
|
}
|
|
public void AddY(T input)
|
|
{
|
|
lists.Add(new List<T>(lists.Get(0).Length, input));
|
|
}
|
|
public void AddY(T[] input)
|
|
{
|
|
if (input.Length > lists.Get(0).Length) throw new OverflowException();
|
|
lists.Add(new List<T>(input));
|
|
}
|
|
public void AddY(List<T> input)
|
|
{
|
|
if (input.Length > lists.Get(0).Length) throw new OverflowException();
|
|
lists.Add(input);
|
|
}
|
|
public bool Check(int placeX, int placeY)
|
|
{
|
|
return lists.Get(placeY).Get(placeX) != null;
|
|
}
|
|
public bool Compare(T input)
|
|
{
|
|
foreach (List<T> list in lists)
|
|
{
|
|
if (list.Compare(input)) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
public void Convert(T input)
|
|
{
|
|
foreach (List<T> list in lists)
|
|
{
|
|
list.Convert(input);
|
|
}
|
|
}
|
|
public void Convert(T[] input)
|
|
{
|
|
foreach (List<T> list in lists)
|
|
{
|
|
list.Convert(input);
|
|
}
|
|
}
|
|
public void Convert(List<T> input)
|
|
{
|
|
foreach (List<T> list in lists)
|
|
{
|
|
list.Convert(input);
|
|
}
|
|
}
|
|
public void Convert(Matrix<T> input)
|
|
{
|
|
lists = input.lists;
|
|
}
|
|
public int Count()
|
|
{
|
|
int returned = 0;
|
|
|
|
foreach (List<T> list in lists)
|
|
{
|
|
returned += list.Count();
|
|
}
|
|
|
|
return returned;
|
|
}
|
|
public int Count(DirectionType type)
|
|
{
|
|
if (type == DirectionType.y) return LengthY;
|
|
return LengthX;
|
|
}
|
|
public Vector2 CountXY()
|
|
{
|
|
return Length;
|
|
}
|
|
public T Get(int placeX, int placeY)
|
|
{
|
|
return lists.Get(placeY).Get(placeX);
|
|
}
|
|
public void Get(int placeX, int placeY, out T output)
|
|
{
|
|
output = Get(placeX, placeY);
|
|
}
|
|
public List<T> GetAll()
|
|
{
|
|
List<T> returned = new();
|
|
|
|
foreach (List<T> list in lists)
|
|
{
|
|
returned.Add(list);
|
|
}
|
|
|
|
return returned;
|
|
}
|
|
public void GetAll(out List<T> output)
|
|
{
|
|
List<T> returned = new();
|
|
|
|
foreach (List<T> list in lists)
|
|
{
|
|
returned.Add(list);
|
|
}
|
|
|
|
output = returned;
|
|
}
|
|
public IEnumerator GetEnumerator()
|
|
{
|
|
foreach (List<T> list in lists)
|
|
{
|
|
foreach (T t in list)
|
|
{
|
|
yield return t;
|
|
}
|
|
}
|
|
}
|
|
public void Remove(int placeX, int placeY)
|
|
{
|
|
lists.Get(placeY).Remove(placeX);
|
|
}
|
|
public void Set(int placeX, int placeY, T input)
|
|
{
|
|
lists.Get(placeY).Set(placeX, input);
|
|
}
|
|
public void SetAll(T input)
|
|
{
|
|
for (int i = 0; i < lists.Length; i++)
|
|
{
|
|
for (int j = 0; j < lists.Get(i).Length; j++)
|
|
{
|
|
lists.Get(i).Set(j, input);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static Matrix<T> AllDefault(int lengthX, int lengthY)
|
|
{
|
|
return new(lengthX, lengthY, default);
|
|
}
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
return base.Equals(obj);
|
|
}
|
|
public bool Equals(Matrix<T> other)
|
|
{
|
|
return GetAll() == other.GetAll();
|
|
}
|
|
public override int GetHashCode()
|
|
{
|
|
return base.GetHashCode();
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return lists.ToString();
|
|
}
|
|
public string ToString(bool showAll)
|
|
{
|
|
if (showAll)
|
|
{
|
|
string r = "";
|
|
for (int i = 0; i < lists.Length; i++)
|
|
{
|
|
for (int j = 0; j < lists.Get(i).Length; j++)
|
|
{
|
|
r += lists.Get(i).Get(j);
|
|
if (j != lists.Get(i).Length - 1) r += ", ";
|
|
}
|
|
if (i != lists.Length - 1) r += "\n";
|
|
}
|
|
return r;
|
|
}
|
|
else
|
|
{
|
|
return ToString();
|
|
}
|
|
}
|
|
|
|
public static bool operator ==(Matrix<T> a, Matrix<T> b)
|
|
{
|
|
return a.Equals(b);
|
|
}
|
|
public static bool operator !=(Matrix<T> a, Matrix<T> b)
|
|
{
|
|
return !a.Equals(b);
|
|
}
|
|
|
|
public enum DirectionType
|
|
{
|
|
x,
|
|
y,
|
|
}
|
|
}
|
|
|
|
public class List<T>
|
|
{
|
|
internal T[] list;
|
|
|
|
public int Length
|
|
{
|
|
get
|
|
{
|
|
return list.Length;
|
|
}
|
|
}
|
|
public T this[int index]
|
|
{
|
|
get
|
|
{
|
|
return Get(index);
|
|
}
|
|
set
|
|
{
|
|
Set(index, value);
|
|
}
|
|
}
|
|
|
|
public static List<T> Empty
|
|
{
|
|
get
|
|
{
|
|
return new List<T>(Array.Empty<T>());
|
|
}
|
|
}
|
|
|
|
public List()
|
|
{
|
|
list = Array.Empty<T>();
|
|
}
|
|
public List(int length)
|
|
{
|
|
list = new T[length];
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
list[i] = default;
|
|
}
|
|
}
|
|
public List(int length, T inputAll)
|
|
{
|
|
list = new T[length];
|
|
for (int i = 0; i < list.Length; i++)
|
|
{
|
|
list[i] = inputAll;
|
|
}
|
|
}
|
|
public List(T[] input)
|
|
{
|
|
list = Array.Empty<T>();
|
|
if (input != default) list = input;
|
|
}
|
|
public List(List<T> input)
|
|
{
|
|
list = Array.Empty<T>();
|
|
if (input.list != default) list = input.list;
|
|
}
|
|
|
|
public void Add()
|
|
{
|
|
T[] before = list;
|
|
|
|
if (before.Length == 0)
|
|
{
|
|
list = new T[1];
|
|
list[0] = default;
|
|
}
|
|
else
|
|
{
|
|
list = new T[before.Length + 1];
|
|
int place = 0;
|
|
while (place < before.Length)
|
|
{
|
|
list[place] = before[place];
|
|
place++;
|
|
}
|
|
list[place] = default;
|
|
}
|
|
}
|
|
public void Add(T add)
|
|
{
|
|
T[] before = list;
|
|
|
|
if (before.Length == 0)
|
|
{
|
|
list = new T[1];
|
|
list[0] = add;
|
|
}
|
|
else
|
|
{
|
|
list = new T[before.Length + 1];
|
|
int place = 0;
|
|
while (place < before.Length)
|
|
{
|
|
list[place] = before[place];
|
|
place++;
|
|
}
|
|
list[place] = add;
|
|
}
|
|
}
|
|
public void Add(T[] add)
|
|
{
|
|
foreach (T input in add)
|
|
{
|
|
Add(input);
|
|
}
|
|
}
|
|
public void Add(List<T> add)
|
|
{
|
|
Add(add.list);
|
|
}
|
|
public bool Check(int place)
|
|
{
|
|
return list[place] != null;
|
|
}
|
|
public bool Compare(T input)
|
|
{
|
|
foreach (T place in list)
|
|
{
|
|
if (place == null) continue;
|
|
if (place.Equals(input)) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
public void Convert(T input)
|
|
{
|
|
for (int i = 0; i < list.Length; i++)
|
|
{
|
|
list[i] = input;
|
|
}
|
|
}
|
|
public void Convert(T[] input)
|
|
{
|
|
list = input;
|
|
}
|
|
public void Convert(List<T> input)
|
|
{
|
|
Convert(input.list);
|
|
}
|
|
public int Count()
|
|
{
|
|
int returned = 0;
|
|
foreach (T _ in list)
|
|
{
|
|
returned++;
|
|
}
|
|
return returned;
|
|
}
|
|
public T Get(int place)
|
|
{
|
|
return list[place];
|
|
}
|
|
public void Get(int place, out T output)
|
|
{
|
|
output = Get(place);
|
|
}
|
|
public T[] GetAll()
|
|
{
|
|
return list;
|
|
}
|
|
public IEnumerator GetEnumerator()
|
|
{
|
|
return list.GetEnumerator();
|
|
}
|
|
public void Remove(int place)
|
|
{
|
|
list[place] = default;
|
|
}
|
|
public void Remove(int place, bool shift)
|
|
{
|
|
list[place] = default;
|
|
if (shift)
|
|
{
|
|
for (int i = place; i < list.Length - 1; i++)
|
|
{
|
|
list[i] = list[i + 1];
|
|
}
|
|
T[] save = list;
|
|
list = new T[save.Length - 1];
|
|
for (int i = 0; i < save.Length - 1; i++)
|
|
{
|
|
list[i] = save[i];
|
|
}
|
|
}
|
|
}
|
|
public void Set(int place, T input)
|
|
{
|
|
list[place] = input;
|
|
}
|
|
public void Set(T[] input)
|
|
{
|
|
list = input;
|
|
}
|
|
public void Set(List<T> input)
|
|
{
|
|
Set(input.list);
|
|
}
|
|
public void SetAll(T input)
|
|
{
|
|
for (int i = 0; i < list.Length; i++)
|
|
{
|
|
list[i] = input;
|
|
}
|
|
}
|
|
|
|
public static List<T> AllDefault(int length)
|
|
{
|
|
return new(length, default);
|
|
}
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
return base.Equals(obj);
|
|
}
|
|
public bool Equals(List<T> other)
|
|
{
|
|
bool returned = true;
|
|
if (Length == other.Length)
|
|
{
|
|
for (int i = 0; i < Length; i++)
|
|
{
|
|
returned &= Get(i).Equals(other.Get(i));
|
|
}
|
|
}
|
|
return returned;
|
|
}
|
|
public bool Equals(T[] other)
|
|
{
|
|
bool returned = true;
|
|
if (Length == other.Length)
|
|
{
|
|
for (int i = 0; i < Length; i++)
|
|
{
|
|
returned &= Get(i).Equals(other[i]);
|
|
}
|
|
}
|
|
return returned;
|
|
}
|
|
public override int GetHashCode()
|
|
{
|
|
return base.GetHashCode();
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return list.ToString();
|
|
}
|
|
public string ToString(bool showAll)
|
|
{
|
|
if (showAll)
|
|
{
|
|
string r = "";
|
|
for (int i = 0; i < list.Length; i++)
|
|
{
|
|
r += list[i].ToString();
|
|
if (i != list.Length - 1) r += "\n";
|
|
}
|
|
return r;
|
|
}
|
|
else
|
|
{
|
|
return ToString();
|
|
}
|
|
}
|
|
|
|
public static List<T> operator +(List<T> a, List<T> b)
|
|
{
|
|
a.Add(b);
|
|
return a;
|
|
}
|
|
public static List<T> operator +(List<T> a, T[] b)
|
|
{
|
|
a.Add(b);
|
|
return a;
|
|
}
|
|
public static List<T> operator +(T[] a, List<T> b)
|
|
{
|
|
List<T> returned = new(a);
|
|
returned.Add(b);
|
|
return returned;
|
|
}
|
|
public static List<T> operator +(List<T> a, int add)
|
|
{
|
|
List<T> returned = new(a.Length + add);
|
|
int i = 0;
|
|
while (i < a.Length)
|
|
{
|
|
returned.Set(i, a.Get(i));
|
|
i++;
|
|
}
|
|
while (i < returned.Length)
|
|
{
|
|
returned.Set(i, default);
|
|
}
|
|
return returned;
|
|
}
|
|
public static List<T> operator +(List<T> a, T b)
|
|
{
|
|
a.Add(b);
|
|
|
|
return a;
|
|
}
|
|
public static List<T> operator +(T a, List<T> b)
|
|
{
|
|
b.Add(a);
|
|
|
|
return b;
|
|
}
|
|
public static List<T> operator -(List<T> a, int remove)
|
|
{
|
|
List<T> returned = new(a.Length - remove);
|
|
for (int i = 0; i < returned.Length; i++)
|
|
{
|
|
returned.Set(i, a.Get(i));
|
|
}
|
|
return returned;
|
|
}
|
|
public static List<T> operator -(List<T> a, int[] removes)
|
|
{
|
|
foreach (int remove in removes)
|
|
{
|
|
a.Remove(remove);
|
|
}
|
|
return a;
|
|
}
|
|
public static List<T> operator -(List<T> a, List<int> removes)
|
|
{
|
|
foreach (int remove in removes)
|
|
{
|
|
a.Remove(remove);
|
|
}
|
|
return a;
|
|
}
|
|
public static List<T> operator *(List<T> a, int multiplier)
|
|
{
|
|
List<T> returned = new(a.Length * multiplier);
|
|
int i = 0;
|
|
while (i < a.Length)
|
|
{
|
|
returned.Set(i, a.Get(i));
|
|
i++;
|
|
}
|
|
while (i < returned.Length)
|
|
{
|
|
returned.Set(i, default);
|
|
}
|
|
return returned;
|
|
}
|
|
public static bool operator ==(List<T> a, List<T> b)
|
|
{
|
|
return a.Equals(b);
|
|
}
|
|
public static bool operator ==(List<T> a, T[] b)
|
|
{
|
|
return a.Equals(b);
|
|
}
|
|
public static bool operator ==(T[] a, List<T> b)
|
|
{
|
|
return b.Equals(a);
|
|
}
|
|
public static bool operator !=(List<T> a, List<T> b)
|
|
{
|
|
return !a.Equals(b);
|
|
}
|
|
public static bool operator !=(List<T> a, T[] b)
|
|
{
|
|
return !a.Equals(b);
|
|
}
|
|
public static bool operator !=(T[] a, List<T> b)
|
|
{
|
|
return !b.Equals(a);
|
|
}
|
|
|
|
public static explicit operator T[](List<T> list)
|
|
{
|
|
return list.list;
|
|
}
|
|
public static explicit operator List<T>(T[] list)
|
|
{
|
|
return new List<T>(list);
|
|
}
|
|
}
|
|
} |