Sebastian Ardelean Bending bits... Blog posts feed Emacs webfeeder.el https://sebastianardelean.codeberg.page Wed, 19 Nov 2025 12:07:37 +0200 Safe call Guile functions from C++

While working on a C++ project in which I want to embedd Guile I needed to implement way to safe load and call Guile functions. Guile has a great and easy to use (in my opinion) C API and is easy to embedd it applications. Therefore, a perfect candidate for a scripting language to embedd in my C++ project. Therefore, I needed to implement a layer that loads Guile scripts and call functions, as safe as possible.

The project structure is as follows: 

├── CMakeLists.txt
├── scripts
│   └── test.scm
└── src
    ├── CMakeLists.txt
    ├── guile_loader.hpp
    └── main.cpp

where in scripts/test.scm are the scripts to be loaded and executed and src/guile_loader.hpp is the header-only layer that loads Guile. I won’t go into details about the code, it’s use is pretty straightforward. The CMakeLists.txt files may be a little cumbersome, but I extracted them from some templates that I use.

Root CMake

# Minimum CMake version required
cmake_minimum_required(VERSION 3.20)

# Project name and version
project(cpp_guile VERSION 1.0)
set(PROJECT_NAME cpp_guile)

# Set the C standard to C99 (or C11 if preferred)
set(CMAKE_C_STANDARD 99)
set(CMAKE_C_STANDARD_REQUIRED True)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

add_library(project_options INTERFACE)

option(ENABLE_DEBUG "Enable Debug build" ON)

if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
  # using Clang
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
  target_compile_options(project_options INTERFACE -Wall -Wextra -O2)
  target_compile_options(project_options INTERFACE -Wall -Wextra -g)
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
  # using Intel C++
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
  target_compile_options(project_options INTERFACE /W4 /Zi /utf-8)
  target_link_options(project_options INTERFACE /subsystem:console)
endif()



find_package(PkgConfig REQUIRED)
pkg_check_modules(GUILE REQUIRED guile-3.0)

option(ENABLE_PCH "Enable Precompiled Headers" ON)

if(ENABLE_PCH)
  target_precompile_headers(
    project_options
    INTERFACE
    
    
    
    )
endif()



add_subdirectory("src")

src/CMakeLists.txt

include_directories(${GUILE_INCLUDE_DIRS} ${PROJECT_SOURCE_DIR}/src/)

add_executable(${PROJECT_NAME} main.cpp)


target_link_libraries(
    ${PROJECT_NAME} PRIVATE
    project_options
    ${GUILE_LIBRARIES}
)

src/guile_loader.hpp

 #pragma once
 #include  

 namespace  safe:: scm {
     class  ScmException:  public  std:: runtime_error {
     public:
         explicit  ScmException ( const  std:: string & msg):  std:: runtime_error(msg) {
        }

    };

     template < typename  Func>
     auto  call( Func  func) ->  SCM {
         auto  func_ptr =
             std::make_shared< Func>( std::move(func));

         struct  Context {
             std:: shared_ptr< Func>  func;
        };
         Context  ctx{func_ptr};

         auto  run = []( void * data) -> SCM {
             auto*  ctx =  static_cast< Context*>(data);
             return (*(ctx->func))();
        };

         auto  error = []([[maybe_unused]]  void * data, [[maybe_unused]]  SCM  key,  SCM  args) -> SCM {

             SCM  msg_scm = ::scm_simple_format(
                SCM_BOOL_F,
                ::scm_from_utf8_string( "Guile error: ~A"),
                ::scm_list_1(args)
                );


             char * msg = ::scm_to_locale_string(msg_scm);
             std:: string  errString(msg);
            free(msg);
             throw ScmException(errString);
        };

         return ::scm_c_catch(
            SCM_BOOL_T,
            run,
            &ctx,
            error,
             nullptr,
             nullptr,
             nullptr);
    }

};




 class  GuileLoader {
 public:
     GuileLoader( const  std:: string&  scriptPath)  try:
        sScriptPath(scriptPath)
        {
            scm_init_guile();
             safe:: scm::call([=] {
                 return scm_c_primitive_load(scriptPath.c_str());
            });
        }
     catch ( const  safe:: scm:: ScmException&  e){
         std::println( "Failed to load Guile script: {}",e.what());
    }



     template< typename  T>
     auto  Execute( std:: string_view)-> std:: optional< T>;


 protected:
 private:
     std:: string  sScriptPath;
};


 template< typename  T>
 auto  GuileLoader:: Execute( std:: string_view  function_name) ->  std:: optional< T> {
     try {
        :: SCM  script_function =  safe:: scm::call([&] {
             return scm_c_lookup(function_name.data());
        });
        :: SCM  script_function_ref =  safe:: scm::call([&] {
             return scm_variable_ref(script_function);

        });

        :: SCM  result =  safe:: scm::call([&] {
             return scm_call_0(script_function_ref);
        });
         if  constexpr ( std:: is_same_v< T,  int>) {
             return  std::optional< int>(::scm_to_int(result));
        }
         if  constexpr ( std:: is_same_v< T,  double>) {
             return  std::optional< double>(::scm_to_double(result));
        }
         if  constexpr ( std:: is_same_v< T,  float>) {
             return  std::optional< float>( static_cast< float>(::scm_to_double(result)));
        }
         if  constexpr ( std:: is_same_v< T,  std:: string>) {
             char * cstr = ::scm_to_utf8_string(result);
             std:: string  s(cstr);
            free(cstr);
             return  std::optional< std:: string>(s);
        }

    }  catch( const  safe:: scm:: ScmException&  e) {
         std::println( "Failed to execute Guile script: {}",e.what());
         return  std::nullopt;
    }

}

src/main.cpp

 #include  "guile_loader.hpp"

 auto  main( int  argc,  char ** argv) ->  int
{

     GuileLoader  loader{ "../scripts/test.scm"};

     auto  result = loader.Execute< int>( "test");

     std::println( "Result is {}", result.value());

     return 0;
}

scripts/test.scm

(define (test-function)
  (number->string (+ 2 3)))


(define (test)
  5)
]]> https://sebastianardelean.codeberg.page/posts/2025-11-19-cpp-safe-call-guile/index.html https://sebastianardelean.codeberg.page/posts/2025-11-19-cpp-safe-call-guile/index.html Wed, 19 Nov 2025 08:00:00 +0200 Simple Linux char driver

