That-One-Nerd/Nerd_STF
1
0
Fork 0
Code Issues 63 Pull Requests Actions Packages Projects Releases 19 Wiki Activity

Delete Lists.cs

Browse Source
This commit is contained in:
That_One_Nerd 2021-04-12 19:50:39 -04:00 committed by GitHub
parent 4ad51fffcb
commit 8b42bea8ac
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 0 additions and 694 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

694
Lists.cs
View File

@ -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);
}
}
}