orxfun Goto Github PK

followers: 4.0 following: 46.0 repos: 25.0 gists: 0.0

Name: Ugur Arikan

Type: User

Bio: Operations Research, optimization, algorithms, systems design. like programming languages. love rust.

Location: Germany

Blog: https://orxfun.github.io/cv/

Hi, I'm Uğur Arıkan

👋 𝙰𝚋𝚘𝚞𝚝 𝙼𝚎

Operations Research (OR) Scientist / Practitioner (wiki)
Middle East Technical University & Singapore University of Technology and Design
Located in Bonn Germany, working at DHL
| github | email | linkedin | cv | crates | nuget |

🤟 I like

All things OR, optimization, networks, routing, algorithms, multi objective decision making.

Programming, algorithms, data structures, speed, efficiency and recently concurrency.

Also love programming languages:

rust 🤟 every day, to stay for a long time
c#, react, typescript 👍 quiet often
go, f# 👌🏽 zig, nim 🤔 watching closely

🎈 𝙸'𝚖 currently 𝚞𝚙 𝚝𝚘

mathematical programming / modeling

An expressive, efficient and productive mathematical programming / modeling crate for rust.

macro-free and concise api which does not require more lines than model-on-paper has
concise, simple, solver agnostic, immutable, type safe
with a separation of model and data, and hence, enable abstraction over inputs
with reusable & composable model components
below is a demo of my attempt in C# and here is the documentation

concurrent programming and parallel processing

Working more and more on concurrent programming and parallel processing in rust. One thing lead to another, and I got more and more interested:

First, worked on defining the PinnedVec trait and its implementations such as the SplitVec and FixedVec. A pinned vector is nothing but a vector which keeps its elements pinned in their memory locations.
Turns out this feature is very useful in defining concurrent collections such as ConcurrentBag, ConcurrentVec or ConcurrentOrderedBag. This allows to write outputs of a computation concurrently.
Then, the missing piece is to provide inputs concurrently with the convenience of an iterator. And hence, the ConcurrentIter.
Having concurrent readers and concurrent writers, we can have a very simple yet very performant parallel iterator Par.

self referential collections

Working on convenient and efficient self referential collections.

Such collections are common building blocks of data structures used in many algorithms, but they are tricky to build in rust, certainly trickier than garbage collected languages.
The goal is to define how to create such collections safely and efficiently in rust.
Again the PinnedVec serves as the starting point since we want our references to stay valid.
Second goal is to define and provide core functionalities of such collections. SelfRefCol aims to serve as the core structure for self referential collection.
As the first consumer, worked on building the famously tricky LinkedList on top of SelfRefCol, which turned out to be very efficient.
Efficient & flexible trees 🌴 and graphs are in progress. To continue with graphs.

also

working on efficient data structures as I need in algorithms, such as PriorityQueue trait and efficient d-ary heap implementations.
and whenever I have time, I am trying some experimental ideas such as Closure and FunVec.

Mathematical Modeling Demo

mathematical modeling in action 🔎

Ugur Arikan's Projects

orx-bench-shortest-path

Benchmarks for single source single sink shortest path implementations

orx-closure

An explicit closure with absolute seperation of the captured data from the function.

orx-concurrent-bag

An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance concurrent collection.

orx-concurrent-iter

A thread-safe, ergonomic and lightweight concurrent iterator trait and efficient implementations.

orx-concurrent-ordered-bag

An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance and ordered concurrent collection.

orx-concurrent-vec

An efficient, convenient and lightweight grow-only read & write concurrent data structure allowing high performance concurrent collection.

orx-fixed-vec

An efficient fixed capacity vector with pinned elements.

orx-fun-compose

A function composition library for C#, heavily experimental right now, would be more practical if C# gets generic operator overloading.

orx-fun-funvec

Unified functional collections allowing access by index.

orx-fun-option

An option type for C# aiming to be explicit while concise.

orx-fun-result

A simple result type for C#, not minding the error type, instead aiming to be explicit, concise and fluent.

Traits to unify access to elements of n-dimensional vectors which are particularly useful in algorithms requiring both flexibility through abstraction over inputs and performance through monomorphization.

orx-imp-vec

A data structure to enable conveniently building performant self referential collections such as trees, graphs and linked lists.

orx-linked-list

An efficient and recursive singly and doubly linked list implementation.

orx-mathprog-gallery

Gallery of mathematical models by orx-mathprog of well-known problems.

orx-parallel

A performant and configurable parallel computing library for computations defined as compositions of iterator methods.

orx-pinned-concurrent-col

A core data structure with a focus to enable high performance, possibly lock-free, concurrent collections using a PinnedVec as the underlying storage.

orx-pinned-vec

PinnedVec trait defines the interface for vectors which guarantee that elements added to the vector are pinned to their memory locations unless explicitly changed.