This is the second blog post from a series dedicated to Linux drivers that started with Linux drivers and cross compilation. I aim to publish some skeletons of drivers for different interfaces and modules. I’m not a Linux kernel developer so I can’t say that I will strictly follow the best practices in kernel development, but I have years of experience in bare-metal embedded driver development. Thus, I will follow the best practices in C programming and make the best use of my knowledge in electronics and embedded. Those being said, this series will not be a tutorial in Linux driver development.

In this blog post, I will start with the implementation of 2 simple char drivers that do nothing, except of logging parameters in kernel log. To build the drivers, I use a busybox and a minimalistic Linux kernel built according to the steps form the aforementioned blog post. The kernel, busybox and the drivers are built using the ARM aarch64-linux-gnu compiler. I will use the following Makefile 

ifneq ($(KERNELRELEASE),)
obj-m += simple.o
else
KDIR := /home/mihai/qemu/linux-6.12.54
PWD := $(shell pwd)
CROSS=/bin/aarch64-linux-gnu-

default:
        @echo '   Building driver for kernel 6.12'
        $(MAKE) -C $(KDIR) M=$(PWD) ARCH=arm64 CROSS_COMPILE=$(CROSS) modules

clean:
        make -C $(KDIR) M=$(PWD) clean

endif

to build the drivers. Between blog posts, the only changes will be in the variable obj-m which contain the name of object. The KDIR should point to the location of your built Linux kernel (feel free to change the path accordingly), while CROSS points to the location of the compiler. On my Debian machine, the arm compiler is in /bin. If on your machine is in another location, just change path.

Simple hello world driver

 #include  
 #include  


MODULE_LICENSE( "GPL");
MODULE_AUTHOR( "Sebastian Ardelean");
MODULE_DESCRIPTION( "A simple hello world Linux char driver");
MODULE_VERSION( "0.1");


 static  int  __init simple_init( void)
{
    printk(KERN_INFO  "Simple: Hello World!\n");
     return 0;
}

 static  void  __exit simple_exit( void)
{
    printk(KERN_INFO  "Simple: Goodbye world! :(\n");
}

 module_init(simple_init);
 module_exit(simple_exit);

After built, to test the driver run the command sudo insmod simple.ko to insert the driver. In kernel logs (run dmesg) one should see the line [ 2696.101472] Simple: Hello World!. To remove the driver run the command sudo rmmod simple and in kernel logs one should see the message [ 2772.318862] Simple: Goodbye world! :(.

Simple hello world driver with parameters

This driver is similar to the previous one, the only difference is that it uses module parameters. 

 #include  
 #include  


MODULE_LICENSE( "GPL");
MODULE_AUTHOR( "Sebastian Ardelean");
MODULE_DESCRIPTION( "A simple hello world Linux char driver");
MODULE_VERSION( "0.1");

 static  char * message =  "world";
 module_param(message, charp, S_IRUSR | S_IWUSR);
 MODULE_PARM_DESC(message,  "message parameter");


 static  int  __init simple_init( void)
{
    printk(KERN_INFO  "Simple: Hello %s!\n", message);
     return 0;
}

 static  void  __exit simple_exit( void)
{
    printk(KERN_INFO  "Simple: Goodbye %s! :(\n", message);
}

 module_init(simple_init);
 module_exit(simple_exit);

If you insert the driver with the command sudo insmod simple.ko message="SOMETHING" followed by the command to remove it, in kernel logs one should see the lines 

[ 3190.552534] Simple: Hello SOMETHING!
[ 3201.806278] Simple: Goodbye SOMETHING! :(
]]> https://sebastianardelean.codeberg.page/posts/2025-10-23-simple-linux-char-driver/index.html https://sebastianardelean.codeberg.page/posts/2025-10-23-simple-linux-char-driver/index.html Thu, 23 Oct 2025 08:00:00 +0300 Linux drivers and cross compilation

Some years ago, probably too many, I liked to implement drivers for my Beaglebone Black board. Nothing too fancy, just some char drivers that measured a pwm signal using Input-Capture, or toggled some GPIOS. All those drivers were compiled and tested directly on the target. I know is not the best practice, but I didn’t have the time to build the kernel, launch an emulation in QEMU and so on.

A few days ago I found a Raspberry Pi kit, with fan, grills, and an official box. Pretty nice, but I didn’t liked the fan, because there was no way to control it and it was really loud (continuosly ran at full rpm). The first idea was to implement a user space application in C or probably Python to control somehow the fan. So, took a NPN transistor and a 1k resistor, connected everything together and it works. Then I thought, what if I make it a kernel driver. There is no single benefit to make it a driver, probably is even better if I keep it as a userspace application, but I wanted to play with the kernel APIs. So, start the Raspberry, ssh on it and write the driver? No, definitely no!

My plan:

  1. cross compile the kernel
  2. do some voodoo magic and launch Qemu
  3. develop and test the driver.

Cross compiling the kernel

First try was a disaster, but I found 2 nice guides which I will link at the end of this post.

Preparing the environment

  1. Install the cross compiler for arm64 sudo apt install gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
  2. Install Qemu sudo apt install qemu-system-arm
  3. Download the kernel (when I wrote this article, the longterm version was 6.12.53 ) wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.12.53.tar.xz and untar it.
  4. Download BusyBox wget https://busybox.net/downloads/busybox-1.37.0.tar.bz2 and untar it.
  5. Download a Raspberry Pi OS from Raspi OS.

Building the kernel

  1. Change directory into the kernel source code cd linux-6.12.53
  2. Create a config file ARCH=arm64 CROSS_COMPILE=/bin/aarch64-linux-gnu- make defconfig
  3. Create a kvm_guest config ARCH=arm64 CROSS_COMPILE=/bin/aarch64-linux-gnu- make kvm_guest.config
  4. Build the kernel ARCH=arm64 CROSS_COMPILE=/bin/aarch64-linux-gnu- make -j8

Preparing the OS

  1. Calculate the offset of the first (512 bytes * 16384) device by inspecting the partitions: 

    fdisk -l 2025-10-01-raspios-trixie-arm64-lite.img
Disk 2025-10-01-raspios-trixie-arm64-lite.img: 2.73 GiB, 2927624192 bytes, 5718016 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x7351b90c

