oraqlle / cortexlib

A library of general purpose types, classes, functions, algorithms, utilities and other components for C++.

oraqlle

Just a dude who loves writing (and talking about) software.

Info

• CEO of Monash DeepNeuron for 2023/2024
• Third year student at Monash University
• Interested in language design, compilers/interpreters and game dev.
• Current work:
  • clox: Bytecode Interpreter for Lox written in C
• Noteworthy work:
  • Base64 Decoder in Zig
  • Sorting Algorithm Visualizer
  • Terminal based 2048 (in a few languages)
  • Co-author of MDN's HPC Training Book
  • C++ Standard Container Benchmarker
  • jlox: Tree-Walking Interpreter for Lox Written in Java

cortexlib's Issues

[Feature] Layout and Accessor members for matrix

Support a layout and accessor members for matrix that dictate the memory layout and accessing rules for the structure, similar to std::mdspan.

[Feature] box_view

A view over contiguous data (like std::span) but allows for all of boxes operations on that data as if it were a box. Operators and maps can then return a view of the modified data without changing it initially. Might add better composability to box operations.

[Suggestion] Remove transformation methods

The transformation methods box::add are redundant due to box::map. Map provides a more generic and controllable way for notation transformations on a box.

GitHub actions

• Build
  • Compilers
  • Platforms
• Docs
• Code Coverage

Rename box to matrix

Documentation overhaul

Complete re-write of documentation for all components, libraries etc.
Find a good doc generation tool

Memoize Function Factory

A factory function that creates a function that memoizes the result according to the input parameters

Switch build system to Meson

Tensor Data Structure

I multidimensional owning data structure

[Feature] box - a unique pointer type with value semantics

[API] Array Paradigm Operator Overloads

Remove element-wise operator overloads in favor of using operators as verbs, similar to how array-notational languages work.

auto sum = std::plus{} / bx  ///< folds left
auto nbx = bx / 3;  ///< element-wise division by 3

[Libs] Allocator Library

A allocator library offering more robust ways to manage memory allocation.

[Feature] Dimension Constructor

A constructor that takes the dimensions of another box and constructs a new box of the given size.

[Feature] More concise slicing operations

Use pairs and (with C++23) multi-arg slicing ops to get better slicing control.

e.g.

bx[{1, 4}, {2, 4}]  ///< gets slice from points to point

Revamp

[Feature] Create print_box in details::

Create pretty printer for box in the details namespace.

Uses bars

| 1, 2, 3 |
| 4, 5, 6 |
| 7, 8, 9 |

Match Expression

Match expression for usage with std::variant

[Feature] Support libfmt formatting box

Support formatted string output with libfmt/std::format

[Bug] Remove uses of std::ranges library that cause clang issues

Clang doesn't like gcc's implementation of std::ranges yet as it hasn't finished reducing the need for typename causing compile issues. This could be resolved by using different standard algorithms so we can build against clang as well. Removing the header might also work.

[Enhancement] Better use of C++ standard version macros

Currently we can only build against C++20. Better use of macros can help to allow use to build with lower C++ standards. Hopefully even as low as C++11 (but I want C++17 at least).

[Docs] Specify doc groups for global operators

Currently operators are spaghetti-ed throughout the libraries and this makes it hard for standardese to categorise the operators. Using document groupings could help this.

[Bug] box::operator[] disqualifies `const`

The current implementation of box::slice and box:::operator[] (slicing operator) currently don't have both const and non-const qualified versions. When called on a const box object, this discards qualifiers. A const qualified version should be added for box::operator[] and a non-const for box::slice.

/// Non-const slice
constexpr auto
slice(size_type ridx) /* no const */
    -> std::span<value_type>
{
    if (ridx >= m_rows)
        throw std::out_of_range("box::slice - row index out of range");

        return std::span<value_type>{
            _M_data_ptr(m_start) + ridx * m_columns,
            m_columns
        };
}

/// `const` operator[]
constexpr auto
operator[](size_type ridx) const ///< `const` added here
    -> std::span<value_type>
{ return slice(ridx); }

[Feature] Ranges over columns and rows

Create methods that access ranges of the box (columns, rows, sub-columns and sub-rows).
Ranges can be lazy.
Could be done with slicing.

Transition to CMake