A library for working with coordinate systems and transformations between them. It abstracts working with coordinate systems so powerfully that I use it in every project of mine that has even a little bit of graphics.
I completely rewrote this ray tracer from scratch, improved the architecture, and added the ability to render not only with path tracing (photorealistic graphics) but also with ray tracing (fast, but not as realistic). Used in many of my other projects.
A fork of some guy's code from GitHub. I chose his code in particular because it was as simple as it gets, compiled without problems, and gave impressive results. With this code I understood for the first time how ray tracing works, and decided to dig into it even deeper by improving the code and adding a couple of features.
My second wrapper over WinAPI functions. It inherits the ideas of GraphWinApi, but with a much more thought-out architecture. It also contains a wrapper over AGG for anti-aliased drawing, as well as EasyBMP and STB for saving images to files. It's used in many of my other projects, though not as a library for building applications, but as a graphics library. And I think the part responsible for colors, points and drawing should be moved out into a separate lib.
An algorithm for drawing an image that hasn't been fully received yet. It defines not only the order in which the pixels are traversed, but also the algorithm for drawing the image itself. I used it for ray tracing, to show in real time what was taking a very long time to render. Running time with respect to the number of pixels: linear. Unfortunately, it depends on TWG, so nobody except me will be able to use it.
A program for learning English words. The interface is as simple as it gets: a word in English and four buttons where you have to choose the right answer. Built on TWG. I don't actually learn words with it *facepalm*.
An attempt to invent an algorithm for checking whether a point lies inside a polygon by decomposing the polygon's space into a tree. The attempt failed, or maybe I just didn't have enough patience.
An attempt to write code that finds the optimal layout based on the idea of chords. I abandoned the project because of the incredible complexity I had piled up for myself (I wanted to account for layers and duplicated keys at the same time). Layout development diary (in Russian).
I explain how Newton's method for solving systems of nonlinear equations works. I try to explain it in as much detail and as well as I can. I wanted to write it after I had figured it out myself and couldn't find anything like it on the internet.
Since I've been writing my reports in LaTeX since my third year, I decided to gather most of the stuff I use in one place, along with a title page template. It's much more convenient than Word for generating tables, plots and math formulas. But unfortunately, the learning curve is very steep, and in the six months this repository has existed, none of my classmates has ever used it.
Once, with the help of some program, I collected all the solar eclipses of the 21st century in one place, so that search engines would index it and I would become popular. The attempt failed, but at least I know when the next solar eclipse in my city will be.
I posted them so I could tell my classmates look on GitHub to see how I did it, and also to have lots of green squares in my daily activity, as if to say I'm not just goofing off. There are also some genuinely good repositories among them.
We write methods for solving systems of linear equations. But the systems aren't given in a dense format, but in a sparse format with lots of zeros. And they have to be solved in that same format. This is used in the finite element method (FEM), where each element has only a few neighbors, and when RAM is limited to gigabytes and time to weeks (if you build the matrix with all its zeros, you won't find enough RAM to store it all or enough time to wait for it).
We implement methods for solving the differential equations from the first part of this course, using methods similar to FEM. The bad thing about this course is that the course manual is terribly written, nothing makes sense, the research tasks are pointless, and we don't simulate any physical processes, only abstract spherical cows in a vacuum. On the plus side, my term project came out almost divine.
We write solvers for ordinary differential equations and apply them to some physics problems. Since the course was only introduced in our year, I tried to write my own course manual for it.
We write our own compiler for a very small subset of C. The course is meant to teach how compilers work and to study programming concepts such as finite state machines and grammars. Most of the code wasn't written by me.
Simple labs for mastering basic cryptographic concepts, such as letter frequency, hashes, the Diffie–Hellman protocol, public and private keys, symmetric and asymmetric encryption. The coolest thing in this repository is a program that automatically decrypts text encrypted by permuting the letters of the alphabet (a simple substitution cipher). For this I use a genetic algorithm and clever metrics based on bigram and trigram frequencies. See folder 1 for it.
We write programs that use Linux features such as fork, pipe, execl, openp. Thanks to this course I realized that either I don't understand Linux, or it has a terrible architecture!
Changelog
2021.08.26
Moved this page to the new blog on Zola.
2019.06.10
First release.