Device                                    Boot   Start     End Sectors  Size Id Type
2025-10-01-raspios-trixie-arm64-lite.img1        16384 1064959 1048576  512M  c W95 FAT32 (LBA)
2025-10-01-raspios-trixie-arm64-lite.img2      1064960 5718015 4653056  2.2G 83 Linux

  2. Mount the image: 

    sudo mkdir /mnt/rpi
sudo mount -o loop, offset=8388608 2025-10-01-raspios-trixie-arm64-lite.img /mnt/rpi
  3. Create a file named ssh: cd /mnt/rpi && sudo touch ssh
  4. Create a file userconf: sudo touch userconf.txt

  5. Generate a password and save it to userconf: 

    openssl passwd -6                                      #  Generate the 
 echo  'pi:' | sudo tee userconf.txt    #  Put them inside `userconf.txt`
  6. Unmount: sudo umount /mnt/rpi

Build a minimalistic Linux system

  1. Defconfig the busybox: ARCH=arm64 CROSS_COMPILE=/bin/aarch64-linux-gnu- make defconfig
  2. Enable static link and dissable the use of special instructions for SHA. (The options are in Busybox Settings): ARCH=arm64 CROSS_COMPILE=/bin/aarch64-linux-gnu- make menuconfig
  3. Build busybox: ARCH=arm64 CROSS_COMPILE=/bin/aarch64-linux-gnu- make -j8
  4. And install it: ARCH=arm64 CROSS_COMPILE=/bin/aarch64-linux-gnu- make install

