TUI-apps VS cupy

Hello!

I am pleased to announce a new version of my "CLI text processing with GNU sed" ebook. This book heavily leans on examples to present features one by one. In addition to sed commands and options, regular expressions are also discussed in detail.

Links:

* PDF/EPUB versions: https://learnbyexample.gumroad.com/l/gnu_sed (free for a few days)

* Web version: https://learnbyexample.github.io/learn_gnused/ (always free)

* Markdown source, example files, etc: https://github.com/learnbyexample/learn_gnused

* Interactive TUI app for exercises: https://github.com/learnbyexample/TUI-apps/blob/main/SedExercises

I would highly appreciate it if you'd let me know how you felt about this book. It could be anything from a simple thank you, pointing out a typo, mistakes in code snippets, which aspects of the book worked for you (or didn't!) and so on. Reader feedback is essential and especially so for self-published authors.

Happy learning :)

I also wrote an interactive TUI app based on some of the exercises from the ebook. Reference solutions are provided for both GNU grep and ripgrep.

This year I started updating my existing books and I'm also creating interactive apps. Here's one for Python regex: https://github.com/learnbyexample/TUI-apps/blob/main/PyRegexExercises. Next is grep.

Having an interactive program that automatically loads questions and checks the solution is wonderful to have while learning a topic. I wrote a TUI app that has beginner to advanced level exercises for Python regular expressions. There are more than 100 exercises covering both the builtin re and third-party regex modules.

My first app with Textual was a board game. Like Tic Tac Toe but make a square on a 4x4 board: https://github.com/learnbyexample/TUI-apps/tree/main/SquareTicTacToe

To make it easier to experiment, I'm currently working on an interactive app. See PyRegexPlayground repo for installation instructions and usage guide. A sample screenshot is shown below:

Python regex playground

I also made an interactive TUI app with 40 cli text processing exercises - I plan to cover all the 200+ exercises sometime later this year.

I wrote an interactive CLI exercises TUI with textual a few weeks back. Having a fixed location to play with commands interactively felt nice and I did wonder if something like could be expanded to make a nice terminal alternative for some tasks.

I did not expect anything interesting, but this is actually cool.

> A full implementation of the NumPy API. Not something "NumPy-like" — just literally the NumPy API, with the same functions and the same arguments.

I suppose it's like https://cupy.dev/

Cupy replicates the numpy and scipy APIs but runs on the GPU.

For that, you can use cupy[0], PyTorch[1] or Tensorflow[2]. They all mimic the numpy's API with the possibility to use your GPU.

[0] https://cupy.dev/

You can look into using CUPy to build some classical algorithms.

I never used it outside of DL. Why would you need that (I'm just curious)? There are projects like CuPy (or even just numba) which are adding the power of a gpu to numpy.

Fast Array Manipulation in Python: Since Numpy is the de facto standard for storing multi-dimensional data, any performance gain you see using librapid math kernels will need to be realized on data which probably started its life as a numpy array, and needs to be passed to another tool as a numpy array. Hopefully there will be (or already is?) a way to build a librapid array out of a numpy array without copying the data and vice versa. In fact I might suggest that librapid focus on the fast math operations and simply become an accelerator for numpy arrays. For instance, look at CuPy which provides GPU-implemented operations within a numpy-compatible API, and Bottleneck which simply provides fast C-based implementations of some otherwise slow parts of Numpy. Also note that numpy *can* be multi-threaded depending on the operation and some environment variables. Single-threaded to Single-threaded I think you will be hard-pressed to beat Numpy on general math operations, but that doesn't mean there aren't specific "kernels" that are more specialized that can be greatly improved with a C++ back-end.

CuPy

Curious, have you looked into CuPy or Numba to help speed up your calculations? They are both relatively easy to implement.

pip install wheel git clone --recursive https://github.com/cupy/cupy.git cd cupy python setup.py bdist_wheel