Delete Lists.cs
This commit is contained in:
GitHub
parent
4ad51fffcb
commit
8b42bea8ac
694
Lists.cs
694
Lists.cs
@ -1,694 +0,0 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user