Now, we must create a rootfs directory and populate it.

  1. Create rootfs: mkdir rootfs
  2. Copy the content from busybox/install into rootfs: cp -av busybox-1.24.2/_install/* rootfs/
  3. Create a symlink to busybox ln -s bin/busybox init.
  4. Create the required directories: mkdir -pv rootfs/{bin,sbin,etc,proc,sys,mnt,var/{log},usr/{bin,sbin}}

  5. Create the required /dev with mem and ttys: 

    mkdir dev &&  cd dev
sudo mknod -m 660 mem c 1 1
sudo mknod -m 660 tty2 c 4 2
sudo mknod -m 660 tty3 c 4 3
sudo mknod -m 660 tty4 c 4 4
  6. Use the content of this directory as initram disk, thus, from rootfs directory we run: find . -print0 | cpio --null -ov --format=newc | gzip -9 > ../rootfs.cpio.gz

Emulate the minimalistic Linux system

  1. Launch Qemu: qemu-system-aarch64 -machine virt -cpu cortex-a72 -smp 6 -m 4G -kernel Image -initrd rootfs.cpio.gz -serial stdio -append "root=/dev/mem serial=ttyAMA0" -virtfs local,id=hostshare,path=/home/share,mount_tag=hostshare,security_model=none
  2. Inside Qemu shell create the /mnt/hostshare directory mkdir /mnt/hostshare and mount it mount -t 9p -o trans=virtio,version=9p2000.L hostshare /mnt/hostshare.

Emulate Raspberry Pi in Qemu

To emulate the Raspberry Pi in Qemu, just run the following command: 

qemu-system-aarch64 -machine virt -cpu cortex-a72 -smp 6 -m 4G  \
    -kernel Image -append  "root=/dev/vda2 rootfstype=ext4 rw panic=0 console=ttyAMA0"  \
    -drive  format=raw, file=2023-05-03-raspios-bullseye-arm64.img, if=none, id=hd0, cache=writeback  \
    -device virtio-blk, drive=hd0, bootindex=0  \
    -netdev user, id=mynet, hostfwd=tcp::2222-:22  \
    -device virtio-net-pci, netdev=mynet  \
    -monitor telnet:127.0.0.1:5555,server,nowait

and connect with the ssh as ssh -l pi localhost -p 2222.

Creating the driver

Preparing the Makefile

Now, the problem is that we want to cross-compile the driver using the Linux kernel we built. Thus, we have to define a simple Makefile that use the kernel sources, checks them, and use the cross-compiler: 

ifneq ($(KERNELRELEASE),)
obj-m += rpifan.o
else
KDIR := ../cross_compile/linux-6.12.53
PWD := $(shell pwd)
CROSS=/bin/aarch64-linux-gnu-

default:
   @echo '   Building RPI fan driver for kernel 6.12.'
   $(MAKE) -C $(KDIR) M=$(PWD) ARCH=arm64 CROSS_COMPILE=$(CROSS) modules

install:
   sudo insmod ./rpifan.ko

clean:
   make -C $(KDIR) M=$(PWD) clean

uninstall:
   sudo rmmod rpifan
endif

Building the Driver

We will try to build and insert the following char driver: 

 #include  
 #include  
 #include  
 #include  
 #include  
 #include  



 #define  DEVICE_NAME  "rpifan"
 #define  CLASS_NAME  "rpi"

MODULE_LICENSE( "GPL");
MODULE_AUTHOR( "Sebastian Ardelean");
MODULE_DESCRIPTION( "A Linux Driver for fan controlling on RPi.");
MODULE_VERSION( "0.1");

 static  char * name =  "world";

 module_param(name, charp, S_IRUGO);
 MODULE_PARM_DESC(name,  "The name to display");


 static  int  __init rpifan_init( void) {

  printk(KERN_INFO  "RpiFan: Initializing\n");
   return 0;
}

 static  void  __exit rpifan_exit( void) {
  printk(KERN_INFO  "RpiFan: Goodbye! :(\n");
}


 module_init(rpifan_init);
 module_exit(rpifan_exit);

There are probably more include statements that needed but, I extracted this skeleton from a working driver, and adjusted it.

And Happy development!

Thank you to the authors of the following resources:

  1. Emulating Raspberry Pi 4 with QEMU
  2. Minimalistic Linux system on qemu ARM
]]> https://sebastianardelean.codeberg.page/posts/2025-10-19-linux-drivers-cross-compile/index.html https://sebastianardelean.codeberg.page/posts/2025-10-19-linux-drivers-cross-compile/index.html Sun, 19 Oct 2025 08:00:00 +0300 Barenco decomposition without ancilla qubits, in CL

Sick of using Qiskit for the implementation of quantum circuits—they change and broke the APIs with each release— I decided to implement a CL library that allows the definition of quantum circuits and translates the code into openQASM v2.0. The library CLQ is already almost 2 years old but, being occupied with other things, I didn’t use it in big projects; just some minor circuits like 4 qubits adders, 4 qubits Grover and so on. From the development I noticed a weak point in not having n-qubits Toffoli gates. And somehow, I avoided the library until I decided to implement a quantum genetic algorithm using it.

A n-qubits Toffoli gate is relatively easy to implement using ancilla qubits. I won’t dive into the circuit, but the basic idea is to use CCNOT gates to change the state of the ancilla qubits, and finally, use a CNOT with the last ancilla qubit as control. But this technique requires a lot of qubits and, in my circuit, to implement a simple knapsack solver it required over 32 qubits, with most of them being ancilla. That’s a waste and one cannot simulate that on a machine using Qiskit, QVM (my new favourite), or others.

Thus, welcome to the Barenco et all. Elementary gates for quantum computation. After studying the paper, I started to write some qasm to define a base case, and after defining CNOTS with 2 control qubits, I jumped to 3 control qubits and so on.

Therefore, using CLQ library I implemented the decomposition for a CCNOT gate: 

( defun  barenco-decomposition (qc ctrl-reg-0 ctrl-0 ctrl-reg-1 ctrl-1 target-reg targ)
  (clq:hgate qc target-reg targ)
  (clq:cxgate qc ctrl-reg-1 ctrl-1 target-reg targ)
  (clq:tdggate qc target-reg targ)
  (clq:cxgate qc ctrl-reg-0 ctrl-0 target-reg targ)
  (clq:tgate qc target-reg targ)
  (clq:cxgate qc ctrl-reg-1 ctrl-1 target-reg targ)
  (clq:tdggate qc target-reg targ)
  (clq:cxgate qc ctrl-reg-0 ctrl-0 target-reg targ)
  (clq:tgate qc ctrl-reg-1 ctrl-1)
  (clq:tgate qc target-reg targ)
  (clq:hgate qc target-reg targ))

and then I started to think about how to use 3,4,5,etc. controls. (By the way, LLMs are pretty stupid, I would say quite idiots, at implementing it, giving the same incorrect code over and over again.) 

( defun  mcx-no-ancilla (qc ctrl-reg ctrl-pos target-reg targ)
  ( let ((len (length ctrl-pos)))
    ( cond ((= len 0)
           (clq:xgate qc target-reg targ))
          ((= len 1)
           (clq:cxgate qc ctrl-reg (car ctrl-pos) target-reg targ))
          ((= len 2)
           (barenco-decomposition qc
                                  ctrl-reg
                                  (nth 0 ctrl-pos)
                                  ctrl-reg
                                  (nth 1 ctrl-pos)
                                  target-reg
                                  targ))
          ((> len 2)
           ( dotimes (i (- len 2))
             (barenco-decomposition qc
                                    ctrl-reg
                                    (nth i ctrl-pos)
                                    ctrl-reg
                                    (nth (+ i 1) ctrl-pos)
                                    target-reg
                                    targ))
           (clq:cxgate qc ctrl-reg (car (last ctrl-pos)) target-reg targ)
           ( dotimes (i (- len 2))
             (barenco-decomposition qc
                                    ctrl-reg
                                    (nth i ctrl-pos)
                                    ctrl-reg
                                    (nth (+ i 1) ctrl-pos)
                                    target-reg
                                    targ))))))

Finally, we can define the circuit as 

( defun  build-circuit ()
  ( let* ((qreg (clq:make-qregister 8  "qr"))
         (creg (clq:make-cregister 8  "cr"))
         (qc (clq:make-qcircuit (list qreg)
                                (list creg))))
    ( dotimes (i 7)
      (clq:xgate qc qreg i))
    (mcx-no-ancilla qc qreg (list 0 1 2 3 4 5 6) qreg 7)
    ( dotimes (i 8)
      (clq:measure qc qreg i creg i))
    
    (clq:save-openqasm-to-file qc  "test.qasm")

And simulate it using QVM or Qiskit (YAC!) or other simulators.

Later edit

Furthermore, we can define different multi-controlled gates, like for the H,S,T gates. 

( defun  mch-no-ancilla (qc ctrl-reg ctrl-pos target-reg targ)
  ( let ((len (length ctrl-pos)))
    ( cond ((= len 0)
           (clq:hgate qc target-reg targ))
          ((= len 1)
           (clq:chgate qc ctrl-reg (car ctrl-pos) target-reg targ))
          ((= len 2)
           (clq:cchgate qc ctrl-reg (car ctrl-pos) ctrl-reg (car (cdr ctrl-pos)) target-reg targ))
          ((> len 2)
           ( dotimes (i (- len 2))
             (barenco-decomposition qc
                                    ctrl-reg
                                    (nth i ctrl-pos)
                                    ctrl-reg
                                    (nth (+ i 1) ctrl-pos)
                                    target-reg
                                    targ))
           (clq:chgate qc ctrl-reg (car (last ctrl-pos)) target-reg targ)
           ( dotimes (i (- len 2))
             (barenco-decomposition qc
                                    ctrl-reg
                                    (nth i ctrl-pos)
                                    ctrl-reg
                                    (nth (+ i 1) ctrl-pos)
                                    target-reg
                                    targ))))))

( defun  mcs-no-ancilla (qc ctrl-reg ctrl-pos target-reg targ)
  ( let ((len (length ctrl-pos)))
    ( cond ((= len 0)
           (clq:sgate qc target-reg targ))
          ((= len 1)
           (clq:csgate qc ctrl-reg (car ctrl-pos) target-reg targ))
          ((= len 2)
           (barenco-decomposition qc
                                  ctrl-reg
                                  (nth 0 ctrl-pos)
                                  ctrl-reg
                                  (nth 1 ctrl-pos)
                                  target-reg
                                  targ))
          ((> len 2)
           ( dotimes (i (- len 2))
             (barenco-decomposition qc
                                    ctrl-reg
                                    (nth i ctrl-pos)
                                    ctrl-reg
                                    (nth (+ i 1) ctrl-pos)
                                    target-reg
                                    targ))
           (clq:csgate qc ctrl-reg (car (last ctrl-pos)) target-reg targ)
           ( dotimes (i (- len 2))
             (barenco-decomposition qc
                                    ctrl-reg
                                    (nth i ctrl-pos)
                                    ctrl-reg
                                    (nth (+ i 1) ctrl-pos)
                                    target-reg
                                    targ))))))
           
  
( defun  mct-no-ancilla (qc ctrl-reg ctrl-pos target-reg targ)
  ( let ((len (length ctrl-pos)))
    ( cond ((= len 0)
           (clq:tgate qc target-reg targ))
          ((= len 1)
           (clq:ctgate qc ctrl-reg (car ctrl-pos) target-reg targ))
          ((= len 2)
           (barenco-decomposition qc
                                  ctrl-reg
                                  (nth 0 ctrl-pos)
                                  ctrl-reg
                                  (nth 1 ctrl-pos)
                                  target-reg
                                  targ))
          ((> len 2)
           ( dotimes (i (- len 2))
             (barenco-decomposition qc
                                    ctrl-reg
                                    (nth i ctrl-pos)
                                    ctrl-reg
                                    (nth (+ i 1) ctrl-pos)
                                    target-reg
                                    targ))
           (clq:ctgate qc ctrl-reg (car (last ctrl-pos)) target-reg targ)
           ( dotimes (i (- len 2))
             (barenco-decomposition qc
                                    ctrl-reg
                                    (nth i ctrl-pos)
                                    ctrl-reg
                                    (nth (+ i 1) ctrl-pos)
                                    target-reg
                                    targ))))))
]]> https://sebastianardelean.codeberg.page/posts/2025-09-25-lisp-barenco-decomposition/index.html https://sebastianardelean.codeberg.page/posts/2025-09-25-lisp-barenco-decomposition/index.html Thu, 25 Sep 2025 08:00:00 +0300 C++ signal dispatcher 
 // main.cpp
 #include  
 #include  
 #include  
 #include  "sig.hpp"

 auto  handler( int  signum) ->  void {
     std::cout<< "SIGALRM\n";
}

 auto  main( void) ->  int {
   bool  stop =  false;
   sig_handler::setHandler(SIGINT, [& stop] ( int) { stop =  true; });
   sig_handler::setHandler(SIGALRM, &handler);

   while ( !stop) {
     std:: this_thread::sleep_for( std:: chrono::seconds(1));
    raise(SIGALRM);
  }
   std::cout <<  "Bye" <<  std::endl;
   return 0;
}
 //  sig.cpp
 #include    //  strsignal
 #include  
 #include  
 #include  
 #include  
 #include  
 #include  "sig.hpp"

 namespace  sig_handler {

   std:: timed_mutex  signalHandlersMutex;
   std:: unordered_map< int,  std:: function< void( int)>>  signalHandlers;

   auto  dispatcher( int  signal) ->  void {
     std:: unique_lock< std:: timed_mutex>  lock(signalHandlersMutex,  std::defer_lock);
     if ( !lock.try_lock_for( std:: chrono::seconds(1))) {
       //  unable to get the lock. should be a strange case
       return;
    }
     auto  it = signalHandlers.find(signal);
     if (it != signalHandlers.end()) {
      it->second(signal);
    }
  }

   auto  registerHandler( int  signal,  const  std:: function< void( int)>&  handler) ->  void {
     std:: lock_guard< std:: timed_mutex>  lock(signalHandlersMutex);
    signalHandlers.emplace(signal, handler);
  }


   auto  setHandler( int  signal,  const  std:: function< void( int)>&  handler,  int  flags) ->  void {

     struct  sigaction  action;
     if (sigfillset(&action.sa_mask) == -1) {
       throw  std::runtime_error( "sigfillset failed");
    }
    action.sa_flags = flags;
    action.sa_handler = dispatcher;

     //  set handler for the signal
     if (sigaction(signal, &action,  nullptr) == -1 && signal < __SIGRTMIN) {
       throw  std::runtime_error( "Fail at configuring handler for signal: " +  std::string(strsignal(signal)));
    }
    registerHandler(signal, handler);
  }

}
 // sig.hpp
 #if  n def SIG_HPP
 #define  SIG_HPP

 #include  

 namespace  sig_handler {

         auto  setHandler( int  signal,  const  std:: function< void( int)>&  handler,  int  flags=0) ->  void;

}

 #endif
]]> https://sebastianardelean.codeberg.page/posts/2025-01-22-cpp-signal-handler/index.html https://sebastianardelean.codeberg.page/posts/2025-01-22-cpp-signal-handler/index.html Wed, 22 Jan 2025 08:00:00 +0200 Decimal to binary in Clojure 
(defn convert-to-binary [value bits]
  (letfn [(to-binary [value bits] 
            (-> value (Integer/toString 2)
                (Integer/parseInt) (->> (format (str "%0" bits "d")))))]
    (let [binary-value (to-binary value bits) result-size (count binary-value)
          default-value (apply str (repeat bits 1))]
      (if (not= result-size bits) default-value  binary-value))))
]]> https://sebastianardelean.codeberg.page/posts/2024-08-21-decimal-to-binary-in-clojure/index.html https://sebastianardelean.codeberg.page/posts/2024-08-21-decimal-to-binary-in-clojure/index.html Wed, 21 Aug 2024 08:00:00 +0300 Decorator design pattern 
 include 
 #include  
 #include  
 /**
 * The base Component interface 
 */
 class Component {
  public:
   Component(){ std::cout<< "[Constructor] Component\n";}
   virtual ~ Component(){ std::cout<< "[Destructor] Component\n";}
   virtual  void  Operation() = 0;
};
 /**
 * Concrete Components 
 */
 class  ConcreteComponent :  public  Component {
  public:
   ConcreteComponent(){ std::cout<< "[Constructor] ConcreteComponent\n";}
  ~ ConcreteComponent(){ std::cout<< "[Destructor] ConcreteComponent\n";}
   void  Operation()  override {
     std::cout<< "ConcreteComponent";
  }
};

 class  Decorator :  public  Component {

  protected:
   std:: unique_ptr< Component>  component_;

  public:
  
   Decorator(  std:: unique_ptr< Component>  component)  {
      component_= std::move(component);
       std::cout<< "[Constructor] Decorator\n";
  }
  ~ Decorator(){ std::cout<< "[Destructor] Decorator\n";}
  
 
   void  Operation()   override {
     this->component_->Operation();
  }
};

 class  ConcreteDecorator :  public  Decorator {
  
  public:
  
   ConcreteDecorator(  std:: unique_ptr< Component>  component) : Decorator( std::move(component)) {
       std::cout<< "[Constructor] ConcreteDecorator\n";
  }
  ~ ConcreteDecorator() { std::cout<< "[Destructor] ConcreteDecoratorA\n";}
   void  Operation()   override {
     std::cout<<  "ConcreteDecorator(";  Decorator::Operation();  std::cout<< ")";
  }
};


 int  main() {
 
   std:: unique_ptr< Component>  simple= std::make_unique< ConcreteComponent>();
   std::cout <<  "Client: I've got a simple component:\n";
  simple->Operation();
   std::cout <<  "\n\n";

    std:: unique_ptr< Component>  decorator =  std::make_unique< ConcreteDecorator>( std::move(simple));
    std::cout <<  "Client: Now I've got a decorated component:\n";
   decorator->Operation();
    std::cout <<  "\n";

   

   return 0;
}
]]> https://sebastianardelean.codeberg.page/posts/2024-08-21-decorator-design-pattern-in-cpp/index.html https://sebastianardelean.codeberg.page/posts/2024-08-21-decorator-design-pattern-in-cpp/index.html Wed, 21 Aug 2024 08:00:00 +0300 Flask API served using Gunicorn and Nginx

