diff --git a/src/TMG-Framework/Construct/ConstructTimePeriodFromTimes.cs b/src/TMG-Framework/Construct/ConstructTimePeriodFromTimes.cs
index ec91489..82f9103 100644
--- a/src/TMG-Framework/Construct/ConstructTimePeriodFromTimes.cs
+++ b/src/TMG-Framework/Construct/ConstructTimePeriodFromTimes.cs
@@ -16,26 +16,23 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
{
- [Module(Name = "Construct Time Period from Times", Description = "Given the start and end times construct a time period.",
- DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
- public sealed class ConstructTimePeriodFromTimes : BaseFunction
- {
- [Parameter(Index = 0, Name = "Start Time", Required = true, Description = "The time to use as the starting point of the time period (Inclusive).")]
- public IFunction StartTime = null!;
+ [Parameter(Index = 0, Name = "Start Time", Required = true, Description = "The time to use as the starting point of the time period (Inclusive).")]
+ public IFunction StartTime = null!;
- [Parameter(Index = 1, Name = "End Time", Required = true, Description = "The time to use as the ending point of the time period (Exclusive).")]
- public IFunction EndTime = null!;
+ [Parameter(Index = 1, Name = "End Time", Required = true, Description = "The time to use as the ending point of the time period (Exclusive).")]
+ public IFunction EndTime = null!;
- public override TimePeriod Invoke()
- {
- return new TimePeriod(StartTime.Invoke(), EndTime.Invoke());
- }
+ public override TimePeriod Invoke()
+ {
+ return new TimePeriod(StartTime.Invoke(), EndTime.Invoke());
}
}
diff --git a/src/TMG-Framework/Convert/ConvertTimesToTimePeriod.cs b/src/TMG-Framework/Convert/ConvertTimesToTimePeriod.cs
index 2ba463b..4eb93a1 100644
--- a/src/TMG-Framework/Convert/ConvertTimesToTimePeriod.cs
+++ b/src/TMG-Framework/Convert/ConvertTimesToTimePeriod.cs
@@ -16,13 +16,11 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
+///
+///
+public sealed class Categories : IEnumerable
{
///
- ///
+ /// Get the number of elements in the categories.
///
- public sealed class Categories : IEnumerable
- {
- ///
- /// Get the number of elements in the categories.
- ///
- public int Count => _elements.Count;
+ public int Count => _elements.Count;
- ///
- /// TODO: Update the representation later on to something more efficient
- ///
- private readonly List _elements;
+ ///
+ /// TODO: Update the representation later on to something more efficient
+ ///
+ private readonly List _elements;
- ///
- /// Create a Categories instance from a list of elements
- ///
- /// True if creation succeeds, false otherwise
- public static bool CreateCategories(List elements,
- [NotNullWhen(true)] out Categories? categories,
- [NotNullWhen(false)] ref string? error)
+ ///
+ /// Create a Categories instance from a list of elements
+ ///
+ /// True if creation succeeds, false otherwise
+ public static bool CreateCategories(List elements,
+ [NotNullWhen(true)] out Categories? categories,
+ [NotNullWhen(false)] ref string? error)
+ {
+ elements = elements?.ToList() ?? throw new ArgumentNullException(nameof(elements));
+ elements.Sort();
+ for (int i = 1; i < elements.Count; i++)
{
- elements = elements?.ToList() ?? throw new ArgumentNullException(nameof(elements));
- elements.Sort();
- for (int i = 1; i < elements.Count; i++)
+ if (elements[i - 1] == elements[i])
{
- if(elements[i - 1] == elements[i])
- {
- error = $"Found a duplicate category {elements[i]}!";
- categories = null;
- return false;
- }
+ error = $"Found a duplicate category {elements[i]}!";
+ categories = null;
+ return false;
}
- categories = new Categories(elements);
- return true;
}
+ categories = new Categories(elements);
+ return true;
+ }
- ///
- /// Create a Categories instance from a list of elements
- ///
- /// True if creation succeeds, false otherwise
- public static bool CreateCategories(Span elements,
- [NotNullWhen(true)] out Categories? categories,
- [NotNullWhen(false)] ref string? error)
+ ///
+ /// Create a Categories instance from a list of elements
+ ///
+ /// True if creation succeeds, false otherwise
+ public static bool CreateCategories(Span elements,
+ [NotNullWhen(true)] out Categories? categories,
+ [NotNullWhen(false)] ref string? error)
+ {
+ var list = new List(elements.ToArray());
+ list.Sort();
+ for (int i = 1; i < list.Count; i++)
{
- var list = new List(elements.ToArray());
- list.Sort();
- for (int i = 1; i < list.Count; i++)
+ if (list[i - 1] == list[i])
{
- if(list[i - 1] == list[i])
- {
- error = $"Found a duplicate category {list[i]}!";
- categories = null;
- return false;
- }
+ error = $"Found a duplicate category {list[i]}!";
+ categories = null;
+ return false;
}
- categories = new Categories(list);
- return true;
}
+ categories = new Categories(list);
+ return true;
+ }
- ///
- /// Create a Categories instance from a list of elements
- ///
- /// elements)
+ ///
+ /// Create a Categories instance from a list of elements
+ ///
+ /// elements)
+ {
+ if (elements == null)
{
- if(elements == null)
- {
- ThrowParameterNull(nameof(elements));
- }
- _elements = elements;
+ ThrowParameterNull(nameof(elements));
}
+ _elements = elements;
+ }
- ///
- /// Gives the flat index of the specified sparse index, or less than 0 if the sparse index is not in the map.
- ///
- /// Gives the flat index of the specified sparse index, or less than 0 if the sparse index is not in the map.
- public int GetFlatIndex(CategoryIndex sparseIndex)
- {
- return _elements.BinarySearch(sparseIndex);
- }
+ ///
+ /// Gives the flat index of the specified sparse index, or less than 0 if the sparse index is not in the map.
+ ///
+ /// Gives the flat index of the specified sparse index, or less than 0 if the sparse index is not in the map.
+ public int GetFlatIndex(CategoryIndex sparseIndex)
+ {
+ return _elements.BinarySearch(sparseIndex);
+ }
- ///
- ///
- ///
- ///
+ ///
+ ///
+ /// GetEnumerator()
- {
- return _elements.GetEnumerator();
- }
+ /// GetEnumerator()
+ {
+ return _elements.GetEnumerator();
+ }
- ///
+/// Represents an index into an object of Categories.
+///
+public readonly struct CategoryIndex : IEquatable, IComparable, IEqualityComparer
{
- ///
- /// Represents an index into an object of Categories.
- ///
- public readonly struct CategoryIndex : IEquatable, IComparable, IEqualityComparer
- {
- private readonly int _Value;
+ private readonly int _Value;
- public CategoryIndex(int value)
- {
- _Value = value;
- }
+ public CategoryIndex(int value)
+ {
+ _Value = value;
+ }
- ///
- /// Test if the value is a valid reference to the category
- ///
- public bool Exists => _Value >= 0;
+ ///
+ /// Test if the value is a valid reference to the category
+ ///
+ public bool Exists => _Value >= 0;
- public static implicit operator int(CategoryIndex index) => index._Value;
+ public static implicit operator int(CategoryIndex index) => index._Value;
- public static implicit operator CategoryIndex(int index) => new(index);
+ public static implicit operator CategoryIndex(int index) => new(index);
- public static bool TryParse(string s, out CategoryIndex result)
+ public static bool TryParse(string s, out CategoryIndex result)
+ {
+ if (!int.TryParse(s, out int temp))
{
- if (!int.TryParse(s, out int temp))
- {
- result = temp;
- return true;
- }
- result = -1;
- return false;
+ result = temp;
+ return true;
}
+ result = -1;
+ return false;
+ }
- public bool Equals(CategoryIndex x, CategoryIndex y)
- {
- return x._Value == y._Value;
- }
+ public bool Equals(CategoryIndex x, CategoryIndex y)
+ {
+ return x._Value == y._Value;
+ }
- public int GetHashCode([DisallowNull] CategoryIndex obj)
- {
- return obj._Value.GetHashCode();
- }
+ public int GetHashCode([DisallowNull] CategoryIndex obj)
+ {
+ return obj._Value.GetHashCode();
+ }
- public int CompareTo(CategoryIndex other)
- {
- return _Value.CompareTo(other._Value);
- }
+ public int CompareTo(CategoryIndex other)
+ {
+ return _Value.CompareTo(other._Value);
+ }
- public bool Equals(CategoryIndex other)
- {
- return _Value == other._Value;
- }
+ public bool Equals(CategoryIndex other)
+ {
+ return _Value == other._Value;
+ }
- public override bool Equals(object? obj)
+ public override bool Equals(object? obj)
+ {
+ if (obj is CategoryIndex other)
{
- if (obj is CategoryIndex other)
- {
- return Equals(other);
- }
- return false;
+ return Equals(other);
}
+ return false;
+ }
- public override int GetHashCode()
- {
- return _Value.GetHashCode();
- }
+ public override int GetHashCode()
+ {
+ return _Value.GetHashCode();
+ }
- public static bool operator ==(CategoryIndex left, CategoryIndex right)
- {
- return left._Value == right._Value;
- }
+ public static bool operator ==(CategoryIndex left, CategoryIndex right)
+ {
+ return left._Value == right._Value;
+ }
- public static bool operator !=(CategoryIndex left, CategoryIndex right)
- {
- return left._Value != right._Value;
- }
+ public static bool operator !=(CategoryIndex left, CategoryIndex right)
+ {
+ return left._Value != right._Value;
+ }
- public static bool operator <(CategoryIndex left, CategoryIndex right)
- {
- return left._Value < right._Value;
- }
+ public static bool operator <(CategoryIndex left, CategoryIndex right)
+ {
+ return left._Value < right._Value;
+ }
- public static bool operator <=(CategoryIndex left, CategoryIndex right)
- {
- return left._Value <= right._Value;
- }
+ public static bool operator <=(CategoryIndex left, CategoryIndex right)
+ {
+ return left._Value <= right._Value;
+ }
- public static bool operator >(CategoryIndex left, CategoryIndex right)
- {
- return left._Value > right._Value;
- }
+ public static bool operator >(CategoryIndex left, CategoryIndex right)
+ {
+ return left._Value > right._Value;
+ }
- public static bool operator >=(CategoryIndex left, CategoryIndex right)
- {
- return left._Value >= right._Value;
- }
+ public static bool operator >=(CategoryIndex left, CategoryIndex right)
+ {
+ return left._Value >= right._Value;
}
}
+
diff --git a/src/TMG-Framework/Data/CategoryMap.cs b/src/TMG-Framework/Data/CategoryMap.cs
index cd96643..b725a54 100644
--- a/src/TMG-Framework/Data/CategoryMap.cs
+++ b/src/TMG-Framework/Data/CategoryMap.cs
@@ -16,174 +16,168 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
+/// Provides a mapping between categories and provides a method for aggregating
+/// data from the base categories to the destination categories.
+///
+public sealed class CategoryMap
{
///
- /// Provides a mapping between categories and provides a method for aggregating
- /// data from the base categories to the destination categories.
+ /// The categories to start with.
+ ///
+ public Categories Base { get; }
+
+ ///
+ /// The categories to converge the base into.
+ ///
+ public Categories Destination { get; }
+
+ ///
+ /// The mapping between the two category types.
///
- public sealed class CategoryMap
+ private readonly List<(int originFlatIndex, int destinationFlatIndex)> _baseToDestination;
+
+ public static bool CreateCategoryMap(Categories baseCategories, Categories destinationCategories,
+ List<(int originFlatIndex, int destinationFlatIndex)> baseToDestination,
+ [NotNullWhen(true)] out CategoryMap? map,
+ [NotNullWhen(false)] ref string? error)
{
- ///
- /// The categories to start with.
- ///
- public Categories Base { get; }
-
- ///
- /// The categories to converge the base into.
- ///
- public Categories Destination { get; }
-
- ///
- /// The mapping between the two category types.
- ///
- private readonly List<(int originFlatIndex, int destinationFlatIndex)> _baseToDestination;
-
- public static bool CreateCategoryMap(Categories baseCategories, Categories destinationCategories,
- List<(int originFlatIndex, int destinationFlatIndex)> baseToDestination,
- [NotNullWhen(true) ] out CategoryMap? map,
- [NotNullWhen(false)] ref string? error)
+ if (baseCategories == null)
{
- if (baseCategories == null)
- {
- ThrowParameterNull(nameof(baseCategories));
- }
- if (destinationCategories == null)
- {
- ThrowParameterNull(nameof(destinationCategories));
- }
- if (baseToDestination == null)
- {
- ThrowParameterNull(nameof(baseToDestination));
- }
- if (ValidateMapping(baseCategories, destinationCategories, baseToDestination, ref error))
- {
- map = new CategoryMap(baseCategories, destinationCategories, baseToDestination);
- return true;
- }
- map = null;
- return false;
+ ThrowParameterNull(nameof(baseCategories));
}
-
- ///
- /// Given two categories create the mapping between the two.
- ///
- ///
- /// Ensure that all of the indexes exist in the base and destination categories.
- ///
- ///
- /// Aggregate the baseVector data into the destination category system.
- ///
- ///
+ /// Given two categories create the mapping between the two.
+ ///
+ ///
- /// Creates a reverse index of destination category indexes relating them to the list of Base category indexes that they map.
- ///
- /// A reverse index dictionary mapping Destination elements to a list of base category indexes that represent them.
- public Dictionary> CreateReverseIndex()
+ ///
+ /// Ensure that all of the indexes exist in the base and destination categories.
+ ///
+ ///
- /// Creates an index of base category to destination category indexes.
- ///
- /// A dictionary containing the mapping between base CategoryIndex to destination CategoryIndex.
- public Dictionary CreateIndex()
+ ///
+ /// Aggregate the baseVector data into the destination category system.
+ ///
+ ///
+ /// Creates a reverse index of destination category indexes relating them to the list of Base category indexes that they map.
+ ///
+ /// A reverse index dictionary mapping Destination elements to a list of base category indexes that represent them.
+ public Dictionary> CreateReverseIndex()
+ {
+ return _baseToDestination
+ .GroupBy(record => record.destinationFlatIndex)
+ .ToDictionary(group => (CategoryIndex)group.Key, group => group.Select(record => (CategoryIndex)record.originFlatIndex).ToList());
+ }
+
+ ///
+ /// Creates an index of base category to destination category indexes.
+ ///
+ /// A dictionary containing the mapping between base CategoryIndex to destination CategoryIndex.
+ public Dictionary CreateIndex()
+ {
+ return _baseToDestination
+ .ToDictionary(record => (CategoryIndex)record.originFlatIndex, record => (CategoryIndex)record.destinationFlatIndex);
}
}
diff --git a/src/TMG-Framework/Data/Matrix.cs b/src/TMG-Framework/Data/Matrix.cs
index bbe6923..a421160 100644
--- a/src/TMG-Framework/Data/Matrix.cs
+++ b/src/TMG-Framework/Data/Matrix.cs
@@ -16,245 +16,238 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
+/// A 2D representation with categories for rows and columns
+///
+public sealed class Matrix : IDisposable
{
///
- /// A 2D representation with categories for rows and columns
+ /// The categories for the rows.
///
- public sealed class Matrix : IDisposable
- {
- ///
- /// The categories for the rows.
- ///
- public Categories RowCategories { get; }
+ public Categories RowCategories { get; }
- ///
- /// The categories for the columns.
- ///
- public Categories ColumnCategories { get; }
+ ///
+ /// The categories for the columns.
+ ///
+ public Categories ColumnCategories { get; }
- ///
- /// The backend storage for the matrix
- ///
- public Span Data => _backingMemory is null ? ThrowAlreadyDisposed() : _backingMemory.Value.Span;
+ ///
+ /// The backend storage for the matrix
+ ///
+ public Span Data => _backingMemory is null ? ThrowAlreadyDisposed() : _backingMemory.Value.Span;
- [DoesNotReturn]
- private Span ThrowAlreadyDisposed()
- {
- throw new ObjectDisposedException(nameof(Matrix));
- }
+ [DoesNotReturn]
+ private Span ThrowAlreadyDisposed()
+ {
+ throw new ObjectDisposedException(nameof(Matrix));
+ }
- private Memory? _backingMemory;
+ private Memory? _backingMemory;
- ///
- /// Used as a quick lookup for the number of columns per row.
- ///
- private readonly int _rowSpan;
+ ///
+ /// Used as a quick lookup for the number of columns per row.
+ ///
+ private readonly int _rowSpan;
- private IMemoryOwner? _allocator;
+ private IMemoryOwner? _allocator;
- ///
- /// Create a new matrix with the given row and column categories.
- ///
- ///
+ /// Create a new matrix with the given row and column categories.
+ ///
+ ///
- /// Get the number of columns in this matrix.
- ///
- public int NumberOfColumns => ColumnCategories.Count;
+ ///
+ /// Get the number of columns in this matrix.
+ ///
+ public int NumberOfColumns => ColumnCategories.Count;
- ///
- /// Get the number of rows in this matrix.
- ///
- public int NumberOfRows => RowCategories.Count;
+ ///
+ /// Get the number of rows in this matrix.
+ ///
+ public int NumberOfRows => RowCategories.Count;
- ///
- /// Create a new matrix with the given row and column categories.
- ///
- /// ? allocator)
- {
- RowCategories = rowCategories ?? ThrowParameterNull(nameof(rowCategories));
- ColumnCategories = columnCategories ?? ThrowParameterNull(nameof(columnCategories));
- _rowSpan = ColumnCategories.Count;
- var size = RowCategories.Count * ColumnCategories.Count;
- _backingMemory = allocator is null ?
- new float[size].AsMemory()
- : (_allocator = allocator.Rent(size)).Memory[..size];
- }
+ ///
+ /// Create a new matrix with the given row and column categories.
+ ///
+ /// ? allocator)
+ {
+ RowCategories = rowCategories ?? ThrowParameterNull(nameof(rowCategories));
+ ColumnCategories = columnCategories ?? ThrowParameterNull(nameof(columnCategories));
+ _rowSpan = ColumnCategories.Count;
+ var size = RowCategories.Count * ColumnCategories.Count;
+ _backingMemory = allocator is null ?
+ new float[size].AsMemory()
+ : (_allocator = allocator.Rent(size)).Memory[..size];
+ }
- ///
- /// Create a new matrix using the dimensions from the given vector.
- ///
- ///
+ /// Create a new matrix using the dimensions from the given vector.
+ ///
+ /// ? allocator)
+ public Matrix(Vector vector, MemoryPool? allocator)
+ {
+ if (vector is null)
{
- if (vector is null)
- {
- ThrowParameterNull(nameof(vector));
- }
- ColumnCategories = RowCategories = vector.Categories;
- _rowSpan = ColumnCategories.Count;
- var size = RowCategories.Count * ColumnCategories.Count;
- _backingMemory = allocator is null ?
- new float[size].AsMemory() :
- (_allocator = allocator.Rent(size)).Memory[..size];
+ ThrowParameterNull(nameof(vector));
}
+ ColumnCategories = RowCategories = vector.Categories;
+ _rowSpan = ColumnCategories.Count;
+ var size = RowCategories.Count * ColumnCategories.Count;
+ _backingMemory = allocator is null ?
+ new float[size].AsMemory() :
+ (_allocator = allocator.Rent(size)).Memory[..size];
+ }
- ///
- /// Create a new matrix with the dimensions from the provided
- /// matrix.
- ///
- ///
- /// Create a new matrix with the dimensions from the provided
- ///
- /// ? allocator)
- {
- if (matrix is null)
- {
- ThrowParameterNull(nameof(matrix));
- }
- RowCategories = matrix.RowCategories;
- ColumnCategories = matrix.ColumnCategories;
- _rowSpan = matrix._rowSpan;
- var size = RowCategories.Count * ColumnCategories.Count;
- _backingMemory = allocator is null ?
- new float[size].AsMemory() :
- (_allocator = allocator.Rent(size)).Memory[..size];
- }
+ ///
+ /// Create a new matrix with the dimensions from the provided
+ /// matrix.
+ ///
+ ///
- /// Get the row and column for a given flat index into the backend data
- ///
- /// The row and column in sparse space for this flat index.
- [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
- public (CategoryIndex Row, CategoryIndex Column) GetSparseIndex(int flatIndex)
+ ///
+ /// Create a new matrix with the dimensions from the provided
+ ///
+ /// ? allocator)
+ {
+ if (matrix is null)
{
- return (RowCategories.GetSparseIndex(flatIndex / _rowSpan), RowCategories.GetSparseIndex(flatIndex % _rowSpan));
+ ThrowParameterNull(nameof(matrix));
}
+ RowCategories = matrix.RowCategories;
+ ColumnCategories = matrix.ColumnCategories;
+ _rowSpan = matrix._rowSpan;
+ var size = RowCategories.Count * ColumnCategories.Count;
+ _backingMemory = allocator is null ?
+ new float[size].AsMemory() :
+ (_allocator = allocator.Rent(size)).Memory[..size];
+ }
- ///
- /// Get the index in data given the flat row and columns
- ///
- /// The index in data for this data.
- [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
- public int GetFlatIndex(int flatRow, int flatColumn)
- {
- return _rowSpan * flatRow + flatColumn;
- }
+ ///
+ /// Get the row and column for a given flat index into the backend data
+ ///
+ /// The row and column in sparse space for this flat index.
+ [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+ public (CategoryIndex Row, CategoryIndex Column) GetSparseIndex(int flatIndex)
+ {
+ return (RowCategories.GetSparseIndex(flatIndex / _rowSpan), RowCategories.GetSparseIndex(flatIndex % _rowSpan));
+ }
- ///
- /// Get the index in the data for the starting point of a given row
- ///
- ///
+ /// Get the index in data given the flat row and columns
+ ///
+ /// The index in data for this data.
+ [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+ public int GetFlatIndex(int flatRow, int flatColumn)
+ {
+ return _rowSpan * flatRow + flatColumn;
+ }
- ///
- /// Get the index int he data for the starting point given a sparse row
- ///
- /// The index in data for the start of this row
- [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
- public int GetSparseRowIndex(CategoryIndex sparseRow)
- {
- var index = RowCategories.GetFlatIndex(sparseRow);
- return index >= 0 ? index * _rowSpan : -1;
- }
+ ///
+ /// Get the index in the data for the starting point of a given row
+ ///
+ ///
- /// Get a reference to a row in the matrix.
- ///
- /// A reference to the row.
- [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
- public Span GetRow(int flatRowIndex)
- {
- if ((flatRowIndex < 0) | (flatRowIndex > RowCategories.Count))
- {
- ThrowOutOfRangeException(nameof(flatRowIndex));
- }
- flatRowIndex = GetFlatRowIndex(flatRowIndex);
- return Data.Slice(flatRowIndex, _rowSpan);
- }
+ ///
+ /// Get the index int he data for the starting point given a sparse row
+ ///
+ /// The index in data for the start of this row
+ [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+ public int GetSparseRowIndex(CategoryIndex sparseRow)
+ {
+ var index = RowCategories.GetFlatIndex(sparseRow);
+ return index >= 0 ? index * _rowSpan : -1;
+ }
- [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
- public ref float GetFromSparseIndexes(int rowIndex, int columnIndex)
+ ///
+ /// Get a reference to a row in the matrix.
+ ///
+ /// A reference to the row.
+ [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+ public Span GetRow(int flatRowIndex)
+ {
+ if ((flatRowIndex < 0) | (flatRowIndex > RowCategories.Count))
{
- var o = RowCategories.GetFlatIndex(rowIndex);
- var d = ColumnCategories.GetFlatIndex(columnIndex);
- if(o < 0)
- {
- InvalidRow(rowIndex);
- }
- if(d < 0)
- {
- InvalidColumns(columnIndex);
- }
- return ref Data[GetFlatIndex(o,d)];
+ ThrowOutOfRangeException(nameof(flatRowIndex));
}
+ flatRowIndex = GetFlatRowIndex(flatRowIndex);
+ return Data.Slice(flatRowIndex, _rowSpan);
+ }
- ///
- /// Create a copy of this matrix.
- ///
- /// Creates a deep copy of the matrix.
- public Matrix Clone()
+ [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+ public ref float GetFromSparseIndexes(int rowIndex, int columnIndex)
+ {
+ var o = RowCategories.GetFlatIndex(rowIndex);
+ var d = ColumnCategories.GetFlatIndex(columnIndex);
+ if (o < 0)
{
- var ret = new Matrix(this);
- Data.CopyTo(ret.Data);
- return ret;
+ InvalidRow(rowIndex);
}
-
- [MethodImpl(MethodImplOptions.NoInlining)]
- private void InvalidColumns(int columnIndex)
+ if (d < 0)
{
- throw new ArgumentOutOfRangeException($"Invalid column index {columnIndex}!");
+ InvalidColumns(columnIndex);
}
+ return ref Data[GetFlatIndex(o, d)];
+ }
- [MethodImpl(MethodImplOptions.NoInlining)]
- private void InvalidRow(int rowIndex)
- {
- throw new ArgumentOutOfRangeException($"Invalid row index {rowIndex}!");
- }
+ ///
+ /// Create a copy of this matrix.
+ ///
+ /// Creates a deep copy of the matrix.
+ public Matrix Clone()
+ {
+ var ret = new Matrix(this);
+ Data.CopyTo(ret.Data);
+ return ret;
+ }
- ~Matrix()
- {
- Dispose();
- }
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ private void InvalidColumns(int columnIndex)
+ {
+ throw new ArgumentOutOfRangeException($"Invalid column index {columnIndex}!");
+ }
- public void Dispose()
- {
- _backingMemory = null;
- Thread.MemoryBarrier();
- _allocator?.Dispose();
- _allocator = null;
- }
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ private void InvalidRow(int rowIndex)
+ {
+ throw new ArgumentOutOfRangeException($"Invalid row index {rowIndex}!");
+ }
+
+ ~Matrix()
+ {
+ Dispose();
+ }
+
+ public void Dispose()
+ {
+ _backingMemory = null;
+ Thread.MemoryBarrier();
+ _allocator?.Dispose();
+ _allocator = null;
}
}
diff --git a/src/TMG-Framework/Data/Range.cs b/src/TMG-Framework/Data/Range.cs
index a24e783..269180f 100644
--- a/src/TMG-Framework/Data/Range.cs
+++ b/src/TMG-Framework/Data/Range.cs
@@ -16,109 +16,106 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with XTMF. If not, see
- /// Checks if a given value is inside the range defined by [Start, Stop)
- ///
- /// True IFF i is greater than or equal to Start and i is less than Stop.
- public bool Contains(int i)
- {
- return (i >= Start) & (i < Stop);
- }
+ ///
+ /// Checks if a given value is inside the range defined by [Start, Stop)
+ ///
+ /// True IFF i is greater than or equal to Start and i is less than Stop.
+ public bool Contains(int i)
+ {
+ return (i >= Start) & (i < Stop);
+ }
- ///
- /// Checks if a given value is inside the range defined by (Start, Stop)
- ///
- /// True IFF i is less than Start and i is less than Stop.
- public bool ContainsExcusive(int i)
- {
- return (i > Start) & (i < Stop);
- }
+ ///
+ /// Checks if a given value is inside the range defined by (Start, Stop)
+ ///
+ /// True IFF i is less than Start and i is less than Stop.
+ public bool ContainsExcusive(int i)
+ {
+ return (i > Start) & (i < Stop);
+ }
- ///
- /// Checks if a given value is inside the range defined by (Start, Stop)
- ///
- /// True if the value is contained within the range
- public bool ContainsExcusive(float valueToFind)
- {
- return (valueToFind > Start) & (valueToFind < Stop);
- }
+ ///
+ /// Checks if a given value is inside the range defined by (Start, Stop)
+ ///
+ /// True if the value is contained within the range
+ public bool ContainsExcusive(float valueToFind)
+ {
+ return (valueToFind > Start) & (valueToFind < Stop);
+ }
- ///
- /// Checks if a given value is inside the range defined by [Start, Stop]
- ///
- /// True IFF i is greater than or equal to Start and i is less than or equal to Stop.
- public bool ContainsInclusive(int i)
- {
- return (i >= Start) & (i <= Stop);
- }
+ ///
+ /// Checks if a given value is inside the range defined by [Start, Stop]
+ ///
+ /// True IFF i is greater than or equal to Start and i is less than or equal to Stop.
+ public bool ContainsInclusive(int i)
+ {
+ return (i >= Start) & (i <= Stop);
+ }
- ///
- /// Checks if a given value is inside the range defined by [Start, Stop]
- ///
- /// True if the value is contained within the range
- public bool ContainsInclusive(float valueToFind)
- {
- return (valueToFind >= Start) & (valueToFind <= Stop);
- }
+ ///
+ /// Checks if a given value is inside the range defined by [Start, Stop]
+ ///
+ /// True if the value is contained within the range
+ public bool ContainsInclusive(float valueToFind)
+ {
+ return (valueToFind >= Start) & (valueToFind <= Stop);
+ }
- ///
- /// Checks if another Range overlaps this one.
- ///
- ///
+ /// Checks if another Range overlaps this one.
+ ///
+ ///
{
- public sealed class RangeSet : IList
+ private readonly Range[] SetRanges;
+
+ public RangeSet(List tempRange)
{
- private readonly Range[] SetRanges;
+ SetRanges = tempRange.ToArray();
+ }
- public RangeSet(List tempRange)
+ ///
+ /// Creates a new RangeSet with inclusive values from the given integer set
+ ///
+ /// numbers)
+ {
+ if (numbers == null)
{
- SetRanges = tempRange.ToArray();
+ ThrowParameterNull(nameof(numbers));
}
-
- ///
- /// Creates a new RangeSet with inclusive values from the given integer set
- ///
- /// numbers)
+ var array = new int[numbers.Count];
+ numbers.CopyTo(array, 0);
+ Array.Sort(array);
+ var tempRange = new List();
+ var start = 0;
+ for (var i = 1; i < array.Length; i++)
{
- if (numbers == null)
- {
- ThrowParameterNull(nameof(numbers));
- }
- var array = new int[numbers.Count];
- numbers.CopyTo(array, 0);
- Array.Sort(array);
- var tempRange = new List();
- var start = 0;
- for (var i = 1; i < array.Length; i++)
+ if (array[i] > array[i - 1] + 1)
{
- if (array[i] > array[i - 1] + 1)
- {
- tempRange.Add(new Range(array[start], array[i - 1]));
- start = i;
- }
+ tempRange.Add(new Range(array[start], array[i - 1]));
+ start = i;
}
- // and in the end
- tempRange.Add(new Range(array[start], array[array.Length - 1]));
- SetRanges = tempRange.ToArray();
}
+ // and in the end
+ tempRange.Add(new Range(array[start], array[array.Length - 1]));
+ SetRanges = tempRange.ToArray();
+ }
- public int Count => SetRanges.Length;
+ public int Count => SetRanges.Length;
- public bool IsReadOnly => false;
+ public bool IsReadOnly => false;
- public Range this[int index]
- {
- get => SetRanges[index];
- set => SetRanges[index] = value;
- }
+ public Range this[int index]
+ {
+ get => SetRanges[index];
+ set => SetRanges[index] = value;
+ }
- public static bool TryParse(string rangeString, [NotNullWhen(true)] out RangeSet? output)
+ public static bool TryParse(string rangeString, [NotNullWhen(true)] out RangeSet? output)
+ {
+ string? error = null;
+ return TryParse(ref error, rangeString, out output);
+ }
+
+ public static bool TryParse([NotNullWhen(false)] ref string? error,
+ string rangeString,
+ [NotNullWhen(true)] out RangeSet? output)
+ {
+ var tempRange = new List();
+ var length = rangeString.Length;
+ var str = rangeString.ToCharArray();
+ var index = 0;
+ var start = 0;
+ var end = 0;
+ output = null;
+ //Phase == 0 -> index
+ //Phase == 1 -> start
+ //Phase == 2 -> end
+ var phase = 0;
+ var lastPlus = false;
+ var tallyingInZero = false;
+ if (IsNullOrWhiteSpace(rangeString))
{
- string? error = null;
- return TryParse(ref error, rangeString, out output);
+ output = new RangeSet(tempRange);
+ return true;
}
-
- public static bool TryParse([NotNullWhen(false)] ref string? error,
- string rangeString,
- [NotNullWhen(true)] out RangeSet? output)
+ for (var i = 0; i < length; i++)
{
- var tempRange = new List();
- var length = rangeString.Length;
- var str = rangeString.ToCharArray();
- var index = 0;
- var start = 0;
- var end = 0;
- output = null;
- //Phase == 0 -> index
- //Phase == 1 -> start
- //Phase == 2 -> end
- var phase = 0;
- var lastPlus = false;
- var tallyingInZero = false;
- if (IsNullOrWhiteSpace(rangeString))
- {
- output = new RangeSet(tempRange);
- return true;
- }
- for (var i = 0; i < length; i++)
+ var c = str[i];
+ if (IsWhiteSpace(c) || IsLetter(c)) continue;
+ lastPlus = false;
+ switch (phase)
{
- var c = str[i];
- if (IsWhiteSpace(c) || IsLetter(c)) continue;
- lastPlus = false;
- switch (phase)
- {
- case 0:
- if (IsNumber(c))
+ case 0:
+ if (IsNumber(c))
+ {
+ index = ((index << 3) + (index << 1)) + (c - '0');
+ tallyingInZero = true;
+ }
+ else switch (c)
{
- index = ((index << 3) + (index << 1)) + (c - '0');
- tallyingInZero = true;
- }
- else switch (c)
- {
- case ',':
- tempRange.Add(new Range(index, index));
- index = 0;
- start = 0;
- end = 0;
- break;
- case '-':
- if (!tallyingInZero)
- {
- error = "No number was inserted before a range!";
- return false;
- }
- start = index;
- end = 0;
- phase = 2;
- break;
- case '+':
- if (!tallyingInZero)
- {
- error = "No number was inserted before a range!";
- return false;
- }
- end = int.MaxValue;
- tempRange.Add(new Range(start, end));
- index = 0;
- start = 0;
- phase = 0;
- tallyingInZero = false;
- lastPlus = true;
- break;
- default:
- error = "Unrecognized symbol " + c;
+ case ',':
+ tempRange.Add(new Range(index, index));
+ index = 0;
+ start = 0;
+ end = 0;
+ break;
+ case '-':
+ if (!tallyingInZero)
+ {
+ error = "No number was inserted before a range!";
return false;
- }
- break;
- case 1:
- if (IsNumber(c))
- {
- start = ((start << 3) + (start << 1)) + (c - '0');
- }
- else switch (c)
- {
- case '+':
- end = int.MaxValue;
- tempRange.Add(new Range(start, end));
- index = 0;
- start = 0;
- phase = 0;
- tallyingInZero = false;
- lastPlus = true;
- break;
- case '-':
- end = 0;
- phase = 2;
- break;
- }
- break;
- case 2:
- if (IsNumber(c))
- {
- end = ((end << 3) + (end << 1)) + (c - '0');
+ }
+ start = index;
+ end = 0;
+ phase = 2;
+ break;
+ case '+':
+ if (!tallyingInZero)
+ {
+ error = "No number was inserted before a range!";
+ return false;
+ }
+ end = int.MaxValue;
+ tempRange.Add(new Range(start, end));
+ index = 0;
+ start = 0;
+ phase = 0;
+ tallyingInZero = false;
+ lastPlus = true;
+ break;
+ default:
+ error = "Unrecognized symbol " + c;
+ return false;
}
- else if (c == ',')
+ break;
+ case 1:
+ if (IsNumber(c))
+ {
+ start = ((start << 3) + (start << 1)) + (c - '0');
+ }
+ else switch (c)
{
- tempRange.Add(new Range(start, end));
- index = 0;
- phase = 0;
- start = 0;
- end = 0;
- tallyingInZero = false;
+ case '+':
+ end = int.MaxValue;
+ tempRange.Add(new Range(start, end));
+ index = 0;
+ start = 0;
+ phase = 0;
+ tallyingInZero = false;
+ lastPlus = true;
+ break;
+ case '-':
+ end = 0;
+ phase = 2;
+ break;
}
- break;
- }
- }
- if (phase == 2)
- {
- tempRange.Add(new Range(start, end));
- }
- else if (phase == 0 && tallyingInZero)
- {
- tempRange.Add(new Range(index, index));
- }
- else if (!lastPlus)
- {
- error = "Ended while reading a " + (phase == 0 ? "range's index!" : "range's start value!");
- return false;
+ break;
+ case 2:
+ if (IsNumber(c))
+ {
+ end = ((end << 3) + (end << 1)) + (c - '0');
+ }
+ else if (c == ',')
+ {
+ tempRange.Add(new Range(start, end));
+ index = 0;
+ phase = 0;
+ start = 0;
+ end = 0;
+ tallyingInZero = false;
+ }
+ break;
}
- output = new RangeSet(tempRange);
- return true;
}
+ if (phase == 2)
+ {
+ tempRange.Add(new Range(start, end));
+ }
+ else if (phase == 0 && tallyingInZero)
+ {
+ tempRange.Add(new Range(index, index));
+ }
+ else if (!lastPlus)
+ {
+ error = "Ended while reading a " + (phase == 0 ? "range's index!" : "range's start value!");
+ return false;
+ }
+ output = new RangeSet(tempRange);
+ return true;
+ }
- public void Add(Range item) => throw new InvalidOperationException("Unable to add items");
+ public void Add(Range item) => throw new InvalidOperationException("Unable to add items");
- public void Clear() => throw new InvalidOperationException("Unable to remove items");
+ public void Clear() => throw new InvalidOperationException("Unable to remove items");
- public bool Contains(Range item) => IndexOf(item) != -1;
+ public bool Contains(Range item) => IndexOf(item) != -1;
- public bool Contains(float value) => IndexOf(value) != -1;
+ public bool Contains(float value) => IndexOf(value) != -1;
- public bool Contains(int number)
+ public bool Contains(int number)
+ {
+ for (var i = 0; i < SetRanges.Length; i++)
{
- for (var i = 0; i < SetRanges.Length; i++)
+ if ((number >= SetRanges[i].Start) && (number <= SetRanges[i].Stop))
{
- if ((number >= SetRanges[i].Start) && (number <= SetRanges[i].Stop))
- {
- return true;
- }
+ return true;
}
- return false;
}
+ return false;
+ }
- public void CopyTo(Range[] array, int arrayIndex)
+ public void CopyTo(Range[] array, int arrayIndex)
+ {
+ for (var i = 0; i < SetRanges.Length; i++)
{
- for (var i = 0; i < SetRanges.Length; i++)
- {
- array[arrayIndex + i] = SetRanges[i];
- }
+ array[arrayIndex + i] = SetRanges[i];
}
+ }
- public override bool Equals(object? obj)
+ public override bool Equals(object? obj)
+ {
+ var other = obj as RangeSet;
+ if (other?.Count != Count) return false;
+ for (var i = 0; i < SetRanges.Length; i++)
{
- var other = obj as RangeSet;
- if (other?.Count != Count) return false;
- for (var i = 0; i < SetRanges.Length; i++)
+ if (!(SetRanges[i] == other[i]))
{
- if (!(SetRanges[i] == other[i]))
- {
- return false;
- }
+ return false;
}
- return true;
}
+ return true;
+ }
- public IEnumerator GetEnumerator() => ((ICollection)SetRanges).GetEnumerator();
+ public IEnumerator GetEnumerator() => ((ICollection)SetRanges).GetEnumerator();
- public override int GetHashCode()
+ public override int GetHashCode()
+ {
+ var hash = 0;
+ for (var i = 0; i < SetRanges.Length; i++)
{
- var hash = 0;
- for (var i = 0; i < SetRanges.Length; i++)
- {
- hash += SetRanges.GetHashCode();
- }
- return hash;
+ hash += SetRanges.GetHashCode();
}
+ return hash;
+ }
- public int IndexOf(Range item)
+ public int IndexOf(Range item)
+ {
+ for (var i = 0; i < SetRanges.Length; i++)
{
- for (var i = 0; i < SetRanges.Length; i++)
+ if (SetRanges[i] == item)
{
- if (SetRanges[i] == item)
- {
- return i;
- }
+ return i;
}
- return -1;
}
+ return -1;
+ }
- ///
- /// Gives the index in the range set where this integer is first contained.
- ///
- /// -1 if not found, otherwise the index of the Range in the rangeset that first contains this integer
- public int IndexOf(int integerToFind)
+ ///
+ /// Gives the index in the range set where this integer is first contained.
+ ///
+ /// -1 if not found, otherwise the index of the Range in the rangeset that first contains this integer
+ public int IndexOf(int integerToFind)
+ {
+ for (var i = 0; i < SetRanges.Length; i++)
{
- for (var i = 0; i < SetRanges.Length; i++)
+ if (SetRanges[i].ContainsInclusive(integerToFind))
{
- if (SetRanges[i].ContainsInclusive(integerToFind))
- {
- return i;
- }
+ return i;
}
- return -1;
}
+ return -1;
+ }
- ///
- /// Gives the index in the range set where this integer is first contained.
- ///
- /// The index of the range that contains the value, -1 otherwise.
- public int IndexOf(float valueToFind)
+ ///
+ /// Gives the index in the range set where this integer is first contained.
+ ///
+ /// The index of the range that contains the value, -1 otherwise.
+ public int IndexOf(float valueToFind)
+ {
+ for (var i = 0; i < SetRanges.Length; i++)
{
- for (var i = 0; i < SetRanges.Length; i++)
+ if (SetRanges[i].ContainsInclusive(valueToFind))
{
- if (SetRanges[i].ContainsInclusive(valueToFind))
- {
- return i;
- }
+ return i;
}
- return -1;
}
+ return -1;
+ }
- public void Insert(int index, Range item)
- {
- this[index] = item;
- }
+ public void Insert(int index, Range item)
+ {
+ this[index] = item;
+ }
- public bool Overlaps(Range other)
+ public bool Overlaps(Range other)
+ {
+ for (var i = 0; i < SetRanges.Length; i++)
{
- for (var i = 0; i < SetRanges.Length; i++)
+ if (SetRanges[i].Contains(other.Start) || SetRanges[i].Contains(other.Stop))
{
- if (SetRanges[i].Contains(other.Start) || SetRanges[i].Contains(other.Stop))
- {
- return true;
- }
+ return true;
}
- return false;
}
+ return false;
+ }
- public bool Overlaps(RangeSet other)
+ public bool Overlaps(RangeSet other)
+ {
+ for (var i = 0; i < SetRanges.Length; i++)
{
- for (var i = 0; i < SetRanges.Length; i++)
+ for (var j = 0; j < other.SetRanges.Length; j++)
{
- for (var j = 0; j < other.SetRanges.Length; j++)
+ if (SetRanges[i].Contains(other.SetRanges[j].Start) || SetRanges[i].Contains(other.SetRanges[j].Stop))
{
- if (SetRanges[i].Contains(other.SetRanges[j].Start) || SetRanges[i].Contains(other.SetRanges[j].Stop))
- {
- return true;
- }
+ return true;
}
}
- return false;
}
+ return false;
+ }
- public bool Remove(Range item) => throw new InvalidOperationException("Unable to remove items");
+ public bool Remove(Range item) => throw new InvalidOperationException("Unable to remove items");
- public void RemoveAt(int index) => throw new InvalidOperationException("Unable to remove items");
+ public void RemoveAt(int index) => throw new InvalidOperationException("Unable to remove items");
- System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => SetRanges.GetEnumerator();
+ System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => SetRanges.GetEnumerator();
- public override string ToString()
+ public override string ToString()
+ {
+ var builder = new StringBuilder();
+ var first = true;
+ if (SetRanges.Length == 0)
{
- var builder = new StringBuilder();
- var first = true;
- if (SetRanges.Length == 0)
- {
- // do nothing we already have a blank builder
- }
- else
+ // do nothing we already have a blank builder
+ }
+ else
+ {
+ foreach (var res in SetRanges)
{
- foreach (var res in SetRanges)
+ if (!first)
{
- if (!first)
- {
- builder.Append(',');
- }
- if (res.Start != res.Stop)
- {
- builder.Append(res.Start);
- builder.Append('-');
- builder.Append(res.Stop);
- }
- else
- {
- builder.Append(res.Start);
- }
- first = false;
+ builder.Append(',');
+ }
+ if (res.Start != res.Stop)
+ {
+ builder.Append(res.Start);
+ builder.Append('-');
+ builder.Append(res.Stop);
+ }
+ else
+ {
+ builder.Append(res.Start);
}
+ first = false;
}
- return builder.ToString();
}
+ return builder.ToString();
}
-}
\ No newline at end of file
+}
diff --git a/src/TMG-Framework/Data/RangeSetSet.cs b/src/TMG-Framework/Data/RangeSetSet.cs
index c99094a..336b556 100644
--- a/src/TMG-Framework/Data/RangeSetSet.cs
+++ b/src/TMG-Framework/Data/RangeSetSet.cs
@@ -16,227 +16,222 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with XTMF. If not, see
{
- public sealed class RangeSetSet : IList
+ private readonly RangeSet[] RangeSets;
+
+ public RangeSetSet(List tempRange)
{
- private readonly RangeSet[] RangeSets;
+ RangeSets = tempRange.ToArray();
+ }
- public RangeSetSet(List tempRange)
- {
- RangeSets = tempRange.ToArray();
- }
+ public int Count => RangeSets.Length;
- public int Count => RangeSets.Length;
+ public bool IsReadOnly => false;
- public bool IsReadOnly => false;
+ public RangeSet this[int index]
+ {
+ get => RangeSets[index];
+ set => RangeSets[index] = value;
+ }
- public RangeSet this[int index]
- {
- get => RangeSets[index];
- set => RangeSets[index] = value;
- }
+ public static bool TryParse(string rangeString, [NotNullWhen(true)] out RangeSetSet? output)
+ {
+ string? error = null;
+ return TryParse(ref error, rangeString, out output);
+ }
- public static bool TryParse(string rangeString, [NotNullWhen(true)] out RangeSetSet? output)
+ public static bool TryParse([NotNullWhen(false)] ref string? error,
+ string rangeString,
+ [NotNullWhen(true)] out RangeSetSet? output)
+ {
+ if (rangeString == null)
{
- string? error = null;
- return TryParse(ref error, rangeString, out output);
+ ThrowParameterNull(nameof(rangeString));
}
- public static bool TryParse([NotNullWhen(false)] ref string? error,
- string rangeString,
- [NotNullWhen(true)] out RangeSetSet? output)
+ var rangeSets = new List();
+ output = null;
+ var strLength = rangeString.Length;
+ int startPos;
+ for (startPos = 0; startPos < strLength; startPos++)
{
- if (rangeString == null)
- {
- ThrowParameterNull(nameof(rangeString));
- }
-
- var rangeSets = new List();
- output = null;
- var strLength = rangeString.Length;
- int startPos;
- for (startPos = 0; startPos < strLength; startPos++)
+ if (rangeString[startPos] == '{')
{
- if (rangeString[startPos] == '{')
+ var success = false;
+ for (var endPos = startPos + 1; endPos < strLength; endPos++)
{
- var success = false;
- for (var endPos = startPos + 1; endPos < strLength; endPos++)
+ if (rangeString[endPos] == '}')
{
- if (rangeString[endPos] == '}')
+ if (!RangeSet.TryParse(ref error, rangeString.Substring(startPos + 1, endPos - startPos - 1), out RangeSet? temp))
{
- if (!RangeSet.TryParse(ref error, rangeString.Substring(startPos + 1, endPos - startPos - 1), out RangeSet? temp))
- {
- return false;
- }
- rangeSets.Add(temp);
- startPos = endPos; // the increment will make sure we don't re explore this
- success = true;
- break;
+ return false;
}
- }
- if (!success)
- {
- error = "There was an unmatched '{' at position " + startPos;
- return false;
+ rangeSets.Add(temp);
+ startPos = endPos; // the increment will make sure we don't re explore this
+ success = true;
+ break;
}
}
- }
- // in case it is a set of 1 element
- if (rangeSets.Count == 0)
- {
- if (!RangeSet.TryParse(ref error, rangeString, out RangeSet? temp))
+ if (!success)
{
+ error = "There was an unmatched '{' at position " + startPos;
return false;
}
- rangeSets.Add(temp);
}
- output = new RangeSetSet(rangeSets);
- return true;
}
+ // in case it is a set of 1 element
+ if (rangeSets.Count == 0)
+ {
+ if (!RangeSet.TryParse(ref error, rangeString, out RangeSet? temp))
+ {
+ return false;
+ }
+ rangeSets.Add(temp);
+ }
+ output = new RangeSetSet(rangeSets);
+ return true;
+ }
- ///
- /// Not Supported
- ///
- ///
+ /// Not Supported
+ ///
+ ///
- /// Not Supported
- ///
- public void Clear() => throw new NotSupportedException();
+ ///
+ /// Not Supported
+ ///
+ public void Clear() => throw new NotSupportedException();
- public bool Contains(RangeSet item) => IndexOf(item) != -1;
+ public bool Contains(RangeSet item) => IndexOf(item) != -1;
- public void CopyTo(RangeSet[] array, int arrayIndex)
+ public void CopyTo(RangeSet[] array, int arrayIndex)
+ {
+ var localRangeSets = RangeSets;
+ if (localRangeSets.Length + arrayIndex >= array.Length)
{
- var localRangeSets = RangeSets;
- if (localRangeSets.Length + arrayIndex >= array.Length)
- {
- throw new ArgumentException("The given array is not long enough to support copying starting at index " + arrayIndex);
- }
- if (arrayIndex < 0)
- {
- throw new ArgumentOutOfRangeException("arrayIndex", "This argument must be greater than or equal to zero!");
- }
- for (var i = 0; i < localRangeSets.Length; i++)
- {
- array[i + arrayIndex] = localRangeSets[i];
- }
+ throw new ArgumentException("The given array is not long enough to support copying starting at index " + arrayIndex);
+ }
+ if (arrayIndex < 0)
+ {
+ throw new ArgumentOutOfRangeException("arrayIndex", "This argument must be greater than or equal to zero!");
+ }
+ for (var i = 0; i < localRangeSets.Length; i++)
+ {
+ array[i + arrayIndex] = localRangeSets[i];
}
+ }
- public override bool Equals(object? obj)
+ public override bool Equals(object? obj)
+ {
+ var other = obj as RangeSetSet;
+ if (Count != other?.Count) return false;
+ for (var i = 0; i < RangeSets.Length; i++)
{
- var other = obj as RangeSetSet;
- if (Count != other?.Count) return false;
- for (var i = 0; i < RangeSets.Length; i++)
+ if (!RangeSets[i].Equals(other.RangeSets[i]))
{
- if (!RangeSets[i].Equals(other.RangeSets[i]))
- {
- return false;
- }
+ return false;
}
- return true;
}
+ return true;
+ }
- public IEnumerator GetEnumerator() => ((ICollection)RangeSets).GetEnumerator();
+ public IEnumerator GetEnumerator() => ((ICollection)RangeSets).GetEnumerator();
- public override int GetHashCode()
+ public override int GetHashCode()
+ {
+ var hash = 0;
+ for (var i = 0; i < RangeSets.Length; i++)
{
- var hash = 0;
- for (var i = 0; i < RangeSets.Length; i++)
- {
- hash += RangeSets[i].GetHashCode();
- }
- return hash;
+ hash += RangeSets[i].GetHashCode();
}
+ return hash;
+ }
- public int IndexOf(RangeSet item)
+ public int IndexOf(RangeSet item)
+ {
+ if (item == null)
{
- if (item == null)
- {
- ThrowParameterNull(nameof(item));
- }
- for (var i = 0; i < RangeSets.Length; i++)
+ ThrowParameterNull(nameof(item));
+ }
+ for (var i = 0; i < RangeSets.Length; i++)
+ {
+ if (item.Equals(RangeSets[i]))
{
- if (item.Equals(RangeSets[i]))
- {
- return i;
- }
+ return i;
}
- return -1;
}
+ return -1;
+ }
- public int IndexOf(int numberToFind)
+ public int IndexOf(int numberToFind)
+ {
+ for (var i = 0; i < RangeSets.Length; i++)
{
- for (var i = 0; i < RangeSets.Length; i++)
+ if (RangeSets[i].Contains(numberToFind))
{
- if (RangeSets[i].Contains(numberToFind))
- {
- return i;
- }
+ return i;
}
- return -1;
}
+ return -1;
+ }
- ///
- /// Returns the first set that contains a range that contains the value.
- ///
- /// The index of the set that first contains the value, -1 otherwise.
- public int IndexOf(float value)
+ ///
+ /// Returns the first set that contains a range that contains the value.
+ ///
+ /// The index of the set that first contains the value, -1 otherwise.
+ public int IndexOf(float value)
+ {
+ for (var i = 0; i < RangeSets.Length; i++)
{
- for (var i = 0; i < RangeSets.Length; i++)
+ if (RangeSets[i].Contains(value))
{
- if (RangeSets[i].Contains(value))
- {
- return i;
- }
+ return i;
}
- return -1;
}
+ return -1;
+ }
- ///
- /// Not Supported
- ///
- ///
+ /// Not Supported
+ ///
+ ///
- /// Not Supported
- ///
- public void RemoveAt(int index) => throw new NotSupportedException();
+ ///
+ /// Not Supported
+ ///
+ public void RemoveAt(int index) => throw new NotSupportedException();
- System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
- {
- return RangeSets.GetEnumerator();
- }
+ System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+ {
+ return RangeSets.GetEnumerator();
+ }
- public override string ToString()
+ public override string ToString()
+ {
+ var builder = new StringBuilder();
+ var first = true;
+ for (var i = 0; i < RangeSets.Length; i++)
{
- var builder = new StringBuilder();
- var first = true;
- for (var i = 0; i < RangeSets.Length; i++)
+ if (!first)
{
- if (!first)
- {
- builder.Append(',');
- }
- first = false;
- builder.Append('{');
- builder.Append(RangeSets[i]);
- builder.Append('}');
+ builder.Append(',');
}
- return builder.ToString();
+ first = false;
+ builder.Append('{');
+ builder.Append(RangeSets[i]);
+ builder.Append('}');
}
+ return builder.ToString();
}
-}
\ No newline at end of file
+}
diff --git a/src/TMG-Framework/Data/Time.cs b/src/TMG-Framework/Data/Time.cs
index 1fe76a6..ef7a94f 100644
--- a/src/TMG-Framework/Data/Time.cs
+++ b/src/TMG-Framework/Data/Time.cs
@@ -16,524 +16,494 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with XTMF. If not, see
+/// Simple Time Struct for holding simple time data.
+///
+public struct Time : IComparable
{
///
- /// Simple Time Struct for holding simple time data.
+ /// Our internal representation, to the millisecond
///
- public struct Time : IComparable
- {
- public static Time EndOfDay = new Time() { Hours = 28 };
+ private long _internalTime;
- public static Time OneQuantum;
-
- public static Time StartOfDay = new Time() { Hours = 4 };
+ ///
+ /// Converts the given float time in format HH.MM to
+ /// this class representation
+ ///
+ ///
- /// Our internal representation, to the millisecond
- ///
- private long _internalTime;
+ public Time(DateTime time)
+ {
+ var hours = time.Hour;
+ var minutes = time.Minute;
+ var seconds = time.Second;
+ var milliseconds = time.Millisecond;
+ var hourToMilliseconds = hours * 3600000L;
+ var minuteToMilliseconds = minutes * 60000L;
+ var secondToMilliseconds = seconds * 1000L;
+ _internalTime = (hourToMilliseconds + minuteToMilliseconds) + (secondToMilliseconds + milliseconds);
+ }
- ///
- /// Converts the given float time in format HH.MM to
- /// this class representation
- ///
- ///
+ /// Creates a TashaTime given the string representation
+ /// Example 4:25:00 4 hours 25 minutes and 0 seconds
+ ///
+ ///
- /// Creates a TashaTime given the string representation
- /// Example 4:25:00 4 hours 25 minutes and 0 seconds
- ///
- ///
+ /// The number of Hours this Time Object represents
+ ///
+ public int Hours
+ {
+ get => (int)(_internalTime / 3600000L);
+ set => _internalTime = (_internalTime % 3600000L + (value * 3600000L));
+ }
- public static Time Zero { get; } = new Time();
+ ///
+ ///
+ ///
+ public int Minutes
+ {
+ get => (int)((_internalTime / 60000L) % 60L);
+ set => _internalTime = _internalTime - ((_internalTime / 60000L) % 60L) + (value * 60000L);
+ }
- ///
- /// The number of Hours this Time Object represents
- ///
- public int Hours
+ ///
+ /// The number of seconds this Time Object Represents
+ ///
+ public int Seconds
+ {
+ get => (int)((_internalTime / 1000L) % 60L);
+ set
{
- get => (int)(_internalTime / 3600000L);
- set => _internalTime = (_internalTime % 3600000L + (value * 3600000L));
+ var temp = _internalTime / 1000L;
+ _internalTime = ((temp - temp % 60L) + value) * 1000L;
}
+ }
- ///
- ///
- ///
- public int Minutes
- {
- get => (int)((_internalTime / 60000L) % 60L);
- set => _internalTime = _internalTime - ((_internalTime / 60000L) % 60L) + (value * 60000L);
- }
+ public static Time FromMinutes(float result) => new Time() { _internalTime = (long)(result * 60000.0f) };
- ///
- /// The number of seconds this Time Object Represents
- ///
- public int Seconds
- {
- get => (int)((_internalTime / 1000L) % 60L);
- set
- {
- var temp = _internalTime / 1000L;
- _internalTime = ((temp - temp % 60L) + value) * 1000L;
- }
- }
+ public static implicit operator DateTime(Time t) => new DateTime(0, 0, 0, t.Hours, t.Minutes, t.Seconds, 0);
- public static Time FromMinutes(float result) => new Time() { _internalTime = (long)(result * 60000.0f) };
+ public static implicit operator Time(DateTime t) => new Time(t);
- public static implicit operator DateTime(Time t) => new DateTime(0, 0, 0, t.Hours, t.Minutes, t.Seconds, 0);
+ public static bool Intersection(Time start1, Time end1, Time start2, Time end2) => !((end1._internalTime < start2._internalTime)
+ | (end2._internalTime < start1._internalTime));
- public static implicit operator Time(DateTime t) => new Time(t);
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static bool Intersection(Time start1, Time end1, Time start2, Time end2, out Time intersection)
+ {
+ var intersectionStart = Math.Max(start1._internalTime, start2._internalTime);
+ var intersectionEnd = Math.Min(end1._internalTime, end2._internalTime);
+ var intersectionDuration = intersectionEnd - intersectionStart;
+ var mask = ~(intersectionDuration >> 63);
- public static bool Intersection(Time start1, Time end1, Time start2, Time end2) => !((end1._internalTime < start2._internalTime)
- | (end2._internalTime < start1._internalTime));
+ intersection._internalTime = intersectionDuration & mask;
+ return mask != 0L;
+ }
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- public static bool Intersection(Time start1, Time end1, Time start2, Time end2, out Time intersection)
- {
- if ((end1._internalTime < start2._internalTime)
- | (end2._internalTime < start1._internalTime))
- {
- intersection = new Time();
- return false;
- }
- // passenger is first
- if (start1._internalTime <= start2._internalTime)
- {
- intersection._internalTime =
- (end1._internalTime >= end2._internalTime) ? end2._internalTime - start2._internalTime : end1._internalTime - start2._internalTime;
- return true;
- }
- else
- {
- // passenger is second
- intersection._internalTime =
- (end1._internalTime >= end2._internalTime) ? end2._internalTime - start1._internalTime : end1._internalTime - start1._internalTime;
- return true;
- }
- }
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static bool Intersection(Time start1, Time end1, Time start2, Time end2, out Time intersectionStart, out Time intersectionEnd)
+ {
+ var start = Math.Max(start1._internalTime, start2._internalTime);
+ var end = Math.Min(end1._internalTime, end2._internalTime);
+ var mask = ~((end - start) >> 63);
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- public static bool Intersection(Time start1, Time end1, Time start2, Time end2, out Time intersectionStart, out Time intersectionEnd)
- {
- if (end1._internalTime < start2._internalTime
- || end2._internalTime < start1._internalTime)
- {
- intersectionStart = new Time();
- intersectionEnd = new Time();
- return false;
- }
- // passenger is first
- if (start1._internalTime <= start2._internalTime)
- {
- intersectionStart._internalTime = start2._internalTime;
- intersectionEnd._internalTime = (end1._internalTime >= end2._internalTime) ? end2._internalTime : end1._internalTime;
- return true;
- }
- else
- {
- // passenger is second
- intersectionStart._internalTime = start1._internalTime;
- intersectionEnd._internalTime = (end1._internalTime >= end2._internalTime) ? end2._internalTime : end1._internalTime;
- return true;
- }
- }
+ intersectionStart._internalTime = start & mask;
+ intersectionEnd._internalTime = end & mask;
+ return mask != 0L;
+ }
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
- ///
+ ///
+ ///
+ ///
- ///
- ///
- ///
+ ///
+ ///
+ ///
+/// This class represents an identified range of time [Start, End).
+///
+public struct TimePeriod
{
///
- /// This class represents an identified range of time [Start, End).
+ /// The start of the time period
+ ///
+ public Time Start { get; private set; }
+
+ ///
+ /// The end of the time period
+ ///
+ public Time End { get; private set; }
+
+ ///
+ /// Construct a time period from the given times.
///
- public struct TimePeriod
+ ///
- /// The start of the time period
- ///
- public Time Start { get; private set; }
-
- ///
- /// The end of the time period
- ///
- public Time End { get; private set; }
-
- ///
- /// Construct a time period from the given times.
- ///
- ///
- /// Is the given time within this time period.
- ///
- /// True if it is in the time period, false otherwise.
- public bool Contains(Time time) => (Start <= time) & (time < End);
+ Start = start;
+ End = end;
}
+
+ ///
+ /// Is the given time within this time period.
+ ///
+ /// True if it is in the time period, false otherwise.
+ public bool Contains(Time time) => (Start <= time) & (time < End);
}
diff --git a/src/TMG-Framework/Data/Vector.cs b/src/TMG-Framework/Data/Vector.cs
index 10d753b..4fbd10d 100644
--- a/src/TMG-Framework/Data/Vector.cs
+++ b/src/TMG-Framework/Data/Vector.cs
@@ -16,118 +16,117 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
+/// Represents a single dimension floating point data storage with a given shape.
+///
+public sealed class Vector : IDisposable
{
///
- /// Represents a single dimension floating point data storage with a given shape.
+ /// The categories that shape this vector.
///
- public sealed class Vector : IDisposable
- {
- ///
- /// The categories that shape this vector.
- ///
- public Categories Categories { get; }
+ public Categories Categories { get; }
- ///
- /// The backing data for this vector.
- ///
- public Span Data => _backingMemory is null ? ThrowAlreadyDisposed() : _backingMemory.Value.Span;
+ ///
+ /// The backing data for this vector.
+ ///
+ public Span Data => _backingMemory is null ? ThrowAlreadyDisposed() : _backingMemory.Value.Span;
- private Span ThrowAlreadyDisposed()
- {
- throw new ObjectDisposedException(nameof(Vector));
- }
+ private Span ThrowAlreadyDisposed()
+ {
+ throw new ObjectDisposedException(nameof(Vector));
+ }
- public void Dispose()
- {
- _backingMemory = default;
- Thread.MemoryBarrier();
- _allocator?.Dispose();
- _allocator = null;
- }
+ public void Dispose()
+ {
+ _backingMemory = default;
+ Thread.MemoryBarrier();
+ _allocator?.Dispose();
+ _allocator = null;
+ }
- ~Vector()
- {
- Dispose();
- }
+ ~Vector()
+ {
+ Dispose();
+ }
- private Memory? _backingMemory;
+ private Memory? _backingMemory;
- private IMemoryOwner? _allocator;
+ private IMemoryOwner? _allocator;
+
+ ///
+ /// Create a new vector given the shape of the categories.
+ ///
+ ///
- /// Create a new vector given the shape of the categories.
- ///
- ///
- /// Create a new vector given the shape of the categories and an optional memory allocator.
- ///
- /// ? allocator)
+ ///
+ /// Create a new vector given the shape of the categories and an optional memory allocator.
+ ///
+ /// ? allocator)
+ {
+ if (categories == null)
{
- if(categories == null)
- {
- ThrowParameterNull(nameof(categories));
- }
- Categories = categories;
- _allocator = allocator?.Rent(Categories.Count);
- _backingMemory = _allocator?.Memory ?? new float[Categories.Count];
+ ThrowParameterNull(nameof(categories));
}
+ Categories = categories;
+ _allocator = allocator?.Rent(Categories.Count);
+ _backingMemory = _allocator?.Memory ?? new float[Categories.Count];
+ }
+
+ ///
+ /// Create a new vector given the shape of the given vector.
+ /// This will not create a clone of the given vector.
+ ///
+ ///
- /// Create a new vector given the shape of the given vector.
- /// This will not create a clone of the given vector.
- ///
- ///
- /// Create a new vector given the shape of the given vector and an optional memory allocator.
- ///
- /// ? allocator)
+ ///
+ /// Create a new vector given the shape of the given vector and an optional memory allocator.
+ ///
+ /// ? allocator)
+ {
+ if (vector == null)
{
- if(vector == null)
- {
- ThrowParameterNull(nameof(vector));
- }
- Categories = vector.Categories;
- _allocator = allocator?.Rent(Categories.Count);
- _backingMemory = _allocator?.Memory ?? new float[Categories.Count];
+ ThrowParameterNull(nameof(vector));
}
+ Categories = vector.Categories;
+ _allocator = allocator?.Rent(Categories.Count);
+ _backingMemory = _allocator?.Memory ?? new float[Categories.Count];
+ }
- public float this[CategoryIndex sparseIndex]
+ public float this[CategoryIndex sparseIndex]
+ {
+ get
{
- get
- {
- var index = Categories.GetFlatIndex(sparseIndex);
- return index >= 0 ? Data[index] : 0.0f;
- }
- set
+ var index = Categories.GetFlatIndex(sparseIndex);
+ return index >= 0 ? Data[index] : 0.0f;
+ }
+ set
+ {
+ var index = Categories.GetFlatIndex(sparseIndex);
+ if (index >= 0)
{
- var index = Categories.GetFlatIndex(sparseIndex);
- if (index >= 0)
- {
- Data[index] = value;
- }
- ThrowOutOfRangeException(nameof(sparseIndex));
+ Data[index] = value;
}
+ ThrowOutOfRangeException(nameof(sparseIndex));
}
-
- ///
- /// The number of records contained in this vector.
- ///
- /// The number of elements.
- public int Count => _backingMemory?.Length ?? 0;
}
+
+ ///
+ /// The number of records contained in this vector.
+ ///
+ /// The number of elements.
+ public int Count => _backingMemory?.Length ?? 0;
}
+
diff --git a/src/TMG-Framework/FileOperations/CopyFile.cs b/src/TMG-Framework/FileOperations/CopyFile.cs
index 92e40a5..069186d 100644
--- a/src/TMG-Framework/FileOperations/CopyFile.cs
+++ b/src/TMG-Framework/FileOperations/CopyFile.cs
@@ -16,95 +16,89 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see Origin = null!;
+ [Parameter(DefaultValue = "", Name = "Origin", Index = 0, Description = "The path to the file/directory to copy.")]
+ public IFunction Origin = null!;
- [Parameter(DefaultValue = "", Name = "Destination", Index = 1, Description = "The path to the file/directory to copy into.")]
- public IFunction Destination = null!;
+ [Parameter(DefaultValue = "", Name = "Destination", Index = 1, Description = "The path to the file/directory to copy into.")]
+ public IFunction Destination = null!;
- [Parameter(DefaultValue = "False", Name = "Move", Index = 2, Description = "Should the origin be erased after the file is copied?")]
- public IFunction Move = null!;
+ [Parameter(DefaultValue = "False", Name = "Move", Index = 2, Description = "Should the origin be erased after the file is copied?")]
+ public IFunction Move = null!;
- public override void Invoke()
+ public override void Invoke()
+ {
+ var oInfo = new FileInfo(Origin.Invoke());
+ var dInfo = new FileInfo(Destination.Invoke());
+ var move = Move.Invoke();
+ if (!oInfo.Exists)
{
- var oInfo = new FileInfo(Origin.Invoke());
- var dInfo = new FileInfo(Destination.Invoke());
- var move = Move.Invoke();
- if(!oInfo.Exists)
+ throw new XTMFRuntimeException(this, $"There is no file at the path {oInfo.FullName}!");
+ }
+ var originIsDir = oInfo.Attributes.HasFlag(FileAttributes.Directory);
+ var destIsDir = dInfo.Attributes.HasFlag(FileAttributes.Directory);
+ if (originIsDir)
+ {
+ if (!destIsDir)
{
- throw new XTMFRuntimeException(this, $"There is no file at the path {oInfo.FullName}!");
+ throw new XTMFRuntimeException(this, $"The path {dInfo.FullName} is not a directory where are the source {oInfo.FullName} is!");
}
- var originIsDir = oInfo.Attributes.HasFlag(FileAttributes.Directory);
- var destIsDir = dInfo.Attributes.HasFlag(FileAttributes.Directory);
- if (originIsDir)
+ // copy the directories
+ DirectoryCopy(oInfo.FullName, dInfo.FullName);
+ Directory.Delete(oInfo.FullName);
+ }
+ else
+ {
+ if (destIsDir)
{
- if(!destIsDir)
- {
- throw new XTMFRuntimeException(this, $"The path {dInfo.FullName} is not a directory where are the source {oInfo.FullName} is!");
- }
- // copy the directories
- DirectoryCopy(oInfo.FullName, dInfo.FullName);
- Directory.Delete(oInfo.FullName);
+ oInfo.CopyTo(dInfo.FullName, true);
}
else
{
- if(destIsDir)
- {
- oInfo.CopyTo(dInfo.FullName, true);
- }
- else
- {
- var directory = dInfo.Directory ??
- throw new XTMFRuntimeException(this, $"The path {dInfo.FullName} does not have a valid parent directory!");
- oInfo.CopyTo(directory.FullName, true);
- }
+ var directory = dInfo.Directory ??
+ throw new XTMFRuntimeException(this, $"The path {dInfo.FullName} does not have a valid parent directory!");
+ oInfo.CopyTo(directory.FullName, true);
}
}
+ }
- private static void DirectoryCopy(string sourceDirectory, string destinationDirectory)
+ private static void DirectoryCopy(string sourceDirectory, string destinationDirectory)
+ {
+ // Get the subdirectories for the specified directory.
+ DirectoryInfo dir = new DirectoryInfo(sourceDirectory);
+ DirectoryInfo[] dirs = dir.GetDirectories();
+ if (!dir.Exists)
{
- // Get the subdirectories for the specified directory.
- DirectoryInfo dir = new DirectoryInfo(sourceDirectory);
- DirectoryInfo[] dirs = dir.GetDirectories();
- if (!dir.Exists)
- {
- throw new DirectoryNotFoundException(
- "Source directory does not exist or could not be found: "
- + sourceDirectory);
- }
+ throw new DirectoryNotFoundException(
+ "Source directory does not exist or could not be found: "
+ + sourceDirectory);
+ }
- // If the destination directory doesn't exist, create it.
- if (!Directory.Exists(destinationDirectory))
- {
- Directory.CreateDirectory(destinationDirectory);
- }
+ // If the destination directory doesn't exist, create it.
+ if (!Directory.Exists(destinationDirectory))
+ {
+ Directory.CreateDirectory(destinationDirectory);
+ }
- // Get the files in the directory and copy them to the new location.
- FileInfo[] files = dir.GetFiles();
- foreach (FileInfo file in files)
- {
- string temppath = Path.Combine(destinationDirectory, file.Name);
- file.CopyTo(temppath, true);
- }
+ // Get the files in the directory and copy them to the new location.
+ FileInfo[] files = dir.GetFiles();
+ foreach (FileInfo file in files)
+ {
+ string temppath = Path.Combine(destinationDirectory, file.Name);
+ file.CopyTo(temppath, true);
+ }
- // If copying subdirectories, copy them and their contents to new location.
- foreach (DirectoryInfo subdir in dirs)
- {
- string temppath = Path.Combine(destinationDirectory, subdir.Name);
- DirectoryCopy(subdir.FullName, temppath);
- }
+ // If copying subdirectories, copy them and their contents to new location.
+ foreach (DirectoryInfo subdir in dirs)
+ {
+ string temppath = Path.Combine(destinationDirectory, subdir.Name);
+ DirectoryCopy(subdir.FullName, temppath);
}
}
}
diff --git a/src/TMG-Framework/FileOperations/DeleteFile.cs b/src/TMG-Framework/FileOperations/DeleteFile.cs
index 8390d2a..cd68078 100644
--- a/src/TMG-Framework/FileOperations/DeleteFile.cs
+++ b/src/TMG-Framework/FileOperations/DeleteFile.cs
@@ -16,36 +16,30 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see ToDelete = null!;
+ [Parameter(DefaultValue = "", Name = "To Delete", Index = 0, Description = "The path to delete.")]
+ public IFunction ToDelete = null!;
- public override void Invoke()
+ public override void Invoke()
+ {
+ var info = new FileInfo(ToDelete.Invoke());
+ if (!info.Exists)
+ {
+ throw new XTMFRuntimeException(this, $"The file does not exist {info.FullName}!");
+ }
+ if (info.Attributes.HasFlag(FileAttributes.Directory))
+ {
+ new DirectoryInfo(info.FullName).Delete(true);
+ }
+ else
{
- var info = new FileInfo(ToDelete.Invoke());
- if(!info.Exists)
- {
- throw new XTMFRuntimeException(this, $"The file does not exist {info.FullName}!");
- }
- if (info.Attributes.HasFlag(FileAttributes.Directory))
- {
- new DirectoryInfo(info.FullName).Delete(true);
- }
- else
- {
- info.Delete();
- }
+ info.Delete();
}
}
}
diff --git a/src/TMG-Framework/GlobalUsings.cs b/src/TMG-Framework/GlobalUsings.cs
new file mode 100644
index 0000000..0f513b1
--- /dev/null
+++ b/src/TMG-Framework/GlobalUsings.cs
@@ -0,0 +1,9 @@
+global using System;
+global using System.Collections.Generic;
+global using System.Diagnostics.CodeAnalysis;
+global using System.Linq;
+global using System.Runtime.CompilerServices;
+global using System.Runtime.InteropServices;
+global using System.Text;
+
+global using XTMF2;
diff --git a/src/TMG-Framework/Loading/LoadCategoriesFromCSV.cs b/src/TMG-Framework/Loading/LoadCategoriesFromCSV.cs
index d4489e1..bcaf3d7 100644
--- a/src/TMG-Framework/Loading/LoadCategoriesFromCSV.cs
+++ b/src/TMG-Framework/Loading/LoadCategoriesFromCSV.cs
@@ -16,11 +16,8 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
{
- [Module(Name = "Load Category Map From Third Normalized CSV",
- Description = "Loads a category map (such as planning districts)",
- DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
- public class LoadCategoryMapFromThirdNormalizedCSV : BaseFunction
- {
- [SubModule(Index = 0, Required = true, Name = "Base Categories", Description = "The categories that this map from to the Destination Categories.")]
- public IFunction BaseCategories = null!;
+ [SubModule(Index = 0, Required = true, Name = "Base Categories", Description = "The categories that this map from to the Destination Categories.")]
+ public IFunction BaseCategories = null!;
- [SubModule(Index = 1, Required = false, Name = "Destination Categories", Description = "The categories that this map to from the Base Categories. If not linked the CSV will create a new one based on the destination values found.")]
- public IFunction? DestinationCategories;
+ [SubModule(Index = 1, Required = false, Name = "Destination Categories", Description = "The categories that this map to from the Base Categories. If not linked the CSV will create a new one based on the destination values found.")]
+ public IFunction? DestinationCategories;
- [SubModule(Index = 2, Required = true, Name = "CSV Stream", Description = "The stream that we will read from.")]
- public IFunction CSVStream = null!;
+ [SubModule(Index = 2, Required = true, Name = "CSV Stream", Description = "The stream that we will read from.")]
+ public IFunction CSVStream = null!;
- [Parameter(DefaultValue = "0", Name = "Base Column", Index = 3, Description = "The 0 indexed column containing the sparse map index for the base category index.")]
- public IFunction BaseColumn = null!;
+ [Parameter(DefaultValue = "0", Name = "Base Column", Index = 3, Description = "The 0 indexed column containing the sparse map index for the base category index.")]
+ public IFunction BaseColumn = null!;
- [Parameter(DefaultValue = "1", Name = "Destination Column", Index = 4, Description = "The 0 indexed column containing the sparse map index for the destination category index.")]
- public IFunction DestinationColumn = null!;
+ [Parameter(DefaultValue = "1", Name = "Destination Column", Index = 4, Description = "The 0 indexed column containing the sparse map index for the destination category index.")]
+ public IFunction DestinationColumn = null!;
- public override CategoryMap Invoke()
+ public override CategoryMap Invoke()
+ {
+ var destinationCategories = DestinationCategories?.Invoke();
+ if (destinationCategories is null)
{
- var destinationCategories = DestinationCategories?.Invoke();
- if (destinationCategories is null)
- {
- return LoadWithCustomDestinations();
- }
- else
- {
- return LoadWithStrictDestinations(destinationCategories);
- }
+ return LoadWithCustomDestinations();
}
-
- ///
- /// Load the category map where we are generating the destinations on the fly.
- ///
- /// Returns the mapping of categories from the base to the destination.
- private CategoryMap LoadWithCustomDestinations()
+ else
{
- var records = LoadMapRecords();
- Categories destinationCategories = GetDestinationCategoriesFromRecords(records);
- return Load(records, destinationCategories);
+ return LoadWithStrictDestinations(destinationCategories);
}
+ }
- ///
- /// Load the category map where there are pre-defined destination categories.
- ///
- /// Returns the mapping of categories from the base to the destination.
- private CategoryMap LoadWithStrictDestinations(Categories destinationCategories)
- {
- return Load(LoadMapRecords(), destinationCategories);
- }
+ ///
+ /// Load the category map where we are generating the destinations on the fly.
+ ///
+ /// Returns the mapping of categories from the base to the destination.
+ private CategoryMap LoadWithCustomDestinations()
+ {
+ var records = LoadMapRecords();
+ Categories destinationCategories = GetDestinationCategoriesFromRecords(records);
+ return Load(records, destinationCategories);
+ }
- ///
- /// Generates a Categories object using the destinations specified in the loaded mapping records.
- ///
- /// A Categories object that represents the destinations from the records organized in ascending order.
- /// This throws when we are unable to create the categories object.
- private Categories GetDestinationCategoriesFromRecords(List<(int baseSparseIndex, int destinationSparseIndex)> records)
- {
- string? error = null;
- if(!Categories.CreateCategories(records
- .Select(r => r.destinationSparseIndex)
- .Distinct()
- .OrderBy(r => r)
- .ToList(), out var ret,ref error))
- {
- throw new XTMFRuntimeException(this, error);
- }
- return ret;
- }
+ ///
+ /// Load the category map where there are pre-defined destination categories.
+ ///
+ /// Returns the mapping of categories from the base to the destination.
+ private CategoryMap LoadWithStrictDestinations(Categories destinationCategories)
+ {
+ return Load(LoadMapRecords(), destinationCategories);
+ }
- ///
- /// Creates the CategoryMap using the sparse records and destination categories.
- ///
- /// Returns a category map between the Base categories and the Destination categories.
- /// This is thrown if there is a sparse-record that is not defined in their respective category.
- private CategoryMap Load(List<(int baseSparseIndex, int destinationSparseIndex)> records, Categories destinationCategories)
+ ///
+ /// Generates a Categories object using the destinations specified in the loaded mapping records.
+ ///
+ /// A Categories object that represents the destinations from the records organized in ascending order.
+ /// This throws when we are unable to create the categories object.
+ private Categories GetDestinationCategoriesFromRecords(List<(int baseSparseIndex, int destinationSparseIndex)> records)
+ {
+ string? error = null;
+ if (!Categories.CreateCategories(records
+ .Select(r => r.destinationSparseIndex)
+ .Distinct()
+ .OrderBy(r => r)
+ .ToList(), out var ret, ref error))
{
- var baseCategories = BaseCategories!.Invoke();
- var flatRecords = records
- .Select(record =>
- {
- var ret = (BaseIndex: baseCategories.GetFlatIndex(record.baseSparseIndex),
- DestinationIndex: destinationCategories.GetFlatIndex(record.destinationSparseIndex));
- if (ret.BaseIndex < 0)
- {
- ThrowBadBaseIndex(ret.BaseIndex);
- }
- if (ret.DestinationIndex < 0)
- {
- ThrowBadDestinationIndex(ret.DestinationIndex);
- }
- return ret;
- }).ToList();
- string? error = null;
- if (!CategoryMap.CreateCategoryMap(baseCategories, destinationCategories, flatRecords, out var map, ref error))
- {
- throw new XTMFRuntimeException(this, error);
- }
- return map;
+ throw new XTMFRuntimeException(this, error);
}
+ return ret;
+ }
- ///
- /// A helper function to throw if we load a sparse index that is not contained in the base categories.
- ///
- /// This always throws.
- private void ThrowBadBaseIndex(int baseSparseIndex)
+ ///
+ /// Creates the CategoryMap using the sparse records and destination categories.
+ ///
+ /// Returns a category map between the Base categories and the Destination categories.
+ /// This is thrown if there is a sparse-record that is not defined in their respective category.
+ private CategoryMap Load(List<(int baseSparseIndex, int destinationSparseIndex)> records, Categories destinationCategories)
+ {
+ var baseCategories = BaseCategories!.Invoke();
+ var flatRecords = records
+ .Select(record =>
+ {
+ var ret = (BaseIndex: baseCategories.GetFlatIndex(record.baseSparseIndex),
+ DestinationIndex: destinationCategories.GetFlatIndex(record.destinationSparseIndex));
+ if (ret.BaseIndex < 0)
+ {
+ ThrowBadBaseIndex(ret.BaseIndex);
+ }
+ if (ret.DestinationIndex < 0)
+ {
+ ThrowBadDestinationIndex(ret.DestinationIndex);
+ }
+ return ret;
+ }).ToList();
+ string? error = null;
+ if (!CategoryMap.CreateCategoryMap(baseCategories, destinationCategories, flatRecords, out var map, ref error))
{
- throw new XTMFRuntimeException(this, $"Found an invalid base category sparse index {baseSparseIndex} while loading in the category map!");
+ throw new XTMFRuntimeException(this, error);
}
+ return map;
+ }
- ///
- /// A helper function to throw if we load a sparse index that is not contained in the destination categories.
- ///
- /// This always throws.
- private void ThrowBadDestinationIndex(int destinationSparseIndex)
- {
- throw new XTMFRuntimeException(this, $"Found an invalid destination category sparse index {destinationSparseIndex} while loading in the category map!");
- }
+ ///
+ /// A helper function to throw if we load a sparse index that is not contained in the base categories.
+ ///
+ /// This always throws.
+ private void ThrowBadBaseIndex(int baseSparseIndex)
+ {
+ throw new XTMFRuntimeException(this, $"Found an invalid base category sparse index {baseSparseIndex} while loading in the category map!");
+ }
- ///
- /// Loads the sparse-index mapping records from the stream.
- ///
- /// The sparse-indexed records.
- /// This is thrown if we are unable to properly parse a line.
- private List<(int baseSparseIndex, int destinationSparseIndex)> LoadMapRecords()
+ ///
+ /// A helper function to throw if we load a sparse index that is not contained in the destination categories.
+ ///
+ /// This always throws.
+ private void ThrowBadDestinationIndex(int destinationSparseIndex)
+ {
+ throw new XTMFRuntimeException(this, $"Found an invalid destination category sparse index {destinationSparseIndex} while loading in the category map!");
+ }
+
+ ///
+ /// Loads the sparse-index mapping records from the stream.
+ ///
+ /// The sparse-indexed records.
+ /// This is thrown if we are unable to properly parse a line.
+ private List<(int baseSparseIndex, int destinationSparseIndex)> LoadMapRecords()
+ {
+ var baseColumn = BaseColumn!.Invoke();
+ var destinationColumn = DestinationColumn!.Invoke();
+ int requiredColumns = Math.Max(baseColumn, destinationColumn) + 1;
+ var streamReader = new CsvReader(CSVStream!.Invoke(), true);
+ var records = new List<(int baseSparseIndex, int destinationSparseIndex)>();
+ try
{
- var baseColumn = BaseColumn!.Invoke();
- var destinationColumn = DestinationColumn!.Invoke();
- int requiredColumns = Math.Max(baseColumn, destinationColumn) + 1;
- var streamReader = new CsvReader(CSVStream!.Invoke(), true);
- var records = new List<(int baseSparseIndex, int destinationSparseIndex)>();
- try
+ while (streamReader.LoadLine(out int columns))
{
- while (streamReader.LoadLine(out int columns))
+ if (columns >= requiredColumns)
{
- if (columns >= requiredColumns)
- {
- streamReader.Get(out int baseSparseIndex, baseColumn);
- streamReader.Get(out int destinationSparseIndex, destinationColumn);
- records.Add((baseSparseIndex, destinationSparseIndex));
- }
+ streamReader.Get(out int baseSparseIndex, baseColumn);
+ streamReader.Get(out int destinationSparseIndex, destinationColumn);
+ records.Add((baseSparseIndex, destinationSparseIndex));
}
}
- catch
- {
- throw new XTMFRuntimeException(this, $"Unable to read category map from {streamReader.FileName} on line {streamReader.LineNumber}!");
- }
-
- return records;
}
+ catch
+ {
+ throw new XTMFRuntimeException(this, $"Unable to read category map from {streamReader.FileName} on line {streamReader.LineNumber}!");
+ }
+
+ return records;
}
}
+
diff --git a/src/TMG-Framework/Loading/LoadMatrixFromCSVMatrix.cs b/src/TMG-Framework/Loading/LoadMatrixFromCSVMatrix.cs
index 28ed1f5..907f829 100644
--- a/src/TMG-Framework/Loading/LoadMatrixFromCSVMatrix.cs
+++ b/src/TMG-Framework/Loading/LoadMatrixFromCSVMatrix.cs
@@ -16,63 +16,58 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
{
- [Module(Name = "Load Matrix From CSV", Description = "Loads a matrix of data in the shape of the SparseMap from a CSV in third normalized form.",
- DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
- public sealed class LoadMatrixFromCSVMatrix : BaseFunction
- {
- [SubModule(Required = true, Name = "Row Categories", Description = "The sparse map this vector will be shaped in.", Index = 0)]
- public IFunction RowCategories = null!;
+ [SubModule(Required = true, Name = "Row Categories", Description = "The sparse map this vector will be shaped in.", Index = 0)]
+ public IFunction RowCategories = null!;
- [SubModule(Required = true, Name = "Column Categories", Description = "The sparse map this vector will be shaped in.", Index = 1)]
- public IFunction ColumnCategories = null!;
+ [SubModule(Required = true, Name = "Column Categories", Description = "The sparse map this vector will be shaped in.", Index = 1)]
+ public IFunction ColumnCategories = null!;
- public override Matrix Invoke(ReadStream stream)
+ public override Matrix Invoke(ReadStream stream)
+ {
+ var columnCategories = ColumnCategories.Invoke();
+ var rowCategories = RowCategories.Invoke();
+ var ret = new Matrix(rowCategories, columnCategories);
+ var flatData = ret.Data;
+ var rowSize = columnCategories.Count;
+ using (var reader = new CsvReader(stream, true))
{
- var columnCategories = ColumnCategories.Invoke();
- var rowCategories = RowCategories.Invoke();
- var ret = new Matrix(rowCategories, columnCategories);
- var flatData = ret.Data;
- var rowSize = columnCategories.Count;
- using (var reader = new CsvReader(stream, true))
+ var headers = reader.Headers;
+ // read in the destination indexes
+ int[] destinationFlatIndex = new int[headers.Length - 1];
+ for (int i = 1; i < headers.Length; i++)
{
- var headers = reader.Headers;
- // read in the destination indexes
- int[] destinationFlatIndex = new int[headers.Length - 1];
- for (int i = 1; i < headers.Length; i++)
+ var sparseIndex = int.Parse(headers[i]);
+ if ((destinationFlatIndex[i - 1] = columnCategories.GetFlatIndex(sparseIndex)) < 0)
{
- var sparseIndex = int.Parse(headers[i]);
- if((destinationFlatIndex[i - 1] = columnCategories.GetFlatIndex(sparseIndex)) < 0)
- {
- throw new XTMFRuntimeException(this, $"Invalid sparse column index {sparseIndex}!");
- }
+ throw new XTMFRuntimeException(this, $"Invalid sparse column index {sparseIndex}!");
}
- while(reader.LoadLine(out var columns))
+ }
+ while (reader.LoadLine(out var columns))
+ {
+ if (columns >= destinationFlatIndex.Length + 1)
{
- if(columns >= destinationFlatIndex.Length + 1)
+ reader.Get(out int sparseIndex, 0);
+ var originOffset = rowCategories.GetFlatIndex(sparseIndex) * rowSize;
+ if (originOffset < 0)
+ {
+ throw new XTMFRuntimeException(this, $"Invalid sparse row index {sparseIndex}!");
+ }
+ for (int i = 0; i < destinationFlatIndex.Length; i++)
{
- reader.Get(out int sparseIndex, 0);
- var originOffset = rowCategories.GetFlatIndex(sparseIndex) * rowSize;
- if(originOffset < 0)
- {
- throw new XTMFRuntimeException(this, $"Invalid sparse row index {sparseIndex}!");
- }
- for (int i = 0; i < destinationFlatIndex.Length; i++)
- {
- reader.Get(out flatData[originOffset + destinationFlatIndex[i]], i + 1);
- }
+ reader.Get(out flatData[originOffset + destinationFlatIndex[i]], i + 1);
}
}
}
- return ret;
}
+ return ret;
}
}
diff --git a/src/TMG-Framework/Loading/LoadMatrixFromCSVThirdNormalized.cs b/src/TMG-Framework/Loading/LoadMatrixFromCSVThirdNormalized.cs
index 147515a..9088c6b 100644
--- a/src/TMG-Framework/Loading/LoadMatrixFromCSVThirdNormalized.cs
+++ b/src/TMG-Framework/Loading/LoadMatrixFromCSVThirdNormalized.cs
@@ -16,80 +16,76 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
{
- [Module(Name = "Load Matrix From CSV", Description = "Loads a matrix of data in the shape of the SparseMap from a CSV in third normalized form.",
- DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
- public sealed class LoadMatrixFromCSVThirdNormalized : BaseFunction
- {
- [SubModule(Required = true, Name = "Row Categories", Description = "The sparse map this vector will be shaped in.", Index = 0)]
- public IFunction RowCategories = null!;
+ [SubModule(Required = true, Name = "Row Categories", Description = "The sparse map this vector will be shaped in.", Index = 0)]
+ public IFunction RowCategories = null!;
- [SubModule(Required = true, Name = "Column Categories", Description = "The sparse map this vector will be shaped in.", Index = 1)]
- public IFunction ColumnCategories = null!;
+ [SubModule(Required = true, Name = "Column Categories", Description = "The sparse map this vector will be shaped in.", Index = 1)]
+ public IFunction ColumnCategories = null!;
- [Parameter(DefaultValue = "0", Name = "Origin Column", Index = 2, Description = "The 0 indexed column containing the sparse map index for the origin.")]
- public IFunction OriginColumn = null!;
+ [Parameter(DefaultValue = "0", Name = "Origin Column", Index = 2, Description = "The 0 indexed column containing the sparse map index for the origin.")]
+ public IFunction OriginColumn = null!;
- [Parameter(DefaultValue = "1", Name = "Destination Column", Index = 3, Description = "The 0 indexed column containing the sparse map index for the destination.")]
- public IFunction DestinationColumn = null!;
+ [Parameter(DefaultValue = "1", Name = "Destination Column", Index = 3, Description = "The 0 indexed column containing the sparse map index for the destination.")]
+ public IFunction DestinationColumn = null!;
- [Parameter(DefaultValue = "2", Name = "Data Column", Index = 4, Description = "The 0 indexed column containing the data to load index.")]
- public IFunction DataColumn = null!;
+ [Parameter(DefaultValue = "2", Name = "Data Column", Index = 4, Description = "The 0 indexed column containing the data to load index.")]
+ public IFunction DataColumn = null!;
- public override Matrix Invoke(ReadStream stream)
+ public override Matrix Invoke(ReadStream stream)
+ {
+ var rowCategories = RowCategories.Invoke();
+ var columnCategories = ColumnCategories.Invoke();
+ var rowSize = rowCategories.Count;
+ var ret = new Matrix(rowCategories, columnCategories);
+ var data = ret.Data;
+ var originColumn = OriginColumn.Invoke();
+ var destinationColumn = DestinationColumn.Invoke();
+ var dataColumn = DataColumn.Invoke();
+ if (originColumn < 0 || destinationColumn < 0 || dataColumn < 0)
{
- var rowCategories = RowCategories.Invoke();
- var columnCategories = ColumnCategories.Invoke();
- var rowSize = rowCategories.Count;
- var ret = new Matrix(rowCategories, columnCategories);
- var data = ret.Data;
- var originColumn = OriginColumn.Invoke();
- var destinationColumn = DestinationColumn.Invoke();
- var dataColumn = DataColumn.Invoke();
- if (originColumn < 0 || destinationColumn < 0 || dataColumn < 0)
- {
- throw new XTMFRuntimeException(this, "Column indexes must be greater than or equal to zero!");
- }
- var minColumnSize = Math.Max(originColumn, dataColumn);
- using (var reader = new CsvReader(stream, true))
+ throw new XTMFRuntimeException(this, "Column indexes must be greater than or equal to zero!");
+ }
+ var minColumnSize = Math.Max(originColumn, dataColumn);
+ using (var reader = new CsvReader(stream, true))
+ {
+ reader.LoadLine();
+ while (reader.LoadLine(out var columns))
{
- reader.LoadLine();
- while (reader.LoadLine(out var columns))
+ // This is strictly greater because the column size is 0 indexed
+ if (columns > minColumnSize)
{
- // This is strictly greater because the column size is 0 indexed
- if (columns > minColumnSize)
+ int flatOrigin, flatDestination;
+ reader.Get(out int originIndex, originColumn);
+ reader.Get(out int destinationIndex, originColumn);
+ reader.Get(out float dataValue, dataColumn);
+ if ((flatOrigin = rowCategories.GetFlatIndex(originIndex)) >= 0 && (flatDestination = columnCategories.GetFlatIndex(destinationIndex)) >= 0)
+ {
+ // if we know where to put it
+ data[flatOrigin * rowSize + flatDestination] = dataValue;
+ }
+ else
{
- int flatOrigin, flatDestination;
- reader.Get(out int originIndex, originColumn);
- reader.Get(out int destinationIndex, originColumn);
- reader.Get(out float dataValue, dataColumn);
- if ((flatOrigin = rowCategories.GetFlatIndex(originIndex)) >= 0 && (flatDestination = columnCategories.GetFlatIndex(destinationIndex)) >= 0)
+ if (flatOrigin < 0)
{
- // if we know where to put it
- data[flatOrigin * rowSize + flatDestination] = dataValue;
+ throw new XTMFRuntimeException(this, $"An invalid origin was specified {originIndex}!");
}
else
{
- if (flatOrigin < 0)
- {
- throw new XTMFRuntimeException(this, $"An invalid origin was specified {originIndex}!");
- }
- else
- {
- throw new XTMFRuntimeException(this, $"An invalid destination was specified {destinationIndex}!");
- }
+ throw new XTMFRuntimeException(this, $"An invalid destination was specified {destinationIndex}!");
}
}
}
}
- return ret;
}
+ return ret;
}
}
diff --git a/src/TMG-Framework/Loading/LoadMatrixFromMTX.cs b/src/TMG-Framework/Loading/LoadMatrixFromMTX.cs
index 0967881..e653a8e 100644
--- a/src/TMG-Framework/Loading/LoadMatrixFromMTX.cs
+++ b/src/TMG-Framework/Loading/LoadMatrixFromMTX.cs
@@ -16,163 +16,155 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
{
- [Module(Name = "Load SparseMatrix From MTX", Description = "Loads a matrix of data in the shape of the SparseMap from an EMME matrix file.",
- DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
- public sealed class LoadMatrixFromMTX : BaseFunction
- {
- [SubModule(Required = true, Name = "Map", Description = "The sparse map this vector will be shaped in.", Index = 0)]
- public IFunction Categories = null!;
+ [SubModule(Required = true, Name = "Map", Description = "The sparse map this vector will be shaped in.", Index = 0)]
+ public IFunction Categories = null!;
- [Parameter(Name = "Convert Between Zone Systems", DefaultValue = "false", Description = "A function that converts between the zone system of the matrix and the zone system of the map.", Index = 1)]
- public IFunction ConvertBetweenZoneSystems = null!;
+ [Parameter(Name = "Convert Between Zone Systems", DefaultValue = "false", Description = "A function that converts between the zone system of the matrix and the zone system of the map.", Index = 1)]
+ public IFunction ConvertBetweenZoneSystems = null!;
- private const uint MagicNumber = 0xC4D4F1B2;
+ private const uint MagicNumber = 0xC4D4F1B2;
- private const int FloatType = 0x1;
+ private const int FloatType = 0x1;
- public override Matrix Invoke(ReadStream context)
+ public override Matrix Invoke(ReadStream context)
+ {
+ var categories = Categories.Invoke();
+ var matrix = new Matrix(categories, categories);
+ using (var reader = new BinaryReader(context))
{
- var categories = Categories.Invoke();
- var matrix = new Matrix(categories, categories);
- using (var reader = new BinaryReader(context))
+ var magic = reader.ReadUInt32();
+ if (magic != MagicNumber)
{
- var magic = reader.ReadUInt32();
- if(magic != MagicNumber)
- {
- throw new XTMFRuntimeException(this, "The file was not an EMME matrix!");
- }
- // version
- reader.ReadInt32();
- var type = reader.ReadInt32();
- if(type != FloatType)
- {
- throw new XTMFRuntimeException(this, "The matrix was not using a float type!");
- }
- var numberOfIndexes = reader.ReadInt32();
- if(numberOfIndexes != 2)
- {
- throw new XTMFRuntimeException(this, $"The matrix contained {numberOfIndexes} dimensions!");
- }
-
- var convert = ConvertBetweenZoneSystems.Invoke();
- if(!convert)
- {
- LoadWithoutConversion(categories, matrix, reader);
- }
- else
- {
- LoadWithConversion(categories, matrix, reader);
- }
+ throw new XTMFRuntimeException(this, "The file was not an EMME matrix!");
}
- return matrix;
- }
-
- private void LoadWithoutConversion(Categories categories, Matrix matrix, BinaryReader reader)
- {
- int firstSize = reader.ReadInt32();
- int secondSize = reader.ReadInt32();
- if (categories.Count != firstSize)
+ // version
+ reader.ReadInt32();
+ var type = reader.ReadInt32();
+ if (type != FloatType)
{
- throw new XTMFRuntimeException(this, "The matrix had the wrong number of elements in the first dimension!");
+ throw new XTMFRuntimeException(this, "The matrix was not using a float type!");
}
- if (categories.Count != secondSize)
+ var numberOfIndexes = reader.ReadInt32();
+ if (numberOfIndexes != 2)
{
- throw new XTMFRuntimeException(this, "The matrix had the wrong number of elements in the second dimension!");
+ throw new XTMFRuntimeException(this, $"The matrix contained {numberOfIndexes} dimensions!");
}
- ValidateIndexes(reader, categories);
- ValidateIndexes(reader, categories);
- var data = matrix.Data;
- var dataSize = data.Length * sizeof(float);
- var soFar = 0;
- while (soFar < dataSize)
+ var convert = ConvertBetweenZoneSystems.Invoke();
+ if (!convert)
{
- var amount = reader.Read(MemoryMarshal.Cast(data)[soFar..dataSize]);
- if (amount == 0)
- {
- throw new XTMFRuntimeException(this, $"The matrix expected {dataSize}bytes but we only could get {soFar}bytes!");
- }
- soFar += amount;
+ LoadWithoutConversion(categories, matrix, reader);
+ }
+ else
+ {
+ LoadWithConversion(categories, matrix, reader);
}
}
+ return matrix;
+ }
+
+ private void LoadWithoutConversion(Categories categories, Matrix matrix, BinaryReader reader)
+ {
+ int firstSize = reader.ReadInt32();
+ int secondSize = reader.ReadInt32();
+ if (categories.Count != firstSize)
+ {
+ throw new XTMFRuntimeException(this, "The matrix had the wrong number of elements in the first dimension!");
+ }
+ if (categories.Count != secondSize)
+ {
+ throw new XTMFRuntimeException(this, "The matrix had the wrong number of elements in the second dimension!");
+ }
+ ValidateIndexes(reader, categories);
+ ValidateIndexes(reader, categories);
- private void LoadWithConversion(Categories categories, Matrix matrix, BinaryReader reader)
+ var data = matrix.Data;
+ var dataSize = data.Length * sizeof(float);
+ var soFar = 0;
+ while (soFar < dataSize)
{
- int rowSize = reader.ReadInt32();
- int columnSize = reader.ReadInt32();
-
- if (rowSize != columnSize)
+ var amount = reader.Read(MemoryMarshal.Cast(data)[soFar..dataSize]);
+ if (amount == 0)
{
- throw new XTMFRuntimeException(this, "The matrix was not square!");
+ throw new XTMFRuntimeException(this, $"The matrix expected {dataSize}bytes but we only could get {soFar}bytes!");
}
+ soFar += amount;
+ }
+ }
- // Load in the column categories (sparse space)
- var rows = new int[rowSize];
- var columns = new int[columnSize];
+ private void LoadWithConversion(Categories categories, Matrix matrix, BinaryReader reader)
+ {
+ int rowSize = reader.ReadInt32();
+ int columnSize = reader.ReadInt32();
- reader.ReadExactly(MemoryMarshal.Cast(rows.AsSpan()));
- reader.ReadExactly(MemoryMarshal.Cast(columns.AsSpan()));
+ if (rowSize != columnSize)
+ {
+ throw new XTMFRuntimeException(this, "The matrix was not square!");
+ }
+
+ // Load in the column categories (sparse space)
+ var rows = new int[rowSize];
+ var columns = new int[columnSize];
- // Load in the matrix data
- var numberOfElements = rowSize * columnSize;
- var dataSize = numberOfElements * sizeof(float);
- var data = new float[numberOfElements];
- var dataSpan = data.AsSpan();
- var soFar = 0;
- while (soFar < dataSize)
+ reader.ReadExactly(MemoryMarshal.Cast(rows.AsSpan()));
+ reader.ReadExactly(MemoryMarshal.Cast(columns.AsSpan()));
+
+ // Load in the matrix data
+ var numberOfElements = rowSize * columnSize;
+ var dataSize = numberOfElements * sizeof(float);
+ var data = new float[numberOfElements];
+ var dataSpan = data.AsSpan();
+ var soFar = 0;
+ while (soFar < dataSize)
+ {
+ var amount = reader.Read(MemoryMarshal.Cast(dataSpan)[soFar..dataSize]);
+ if (amount == 0)
{
- var amount = reader.Read(MemoryMarshal.Cast(dataSpan)[soFar..dataSize]);
- if (amount == 0)
- {
- throw new XTMFRuntimeException(this, $"The matrix expected {dataSize}bytes but we only could get {soFar}bytes!");
- }
- soFar += amount;
+ throw new XTMFRuntimeException(this, $"The matrix expected {dataSize}bytes but we only could get {soFar}bytes!");
}
+ soFar += amount;
+ }
- ref var matrixData = ref MemoryMarshal.GetReference(matrix.Data);
- ref var rData = ref MemoryMarshal.GetReference(dataSpan);
- var matrixColumnSize = matrix.NumberOfColumns;
- for (int i = 0; i < rowSize; i++)
+ ref var matrixData = ref MemoryMarshal.GetReference(matrix.Data);
+ ref var rData = ref MemoryMarshal.GetReference(dataSpan);
+ var matrixColumnSize = matrix.NumberOfColumns;
+ for (int i = 0; i < rowSize; i++)
+ {
+ var rowIndex = categories.GetFlatIndex(rows[i]);
+ if (rowIndex < 0)
{
- var rowIndex = categories.GetFlatIndex(rows[i]);
- if (rowIndex < 0)
- {
- continue;
- }
- for (int j = 0; j < columnSize; j++)
+ continue;
+ }
+ for (int j = 0; j < columnSize; j++)
+ {
+ var columnIndex = categories.GetFlatIndex(columns[j]);
+ if (columnIndex >= 0)
{
- var columnIndex = categories.GetFlatIndex(columns[j]);
- if (columnIndex >= 0)
- {
- ref var writeTo = ref Unsafe.Add(ref matrixData, rowIndex * matrixColumnSize + columnIndex);
- writeTo = Unsafe.Add(ref rData, i * columnSize + j);
- }
+ ref var writeTo = ref Unsafe.Add(ref matrixData, rowIndex * matrixColumnSize + columnIndex);
+ writeTo = Unsafe.Add(ref rData, i * columnSize + j);
}
}
}
+ }
- private void ValidateIndexes(BinaryReader reader, Categories categories)
+ private void ValidateIndexes(BinaryReader reader, Categories categories)
+ {
+ var length = categories.Count;
+ for (int i = 0; i < length; i++)
{
- var length = categories.Count;
- for (int i = 0; i < length; i++)
+ var index = reader.ReadInt32();
+ if (index != categories.GetSparseIndex(i))
{
- var index = reader.ReadInt32();
- if(index != categories.GetSparseIndex(i))
- {
- throw new XTMFRuntimeException(this, $"The matrix file has an index of {index} where we were expecting an index of {categories.GetSparseIndex(i)}!");
- }
+ throw new XTMFRuntimeException(this, $"The matrix file has an index of {index} where we were expecting an index of {categories.GetSparseIndex(i)}!");
}
}
}
}
+
diff --git a/src/TMG-Framework/Loading/LoadVectorFromCSV.cs b/src/TMG-Framework/Loading/LoadVectorFromCSV.cs
index 50c13df..338b12d 100644
--- a/src/TMG-Framework/Loading/LoadVectorFromCSV.cs
+++ b/src/TMG-Framework/Loading/LoadVectorFromCSV.cs
@@ -16,62 +16,58 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
{
- [Module(Name = "Load Vector From CSV", Description = "Loads a map where each row has a different sparse index.",
- DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
- public sealed class LoadVectorFromCSV : BaseFunction
- {
- [SubModule(Required = true, Name = "Categories", Description = "The sparse map this vector will be shaped in.", Index = 0)]
- public IFunction Categories = null!;
+ [SubModule(Required = true, Name = "Categories", Description = "The sparse map this vector will be shaped in.", Index = 0)]
+ public IFunction Categories = null!;
- [Parameter(DefaultValue = "0", Name = "Map Column", Index = 1, Description = "The 0 indexed column containing the sparse map index.")]
- public IFunction MapColumn = null!;
+ [Parameter(DefaultValue = "0", Name = "Map Column", Index = 1, Description = "The 0 indexed column containing the sparse map index.")]
+ public IFunction MapColumn = null!;
- [Parameter(DefaultValue = "1", Name = "Data Column", Index = 2, Description = "The 0 indexed column containing the data to load index.")]
- public IFunction DataColumn = null!;
+ [Parameter(DefaultValue = "1", Name = "Data Column", Index = 2, Description = "The 0 indexed column containing the data to load index.")]
+ public IFunction DataColumn = null!;
- public override Vector Invoke(ReadStream stream)
+ public override Vector Invoke(ReadStream stream)
+ {
+ var map = Categories.Invoke();
+ var ret = new Vector(map);
+ var data = ret.Data;
+ var mapColumn = MapColumn.Invoke();
+ var dataColumn = DataColumn.Invoke();
+ if (mapColumn < 0 || dataColumn < 0)
{
- var map = Categories.Invoke();
- var ret = new Vector(map);
- var data = ret.Data;
- var mapColumn = MapColumn.Invoke();
- var dataColumn = DataColumn.Invoke();
- if(mapColumn < 0 || dataColumn < 0)
- {
- throw new XTMFRuntimeException(this, "Column indexes must be greater than or equal to zero!");
- }
- var minColumnSize = Math.Max(mapColumn, dataColumn);
- using (var reader = new CsvReader(stream, true))
+ throw new XTMFRuntimeException(this, "Column indexes must be greater than or equal to zero!");
+ }
+ var minColumnSize = Math.Max(mapColumn, dataColumn);
+ using (var reader = new CsvReader(stream, true))
+ {
+ while (reader.LoadLine(out var columns))
{
- while(reader.LoadLine(out var columns))
+ // This is strictly greater because the column size is 0 indexed
+ if (columns > minColumnSize)
{
- // This is strictly greater because the column size is 0 indexed
- if(columns > minColumnSize)
+ int flatIndex;
+ reader.Get(out int mapIndex, mapColumn);
+ reader.Get(out float dataValue, dataColumn);
+ if ((flatIndex = map.GetFlatIndex(mapIndex)) >= 0)
+ {
+ // if we know where to put it
+ data[flatIndex] = dataValue;
+ }
+ else
{
- int flatIndex;
- reader.Get(out int mapIndex, mapColumn);
- reader.Get(out float dataValue, dataColumn);
- if((flatIndex = map.GetFlatIndex(mapIndex)) >= 0)
- {
- // if we know where to put it
- data[flatIndex] = dataValue;
- }
- else
- {
- throw new XTMFRuntimeException(this, $"An invalid sparse map index was specified {mapIndex}!");
- }
+ throw new XTMFRuntimeException(this, $"An invalid sparse map index was specified {mapIndex}!");
}
}
}
- return ret;
}
+ return ret;
}
}
diff --git a/src/TMG-Framework/Processing/AST/ASTNode.cs b/src/TMG-Framework/Processing/AST/ASTNode.cs
index f1e7b84..8b3fe02 100644
--- a/src/TMG-Framework/Processing/AST/ASTNode.cs
+++ b/src/TMG-Framework/Processing/AST/ASTNode.cs
@@ -17,92 +17,87 @@ You should have received a copy of the GNU General Public License
along with XTMF. If not, see
+ /// The starting point of the node
+ ///
+ internal readonly int Start;
+
+ protected AstNode(int start)
{
- ///
- /// The starting point of the node
- ///
- internal readonly int Start;
+ Start = start;
+ }
- protected AstNode(int start)
- {
- Start = start;
- }
+ public abstract ComputationResult Evaluate(IModule[] dataSources);
- public abstract ComputationResult Evaluate(IModule[] dataSources);
+ internal abstract bool OptimizeAst(
+ ref Expression ex,
+ [NotNullWhen(false)] ref string? error);
+}
- internal abstract bool OptimizeAst(
- ref Expression ex,
- [NotNullWhen(false)] ref string? error);
- }
+public class ComputationResult
+{
+ public bool IsOdResult => OdData is not null;
- public class ComputationResult
- {
- public bool IsOdResult => OdData is not null;
+ public bool IsVectorResult => VectorData is not null;
- public bool IsVectorResult => VectorData is not null;
+ public bool Error => ErrorMessage is not null;
- public bool Error => ErrorMessage is not null;
+ public string? ErrorMessage { get; private set; }
- public string? ErrorMessage { get; private set; }
+ public bool Accumulator { get; private set; }
- public bool Accumulator { get; private set; }
+ public enum VectorDirection
+ {
+ Unassigned,
+ Horizontal,
+ Vertical
+ }
- public enum VectorDirection
- {
- Unassigned,
- Horizontal,
- Vertical
- }
+ public VectorDirection Direction { get; private set; }
- public VectorDirection Direction { get; private set; }
+ public Matrix OdData { get; }
- public Matrix OdData { get; }
+ public Vector VectorData { get; }
- public Vector VectorData { get; }
+ public float LiteralValue { get; }
- public float LiteralValue { get; }
-
- public bool IsValue => !IsOdResult && !IsVectorResult && !Error;
+ public bool IsValue => !IsOdResult && !IsVectorResult && !Error;
-// TODO: Get these warnings fixes once we have the time to do so. For now, we will just suppress them.
+ // TODO: Get these warnings fixes once we have the time to do so. For now, we will just suppress them.
#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
- public ComputationResult(float value)
- {
- LiteralValue = value;
- }
-
- public ComputationResult(Matrix data, bool accumulator)
- {
- OdData = data;
- Accumulator = accumulator;
- }
-
- public ComputationResult(Vector data, bool accumulator, VectorDirection direction = VectorDirection.Unassigned)
- {
- VectorData = data;
- Accumulator = accumulator;
- Direction = direction;
- }
-
- public ComputationResult(ComputationResult res, VectorDirection direction)
- {
- OdData = res.OdData;
- LiteralValue = res.LiteralValue;
- VectorData = res.VectorData;
- Direction = direction;
- }
-
- public ComputationResult(string errorMessage)
- {
- ErrorMessage = errorMessage;
- }
- #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
+ public ComputationResult(float value)
+ {
+ LiteralValue = value;
+ }
+
+ public ComputationResult(Matrix data, bool accumulator)
+ {
+ OdData = data;
+ Accumulator = accumulator;
+ }
+
+ public ComputationResult(Vector data, bool accumulator, VectorDirection direction = VectorDirection.Unassigned)
+ {
+ VectorData = data;
+ Accumulator = accumulator;
+ Direction = direction;
+ }
+
+ public ComputationResult(ComputationResult res, VectorDirection direction)
+ {
+ OdData = res.OdData;
+ LiteralValue = res.LiteralValue;
+ VectorData = res.VectorData;
+ Direction = direction;
+ }
+
+ public ComputationResult(string errorMessage)
+ {
+ ErrorMessage = errorMessage;
}
+#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
}
diff --git a/src/TMG-Framework/Processing/AST/Add.cs b/src/TMG-Framework/Processing/AST/Add.cs
index e1a915f..8e2a255 100644
--- a/src/TMG-Framework/Processing/AST/Add.cs
+++ b/src/TMG-Framework/Processing/AST/Add.cs
@@ -17,195 +17,193 @@ You should have received a copy of the GNU General Public License
along with XTMF. If not, see parameters = new List();
+ int lastStart = i + 1;
+ Expression? p;
+ for (int j = i + 1; j < endIndex; j++)
{
- int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
- if (endIndex < 0)
+ if (buffer[j] == '(')
{
- error = $"At position {i} we found a '(' character without an accompanying ')'";
- return false;
- }
- List parameters = new List();
- int lastStart = i + 1;
- Expression? p;
- for (int j = i + 1; j < endIndex; j++)
- {
- if (buffer[j] == '(')
- {
- // skip to the end
- var innerEndIndex = FindEndOfBracket(buffer, j + 1, endIndex, ref error);
- if (innerEndIndex < 0)
- {
- error = $"At position {j} we found a '(' character without an accompanying ')'";
- return false;
- }
- j = innerEndIndex;
- }
- if (buffer[j] == ',')
+ // skip to the end
+ var innerEndIndex = FindEndOfBracket(buffer, j + 1, endIndex, ref error);
+ if (innerEndIndex < 0)
{
- if (!Compile(buffer, lastStart, j - lastStart, out p, ref error))
- {
- return false;
- }
- parameters.Add(p);
- lastStart = j + 1;
+ error = $"At position {j} we found a '(' character without an accompanying ')'";
+ return false;
}
+ j = innerEndIndex;
}
- if (AnyNonWhitespace(buffer, lastStart, endIndex - lastStart))
+ if (buffer[j] == ',')
{
- // add the final parameter
- if (!Compile(buffer, lastStart, endIndex - lastStart, out p, ref error))
+ if (!Compile(buffer, lastStart, j - lastStart, out p, ref error))
{
return false;
}
parameters.Add(p);
+ lastStart = j + 1;
}
- if (!FunctionCall.GetCall(start, builder.ToString(), parameters.ToArray(), out FunctionCall? toReturn, ref error))
+ }
+ if (AnyNonWhitespace(buffer, lastStart, endIndex - lastStart))
+ {
+ // add the final parameter
+ if (!Compile(buffer, lastStart, endIndex - lastStart, out p, ref error))
{
return false;
}
- ex = toReturn;
- return true;
- }
- }
- break;
- default:
- first = false;
- builder.Append(buffer[i]);
- break;
- }
- }
- // deal with brackets
- for (int i = start; i < start + length; i++)
- {
- switch (buffer[i])
- {
- case '(':
- {
- int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
- if (endIndex < 0)
- {
- error = $"At position {i} we found a '(' character without an accompanying ')'";
- return false;
+ parameters.Add(p);
}
- var toReturn = new Bracket(i);
- if (!Compile(buffer, i + 1, (endIndex - i) - 1, out toReturn.InnerExpression, ref error))
+ if (!FunctionCall.GetCall(start, builder.ToString(), parameters.ToArray(), out FunctionCall? toReturn, ref error))
{
return false;
}
ex = toReturn;
return true;
}
- }
+ }
+ break;
+ default:
+ first = false;
+ builder.Append(buffer[i]);
+ break;
}
- // try to extract literal / variable name
- builder.Clear();
- first = true;
- complete = false;
- int index = -1;
- for (int i = start; i < endPlusOne && !complete; i++)
+ }
+ // deal with brackets
+ for (int i = start; i < start + length; i++)
+ {
+ switch (buffer[i])
{
- switch (buffer[i])
- {
- case ' ':
- if (first)
- {
- // just skip
- }
- else
+ case '(':
+ {
+ int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
+ if (endIndex < 0)
{
- complete = true;
- // end of string
+ error = $"At position {i} we found a '(' character without an accompanying ')'";
+ return false;
}
- break;
- default:
- if (first)
+ var toReturn = new Bracket(i);
+ if (!Compile(buffer, i + 1, (endIndex - i) - 1, out toReturn.InnerExpression, ref error))
{
- first = false;
- index = i;
+ return false;
}
- builder.Append(buffer[i]);
- break;
- }
- }
- var value = builder.ToString();
- if (value.Length <= 0)
- {
- error = "We were unable to read in a value at position " + start;
- return false;
- }
- if (float.TryParse(value, out float f))
- {
- // if we can read it in as a floating point number
- ex = new Literal(index, f);
+ ex = toReturn;
+ return true;
+ }
}
- else
+ }
+ // try to extract literal / variable name
+ builder.Clear();
+ first = true;
+ complete = false;
+ int index = -1;
+ for (int i = start; i < endPlusOne && !complete; i++)
+ {
+ switch (buffer[i])
{
- ex = new Variable(index, value);
+ case ' ':
+ if (first)
+ {
+ // just skip
+ }
+ else
+ {
+ complete = true;
+ // end of string
+ }
+ break;
+ default:
+ if (first)
+ {
+ first = false;
+ index = i;
+ }
+ builder.Append(buffer[i]);
+ break;
}
- return true;
}
+ var value = builder.ToString();
+ if (value.Length <= 0)
+ {
+ error = "We were unable to read in a value at position " + start;
+ return false;
+ }
+ if (float.TryParse(value, out float f))
+ {
+ // if we can read it in as a floating point number
+ ex = new Literal(index, f);
+ }
+ else
+ {
+ ex = new Variable(index, value);
+ }
+ return true;
}
+}
- public abstract class MonoExpression : Expression
- {
- public Expression? InnerExpression;
+public abstract class MonoExpression : Expression
+{
+ public Expression? InnerExpression;
- public MonoExpression(int start) : base(start)
- {
+ public MonoExpression(int start) : base(start)
+ {
- }
+ }
- internal override bool OptimizeAst(
- ref Expression ex,
- [NotNullWhen(false)] ref string? error)
+ internal override bool OptimizeAst(
+ ref Expression ex,
+ [NotNullWhen(false)] ref string? error)
+ {
+ if (InnerExpression is null)
{
- if (InnerExpression is null)
- {
- error = "MonoExpression at position " + Start + " has no inner expression!";
- return false;
- }
- return InnerExpression.OptimizeAst(ref InnerExpression, ref error);
+ error = "MonoExpression at position " + Start + " has no inner expression!";
+ return false;
}
+ return InnerExpression.OptimizeAst(ref InnerExpression, ref error);
}
+}
+
+public abstract class BinaryExpression : Expression
+{
+ public Expression? Lhs;
+ public Expression? Rhs;
- public abstract class BinaryExpression : Expression
+ public BinaryExpression(int start) : base(start)
{
- public Expression? Lhs;
- public Expression? Rhs;
- public BinaryExpression(int start) : base(start)
- {
+ }
+ public override ComputationResult Evaluate(IModule[] dataSources)
+ {
+ ComputationResult lhs = null!;
+ ComputationResult rhs = null!;
+ if (Lhs is null)
+ {
+ return new ComputationResult($"BinaryExpression at position {Start} has no LHS!");
}
-
- public override ComputationResult Evaluate(IModule[] dataSources)
+ if (Rhs is null)
{
- ComputationResult lhs = null!;
- ComputationResult rhs = null!;
- if (Lhs is null)
- {
- return new ComputationResult($"BinaryExpression at position {Start} has no LHS!");
- }
- if (Rhs is null)
- {
- return new ComputationResult($"BinaryExpression at position {Start} has no RHS!");
- }
- Parallel.Invoke(
- () => lhs = Lhs.Evaluate(dataSources),
- () => rhs = Rhs.Evaluate(dataSources));
- if (lhs.Error)
- {
- return lhs;
- }
- else if (rhs.Error)
- {
- return rhs;
- }
- if (!ValidateSizes(lhs, rhs, Start, out var errorResult))
- {
- return errorResult;
- }
- return Evaluate(lhs, rhs);
+ return new ComputationResult($"BinaryExpression at position {Start} has no RHS!");
}
-
- public abstract ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs);
-
- internal override bool OptimizeAst(ref Expression ex,
- [NotNullWhen(false)] ref string? error)
+ Parallel.Invoke(
+ () => lhs = Lhs.Evaluate(dataSources),
+ () => rhs = Rhs.Evaluate(dataSources));
+ if (lhs.Error)
{
- if (Lhs is null)
- {
- error = "BinaryExpression at position " + Start + " has no LHS!";
- return false;
- }
- if (Rhs is null)
- {
- error = "BinaryExpression at position " + Start + " has no RHS!";
- return false;
- }
- if (!Lhs.OptimizeAst(ref Lhs, ref error) || !Rhs.OptimizeAst(ref Rhs, ref error))
- {
- return false;
- }
- return true;
+ return lhs;
}
- }
-
- public abstract class Value : Expression
- {
- public Value(int start) : base(start)
+ else if (rhs.Error)
{
-
+ return rhs;
}
-
- internal override bool OptimizeAst(ref Expression ex,
- [NotNullWhen(false)] ref string? error)
+ if (!ValidateSizes(lhs, rhs, Start, out var errorResult))
{
- return true;
+ return errorResult;
}
+ return Evaluate(lhs, rhs);
}
- public class Bracket : MonoExpression
+ public abstract ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs);
+
+ internal override bool OptimizeAst(ref Expression ex,
+ [NotNullWhen(false)] ref string? error)
{
- public Bracket(int start) : base(start)
+ if (Lhs is null)
{
-
+ error = "BinaryExpression at position " + Start + " has no LHS!";
+ return false;
}
-
- public override ComputationResult Evaluate(IModule[] dataSources)
+ if (Rhs is null)
{
- if (InnerExpression is null)
- {
- return new ComputationResult($"Bracket at position {Start} has no inner expression!");
- }
- return InnerExpression.Evaluate(dataSources);
+ error = "BinaryExpression at position " + Start + " has no RHS!";
+ return false;
}
-
- internal override bool OptimizeAst(ref Expression ex,
- [NotNullWhen(false)] ref string? error)
+ if (!Lhs.OptimizeAst(ref Lhs, ref error) || !Rhs.OptimizeAst(ref Rhs, ref error))
{
- if (InnerExpression is null)
- {
- error = "MonoExpression at position " + Start + " has no inner expression!";
- return false;
- }
- if (!InnerExpression.OptimizeAst(ref ex, ref error))
- {
- return false;
- }
- return true;
+ return false;
}
+ return true;
}
+}
- public class Literal : Value
+public abstract class Value : Expression
+{
+ public Value(int start) : base(start)
{
- public readonly float Value;
- public Literal(int start, float value) : base(start)
+ }
+
+ internal override bool OptimizeAst(ref Expression ex,
+ [NotNullWhen(false)] ref string? error)
+ {
+ return true;
+ }
+}
+
+public class Bracket : MonoExpression
+{
+ public Bracket(int start) : base(start)
+ {
+
+ }
+
+ public override ComputationResult Evaluate(IModule[] dataSources)
+ {
+ if (InnerExpression is null)
{
- Value = value;
+ return new ComputationResult($"Bracket at position {Start} has no inner expression!");
}
+ return InnerExpression.Evaluate(dataSources);
+ }
- public override ComputationResult Evaluate(IModule[] dataSources)
+ internal override bool OptimizeAst(ref Expression ex,
+ [NotNullWhen(false)] ref string? error)
+ {
+ if (InnerExpression is null)
+ {
+ error = "MonoExpression at position " + Start + " has no inner expression!";
+ return false;
+ }
+ if (!InnerExpression.OptimizeAst(ref ex, ref error))
{
- return new ComputationResult(Value);
+ return false;
}
+ return true;
+ }
+}
+
+public class Literal : Value
+{
+ public readonly float Value;
+
+ public Literal(int start, float value) : base(start)
+ {
+ Value = value;
+ }
+
+ public override ComputationResult Evaluate(IModule[] dataSources)
+ {
+ return new ComputationResult(Value);
}
}
diff --git a/src/TMG-Framework/Processing/AST/FunctionCall.cs b/src/TMG-Framework/Processing/AST/FunctionCall.cs
index 118e7b4..d0a79a0 100644
--- a/src/TMG-Framework/Processing/AST/FunctionCall.cs
+++ b/src/TMG-Framework/Processing/AST/FunctionCall.cs
@@ -16,956 +16,952 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with XTMF. If not, see (ref T first, ref T second) where T : class
- {
- var temp = first;
- first = second;
- second = temp;
- }
-
- private ComputationResult EvaluateAddIsVector(ComputationResult lhs, ComputationResult rhs, ComputationResult add)
+ else
{
- // Test the simple case of this really just being an add with a constant multiply
- if (lhs.IsValue && rhs.IsValue)
+ if (lhs.IsVectorResult || rhs.IsVectorResult)
{
- var retVector = add.Accumulator ? add.VectorData : new Vector(add.VectorData);
- VectorHelper.Add(retVector.Data, add.VectorData.Data, lhs.LiteralValue * rhs.LiteralValue);
- return new ComputationResult(retVector, true, add.Direction);
- }
- if (lhs.IsOdResult || rhs.IsOdResult)
- {
- if (lhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned)
+ if (lhs.IsVectorResult && rhs.IsVectorResult)
{
- return new ComputationResult("Unable to multiply vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
+ var retVector = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+ VectorHelper.FusedMultiplyAdd(retVector.Data, lhs.VectorData.Data, rhs.VectorData.Data, add.LiteralValue);
+ return new ComputationResult(retVector, true, lhs.Direction);
}
- if (rhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned)
+ else if (lhs.IsVectorResult)
{
- return new ComputationResult("Unable to multiply vector without directionality starting at position " + (MulRhs?.Start ?? -1) + "!");
- }
- if (add.Direction == ComputationResult.VectorDirection.Unassigned)
- {
- return new ComputationResult("Unable to add vector without directionality starting at position " + (Add?.Start ?? -1) + "!");
- }
- // if the lhs is a value just swap the two around
- if (!lhs.IsOdResult)
- {
- Swap(ref lhs, ref rhs);
- }
- //LHS is a matrix
- if (rhs.IsOdResult)
- {
- var retMatrix = rhs.Accumulator ? rhs.OdData :
- (lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData));
- var rowSize = add.VectorData.Data.Length;
- if (add.Direction == ComputationResult.VectorDirection.Vertical)
+ var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+ var flatLhs = lhs.VectorData.Data;
+ var rowSize = flatLhs.Length;
+ if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
{
for (int i = 0; i < rowSize; i++)
{
var retRow = retMatrix.GetRow(i);
- var lhsRow = lhs.OdData.GetRow(i);
var rhsRow = rhs.OdData.GetRow(i);
- VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhsRow, add.VectorData[i]);
+ VectorHelper.FusedMultiplyAdd(retRow, rhsRow, flatLhs[i], add.LiteralValue);
}
}
- else
+ else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
{
for (int i = 0; i < rowSize; i++)
{
var retRow = retMatrix.GetRow(i);
- var lhsRow = lhs.OdData.GetRow(i);
var rhsRow = rhs.OdData.GetRow(i);
- VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhsRow, add.VectorData.Data);
- }
- }
- return new ComputationResult(retMatrix, true);
- }
- else if (rhs.IsVectorResult)
- {
- var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
- var rowSize = add.VectorData.Data.Length;
- if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
- {
- if (add.Direction == ComputationResult.VectorDirection.Vertical)
- {
- for (int i = 0; i < rowSize; i++)
- {
- var retRow = retMatrix.GetRow(i);
- var lhsRow = lhs.OdData.GetRow(i);
- VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data[i], add.VectorData.Data[i]);
- }
- }
- else
- {
- for (int i = 0; i < rowSize; i++)
- {
- var retRow = retMatrix.GetRow(i);
- var lhsRow = lhs.OdData.GetRow(i);
- VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data[i], add.VectorData.Data);
- }
+ VectorHelper.FusedMultiplyAdd(retRow, rhsRow, flatLhs, add.LiteralValue);
}
}
else
{
- if (add.Direction == ComputationResult.VectorDirection.Vertical)
- {
- for (int i = 0; i < rowSize; i++)
- {
- var retRow = retMatrix.GetRow(i);
- var lhsRow = lhs.OdData.GetRow(i);
- VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data, add.VectorData.Data[i]);
- }
- }
- else
- {
- for (int i = 0; i < rowSize; i++)
- {
- var retRow = retMatrix.GetRow(i);
- var lhsRow = lhs.OdData.GetRow(i);
- VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data, add.VectorData.Data);
- }
- }
+ return new ComputationResult("Unable to add vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
}
return new ComputationResult(retMatrix, true);
}
else
{
- //RHS is a scalar
var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
- var rowSize = add.VectorData.Data.Length;
- if (add.Direction == ComputationResult.VectorDirection.Vertical)
+ var flatRhs = rhs.VectorData.Data;
+ var rowSize = flatRhs.Length;
+ if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
{
for (int i = 0; i < rowSize; i++)
{
var retRow = retMatrix.GetRow(i);
var lhsRow = lhs.OdData.GetRow(i);
- VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.LiteralValue, add.VectorData.Data[i]);
+ VectorHelper.FusedMultiplyAdd(retRow, lhsRow, flatRhs[i], add.LiteralValue);
}
}
- else
+ else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
{
for (int i = 0; i < rowSize; i++)
{
var retRow = retMatrix.GetRow(i);
var lhsRow = lhs.OdData.GetRow(i);
- VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.LiteralValue, add.VectorData.Data);
+ VectorHelper.FusedMultiplyAdd(retRow, lhsRow, flatRhs, add.LiteralValue);
}
}
+ else
+ {
+ return new ComputationResult("Unable to add vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
+ }
return new ComputationResult(retMatrix, true);
}
}
- // vector cases
else
{
- // if the lhs is a value just swap the two around
- if (lhs.IsValue)
- {
- Swap(ref lhs, ref rhs);
- }
- // vector * vector + vector
- if (rhs.IsVectorResult)
- {
- var retVector = add.Accumulator ? add.VectorData :
- (rhs.Accumulator ? rhs.VectorData :
- (lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData)));
- VectorHelper.FusedMultiplyAdd(retVector.Data, lhs.VectorData.Data, rhs.VectorData.Data, add.VectorData.Data);
- return new ComputationResult(retVector, true, add.Direction == lhs.Direction && add.Direction == rhs.Direction ? add.Direction : ComputationResult.VectorDirection.Unassigned);
- }
- // vector * lit + vector
- else
- {
- var retVector = add.Accumulator ? add.VectorData :
- (lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData));
- VectorHelper.FusedMultiplyAdd(retVector.Data, lhs.VectorData.Data, rhs.LiteralValue,
- add.VectorData.Data);
- return new ComputationResult(retVector, true, add.Direction == lhs.Direction && add.Direction == rhs.Direction ? add.Direction : ComputationResult.VectorDirection.Unassigned);
- }
+ var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
+ var flatAdd = add.LiteralValue;
+ var rowSize = retMatrix.RowCategories.Count;
+
+ VectorHelper.FusedMultiplyAdd(retMatrix.Data, lhs.OdData.Data,
+ rhs.OdData.Data, flatAdd);
+
+ return new ComputationResult(retMatrix, true);
}
}
+ }
- private ComputationResult EvaluateAddIsMatrix(ComputationResult lhs, ComputationResult rhs, ComputationResult add)
+ private static void Swap(ref T first, ref T second) where T : class
+ {
+ var temp = first;
+ first = second;
+ second = temp;
+ }
+
+ private ComputationResult EvaluateAddIsVector(ComputationResult lhs, ComputationResult rhs, ComputationResult add)
+ {
+ // Test the simple case of this really just being an add with a constant multiply
+ if (lhs.IsValue && rhs.IsValue)
+ {
+ var retVector = add.Accumulator ? add.VectorData : new Vector(add.VectorData);
+ VectorHelper.Add(retVector.Data, add.VectorData.Data, lhs.LiteralValue * rhs.LiteralValue);
+ return new ComputationResult(retVector, true, add.Direction);
+ }
+ if (lhs.IsOdResult || rhs.IsOdResult)
{
if (lhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned)
{
return new ComputationResult("Unable to multiply vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
}
- if (rhs.IsVectorResult && rhs.Direction == ComputationResult.VectorDirection.Unassigned)
+ if (rhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned)
{
return new ComputationResult("Unable to multiply vector without directionality starting at position " + (MulRhs?.Start ?? -1) + "!");
}
- // Ensure that the LHS is a higher or equal order to the RHS (Matrix > Vector > Scalar)
- if (!lhs.IsOdResult)
+ if (add.Direction == ComputationResult.VectorDirection.Unassigned)
{
- Swap(ref lhs, ref rhs);
+ return new ComputationResult("Unable to add vector without directionality starting at position " + (Add?.Start ?? -1) + "!");
}
- if (lhs.IsValue)
+ // if the lhs is a value just swap the two around
+ if (!lhs.IsOdResult)
{
Swap(ref lhs, ref rhs);
}
- // LHS is now a higher or equal to the order of RHS
- if (lhs.IsOdResult)
+ //LHS is a matrix
+ if (rhs.IsOdResult)
{
- if (rhs.IsOdResult)
+ var retMatrix = rhs.Accumulator ? rhs.OdData :
+ (lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData));
+ var rowSize = add.VectorData.Data.Length;
+ if (add.Direction == ComputationResult.VectorDirection.Vertical)
{
- var retMatrix = add.Accumulator ? add.OdData :
- (lhs.Accumulator ? lhs.OdData :
- (rhs.Accumulator ? rhs.OdData : new Matrix(add.OdData)));
- var flatRet = retMatrix.Data;
- var flatLhs = lhs.OdData.Data;
- var flatRhs = rhs.OdData.Data;
- var flatAdd = add.OdData.Data;
- var rowSize = retMatrix.RowCategories.Count;
- VectorHelper.FusedMultiplyAdd(flatRet, flatLhs, flatRhs, flatAdd);
- return new ComputationResult(retMatrix, true);
+ for (int i = 0; i < rowSize; i++)
+ {
+ var retRow = retMatrix.GetRow(i);
+ var lhsRow = lhs.OdData.GetRow(i);
+ var rhsRow = rhs.OdData.GetRow(i);
+ VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhsRow, add.VectorData[i]);
+ }
}
- else if (rhs.IsVectorResult)
+ else
{
- var retMatrix = add.Accumulator ? add.OdData :
- (lhs.Accumulator ? lhs.OdData : new Matrix(add.OdData));
- var flatRet = retMatrix.Data;
- var flatLhs = lhs.OdData.Data;
- var flatRhs = rhs.VectorData.Data;
- var flatAdd = add.OdData.Data;
- var rowSize = retMatrix.RowCategories.Count;
- if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+ for (int i = 0; i < rowSize; i++)
+ {
+ var retRow = retMatrix.GetRow(i);
+ var lhsRow = lhs.OdData.GetRow(i);
+ var rhsRow = rhs.OdData.GetRow(i);
+ VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhsRow, add.VectorData.Data);
+ }
+ }
+ return new ComputationResult(retMatrix, true);
+ }
+ else if (rhs.IsVectorResult)
+ {
+ var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+ var rowSize = add.VectorData.Data.Length;
+ if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+ {
+ if (add.Direction == ComputationResult.VectorDirection.Vertical)
{
for (int i = 0; i < rowSize; i++)
{
var retRow = retMatrix.GetRow(i);
var lhsRow = lhs.OdData.GetRow(i);
- var addRow = add.OdData.GetRow(i);
- VectorHelper.FusedMultiplyAdd(retRow, lhsRow, flatRhs[i], addRow);
+ VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data[i], add.VectorData.Data[i]);
}
}
else
@@ -455,85 +308,227 @@ private ComputationResult EvaluateAddIsMatrix(ComputationResult lhs, Computation
{
var retRow = retMatrix.GetRow(i);
var lhsRow = lhs.OdData.GetRow(i);
- var addRow = add.OdData.GetRow(i);
- VectorHelper.FusedMultiplyAdd(retRow, lhsRow, flatRhs, addRow);
+ VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data[i], add.VectorData.Data);
}
}
- return new ComputationResult(retMatrix, true);
}
else
{
- //RHS is scalar
- var retMatrix = add.Accumulator ? add.OdData :
- (lhs.Accumulator ? lhs.OdData : new Matrix(add.OdData));
- VectorHelper.FusedMultiplyAdd(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue, add.OdData.Data);
- return new ComputationResult(retMatrix, true);
+ if (add.Direction == ComputationResult.VectorDirection.Vertical)
+ {
+ for (int i = 0; i < rowSize; i++)
+ {
+ var retRow = retMatrix.GetRow(i);
+ var lhsRow = lhs.OdData.GetRow(i);
+ VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data, add.VectorData.Data[i]);
+ }
+ }
+ else
+ {
+ for (int i = 0; i < rowSize; i++)
+ {
+ var retRow = retMatrix.GetRow(i);
+ var lhsRow = lhs.OdData.GetRow(i);
+ VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data, add.VectorData.Data);
+ }
+ }
}
+ return new ComputationResult(retMatrix, true);
}
- else if (lhs.IsVectorResult)
+ else
{
- var retMatrix = add.Accumulator ? add.OdData : new Matrix(add.OdData);
- var tempVector = lhs.Accumulator ? lhs.VectorData : (rhs.IsVectorResult && rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
- var flatRet = retMatrix.Data;
- var flatAdd = add.OdData.Data;
- var rowSize = tempVector.Data.Length;
- // compute the multiplication separately in this case for better performance (n multiplies instead of n^2)
- if (rhs.IsVectorResult)
+ //RHS is a scalar
+ var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+ var rowSize = add.VectorData.Data.Length;
+ if (add.Direction == ComputationResult.VectorDirection.Vertical)
{
- if (lhs.Direction != rhs.Direction)
+ for (int i = 0; i < rowSize; i++)
{
- // if the directions don't add up then the sum operation would be undefined!
- return new ComputationResult("Unable to add vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
+ var retRow = retMatrix.GetRow(i);
+ var lhsRow = lhs.OdData.GetRow(i);
+ VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.LiteralValue, add.VectorData.Data[i]);
}
- VectorHelper.Multiply(tempVector.Data, lhs.VectorData.Data, rhs.VectorData.Data);
}
else
{
- VectorHelper.Multiply(tempVector.Data, lhs.VectorData.Data, rhs.LiteralValue);
+ for (int i = 0; i < rowSize; i++)
+ {
+ var retRow = retMatrix.GetRow(i);
+ var lhsRow = lhs.OdData.GetRow(i);
+ VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.LiteralValue, add.VectorData.Data);
+ }
}
-
- if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
+ return new ComputationResult(retMatrix, true);
+ }
+ }
+ // vector cases
+ else
+ {
+ // if the lhs is a value just swap the two around
+ if (lhs.IsValue)
+ {
+ Swap(ref lhs, ref rhs);
+ }
+ // vector * vector + vector
+ if (rhs.IsVectorResult)
+ {
+ var retVector = add.Accumulator ? add.VectorData :
+ (rhs.Accumulator ? rhs.VectorData :
+ (lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData)));
+ VectorHelper.FusedMultiplyAdd(retVector.Data, lhs.VectorData.Data, rhs.VectorData.Data, add.VectorData.Data);
+ return new ComputationResult(retVector, true, add.Direction == lhs.Direction && add.Direction == rhs.Direction ? add.Direction : ComputationResult.VectorDirection.Unassigned);
+ }
+ // vector * lit + vector
+ else
+ {
+ var retVector = add.Accumulator ? add.VectorData :
+ (lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData));
+ VectorHelper.FusedMultiplyAdd(retVector.Data, lhs.VectorData.Data, rhs.LiteralValue,
+ add.VectorData.Data);
+ return new ComputationResult(retVector, true, add.Direction == lhs.Direction && add.Direction == rhs.Direction ? add.Direction : ComputationResult.VectorDirection.Unassigned);
+ }
+ }
+ }
+
+ private ComputationResult EvaluateAddIsMatrix(ComputationResult lhs, ComputationResult rhs, ComputationResult add)
+ {
+ if (lhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned)
+ {
+ return new ComputationResult("Unable to multiply vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
+ }
+ if (rhs.IsVectorResult && rhs.Direction == ComputationResult.VectorDirection.Unassigned)
+ {
+ return new ComputationResult("Unable to multiply vector without directionality starting at position " + (MulRhs?.Start ?? -1) + "!");
+ }
+ // Ensure that the LHS is a higher or equal order to the RHS (Matrix > Vector > Scalar)
+ if (!lhs.IsOdResult)
+ {
+ Swap(ref lhs, ref rhs);
+ }
+ if (lhs.IsValue)
+ {
+ Swap(ref lhs, ref rhs);
+ }
+ // LHS is now a higher or equal to the order of RHS
+ if (lhs.IsOdResult)
+ {
+ if (rhs.IsOdResult)
+ {
+ var retMatrix = add.Accumulator ? add.OdData :
+ (lhs.Accumulator ? lhs.OdData :
+ (rhs.Accumulator ? rhs.OdData : new Matrix(add.OdData)));
+ var flatRet = retMatrix.Data;
+ var flatLhs = lhs.OdData.Data;
+ var flatRhs = rhs.OdData.Data;
+ var flatAdd = add.OdData.Data;
+ var rowSize = retMatrix.RowCategories.Count;
+ VectorHelper.FusedMultiplyAdd(flatRet, flatLhs, flatRhs, flatAdd);
+ return new ComputationResult(retMatrix, true);
+ }
+ else if (rhs.IsVectorResult)
+ {
+ var retMatrix = add.Accumulator ? add.OdData :
+ (lhs.Accumulator ? lhs.OdData : new Matrix(add.OdData));
+ var flatRet = retMatrix.Data;
+ var flatLhs = lhs.OdData.Data;
+ var flatRhs = rhs.VectorData.Data;
+ var flatAdd = add.OdData.Data;
+ var rowSize = retMatrix.RowCategories.Count;
+ if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
{
- Parallel.For(0, rowSize, (int i) =>
+ for (int i = 0; i < rowSize; i++)
{
- var flatTemp = tempVector.Data;
var retRow = retMatrix.GetRow(i);
+ var lhsRow = lhs.OdData.GetRow(i);
var addRow = add.OdData.GetRow(i);
- VectorHelper.Add(retRow, addRow, flatTemp[i]);
- });
+ VectorHelper.FusedMultiplyAdd(retRow, lhsRow, flatRhs[i], addRow);
+ }
}
else
{
- Parallel.For(0, rowSize, (int i) =>
+ for (int i = 0; i < rowSize; i++)
{
- var flatTemp = tempVector.Data;
var retRow = retMatrix.GetRow(i);
+ var lhsRow = lhs.OdData.GetRow(i);
var addRow = add.OdData.GetRow(i);
- VectorHelper.Add(retRow, flatTemp, addRow);
- });
+ VectorHelper.FusedMultiplyAdd(retRow, lhsRow, flatRhs, addRow);
+ }
}
return new ComputationResult(retMatrix, true);
}
else
{
- // in this case LHS is a scalar, and therefore RHS is also a scalar
- var retMatrix = add.Accumulator ? add.OdData : new Matrix(add.OdData);
- VectorHelper.Add(retMatrix.Data, add.OdData.Data, lhs.LiteralValue * rhs.LiteralValue);
+ //RHS is scalar
+ var retMatrix = add.Accumulator ? add.OdData :
+ (lhs.Accumulator ? lhs.OdData : new Matrix(add.OdData));
+ VectorHelper.FusedMultiplyAdd(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue, add.OdData.Data);
return new ComputationResult(retMatrix, true);
}
}
-
- internal override bool OptimizeAst(ref Expression ex,
- [NotNullWhen(false)] ref string? error)
+ else if (lhs.IsVectorResult)
{
- if (MulLhs is null || MulRhs is null || Add is null)
+ var retMatrix = add.Accumulator ? add.OdData : new Matrix(add.OdData);
+ var tempVector = lhs.Accumulator ? lhs.VectorData : (rhs.IsVectorResult && rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+ var flatRet = retMatrix.Data;
+ var flatAdd = add.OdData.Data;
+ var rowSize = tempVector.Data.Length;
+ // compute the multiplication separately in this case for better performance (n multiplies instead of n^2)
+ if (rhs.IsVectorResult)
+ {
+ if (lhs.Direction != rhs.Direction)
+ {
+ // if the directions don't add up then the sum operation would be undefined!
+ return new ComputationResult("Unable to add vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
+ }
+ VectorHelper.Multiply(tempVector.Data, lhs.VectorData.Data, rhs.VectorData.Data);
+ }
+ else
{
- error = "Unable to optimize FusedMultiplyAdd with null operands starting at position " + Start + "!";
- return false;
+ VectorHelper.Multiply(tempVector.Data, lhs.VectorData.Data, rhs.LiteralValue);
}
- return !(!MulLhs.OptimizeAst(ref MulLhs, ref error)
- || !MulLhs.OptimizeAst(ref MulRhs, ref error)
- || !MulLhs.OptimizeAst(ref Add, ref error));
+
+ if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
+ {
+ Parallel.For(0, rowSize, (int i) =>
+ {
+ var flatTemp = tempVector.Data;
+ var retRow = retMatrix.GetRow(i);
+ var addRow = add.OdData.GetRow(i);
+ VectorHelper.Add(retRow, addRow, flatTemp[i]);
+ });
+ }
+ else
+ {
+ Parallel.For(0, rowSize, (int i) =>
+ {
+ var flatTemp = tempVector.Data;
+ var retRow = retMatrix.GetRow(i);
+ var addRow = add.OdData.GetRow(i);
+ VectorHelper.Add(retRow, flatTemp, addRow);
+ });
+ }
+ return new ComputationResult(retMatrix, true);
}
+ else
+ {
+ // in this case LHS is a scalar, and therefore RHS is also a scalar
+ var retMatrix = add.Accumulator ? add.OdData : new Matrix(add.OdData);
+ VectorHelper.Add(retMatrix.Data, add.OdData.Data, lhs.LiteralValue * rhs.LiteralValue);
+ return new ComputationResult(retMatrix, true);
+ }
+ }
+
+ internal override bool OptimizeAst(ref Expression ex,
+ [NotNullWhen(false)] ref string? error)
+ {
+ if (MulLhs is null || MulRhs is null || Add is null)
+ {
+ error = "Unable to optimize FusedMultiplyAdd with null operands starting at position " + Start + "!";
+ return false;
+ }
+ return !(!MulLhs.OptimizeAst(ref MulLhs, ref error)
+ || !MulLhs.OptimizeAst(ref MulRhs, ref error)
+ || !MulLhs.OptimizeAst(ref Add, ref error));
}
}
+
diff --git a/src/TMG-Framework/Processing/AST/Multiply.cs b/src/TMG-Framework/Processing/AST/Multiply.cs
index 6da478d..239acb7 100644
--- a/src/TMG-Framework/Processing/AST/Multiply.cs
+++ b/src/TMG-Framework/Processing/AST/Multiply.cs
@@ -17,151 +17,149 @@ You should have received a copy of the GNU General Public License
along with XTMF. If not, see odSource)
+ {
+ return new ComputationResult(odSource.Invoke(), false);
+ }
+ if (source is IFunction vectorSource)
+ {
+ return new ComputationResult(vectorSource.Invoke(), false);
+ }
+ if (source is IFunction valueSource)
+ {
+ return new ComputationResult(valueSource.Invoke());
+ }
+ if (source is IFunction map)
{
- var source = dataSources.FirstOrDefault(d => d.Name == Name);
- if (source == null)
- {
- return new ComputationResult("Unable to find a data source named '" + Name + "'!");
- }
- if (source is IFunction odSource)
- {
- return new ComputationResult(odSource.Invoke(), false);
- }
- if (source is IFunction vectorSource)
- {
- return new ComputationResult(vectorSource.Invoke(), false);
- }
- if (source is IFunction valueSource)
- {
- return new ComputationResult(valueSource.Invoke());
- }
- if(source is IFunction map)
- {
- return new ComputationResult(new Vector(map.Invoke()), true, ComputationResult.VectorDirection.Unassigned);
- }
- return new ComputationResult("The data source '" + Name + "' was not of a valid resource type!");
+ return new ComputationResult(new Vector(map.Invoke()), true, ComputationResult.VectorDirection.Unassigned);
}
+ return new ComputationResult("The data source '" + Name + "' was not of a valid resource type!");
}
}
diff --git a/src/TMG-Framework/Processing/AppendMatrixValueToCSV.cs b/src/TMG-Framework/Processing/AppendMatrixValueToCSV.cs
index e32a164..70a5fe1 100644
--- a/src/TMG-Framework/Processing/AppendMatrixValueToCSV.cs
+++ b/src/TMG-Framework/Processing/AppendMatrixValueToCSV.cs
@@ -16,77 +16,72 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see ColumnName = null!;
+ [Parameter(Name = "Column Name", DefaultValue = "Value", Description = "The name to use for the column", Index = 0)]
+ public IFunction ColumnName = null!;
- [Parameter(Name = "Row Index", DefaultValue = "1", Description = "The 0 indexed column containing the sparse map index for the row.", Index = 1)]
- public IFunction RowIndex = null!;
+ [Parameter(Name = "Row Index", DefaultValue = "1", Description = "The 0 indexed column containing the sparse map index for the row.", Index = 1)]
+ public IFunction RowIndex = null!;
- [Parameter(Name = "Column Index", DefaultValue = "2", Description = "The 0 indexed column containing the sparse map index for the column.", Index = 2)]
- public IFunction ColumnIndex = null!;
+ [Parameter(Name = "Column Index", DefaultValue = "2", Description = "The 0 indexed column containing the sparse map index for the column.", Index = 2)]
+ public IFunction ColumnIndex = null!;
- [SubModule(Name = "Matrix", Index = 3, Description = "The matrix to assign.", Required = true)]
- public IFunction Matrix = null!;
+ [SubModule(Name = "Matrix", Index = 3, Description = "The matrix to assign.", Required = true)]
+ public IFunction Matrix = null!;
- [SubModule(Name = "Input Stream", Index = 4, Description = "The stream contianing the CSV file.", Required = true)]
- public IFunction InputStream = null!;
+ [SubModule(Name = "Input Stream", Index = 4, Description = "The stream contianing the CSV file.", Required = true)]
+ public IFunction InputStream = null!;
- [SubModule(Name = "Output Stream", Index = 5, Description = "The stream to store the results.", Required = true)]
- public IFunction OutputStream = null!;
+ [SubModule(Name = "Output Stream", Index = 5, Description = "The stream to store the results.", Required = true)]
+ public IFunction OutputStream = null!;
- public override void Invoke()
+ public override void Invoke()
+ {
+ var matrix = Matrix!.Invoke();
+ var columnName = ColumnName?.Invoke();
+ // name sure we don't just have a blank header
+ columnName = String.IsNullOrEmpty(columnName) ? "Value" : columnName;
+ using var reader = new CsvReader(InputStream!.Invoke(), false);
+ using var writer = new StreamWriter(OutputStream!.Invoke());
+ int rowIndex = RowIndex!.Invoke();
+ int columnIndex = ColumnIndex!.Invoke();
+ int minimumRowSize = Math.Max(rowIndex, columnIndex) + 1;
+ // Process header
+ var headers = reader.Headers;
+ for (int i = 0; i < headers.Length; i++)
{
- var matrix = Matrix!.Invoke();
- var columnName = ColumnName?.Invoke();
- // name sure we don't just have a blank header
- columnName = String.IsNullOrEmpty(columnName) ? "Value" : columnName;
- using var reader = new CsvReader(InputStream!.Invoke(), false);
- using var writer = new StreamWriter(OutputStream!.Invoke());
- int rowIndex = RowIndex!.Invoke();
- int columnIndex = ColumnIndex!.Invoke();
- int minimumRowSize = Math.Max(rowIndex, columnIndex) + 1;
- // Process header
- var headers = reader.Headers;
- for (int i = 0; i < headers.Length; i++)
- {
- writer.Write(headers[i]);
- // it is safe to just have a comma after since we are adding a new column
- writer.Write(',');
- }
- writer.Write(columnName);
- writer.WriteLine();
- // Process main body
- while(reader.LoadLine(out var columns))
+ writer.Write(headers[i]);
+ // it is safe to just have a comma after since we are adding a new column
+ writer.Write(',');
+ }
+ writer.Write(columnName);
+ writer.WriteLine();
+ // Process main body
+ while (reader.LoadLine(out var columns))
+ {
+ if (columns >= minimumRowSize)
{
- if (columns >= minimumRowSize)
+ // copy all of the old values
+ for (int i = 0; i < columns; i++)
{
- // copy all of the old values
- for (int i = 0; i < columns; i++)
- {
- reader.Get(out string value, i);
- writer.Write(value);
- writer.Write(',');
- }
- reader.Get(out int o, rowIndex);
- reader.Get(out int d, columnIndex);
- writer.WriteLine(matrix.GetFromSparseIndexes(o, d));
+ reader.Get(out string value, i);
+ writer.Write(value);
+ writer.Write(',');
}
+ reader.Get(out int o, rowIndex);
+ reader.Get(out int d, columnIndex);
+ writer.WriteLine(matrix.GetFromSparseIndexes(o, d));
}
}
}
diff --git a/src/TMG-Framework/Processing/Evaluate2DGravityModel.cs b/src/TMG-Framework/Processing/Evaluate2DGravityModel.cs
index de3fb24..8bf2d83 100644
--- a/src/TMG-Framework/Processing/Evaluate2DGravityModel.cs
+++ b/src/TMG-Framework/Processing/Evaluate2DGravityModel.cs
@@ -16,115 +16,110 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
{
- [Module(Name = "Evaluate 2D Gravity Model", Description = "Evaluate the result of the 2D Gravity model.",
- DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
- public sealed class Evaluate2DGravityModel : BaseFunction
- {
- [SubModule(Name = "Production", Required = true, Index = 0, Description = "")]
- public IFunction Production = null!;
+ [SubModule(Name = "Production", Required = true, Index = 0, Description = "")]
+ public IFunction Production = null!;
- [SubModule(Name = "Attraction", Required = true, Index = 1, Description = "")]
- public IFunction Attraction = null!;
+ [SubModule(Name = "Attraction", Required = true, Index = 1, Description = "")]
+ public IFunction Attraction = null!;
- [SubModule(Name = "Friction", Required = true, Index = 2, Description = "")]
- public IFunction Friction = null!;
+ [SubModule(Name = "Friction", Required = true, Index = 2, Description = "")]
+ public IFunction Friction = null!;
- [Parameter(Name = "Max Iterations", Index = 3, DefaultValue = "100", Description = "The maximum number of iterations before terminating.")]
- public IFunction MaxIterations = null!;
+ [Parameter(Name = "Max Iterations", Index = 3, DefaultValue = "100", Description = "The maximum number of iterations before terminating.")]
+ public IFunction MaxIterations = null!;
- [Parameter(Name = "Max Error", Index = 4, DefaultValue = "0.05", Description = "The maximum amount of error before terminating.")]
- public IFunction MaxError = null!;
+ [Parameter(Name = "Max Error", Index = 4, DefaultValue = "0.05", Description = "The maximum amount of error before terminating.")]
+ public IFunction MaxError = null!;
- private static void Apply(Matrix ret, Matrix friction, Vector production,
- Vector attraction, Vector attractionStar, float[] columnTotals)
- {
- Parallel.For(0, production.Count, new ParallelOptions() { MaxDegreeOfParallelism = Environment.ProcessorCount },
- () => new float[columnTotals.Length],
- (flatOrigin, state, localTotals) =>
+ private static void Apply(Matrix ret, Matrix friction, Vector production,
+ Vector attraction, Vector attractionStar, float[] columnTotals)
+ {
+ Parallel.For(0, production.Count, new ParallelOptions() { MaxDegreeOfParallelism = Environment.ProcessorCount },
+ () => new float[columnTotals.Length],
+ (flatOrigin, state, localTotals) =>
+ {
+ var sProduction = production.Data;
+ var length = sProduction.Length;
+ var rowIndex = length * flatOrigin;
+ var sAttraction = attraction.Data;
+ var sFriction = friction.Data.Slice(rowIndex, length);
+ var sRet = ret.Data.Slice(rowIndex, length);
+ var sAttractionStar = attractionStar.Data;
+
+ // check to see if there is no production, if not skip this
+ if (sProduction[flatOrigin] > 0)
{
- var sProduction = production.Data;
- var length = sProduction.Length;
- var rowIndex = length * flatOrigin;
- var sAttraction = attraction.Data;
- var sFriction = friction.Data.Slice(rowIndex, length);
- var sRet = ret.Data.Slice(rowIndex, length);
- var sAttractionStar = attractionStar.Data;
-
- // check to see if there is no production, if not skip this
- if (sProduction[flatOrigin] > 0)
+ var sumAf = VectorHelper.Multiply3AndSum(sFriction, sAttraction, sAttractionStar);
+ sumAf = (sProduction[flatOrigin] / sumAf);
+ if (float.IsInfinity(sumAf) | float.IsNaN(sumAf))
{
- var sumAf = VectorHelper.Multiply3AndSum(sFriction, sAttraction, sAttractionStar);
- sumAf = (sProduction[flatOrigin] / sumAf);
- if (float.IsInfinity(sumAf) | float.IsNaN(sumAf))
- {
- // this needs to be 0f, otherwise we will be making the attractions have to be balanced higher
- sumAf = 0f;
- }
- VectorHelper.Multiply3Scalar1AndColumnSum(sRet, sFriction, sAttraction, sAttractionStar, sumAf, localTotals.AsSpan());
+ // this needs to be 0f, otherwise we will be making the attractions have to be balanced higher
+ sumAf = 0f;
}
- return localTotals;
- },
- localTotals =>
- {
- lock (columnTotals)
- {
- VectorHelper.Add(columnTotals, 0, columnTotals, 0, localTotals, 0, columnTotals.Length);
+ VectorHelper.Multiply3Scalar1AndColumnSum(sRet, sFriction, sAttraction, sAttractionStar, sumAf, localTotals.AsSpan());
}
- });
- }
+ return localTotals;
+ },
+ localTotals =>
+ {
+ lock (columnTotals)
+ {
+ VectorHelper.Add(columnTotals, 0, columnTotals, 0, localTotals, 0, columnTotals.Length);
+ }
+ });
+ }
- private bool Balance(Vector flatAttractions, Vector flatAttractionStar, float epsilon, float[] columnTotals)
+ private bool Balance(Vector flatAttractions, Vector flatAttractionStar, float epsilon, float[] columnTotals)
+ {
+ VectorHelper.Divide(columnTotals.AsSpan(), flatAttractions.Data, columnTotals.AsSpan());
+ VectorHelper.Multiply(flatAttractionStar.Data, flatAttractionStar.Data, columnTotals);
+ VectorHelper.ReplaceIfNotFinite(flatAttractionStar.Data, 1.0f);
+ return VectorHelper.AreBoundedBy(columnTotals, 0, 1.0f, epsilon, columnTotals.Length);
+ }
+
+ public override Matrix Invoke()
+ {
+ var production = Production.Invoke();
+ var attraction = Attraction.Invoke();
+ var friction = Friction.Invoke();
+ var attractionStar = new Vector(attraction);
+ SetToOne(attractionStar);
+ var ret = new Matrix(friction);
+ var maxIterations = MaxIterations.Invoke();
+ var maxError = MaxError.Invoke();
+ if (production.Categories != attraction.Categories)
{
- VectorHelper.Divide(columnTotals.AsSpan(), flatAttractions.Data, columnTotals.AsSpan());
- VectorHelper.Multiply(flatAttractionStar.Data, flatAttractionStar.Data, columnTotals);
- VectorHelper.ReplaceIfNotFinite(flatAttractionStar.Data, 1.0f);
- return VectorHelper.AreBoundedBy(columnTotals, 0, 1.0f, epsilon, columnTotals.Length);
+ throw new XTMFRuntimeException(this, "The production and attraction are not of the same type.");
}
-
- public override Matrix Invoke()
+ if (production.Categories != friction.RowCategories)
{
- var production = Production.Invoke();
- var attraction = Attraction.Invoke();
- var friction = Friction.Invoke();
- var attractionStar = new Vector(attraction);
- SetToOne(attractionStar);
- var ret = new Matrix(friction);
- var maxIterations = MaxIterations.Invoke();
- var maxError = MaxError.Invoke();
- if (production.Categories != attraction.Categories)
- {
- throw new XTMFRuntimeException(this, "The production and attraction are not of the same type.");
- }
- if (production.Categories != friction.RowCategories)
- {
- throw new XTMFRuntimeException(this, "The production and friction are not of the same type.");
- }
- float[] columnTotals = new float[attraction.Data.Length];
- int iteration = 0;
- do
- {
- Array.Clear(columnTotals, 0, columnTotals.Length);
- Apply(ret, friction, production, attraction, attractionStar, columnTotals);
- } while (!Balance(attraction, attractionStar, maxError, columnTotals) || (++iteration < maxIterations));
- return ret;
+ throw new XTMFRuntimeException(this, "The production and friction are not of the same type.");
}
+ float[] columnTotals = new float[attraction.Data.Length];
+ int iteration = 0;
+ do
+ {
+ Array.Clear(columnTotals, 0, columnTotals.Length);
+ Apply(ret, friction, production, attraction, attractionStar, columnTotals);
+ } while (!Balance(attraction, attractionStar, maxError, columnTotals) || (++iteration < maxIterations));
+ return ret;
+ }
- private static void SetToOne(Vector attractionStar)
+ private static void SetToOne(Vector attractionStar)
+ {
+ var aStarData = attractionStar.Data;
+ for (int i = 0; i < aStarData.Length; i++)
{
- var aStarData = attractionStar.Data;
- for (int i = 0; i < aStarData.Length; i++)
- {
- aStarData[i] = 1.0f;
- }
+ aStarData[i] = 1.0f;
}
}
}
diff --git a/src/TMG-Framework/Processing/EvaluateMatrix.cs b/src/TMG-Framework/Processing/EvaluateMatrix.cs
index 50104b0..910cf53 100644
--- a/src/TMG-Framework/Processing/EvaluateMatrix.cs
+++ b/src/TMG-Framework/Processing/EvaluateMatrix.cs
@@ -16,71 +16,67 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
{
- [Module(Name = "Evaluate Matrix", Description = "Evaluates a matrix given the expression.",
- DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
- public class EvaluateMatrix : BaseFunction
- {
- [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
- public IFunction Expression = null!;
+ [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
+ public IFunction Expression = null!;
- [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
- public IModule[] Variables = null!;
+ [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
+ public IModule[] Variables = null!;
- private string? PreviousExpressionString = null;
- private Expression? PreviousExpression = null;
+ private string? PreviousExpressionString = null;
+ private Expression? PreviousExpression = null;
- public override Matrix Invoke()
+ public override Matrix Invoke()
+ {
+ string? error = null;
+ // compile and optimize the expression
+ var expressionString = Expression.Invoke();
+ if (PreviousExpression == null || expressionString != PreviousExpressionString)
{
- string? error = null;
- // compile and optimize the expression
- var expressionString = Expression.Invoke();
- if (PreviousExpression == null || expressionString != PreviousExpressionString)
- {
- PreviousExpressionString = expressionString;
- if (!TMG.Frameworks.Data.Processing.AST.Compiler.Compile(expressionString, out var expression, ref error))
- {
- throw new XTMFRuntimeException(this, error);
- }
- PreviousExpression = expression;
- }
- var result = PreviousExpression.Evaluate(Variables);
- if(result.Error)
- {
- throw new XTMFRuntimeException(this, result.ErrorMessage);
- }
- // this easy case, the expression was of the correct type
- if(result.IsOdResult)
- {
- return result.OdData;
- }
- // if the result ended up being a
- if(result.IsVectorResult)
+ PreviousExpressionString = expressionString;
+ if (!TMG.Frameworks.Data.Processing.AST.Compiler.Compile(expressionString, out var expression, ref error))
{
- throw new XTMFRuntimeException(this, "The expression resulted in a vector instead of a matrix!");
+ throw new XTMFRuntimeException(this, error);
}
- throw new XTMFRuntimeException(this, "The expression resulted in a scalar instead of a matrix!");
+ PreviousExpression = expression;
+ }
+ var result = PreviousExpression.Evaluate(Variables);
+ if (result.Error)
+ {
+ throw new XTMFRuntimeException(this, result.ErrorMessage);
+ }
+ // this easy case, the expression was of the correct type
+ if (result.IsOdResult)
+ {
+ return result.OdData;
}
+ // if the result ended up being a
+ if (result.IsVectorResult)
+ {
+ throw new XTMFRuntimeException(this, "The expression resulted in a vector instead of a matrix!");
+ }
+ throw new XTMFRuntimeException(this, "The expression resulted in a scalar instead of a matrix!");
+ }
- public override bool RuntimeValidation(ref string? error)
+ public override bool RuntimeValidation(ref string? error)
+ {
+ foreach (var module in Variables)
{
- foreach(var module in Variables)
+ if (!(module is IFunction || module is IFunction || module is IFunction
+ || module is IFunction))
{
- if(!(module is IFunction || module is IFunction || module is IFunction
- || module is IFunction))
- {
- error = $"Invalid variable module type {module.GetType().Name} from module {module.Name}!";
- return false;
- }
+ error = $"Invalid variable module type {module.GetType().Name} from module {module.Name}!";
+ return false;
}
- return true;
}
+ return true;
}
}
diff --git a/src/TMG-Framework/Processing/EvaluateScalar.cs b/src/TMG-Framework/Processing/EvaluateScalar.cs
index db146a6..2b17362 100644
--- a/src/TMG-Framework/Processing/EvaluateScalar.cs
+++ b/src/TMG-Framework/Processing/EvaluateScalar.cs
@@ -16,61 +16,55 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
{
- [Module(Name = "Evaluate Scalar", Description = "Evaluate a scalar given the expression.",
- DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
- public class EvaluateScalar : BaseFunction
- {
- [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
- public IFunction Expression = null!;
+ [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
+ public IFunction Expression = null!;
- [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
- public IModule[] Variables = null!;
+ [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
+ public IModule[] Variables = null!;
- public override float Invoke()
+ public override float Invoke()
+ {
+ string? error = null;
+ // compile and optimize the expression
+ if (!TMG.Frameworks.Data.Processing.AST.Compiler.Compile(Expression.Invoke(), out var expression, ref error))
{
- string? error = null;
- // compile and optimize the expression
- if (!TMG.Frameworks.Data.Processing.AST.Compiler.Compile(Expression.Invoke(), out var expression, ref error))
- {
- throw new XTMFRuntimeException(this, error);
- }
- var result = expression.Evaluate(Variables);
- if (result.Error)
- {
- throw new XTMFRuntimeException(this, result.ErrorMessage);
- }
- if (result.IsVectorResult)
- {
- throw new XTMFRuntimeException(this, "The expression resulted in a vector instead of a scalar!");
- }
- if (result.IsOdResult)
- {
- throw new XTMFRuntimeException(this, "The expression resulted in a matrix instead of a scalar!");
- }
- return result.LiteralValue;
-
+ throw new XTMFRuntimeException(this, error);
+ }
+ var result = expression.Evaluate(Variables);
+ if (result.Error)
+ {
+ throw new XTMFRuntimeException(this, result.ErrorMessage);
+ }
+ if (result.IsVectorResult)
+ {
+ throw new XTMFRuntimeException(this, "The expression resulted in a vector instead of a scalar!");
}
+ if (result.IsOdResult)
+ {
+ throw new XTMFRuntimeException(this, "The expression resulted in a matrix instead of a scalar!");
+ }
+ return result.LiteralValue;
- public override bool RuntimeValidation(ref string? error)
+ }
+
+ public override bool RuntimeValidation(ref string? error)
+ {
+ foreach (var module in Variables)
{
- foreach (var module in Variables)
+ if (!(module is IFunction || module is IFunction || module is IFunction
+ || module is IFunction))
{
- if (!(module is IFunction || module is IFunction || module is IFunction
- || module is IFunction))
- {
- error = $"Invalid variable module type {module.GetType().Name} from module {module.Name}!";
- return false;
- }
+ error = $"Invalid variable module type {module.GetType().Name} from module {module.Name}!";
+ return false;
}
- return true;
}
+ return true;
}
}
diff --git a/src/TMG-Framework/Processing/EvaluateVector.cs b/src/TMG-Framework/Processing/EvaluateVector.cs
index 783d845..32ad012 100644
--- a/src/TMG-Framework/Processing/EvaluateVector.cs
+++ b/src/TMG-Framework/Processing/EvaluateVector.cs
@@ -16,61 +16,55 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
{
- [Module(Name = "Evaluate Vector", Description = "Evaluate a vector given the expression.",
- DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
- public class EvaluateVector : BaseFunction
- {
- [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
- public IFunction Expression = null!;
+ [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
+ public IFunction Expression = null!;
- [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
- public IModule[] Variables = null!;
+ [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
+ public IModule[] Variables = null!;
- public override Vector Invoke()
+ public override Vector Invoke()
+ {
+ string? error = null;
+ // compile and optimize the expression
+ if (!TMG.Frameworks.Data.Processing.AST.Compiler.Compile(Expression.Invoke(), out var expression, ref error))
{
- string? error = null;
- // compile and optimize the expression
- if (!TMG.Frameworks.Data.Processing.AST.Compiler.Compile(Expression.Invoke(), out var expression, ref error))
- {
- throw new XTMFRuntimeException(this, error);
- }
- var result = expression.Evaluate(Variables);
- if (result.Error)
- {
- throw new XTMFRuntimeException(this, result.ErrorMessage);
- }
- // this easy case, the expression was of the correct type
- if (result.IsVectorResult)
- {
- return result.VectorData;
- }
- if (result.IsOdResult)
- {
- throw new XTMFRuntimeException(this, "The expression resulted in a matrix instead of a vector!");
- }
- throw new XTMFRuntimeException(this, "The expression resulted in a scalar instead of a vector!");
+ throw new XTMFRuntimeException(this, error);
+ }
+ var result = expression.Evaluate(Variables);
+ if (result.Error)
+ {
+ throw new XTMFRuntimeException(this, result.ErrorMessage);
+ }
+ // this easy case, the expression was of the correct type
+ if (result.IsVectorResult)
+ {
+ return result.VectorData;
}
+ if (result.IsOdResult)
+ {
+ throw new XTMFRuntimeException(this, "The expression resulted in a matrix instead of a vector!");
+ }
+ throw new XTMFRuntimeException(this, "The expression resulted in a scalar instead of a vector!");
+ }
- public override bool RuntimeValidation(ref string? error)
+ public override bool RuntimeValidation(ref string? error)
+ {
+ foreach (var module in Variables)
{
- foreach (var module in Variables)
+ if (!(module is IFunction || module is IFunction || module is IFunction
+ || module is IFunction))
{
- if (!(module is IFunction || module is IFunction || module is IFunction
- || module is IFunction))
- {
- error = $"Invalid variable module type {module.GetType().Name} from module {module.Name}!";
- return false;
- }
+ error = $"Invalid variable module type {module.GetType().Name} from module {module.Name}!";
+ return false;
}
- return true;
}
+ return true;
}
}
diff --git a/src/TMG-Framework/Processing/ExecutePipelineInOrderParallel.cs b/src/TMG-Framework/Processing/ExecutePipelineInOrderParallel.cs
index 9c082df..125fe16 100644
--- a/src/TMG-Framework/Processing/ExecutePipelineInOrderParallel.cs
+++ b/src/TMG-Framework/Processing/ExecutePipelineInOrderParallel.cs
@@ -16,33 +16,27 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see : BaseFunction, IEnumerable>
{
- [Module(Name = "Execute Pipeline In Order Parallel", Description = "Execute a given pipeline",
- DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
- public sealed class ExecutePipelineInOrderParallel : BaseFunction, IEnumerable>
- {
- [SubModule(Index = 0, Name = "To Execute In Parallel", Required = true, Description = "The functions in order to execute the data through in parallel.")]
- public IFunction ToExecuteInParallel = null!;
+ [SubModule(Index = 0, Name = "To Execute In Parallel", Required = true, Description = "The functions in order to execute the data through in parallel.")]
+ public IFunction ToExecuteInParallel = null!;
- [SubModule(Index = 1, Name = "To Execute In Serial", Required = false, Description = "The functions in order to execute the data through in parallel.")]
- public IFunction[] ToExecuteNotInParallel = null!;
+ [SubModule(Index = 1, Name = "To Execute In Serial", Required = false, Description = "The functions in order to execute the data through in parallel.")]
+ public IFunction[] ToExecuteNotInParallel = null!;
- public override IEnumerable Invoke(IEnumerable context)
+ public override IEnumerable Invoke(IEnumerable context)
+ {
+ var current = context.AsParallel().AsOrdered().Select(element => ToExecuteInParallel.Invoke(element)).AsSequential();
+ for (int i = 0; i < ToExecuteNotInParallel.Length; i++)
{
- var current = context.AsParallel().AsOrdered().Select(element => ToExecuteInParallel.Invoke(element)).AsSequential();
- for (int i = 0; i < ToExecuteNotInParallel.Length; i++)
- {
- int localI = i;
- current = current.Select(element => ToExecuteNotInParallel[localI].Invoke(element));
- }
- return current.AsEnumerable();
+ int localI = i;
+ current = current.Select(element => ToExecuteNotInParallel[localI].Invoke(element));
}
+ return current.AsEnumerable();
}
}
diff --git a/src/TMG-Framework/Processing/IntegerizeMatrix.cs b/src/TMG-Framework/Processing/IntegerizeMatrix.cs
index afa4326..eda7504 100644
--- a/src/TMG-Framework/Processing/IntegerizeMatrix.cs
+++ b/src/TMG-Framework/Processing/IntegerizeMatrix.cs
@@ -16,156 +16,148 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
You should have received a copy of the GNU General Public License
along with TMG-Framework for XTMF2. If not, see
{
- [Module(Name = "Integerize Matrix", Description = "Takes in a matrix and then integerizes it trying to keep the total by planning district.",
- DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
- public class IntegerizeMatrix : BaseFunction
- {
- [SubModule(Required = true, Index = 0, Name = "Input Matrix", Description = "The matrix that will be integerized.")]
- public IFunction InputMatrix = null!;
+ [SubModule(Required = true, Index = 0, Name = "Input Matrix", Description = "The matrix that will be integerized.")]
+ public IFunction InputMatrix = null!;
- [Parameter(Index = 1, Name = "Random Seed", Description = "The number used to initialize the random number generator.")]
- public IFunction RandomSeed = null!;
+ [Parameter(Index = 1, Name = "Random Seed", Description = "The number used to initialize the random number generator.")]
+ public IFunction RandomSeed = null!;
- [SubModule(Required = true, Index = 2, Name = "Zone To PD Map", Description = "A mapping between zone numbers and")]
- public IFunction ZoneToPDMap = null!;
+ [SubModule(Required = true, Index = 2, Name = "Zone To PD Map", Description = "A mapping between zone numbers and")]
+ public IFunction ZoneToPDMap = null!;
- ///
- /// Computes an integer matrix given the input matrix, randomly assigning the remainders within
- /// the planning district for the zones.
- ///
- /// The integerized matrix.
- public override Matrix Invoke()
- {
- var baseMatrix = InputMatrix!.Invoke();
- var pdMap = ZoneToPDMap!.Invoke();
- var zoneToPD = pdMap.CreateIndex();
- var remainders = SplitIntegerAndRemainderMatrix(baseMatrix, pdMap, zoneToPD, out var pdRemainders);
- AssignIntegerRemainders(baseMatrix, remainders, pdRemainders, zoneToPD);
- return baseMatrix;
- }
+ ///
+ /// Computes an integer matrix given the input matrix, randomly assigning the remainders within
+ /// the planning district for the zones.
+ ///
+ /// The integerized matrix.
+ public override Matrix Invoke()
+ {
+ var baseMatrix = InputMatrix!.Invoke();
+ var pdMap = ZoneToPDMap!.Invoke();
+ var zoneToPD = pdMap.CreateIndex();
+ var remainders = SplitIntegerAndRemainderMatrix(baseMatrix, pdMap, zoneToPD, out var pdRemainders);
+ AssignIntegerRemainders(baseMatrix, remainders, pdRemainders, zoneToPD);
+ return baseMatrix;
+ }
- ///
- /// Splits the integer portion of the matrix from the remainders.
- /// The rawMatrix will be integerized.
- ///
- /// A new matrix containing the remainders
- private static Matrix SplitIntegerAndRemainderMatrix(Matrix rawMatrix, CategoryMap pdMap, Dictionary zoneToPd, out Matrix pdRemainderTotals)
- {
- var remainders = new Matrix(rawMatrix.RowCategories, rawMatrix.ColumnCategories);
- var pdMatrix = new Matrix(pdMap.Destination, pdMap.Destination);
+ ///
+ /// Splits the integer portion of the matrix from the remainders.
+ /// The rawMatrix will be integerized.
+ ///
+ /// A new matrix containing the remainders
+ private static Matrix SplitIntegerAndRemainderMatrix(Matrix rawMatrix, CategoryMap pdMap, Dictionary zoneToPd, out Matrix pdRemainderTotals)
+ {
+ var remainders = new Matrix(rawMatrix.RowCategories, rawMatrix.ColumnCategories);
+ var pdMatrix = new Matrix(pdMap.Destination, pdMap.Destination);
- // Split the integer and remainders while also accumulating the remainders into a PDxPD matrix
- Parallel.For(0, rawMatrix.RowCategories.Count,
- () =>
+ // Split the integer and remainders while also accumulating the remainders into a PDxPD matrix
+ Parallel.For(0, rawMatrix.RowCategories.Count,
+ () =>
+ {
+ return new Matrix(pdMap.Destination, pdMap.Destination);
+ }
+ , (int i, ParallelLoopState _, Matrix pdRemainders) =>
+ {
+ int pdI = zoneToPd[i];
+ var iData = rawMatrix.GetRow(i);
+ var rData = remainders.GetRow(i);
+ var pdRow = pdRemainders.GetRow(pdI);
+ for (int j = 0; j < rawMatrix.ColumnCategories.Count; j++)
{
- return new Matrix(pdMap.Destination, pdMap.Destination);
+ int pdJ = zoneToPd[j];
+ var original = iData[j];
+ iData[j] = (float)Math.Truncate(original);
+ rData[j] = original - iData[j];
+ pdRow[pdJ] += rData[j];
}
- , (int i, ParallelLoopState _, Matrix pdRemainders) =>
- {
- int pdI = zoneToPd[i];
- var iData = rawMatrix.GetRow(i);
- var rData = remainders.GetRow(i);
- var pdRow = pdRemainders.GetRow(pdI);
- for (int j = 0; j < rawMatrix.ColumnCategories.Count; j++)
- {
- int pdJ = zoneToPd[j];
- var original = iData[j];
- iData[j] = (float)Math.Truncate(original);
- rData[j] = original - iData[j];
- pdRow[pdJ] += rData[j];
- }
- return pdRemainders;
- }, (pdRemainders) =>
- {
- lock (pdMatrix)
- {
- Utilities.VectorHelper.Add(pdMatrix.Data, pdMatrix.Data, pdRemainders.Data);
- }
- });
- pdRemainderTotals = pdMatrix;
- return remainders;
- }
-
- private void AssignIntegerRemainders(Matrix integers, Matrix remainders, Matrix pdRemainders, Dictionary zoneToPD)
- {
- var flatZones = integers.RowCategories;
- var pdIndexes = flatZones.Select((z, i) => zoneToPD[i]).ToArray();
- var numberOfPDs = pdRemainders.RowCategories.Count;
- // Create indexes to look for each PDxPD
- var pairs = new List[numberOfPDs * numberOfPDs];
- for (int i = 0; i < flatZones.Count; i++)
+ return pdRemainders;
+ }, (pdRemainders) =>
{
- var row = new Span>(pairs, pdIndexes[i] * numberOfPDs, numberOfPDs);
- for (int j = 0; j < flatZones.Count; j++)
+ lock (pdMatrix)
{
- var list = row[pdIndexes[j]];
- if (list == null)
- {
- list = row[pdIndexes[j]] = new List(100);
- }
- list.Add(new ODPair() { Origin = i, Destination = j });
+ Utilities.VectorHelper.Add(pdMatrix.Data, pdMatrix.Data, pdRemainders.Data);
}
- }
-
- var random = new Random(RandomSeed!.Invoke());
+ });
+ pdRemainderTotals = pdMatrix;
+ return remainders;
+ }
- // Method to assign an additional trip to the integer matrix based on the remainders for the given pd of origin and destination
- void Assign(List zoneList, double pop, ref float pdTotal)
+ private void AssignIntegerRemainders(Matrix integers, Matrix remainders, Matrix pdRemainders, Dictionary zoneToPD)
+ {
+ var flatZones = integers.RowCategories;
+ var pdIndexes = flatZones.Select((z, i) => zoneToPD[i]).ToArray();
+ var numberOfPDs = pdRemainders.RowCategories.Count;
+ // Create indexes to look for each PDxPD
+ var pairs = new List[numberOfPDs * numberOfPDs];
+ for (int i = 0; i < flatZones.Count; i++)
+ {
+ var row = new Span