Dependencies

sudo apt install python3-pip python3-dev python3-venv nginx

Python environment

python3 -m venv env
 source env/bin/activate
pip3 install flask gunicorn

Python Application

 # ~/project/app.py
 from flask  import Flask
 app  = Flask( __name__)
 @app.route( "/")
 def  hello():
     return  "Welcome to Flask Application!"
 if  __name__  ==  "__main__":
    app.run(host = '0.0.0.0')

 # ~/project/wsgi.py
 from app  import app
 if  __name__  ==  "__main__":
  app.run()

And deactivate the environment.

Systemd Service

 # vi /etc/systemd/system/flask.service
[Unit]
 Description=Gunicorn instance to serve Flask
 After=network.target
[Service]
 User=root
 Group=www-data
 WorkingDirectory=/home//project
 Environment= "PATH=/home//project/env/bin"
 ExecStart=/home//project/env/bin/gunicorn --bind unix:/home//project/request.sock wsgi:app
[Install]
 WantedBy=multi-user.target
chown -R root:www-data /home//project
chmod -R 775 /home//project
systemctl daemon-reload
systemctl start flask
systemctl enable flask
systemctl status flask

Nginx as reverse proxy

> vim /etc/nginx/sites-available/flask.conf
server {
  listen :5002 ssl http2;
  listen :5001;

  ssl_certificate /home//project/cert.pem;
  ssl_certificate_key /home//project/key.pem;

  access_log /home//project/rest_api.access.log;
  error_log /home//project/rest_api.error.log;



  location / {
    include proxy_params;
    proxy_pass http://unix:/home//project/request.sock;
   }

}
> vim /etc/nginx/nginx.conf
stream {
    upstream http {
        server :5001;
    }

    upstream https {
        server :5002;
    }

    map $ssl_preread_protocol $upstream {
        default https;
        "" http;
    }

    # SSH and SSL on the same port
    server {
        listen 5000;

        proxy_pass $upstream;
        ssl_preread on;
    }
}
sudo ln -s /etc/nginx/sites-available/flask.conf /etc/nginx/sites-enabled
nginx -t
systemctl restart nginx
]]> https://sebastianardelean.codeberg.page/posts/2024-08-21-flask-server-setup/index.html https://sebastianardelean.codeberg.page/posts/2024-08-21-flask-server-setup/index.html Wed, 21 Aug 2024 08:00:00 +0300 Fractals implemented in Clojure

Fractal canopy

(ns fractals.core
  (:gen-class))

(def tree-fractal-file "tree.svg")


(defn append-to-file
  "Uses spit to append to a file specified with its name as a string, or
   anything else that writer can take as an argument.  s is the string to
   append."     
  [file-name s]
  (spit file-name s :append true))



(def header-xml "")
(def header-svg "")
(def footer "\" stroke=\"black\" stroke-width=\"1\"/>\n")



(defn map-y-coordinate [y]
  (- 600 y))

(defn draw-line [x y x1 y1 file]
  (append-to-file file (str " M " x " " (map-y-coordinate y)))
  (append-to-file file (str " L " x1 " " (map-y-coordinate y1)))
  )

(defn draw-tree [x y angle depth len fork-angle]
  (if (> depth 0)
    (let [x2 (- x (* (Math/sin (Math/toRadians angle)) depth len))
          y2 (- y (* (Math/cos (Math/toRadians angle)) depth len))]
      (draw-line x y x2 y2 tree-fractal-file)
      (draw-tree x2 y2 (- angle fork-angle) (- depth 1) len fork-angle)
      (draw-tree x2 y2 (+ angle fork-angle) (- depth 1) len fork-angle)
      )))


(defn run-tree []
  (let [content "

Vicsek fractal

(def header-xml "")
(def header-svg "")
(def footer "\"/>\n")

(defn append-to-file
  [file-name s]
  (spit file-name s :append true))



(defn print-line [x y len file]
  (append-to-file file (str "M " x " " y))
  (append-to-file file (str "h " len))
  (append-to-file file (str "v " len))
  (append-to-file file (str "h " (- 0 len)))
  (append-to-file file (str "v -" len))  
  )

(defn fractal-cross [x y len file]
  (if (< len 3)
    (print-line x y len file)
    (let [l3 (/ len 3.0) l23 (* l3 2)]
      (fractal-cross x y l3 file)
      (fractal-cross (+ x l23) y l3 file)
      (fractal-cross (+ x l3) (+ y l3) l3 file)
      (fractal-cross x (+ y l23) l3 file)
      (fractal-cross (+ x l23) (+ y l23) l3 file))))

(defn run [x,y,len file]
  (let [content "")
(def header-svg "")
(def footer "\"/>\n")

(defn append-to-file
  [file-name s]
  (spit file-name s :append true))



(defn print-line [x y len file]
  (append-to-file file (str "M " x " " y))
  (append-to-file file (str "h " len))
  (append-to-file file (str "v " len))
  (append-to-file file (str "h " (- 0 len)))
  (append-to-file file (str "v -" len))  
  )

(defn fractal-cross [x y len file]
  (if (< len 3)
    (print-line x y len file)
    (let [l3 (/ len 3.0) l23 (* l3 2)]
      (fractal-cross x y l3 file)
      (fractal-cross (+ x l23) y l3 file)
      (fractal-cross (+ x l3) (+ y l3) l3 file)
      (fractal-cross x (+ y l23) l3 file)
      (fractal-cross (+ x l23) (+ y l23) l3 file))))

(defn run [x,y,len file]
  (let [content "
]]> https://sebastianardelean.codeberg.page/posts/2024-08-21-fractals-implemented-in-clojure/index.html https://sebastianardelean.codeberg.page/posts/2024-08-21-fractals-implemented-in-clojure/index.html Wed, 21 Aug 2024 08:00:00 +0300 Latex Diff

Command to diff latex code when pictures/tables are inside a frame latexdiff --append-safecmd=subfile --config="PICTUREENV=(?:picture|DIFnomarkup|align|tabular)[\w\d*@]*" draft.tex revision.tex --flatten > diff_new.tex

]]> https://sebastianardelean.codeberg.page/posts/2024-08-21-latexdiff/index.html https://sebastianardelean.codeberg.page/posts/2024-08-21-latexdiff/index.html Wed, 21 Aug 2024 08:00:00 +0300 Create maps of member functions 
 #include  
 #include  
 #include  
 #include  
 #include  
 class  SomeObj
{
     public:
        void  Run(){
            fct_t  funct;
            for ( auto  entry:functionsMap) {
               funct = entry.second;
               funct( "some string");
           }
       }
     private:
         void  myFunction( const  std:: string & str)
        {
             std::cout<using  fct_t =  std:: function< void( const  std:: string &)>;
         const  std:: map< int, fct_t>  functionsMap = 
        {
                {1, std::bind(& SomeObj::myFunction,  this,
                   std:: placeholders::_1)},
        };
};

 int  main() {
     SomeObj  obj;
    obj.Run();

   return 0;
}
]]> https://sebastianardelean.codeberg.page/posts/2024-08-21-maps-of-member-functions-in-cpp/index.html https://sebastianardelean.codeberg.page/posts/2024-08-21-maps-of-member-functions-in-cpp/index.html Wed, 21 Aug 2024 08:00:00 +0300 Metaprogramming in Cpp

Metaprogramming Collatz conjecture

 template < std:: uint64_t,  std:: uint64_t,  std:: uint64_t>  struct  CollatzHelper;

 template< std:: uint64_t  A,  std:: uint64_t  B>
 struct  CollatzHelper< A, B,1>: public  CollatzHelper<(A*3+1), B+1,(( A*3+1)%2)>{};

 template< std:: uint64_t  A,  std:: uint64_t  B>
 struct  CollatzHelper< A, B,0>: public  CollatzHelper<(A/2), B+1,(( A/2)%2)>{};


 template < std:: uint64_t  B>  struct  CollatzHelper<1, B,1>
{
     static  constexpr  std:: uint64_t  conj = B;
};

 template< std:: uint64_t  A>  struct  Collatz:  public  CollatzHelper< A,0,A%2>{};

Metaprogramming Factorial

 template < std:: uint64_t  N>
 struct  Fact
{
     static  constexpr  std:: uint64_t  val = N *  Fact::val;
};

 template<>
 struct  Fact<0>
{
     static  constexpr  std:: uint64_t  val = 1;
};

Metaprogramming Fibonacci

 template< std:: uint64_t  I>
 struct  Fib
{
     static  constexpr  std:: uint64_t  val =  Fib::val +  Fib::val;
};

 template <>
 struct  Fib<0>
{
     static  constexpr  std:: uint64_t  val = 0;
};

 template <>
 struct  Fib<1>
{
     static  constexpr  std:: uint64_t  val = 1;
};
]]> https://sebastianardelean.codeberg.page/posts/2024-08-21-metaprogramming-in-cpp/index.html https://sebastianardelean.codeberg.page/posts/2024-08-21-metaprogramming-in-cpp/index.html Wed, 21 Aug 2024 08:00:00 +0300 Monte Carlo algorithms in OCaml

Monte Carlo Integration

module type MonteCarlo_type=sig
  val initializePRNG:unit->unit
  val getRandomNumber:unit->float
  val approximate:(float->float)->float->float->int->int->float->float  
end

let rec approximate f a b n index value=
    if index=(n-1) then
      ((b-.a)/.(float_of_int index))*.value
    else
      let randVal=getRandomNumber() in
      let inInterval=a+.randVal*.(b-.a) in
      let fVal=f inInterval in
      approximate f a b n (index+1) (value+.fVal)

open Random
open MonteCarlo_type

module MonteCarlo:MonteCarlo_type=struct
  let initializePRNG ()=Random.self_init()
  let getRandomNumber ()=Random.float 1.0
  
  let rec approximate f a b n index value=
    if index=(n-1) then
      ((b-.a)/.(float_of_int index))*.value
    else
      let randVal=getRandomNumber() in
      let inInterval=a+.randVal*.(b-.a) in
      let fVal=f inInterval in
      approximate f a b n (index+1) (value+.fVal)
end

open MonteCarlo

let pi = 4.0 *. atan 1.0;;
let func (x:float)=sin x
let () = 
  MonteCarlo.initializePRNG();
  print_float (MonteCarlo.approximate func 0.0 pi 100000 0 0.0)

Monte Carlo PI Estimation

Formula to determine PI:

\begin{equation} PI=4.0*\frac{hits}{darts thrown} \end{equation} 
let rnd=System.Random(System.DateTime.Now.Millisecond)

let genRandomNumbers (count:int) =
    List.init count (fun _ -> rnd.NextDouble ())

let isInside (x:double) (y:double)=(sqrt (x*x+y*y))<1.0

let sum (x:^a list)=
    match (isInside (x.Head*2.0-1.0) (x.Tail.Head*2.0-1.0)) with
        | false->0
        | true-> 1

let rec computePi (numThrows:int) (hits:int) (idx:int)=
    if numThrows=idx then
        4.0*((double)hits/(double)numThrows)
    else
          computePi numThrows (hits+(genRandomNumbers 2 |> sum)) (idx+1)

[]
let main argv = 
    let l=computePi 1000000000 0 0
    printfn "%F" l
    0
]]> https://sebastianardelean.codeberg.page/posts/2024-08-21-monte-carlo-algorithms/index.html https://sebastianardelean.codeberg.page/posts/2024-08-21-monte-carlo-algorithms/index.html Wed, 21 Aug 2024 08:00:00 +0300 Polynomial values in Haskell

For a polynomial p of degree N, this function returns the value:

\begin{equation} p_{0}*x^{N-1}+p_{1}*x^{N-2}+...+p_{N-2}*x+p_{N-1} \end{equation} 
evalPoly::Double->[Double]->Double
evalPoly n xs=sum $ map (\e->e*n**fromIntegral ((length xs)-1-(fromJust $ elemIndex e xs))) xs

Usage: 

>evalPoly 3 [-19,7,-4,6]
-456.0
>evalPoly 5 [3,0,1]
76.0
]]> https://sebastianardelean.codeberg.page/posts/2024-08-21-polynomial-values-in-haskell/index.html https://sebastianardelean.codeberg.page/posts/2024-08-21-polynomial-values-in-haskell/index.html Wed, 21 Aug 2024 08:00:00 +0300 Simple GA in Clojure

Based on the implementation presented by Lee Spector. 

(defn new-individual
                  "Function used for creating a new individual"
                  [genome-length]
                  {:genome (vec (repeatedly genome-length #(rand-int 2))) :fitness 0}
                  )
            (defn fitness-function 
                [genome, target]
                (Math/abs (- (reduce + genome) target))
            )

            (defn calculate-fitness
              [population, target]
              (letfn [(fitness-function-helper 
                  [individual, target]
                  (assoc individual :fitness (fitness-function (individual :genome) target))
              )]
                      (map (fn [individual] (#(fitness-function-helper individual target))) population)
              )

          )
          (defn get-best-individual [population]
                        (letfn [(better [i1 i2]
                                                (< (i1 :fitness) (i2 :fitness))
                                        )]
                                (first (sort better population))
                        )
        )
        (defn crossover
              [first-individual, second-individual, crossover-rate, target]
              (let [new-genome (mapv (fn [i1,i2] (let [crossover-probability (rand)]
                                              (cond
                                                  (<= crossover-probability crossover-rate) i1
                                                  :else i2
                                              )
                                          )
                                  ) 
                  (first-individual :genome) (second-individual :genome)
                      )]
                  {:genome new-genome :fitness (fitness-function new-genome target)}
              )

      )
      (defn mate-individuals [population, population-size, crossover-rate, target, tournament-size]
            (letfn [(tournament-selection [population, population-size, tournament-size, target]
                                    (loop [steps 0 new-population ()]
                                            (if (< steps tournament-size)
                                                    (recur (inc steps) (conj new-population (nth population ((comp rand-int -) population-size 2))))
                                                    (get-best-individual (calculate-fitness new-population target))
                                            )
                                    )
                    )]
                                    (loop [steps 0 new-population ()]
                                            (if (< steps population-size)
                                                    (let [i1 (tournament-selection population population-size tournament-size target)]
                                                            (let [i2 (tournament-selection population population-size tournament-size target)]
                                                                    (let [offs (crossover i1 i2 crossover-rate target)]
                                                                            (recur (inc steps) (conj new-population offs))
                                                                    )
                                                            )
                                                    )
                                                    new-population
                                            )
                                    )
            )
    )
    (defn mutate-population [population, population-size, genome-length, target]

                          (letfn [(mutate [individual, genome-length, target]
                                          (let [new-genome (assoc (individual :genome) (rand-int genome-length) (rand-int 2))]
                  {:genome new-genome :fitness (fitness-function new-genome target)}
                          )
                                  )]
                                  (loop [steps 0 new-population ()]
          (if (< steps population-size)
                  (recur (inc steps) (conj new-population (mutate (nth population steps) genome-length target)))
                  new-population
          )

      )

                          )


  )
  (defn evolve [population-size, genome-length, target, number-of-generations, crossover-rate, tournament-size]
(loop [generation 0 population (calculate-fitness (repeatedly population-size #(new-individual genome-length)) target) best {}]
        (if (and (< generation number-of-generations) (not= 0 (best :fitness)))


                                (let [offsprings (mate-individuals population population-size crossover-rate target tournament-size)]
                                        (let [new-population (mutate-population offsprings population-size genome-length target)]
                                                (let [best-individual (get-best-individual new-population)]
                                                        (do
                                                                (printf "Generation %s -> best individual %s%n" generation best-individual)

                                                                (recur (inc generation) new-population best-individual)
                                                        )
                                                )
                                        )

                                )
                                best
        )

)
)

(println (evolve 100 100 1 100 0.3 10))
]]> https://sebastianardelean.codeberg.page/posts/2024-08-21-simple-ga-in-clojure/index.html https://sebastianardelean.codeberg.page/posts/2024-08-21-simple-ga-in-clojure/index.html Wed, 21 Aug 2024 08:00:00 +0300 Thread-safe Singleton Design Pattern 
 class  Singleton {
 public:
   static  std:: shared_ptr< Singleton> & GetInstance() {
     static  std:: shared_ptr< Singleton>  instance =  nullptr;
     if ( !instance) {
       std:: lock_guard< std:: mutex>  lock( Singleton::_mutex);

       if ( !instance) {
        instance.reset( new  Singleton());
      }

    }
     return instance;
  }
 
  ~ Singleton() {}
 private:
     Singleton() {
    }
   Singleton( const  Singleton &) =  delete;
   Singleton( Singleton &&) =  delete;
   Singleton & operator =( const  Singleton &) =  delete;
   Singleton & operator =( Singleton &&) =  delete;
   static  std:: mutex  _mutex;
};

 std:: mutex  Singleton:: _mutex;
]]> https://sebastianardelean.codeberg.page/posts/2024-08-21-thread-safe-singleton-design-pattern-in-cpp/index.html https://sebastianardelean.codeberg.page/posts/2024-08-21-thread-safe-singleton-design-pattern-in-cpp/index.html Wed, 21 Aug 2024 08:00:00 +0300