<?xml version="1.0" encoding="UTF-8"?>
<!-- generator="FeedCreator 1.8" -->
<?xml-stylesheet href="https://yanevskiv.com/lib/exe/css.php?s=feed" type="text/css"?>
<rdf:RDF
    xmlns="http://purl.org/rss/1.0/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
    xmlns:dc="http://purl.org/dc/elements/1.1/">
    <channel rdf:about="https://yanevskiv.com/feed.php">
        <title>Ivan&#039;s wiki</title>
        <description></description>
        <link>https://yanevskiv.com/</link>
        <image rdf:resource="https://yanevskiv.com/_media/logo.png" />
       <dc:date>2026-07-21T22:25:50+00:00</dc:date>
        <items>
            <rdf:Seq>
                <rdf:li rdf:resource="https://yanevskiv.com/115200?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ab-testing?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/aba-problem?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/agile?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/amdahls-law?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/applying-gates-to-zero-state?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/arduino-uno-r4-wifi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/array?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/artifact?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/assert.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/atomic-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/b-plus-tree?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/b-tree?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/barrier-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/bash-internal?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/basis-state?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/bell-state-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/bell-state?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/bell-states?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/binary-tree?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/bloch-sphere?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/blocking-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/blue-green-deployment?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/born-rule?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/brooks-law?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/c-headers?rev=1781515121&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/c-standard-library?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/canary-release?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/canonical-states?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ccx-gate?rev=1781320479&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ccz-gate?rev=1781320781&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ci-cd?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/circular-buffer?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/cnot-gate-cudaq?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/cnot-gate-custatevec?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/cnot-gate-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/collapse-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/collectives-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/communicator-duplication-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/communicators-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/complex.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/coreutils?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/cp-1?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/critical-sections-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ctype.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/curses.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/cx-gate?rev=1781863651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/cy-gate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/cz-gate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/data-sharing-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/deadlock-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/density-matrix?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/derived-datatypes-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/deutsch-jozsa?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/deutsch?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/devops?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/dirac-notation?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/do-while-0?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/docker?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/dynamic-array?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/eat-your-own-dog-food?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/eigenstate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/embedded-engineering?rev=1781515121&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/embedded-glossary?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/eof?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/eqn-electromagnetism?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/errno.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/exit-status?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/false-sharing-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/fdsa?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/feature-branch?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/feature-flag?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/fenv.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/fft?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/float.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/flush-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/forward-list?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/function-macro?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/general-writing-guide?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/getopt.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ghz-state-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/gist-docker?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/gist-git?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/gist-semaphores?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/git?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/gitignore?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/global-phase?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/gnu-linux?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/goodharts-law?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/graph?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/greenspuns-tenth-rule?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/grover?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/gustafsons-law?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/h-gate-cudaq?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/h-gate-custatevec?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/h-gate-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/h-gate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/harvard-architecture?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/hash-map?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/header-guard?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/heap?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/hhl?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/hilbert-space?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/home?rev=1781515400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/hopf-fibration?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/hotfix?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/hsp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/hybrid-openmp-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/i-gate-cudaq?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/i-gate-custatevec?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/i-gate-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/i-gate?rev=1781536969&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/i-state-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ifupdown?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/incremental-build-model?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/intro?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/introduction-to-quantum-computing?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/inttypes.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/iso646.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/iswap-gate-cudaq?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/iswap-gate-custatevec?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/iswap-gate-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/iswap-gate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kanban?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kdp20260110-1?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kdp20260110-2?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kdp20260218-1?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kdp20260218-2?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kdp20260218-3?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-0?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-00?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-01?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-1?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-10?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-11?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-ghz?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-minus-i?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-minus?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-phi-minus?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-phi-plus?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-plus-i?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-plus?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-psi-minus?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-psi-plus?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ket-w?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kpsewhich?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kraus-operator?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/landauers-principle?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/latex-syntax?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/latex?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/limits.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/lindbald-master-equation?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/lindblad-equation-qutip?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/lindblad-equation?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/linked-list?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/liskov-substitution-principle?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-algorithms?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-articles?rev=1781515396&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-c-concepts?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-c-headers?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-commands?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-concepts-in-quantum-control?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-concepts-in-quantum-error-correction?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-concepts?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-cpp-concepts?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-cpp-headers?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-data-structures?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-embedded-engineering-concepts?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-essential-quantum-computing-concepts?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-hardware?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-headers-cpp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-hpc-commands?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-kdp-exercises?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-latex-commands?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-logic-gates?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-miscellaneous-quantum-computing-concepts?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-miscellaneous-topics?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-optimal-quantum-control-algorithms?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-parallel-computing-concepts?rev=1781536038&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-paths?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-quantum-algorithms?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-quantum-computing-concepts?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-quantum-computing-libraries?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-quantum-error-correction-codes?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-quantum-gates?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-software-engineering-concepts?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-software-engineering-tools?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-syntaxes?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-system-commands?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-tools?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-util-linux-commands?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-writing-guides?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/locale.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/lock-free-queue?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/main-return?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/master-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/math-books?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/math.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/mathematical-maturity?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/matmul?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/matrix?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/message-ordering-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/minus-i-state-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/minus-state-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/mixed-state?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/multiqubit-gates?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/my-bookmarks?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/name-mangling?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/net-config?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/nih-syndrome?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/nisq?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/nonblocking-collectives-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/noon-state?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/nowait-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/numbers-every-programmer-should-know?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/nvcc?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/one-sided-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/p-gate-cudaq?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/p-gate-custatevec?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/p-gate-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/p-gate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/parallel-computing-overview?rev=1781516094&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/parallel-computing?rev=1781538462&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/parallel-io-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/parallel-loops-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/parkinsons-law?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/past-disclaimer?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-bin?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-boot?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-dev?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-etc?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-home?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-lib?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-mnt?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-opt?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-proc?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-root?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-sbin?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-srv?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-tmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-usr?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-var?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/pauli-gate-cudaq?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/pauli-gate-custatevec?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/pauli-gate-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/pauli-gates?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/pdflatex?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/perf?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/performance-model-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/persistent-communication-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/playground?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/plus-state-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/point-to-point-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/posix-headers?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/pragma-once?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/prefix-reductions-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/probability-amplitude?rev=1781322581&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/probing-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/process-groups-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/production?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/prototype?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/pure-state?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/qaoa?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/qft?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/qpe?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-algorithm?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-circuit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-computing?rev=1781515121&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-dummy-text?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-error-correction?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-gate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-register?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-state?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/qubit-gates-in-c?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/qubit?rev=1781322406&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/queue?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/r-gate-cudaq?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/r-gate-custatevec?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/r-gate-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/rabi-cycles?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ramsey-interference?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/red-black-tree?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/reduction-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/reduction-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/regression?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/rho-zero?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/roofline-model?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/rotation-gates?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ruin-theory?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/rule-of-5?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/rwa?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/rx-gate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ry-gate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/rz-gate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/s-gate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/saxpy?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/scatter-and-gather-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/scheduling-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/schrodinger-equation-qutip?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/schrodinger-equation?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/sections-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/semaphore?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/send-modes-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/setjmp.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/shared-memory-windows-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/shell?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/shor?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/signal.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/simd-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/single-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/single-qubit-gates?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/smart-and-vapid?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/solid?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/spike-solution?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ssh?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/stack?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/state-vector?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/stdalign.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/stdarg.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/stdatomic.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/stdbit.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/stdbool.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/stdckdint.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/stddef.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/stdint.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/stdio.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/stdlib.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/stdmchar.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/stdnoreturn.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/string.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/strunk-and-white?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/swap-gate-cudaq?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/swap-gate-custatevec?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/swap-gate-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/swap-gate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/syntax?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/t-gate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/tasks-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/terminal?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/test-automation?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/test-driven-development?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/tgmath.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/thinkpad?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/thread-affinity-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/thread.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/three-qubit-gates?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/three-qubits?rev=1781321871&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/time-measurement-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/time-measurement-openmp?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/time.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/tmux?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/todo?rev=1781513749&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/toffoli-gate-cudaq?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/toffoli-gate-custatevec?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/toffoli-gate-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/topics?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/trace-monoid?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/two-qubit-gates?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/two-qubits?rev=1781321039&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/u-gate-cudaq?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/u-gate-custatevec?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/u-gate-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/u-gate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/uchar.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/unit-test?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/virtual-topologies-mpi?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/von-neumann-equation-qutip?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/von-neumann-equation?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/vps?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/vqe?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/w-state-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/wchar.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/wctype.h?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/wip-example?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/writing-guide-on-header-files?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/writing-guide-on-parallel-computing?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/writing-guide-on-quantum-computing?rev=1781513651&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/x-gate-cudaq?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/x-gate-custatevec?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/x-gate-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/x-gate?rev=1781537002&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/x220-gpu-rendering-with-hyprland?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/xp-programming?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/y-gate-cudaq?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/y-gate-custatevec?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/y-gate-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/y-gate?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/yanevskiv-wiki?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/z-gate-cudaq?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/z-gate-custatevec?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/z-gate-qiskit?rev=1781320400&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/z-gate?rev=1781320400&amp;do=diff"/>
            </rdf:Seq>
        </items>
    </channel>
    <image rdf:about="https://yanevskiv.com/_media/logo.png">
        <title>Ivan's wiki</title>
        <link>https://yanevskiv.com/</link>
        <url>https://yanevskiv.com/_media/logo.png</url>
    </image>
    <item rdf:about="https://yanevskiv.com/115200?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>115200</title>
        <link>https://yanevskiv.com/115200?rev=1781320400&amp;do=diff</link>
        <description>115200

115200 is the default baud rate for Arduino USB-UART communication.

picocom

You specify the baudrate using -b option.



 $ picocom /dev/ttyACM0 -b 115200


To exit picocom, use Ctrl + A, X. This means holding control and pressing &#039;A&#039; and &#039;X&#039;. Don&#039;t release control while switching from &#039;A&#039; to &#039;X&#039;.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ab-testing?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>A/B testing</title>
        <link>https://yanevskiv.com/ab-testing?rev=1781320400&amp;do=diff</link>
        <description>A/B testing

A/B testing is a method of comparing two variants of a feature by exposing each to a different subset of users simultaneously and measuring the effect on a target metric. Variant A is typically the control (current behaviour); variant B is the treatment (the change being evaluated).</description>
    </item>
    <item rdf:about="https://yanevskiv.com/aba-problem?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>ABA problem</title>
        <link>https://yanevskiv.com/aba-problem?rev=1781320400&amp;do=diff</link>
        <description>ABA problem

The ABA problem is a correctness hazard in lock-free code that uses compare-and-swap (CAS). CAS reads a value, does some work, then atomically updates the location only if it still holds the value you read — otherwise retrying. The assumption baked in is that a matching value means nothing changed. This is wrong: another thread can change the location from A to B and back to A between your read and your CAS, and CAS cannot tell the difference.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/agile?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Agile</title>
        <link>https://yanevskiv.com/agile?rev=1781320400&amp;do=diff</link>
        <description>Agile

Agile is a broad family of software development approaches that emphasise iterative delivery, collaboration with customers, and responding to change over following a fixed plan. The term was formalised in 2001 when seventeen software developers published the Agile Manifesto, which states four values:</description>
    </item>
    <item rdf:about="https://yanevskiv.com/amdahls-law?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Amdahl&#039;s law</title>
        <link>https://yanevskiv.com/amdahls-law?rev=1781320400&amp;do=diff</link>
        <description>Amdahl&#039;s law

Amdahl&#039;s law is a formula that predicts the maximum speedup you can get from parallelizing a program, given that some fraction of it is inherently sequential. It was stated by Gene Amdahl in 1967. The key insight is that the sequential portion of a program acts as a hard ceiling on how much parallelism can help, no matter how many processors you throw at it.$T$$p$$1 - p$$n$$\frac{p}{n}$$1 - p$$n$$$T(n) = T \left( (1 - p) + \frac{p}{n} \right)$$$S(n)$$n$$$S(n) = \frac{T}{T(n)} = \fr…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/applying-gates-to-zero-state?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Applying gates to $\lvert 0\rangle$ (Zero state)</title>
        <link>https://yanevskiv.com/applying-gates-to-zero-state?rev=1781320400&amp;do=diff</link>
        <description>Applying gates to $\lvert 0\rangle$ (Zero state)
 Gate  Matrix form  Derivation  $I$ gate (Identity gate)  $I = \begin{pmatrix}1&amp;0\\0&amp;1\end{pmatrix}$  $I\lvert 0\rangle = \begin{pmatrix}1&amp;0\\0&amp;1\end{pmatrix}\begin{pmatrix}1\\0\end{pmatrix} = \begin{pmatrix}1\\0\end{pmatrix} = \lvert 0\rangle$  $X$ gate (NOT gate)  $X = \begin{pmatrix}0&amp;1\\1&amp;0\end{pmatrix}$  $X\lvert 0\rangle = \begin{pmatrix}0&amp;1\\1&amp;0\end{pmatrix}\begin{pmatrix}1\\0\end{pmatrix} = \begin{pmatrix}0\\1\end{pmatrix} = \lvert 1\rangl…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/arduino-uno-r4-wifi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Arduino Uno R4 WiFi</title>
        <link>https://yanevskiv.com/arduino-uno-r4-wifi?rev=1781320400&amp;do=diff</link>
        <description>Arduino Uno R4 WiFi

Documentation:

	* &lt;https://docs.arduino.cc/hardware/uno-r4-wifi/&gt;</description>
    </item>
    <item rdf:about="https://yanevskiv.com/array?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Array</title>
        <link>https://yanevskiv.com/array?rev=1781320400&amp;do=diff</link>
        <description>Array

An array is a fixed-size sequence of elements of the same type stored in contiguous memory.

The index of an element determines its address: base + index * sizeof(element). This means any element is reachable in O(1) time without traversal, and the memory layout is cache-friendly — iterating over an array touches sequential cache lines rather than chasing pointers.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/artifact?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Artifact</title>
        <link>https://yanevskiv.com/artifact?rev=1781320400&amp;do=diff</link>
        <description>Artifact

An artifact in software engineering is a file or package produced by a build process that is intended for use or distribution. Source code is the input; artifacts are the outputs. Examples: a compiled binary, a .jar file, a Docker image, a firmware</description>
    </item>
    <item rdf:about="https://yanevskiv.com/assert.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>assert.h</title>
        <link>https://yanevskiv.com/assert.h?rev=1781320400&amp;do=diff</link>
        <description>assert.h

If you have ever had a function produce a wrong result somewhere deep in a call stack with no indication of where things went wrong, assert.h is what you reach for. It provides the assert macro, which checks a condition at runtime and immediately kills the program with a diagnostic message that tells you exactly which file, which line, and which condition failed.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/atomic-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Atomic (OpenMP)</title>
        <link>https://yanevskiv.com/atomic-openmp?rev=1781320400&amp;do=diff</link>
        <description>Atomic (OpenMP)

count++ compiles to three instructions: load, increment, store. When two threads execute this simultaneously, both can load the same value, both increment it, and both store back — the net result is one increment instead of two. This is the classic read-modify-write race condition.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/b-plus-tree?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>B+ tree</title>
        <link>https://yanevskiv.com/b-plus-tree?rev=1781320400&amp;do=diff</link>
        <description>B+ tree

A B+ tree is a variant of the B-tree where all values are stored in the leaf nodes and internal nodes hold only keys used for routing. Leaf nodes are linked together in a sorted doubly linked list. This distinction has a significant practical effect: range queries traverse only the leaf layer rather than the entire tree, and all records are equidistant from the root, giving uniform access time.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/b-tree?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>B-tree</title>
        <link>https://yanevskiv.com/b-tree?rev=1781320400&amp;do=diff</link>
        <description>B-tree

A B-tree is a self-balancing search tree generalised from a binary search tree to allow more than two children per node. Each node holds between $t-1$ and $2t-1$ keys (where $t \geq 2$ is the minimum degree), sorted in order. A node with $k$ keys has $k+1$ child pointers. All leaves are at the same depth, so the tree is perfectly height-balanced, and the height is O(log n).</description>
    </item>
    <item rdf:about="https://yanevskiv.com/barrier-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Barrier (OpenMP)</title>
        <link>https://yanevskiv.com/barrier-openmp?rev=1781320400&amp;do=diff</link>
        <description>Barrier (OpenMP)

Barrier is a synchronisation point where all threads in a team wait until every member has arrived. OpenMP inserts an implicit barrier at the end of every parallel, for, and sections region. All threads wait there until every member of the team has arrived. An explicit</description>
    </item>
    <item rdf:about="https://yanevskiv.com/bash-internal?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of internal Bash shell commands</title>
        <link>https://yanevskiv.com/bash-internal?rev=1781320400&amp;do=diff</link>
        <description>List of internal Bash shell commands</description>
    </item>
    <item rdf:about="https://yanevskiv.com/basis-state?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Basis state</title>
        <link>https://yanevskiv.com/basis-state?rev=1781320400&amp;do=diff</link>
        <description>Basis state

Basis state is a state vector that is part of a basis. A basis is set of two or more quantum states out of which all other quantum states can be built through linear combination.

A qubit is a two-level quantum system so has two basis states. The standard basis $\lvert 0\rangle, \lvert 1\rangle}$$\lvert\text{cat}\rangle$$\lvert\text{dog}\rangle$$d = 2$$\lvert\psi\rangle$$a,b\in\mathbb C$$\mathbb C^2$$\mathbb C^2$$$ \lvert\psi\rangle = \begin{pmatrix}a\\b\end{pmatrix},\quad\lvert\psi…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/bell-state-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Bell state (Qiskit)</title>
        <link>https://yanevskiv.com/bell-state-qiskit?rev=1781320400&amp;do=diff</link>
        <description>Bell state (Qiskit)

Bell states implementation using Qiskit. All four Bell states are prepared from $\lvert 00\rangle$ using a Hadamard gate and a CX gate, with optional single-qubit corrections.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

def bell(z_flip=False, x_flip=False):
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cx(0, 1)
    if z_flip:
        qc.z(0)  # relative phase flip
    if x_flip:
        qc.x(1)  # bit flip on second qubit
    return qc

p…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/bell-state?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title></title>
        <link>https://yanevskiv.com/bell-state?rev=1781320400&amp;do=diff</link>
        <description>This page has moved to Bell states (plural).</description>
    </item>
    <item rdf:about="https://yanevskiv.com/bell-states?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Bell states</title>
        <link>https://yanevskiv.com/bell-states?rev=1781320400&amp;do=diff</link>
        <description>Bell states

Bell states are the four maximally entangled two-qubit states, named after physicist John Bell. They form an orthonormal basis for the two-qubit Hilbert space $\mathbb{C}^4$ and are the canonical examples of quantum entanglement. No product state can approximate them without a dramatic increase in entropy.$$\lvert\Phi^+\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle + \lvert 11\rangle) \qquad \lvert\Phi^-\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle - \lvert 11\rangle)$$$$\lvert\Psi^+…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/binary-tree?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Binary tree</title>
        <link>https://yanevskiv.com/binary-tree?rev=1781320400&amp;do=diff</link>
        <description>Binary tree

A binary tree is a hierarchical structure where each node holds a value and has at most two children, called left and right. The node with no parent is the root. Nodes with no children are leaves. The height of a tree is the number of edges on the longest path from root to leaf; a tree with n nodes has height between O(log n) (balanced) and O(n) (degenerate — essentially a linked list).</description>
    </item>
    <item rdf:about="https://yanevskiv.com/bloch-sphere?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Bloch sphere</title>
        <link>https://yanevskiv.com/bloch-sphere?rev=1781320400&amp;do=diff</link>
        <description>Bloch sphere

Bloch sphere is a geometrical representation of a single qubit state as a point on the surface of a unit sphere in three-dimensional space. It provides an intuitive way to visualize qubit states and the effect of quantum gates as rotations. The Bloch sphere is named after physicist Felix Bloch.$\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$$a, b \in \mathbb{C}$$|a|^2 + |b|^2 = 1$$\theta \in [0, \pi]$$\varphi \in [0, 2\pi)$$$\lvert\psi\rangle = \cos\frac{\theta}{2}\lvert 0…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/blocking-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Blocking and non-blocking (MPI)</title>
        <link>https://yanevskiv.com/blocking-mpi?rev=1781320400&amp;do=diff</link>
        <description>Blocking and non-blocking (MPI)

A read() call on a file descriptor blocks: it doesn&#039;t return until the kernel has data to hand back. That is convenient but ties up the thread for the duration of the wait. POSIX offers aio_read() as an alternative: issue the request, do other work, and check completion later with</description>
    </item>
    <item rdf:about="https://yanevskiv.com/blue-green-deployment?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Blue-green deployment</title>
        <link>https://yanevskiv.com/blue-green-deployment?rev=1781320400&amp;do=diff</link>
        <description>Blue-green deployment

Blue-green deployment is a release strategy where two identical production environments (called blue and green) are maintained simultaneously. At any moment, one environment is live and the other is idle. To deploy a new version, you deploy it to the idle environment, run smoke tests, then switch traffic from the live environment to it.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/born-rule?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Born rule</title>
        <link>https://yanevskiv.com/born-rule?rev=1781320400&amp;do=diff</link>
        <description>Born rule

Born rule is a postulate in quantum mechanics that gives an interpretation of probability amplitudes. Namely, the probability amplitude $c\in\mathbb{C}$ associated with some state $\lvert i\rangle$ encodes the probability of finding the quantum system in the state $\lvert i\rangle$. The value of this probability — according to the Born rule — equals the modulus squared of the probability amplitude $c$$$P_i = |c|^2$$$\lvert\psi\rangle$$a\in\mathbb{C}$$\lvert 0\rangle$$b\in\mathbb{C}$$\…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/brooks-law?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Brooks&#039;s law</title>
        <link>https://yanevskiv.com/brooks-law?rev=1781320400&amp;do=diff</link>
        <description>Brooks&#039;s law

Brooks&#039;s law states that adding manpower to a late software project makes it later. It was articulated by Fred Brooks in his 1975 book The Mythical Man-Month, based on his experience managing the development of OS/360 at IBM.

The reason is that new team members are not immediately productive. They need time to understand the codebase, the domain, and the team&#039;s conventions. During that ramp-up period they consume the time of the experienced members who have to train and answer que…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/c-headers?rev=1781515121&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T09:18:41+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>C headers</title>
        <link>https://yanevskiv.com/c-headers?rev=1781515121&amp;do=diff</link>
        <description>C headers

C headers offer an interface to the C standard library.

List of headers

	* assert.h
	* complex.h
	* ctype.h
	* errno.h
	* fenv.h
	* float.h
	* inttypes.h
	* iso646.h
	* limits.h
	* locale.h
	* math.h
	* setjmp.h
	* signal.h
	* stdalign.h
	* stdarg.h
	* stdatomic.h
	* stdbit.h
	* stdbool.h
	* stdckdint.h
	* stddef.h
	* stdint.h
	* stdio.h
	* stdlib.h
	* stdmchar.h
	* stdnoreturn.h
	* string.h
	* tgmath.h
	* threads.h
	* time.h
	* uchar.h
	* wchar.h
	* wctype.h

Links

	* &lt;https://en.…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/c-standard-library?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>C standard library</title>
        <link>https://yanevskiv.com/c-standard-library?rev=1781320400&amp;do=diff</link>
        <description>C standard library

C standard library is one library that&#039;s always linked by default when you compile C programs.

To use the library, a set of headers is offered which you can include by default.

For example, &lt;stdlib.h&gt; and &lt;stdio.h&gt; in this code are headers from the C standard library (but there are also headers which are</description>
    </item>
    <item rdf:about="https://yanevskiv.com/canary-release?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Canary release</title>
        <link>https://yanevskiv.com/canary-release?rev=1781320400&amp;do=diff</link>
        <description>Canary release

A canary release is a deployment strategy where a new version of software is rolled out to a small subset of users before being promoted to the full user base. The name references the practice of sending canaries into coal mines to detect toxic gas before sending miners in.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/canonical-states?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Canonical states</title>
        <link>https://yanevskiv.com/canonical-states?rev=1781320400&amp;do=diff</link>
        <description>Canonical states

Canonical states are the six single-qubit states corresponding to the six cardinal points of the Bloch sphere — the $\pm z$, $\pm x$, and $\pm y$ poles. They are the eigenstates of the three Pauli operators $Z$, $X$, $Y$ and are the most frequently encountered states in single-qubit quantum computing.$\pm z$$\lvert 0\rangle$$\lvert 1\rangle$$$\lvert 0\rangle = \begin{pmatrix}1\\0\end{pmatrix} \qquad \lvert 1\rangle = \begin{pmatrix}0\\1\end{pmatrix}$$$\pm x$$\lvert +\rangle$$\l…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ccx-gate?rev=1781320479&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:14:39+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>CCX (Toffoli) gate</title>
        <link>https://yanevskiv.com/ccx-gate?rev=1781320479&amp;do=diff</link>
        <description>CCX (Toffoli) gate

CCX gate (doubly-controlled X, also called Toffoli gate or CCNOT) is a three-qubit gate that flips the target qubit if and only if both control qubits are $\lvert 1\rangle$. It was introduced by Tommaso Toffoli in 1980 and is the key building block for reversible classical computation inside a quantum circuit.$\lvert a, b, c\rangle \mapsto \lvert a, b, c \oplus (a \wedge b)\rangle$$\oplus$$\wedge$$8 \times 8$$\lvert 000\rangle$$\lvert 111\rangle$$$\text{CCX} = \begin{pmatrix}…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ccz-gate?rev=1781320781&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:19:41+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>CCZ gate</title>
        <link>https://yanevskiv.com/ccz-gate?rev=1781320781&amp;do=diff</link>
        <description>CCZ gate

CCZ gate (doubly-controlled Z) is a three-qubit gate that applies a Pauli Z to the target qubit if and only if both control qubits are $\lvert 1\rangle$, and does nothing otherwise. Because Z acts as a phase flip, the CCZ gate is fully symmetric: any permutation of the three qubits produces the same unitary.$\lvert a, b, c\rangle \mapsto (-1)^{a \wedge b \wedge c}\lvert a, b, c\rangle$$\lvert 111\rangle$$8 \times 8$$\lvert 000\rangle$$\lvert 111\rangle$$$\text{CCZ} = \begin{pmatrix}
1&amp;…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ci-cd?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>CI/CD</title>
        <link>https://yanevskiv.com/ci-cd?rev=1781320400&amp;do=diff</link>
        <description>CI/CD

CI/CD (continuous integration / continuous delivery) is the practice of automatically building, testing, and deploying software on every change. The goal is to keep the gap between “code written” and “code running in production” as small as possible, and to catch problems as close to the source as possible rather than discovering them weeks later during a manual release.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/circular-buffer?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Circular buffer</title>
        <link>https://yanevskiv.com/circular-buffer?rev=1781320400&amp;do=diff</link>
        <description>Circular buffer

A circular buffer (also called a ring buffer) is a fixed-capacity Queue backed by a flat Array with two indices: a read head and a write head. When either index reaches the end of the array it wraps back to zero, making the array appear circular. This gives O(1) enqueue and dequeue with no allocation and no data movement, at the cost of a fixed maximum size.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/cnot-gate-cudaq?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>CX gate (CUDA-Q)</title>
        <link>https://yanevskiv.com/cnot-gate-cudaq?rev=1781320400&amp;do=diff</link>
        <description>CX gate (CUDA-Q)

CX gate implementation using CUDA-Q. The example prepares the Bell state $\lvert\Phi^+\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle + \lvert 11\rangle)$.


// Compile: nvq++ main.cpp -o main
// Run:     ./main

#include &lt;cudaq.h&gt;

struct kernel {
    __qpu__ void operator()() {
        cudaq::qvector&lt;2&gt; q;
        h(q[0]);        // |00&gt; -&gt; |+0&gt;
        cx(q[0], q[1]); // CX -&gt; Bell state |Phi+&gt;
        mz(q);
    }
};

int main() {
    auto counts = cudaq::sample(kernel{});
  …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/cnot-gate-custatevec?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>CX gate (cuStateVec)</title>
        <link>https://yanevskiv.com/cnot-gate-custatevec?rev=1781320400&amp;do=diff</link>
        <description>CX gate (cuStateVec)

CX gate implementation using cuStateVec. The example prepares the Bell state $\lvert\Phi^+\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle + \lvert 11\rangle)$.


// Compile: nvcc main.cu -o main -lcustatevec
// Run:     ./main

#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;cuda_runtime.h&gt;
#include &lt;custatevec.h&gt;

int main() {
    const int nQubits = 2;
    const int dim = 1 &lt;&lt; nQubits;

    cuDoubleComplex h_sv[4] = {{1,0},{0,0},{0,0},{0,0}};  // |00&gt;
    cuDoubleComplex *d_…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/cnot-gate-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>CX gate (Qiskit)</title>
        <link>https://yanevskiv.com/cnot-gate-qiskit?rev=1781320400&amp;do=diff</link>
        <description>CX gate (Qiskit)

CX gate implementation using Qiskit. The example prepares the Bell state $\lvert\Phi^+\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle + \lvert 11\rangle)$.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(2)
qc.h(0)     # |00&gt; -&gt; |+0&gt;
qc.cx(0, 1) # CX: control=q0, target=q1 -&gt; Bell state
print(Statevector(qc))
# Statevector([0.70710678+0.j, 0.+0.j, 0.+0.j, 0.70710678+0.j], dims=(2, 2))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/collapse-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Collapse (OpenMP)</title>
        <link>https://yanevskiv.com/collapse-openmp?rev=1781320400&amp;do=diff</link>
        <description>Collapse (OpenMP)

Collapse is an OpenMP clause that merges multiple perfectly-nested loops into a single flat iteration space before distributing work across threads.

When a loop nest has too few outer iterations to keep all threads busy, distributing only the outer loop leaves most threads idle.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/collectives-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Collectives (MPI)</title>
        <link>https://yanevskiv.com/collectives-mpi?rev=1781320400&amp;do=diff</link>
        <description>Collectives (MPI)

Many parallel patterns require all processes to participate in a coordinated operation: distributing input, combining results, or synchronising before the next phase. These can always be assembled from point-to-point sends and receives, but writing them manually is verbose and misses optimisation opportunities. A broadcast, for instance, could be written as rank 0 sending the value to each other process in a loop:</description>
    </item>
    <item rdf:about="https://yanevskiv.com/communicator-duplication-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Communicator duplication (MPI)</title>
        <link>https://yanevskiv.com/communicator-duplication-mpi?rev=1781320400&amp;do=diff</link>
        <description>Communicator duplication (MPI)

When a C program calls a library, the library inherits all open file descriptors. If the library reads from stdin without knowing the application also reads from it, input gets silently consumed by the wrong side. The standard fix is to</description>
    </item>
    <item rdf:about="https://yanevskiv.com/communicators-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Communicators (MPI)</title>
        <link>https://yanevskiv.com/communicators-mpi?rev=1781320400&amp;do=diff</link>
        <description>Communicators (MPI)

When two unrelated programs both use TCP on the same machine, their traffic doesn&#039;t collide: each connection is scoped by port numbers that distinguish one stream from another. MPI uses a communicator for the same purpose. A communicator is a group of processes combined with a context that scopes all message traffic: a message sent on one communicator cannot be received on a different communicator, even between the same pair of ranks with the same tag.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/complex.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>complex.h</title>
        <link>https://yanevskiv.com/complex.h?rev=1781320400&amp;do=diff</link>
        <description>complex.h

complex.h is what you include when you need the maths to work directly with complex numbers, rather than manually tracking real and imaginary parts in separate double variables. Added in C99, it gives you _Complex types, the imaginary unit $e^{i\pi} \approx -1$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/coreutils?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of coreutils commands</title>
        <link>https://yanevskiv.com/coreutils?rev=1781320400&amp;do=diff</link>
        <description>List of coreutils commands

coreutils (or GNU core utilities) are a set of commands inherited from Unix and implemented by the GNU project.

These commands are pretty much available on all GNU/Linux systems, no matter the distro.

The following is a table of coreutil commands. You can use</description>
    </item>
    <item rdf:about="https://yanevskiv.com/cp-1?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\mathbb{CP}^1$</title>
        <link>https://yanevskiv.com/cp-1?rev=1781320400&amp;do=diff</link>
        <description>$\mathbb{CP}^1$

Complex projective line (or $\mathbb{CP}^1$) is the space in which pure qubit states live. It is defined as the quotient of $\mathbb{C}^2 \setminus \{0\}$ by $\mathbb{C}^\times$.

$$\mathbb{CP}^1 \stackrel{\text{def}}{=} (\mathbb{C}^2 \setminus\{0\})/\mathbb{C}^\times\qquad \mathbb{C}^\times\stackrel{\text{def}}{=}\mathbb{C} \setminus \{0\}$$

Motivation

To do quantum computing, we usually use the Hilbert space $\mathbb{C}^2$. That&#039;s the Hilbert space in which all qubit state v…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/critical-sections-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Critical sections (OpenMP)</title>
        <link>https://yanevskiv.com/critical-sections-openmp?rev=1781320400&amp;do=diff</link>
        <description>Critical sections (OpenMP)

In POSIX threads, mutual exclusion is explicit: you call pthread_mutex_lock before a shared update and pthread_mutex_unlock after.

Critical sections in OpenMP do the same thing with a pragma. The enclosed block is protected by an implicit mutex: only one thread at a time executes it, and threads that arrive while another is inside are blocked until it exits. Unlike</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ctype.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>ctype.h</title>
        <link>https://yanevskiv.com/ctype.h?rev=1781320400&amp;do=diff</link>
        <description>ctype.h

ctype.h gives you the character classification and conversion functions you reach for when parsing input character by character. If you have ever written if (c &gt;= &#039;a&#039; &amp;&amp; c &lt;= &#039;z&#039;) to check for a lowercase letter, these functions are the right way to do it — they handle the full range of</description>
    </item>
    <item rdf:about="https://yanevskiv.com/curses.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>curses.h</title>
        <link>https://yanevskiv.com/curses.h?rev=1781320400&amp;do=diff</link>
        <description>curses.h

Writing raw escape sequences to position the cursor and handle keyboard input is painful and terminal-specific. curses.h (typically ncurses) abstracts all of that away: you tell it to put text at row 5, column 10, and it figures out the right escape sequence for whatever terminal the user has. It also tracks what is on screen so it only sends the changes on each refresh, rather than redrawing everything.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/cx-gate?rev=1781863651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-19T10:07:31+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>CX gate (CNOT)</title>
        <link>https://yanevskiv.com/cx-gate?rev=1781863651&amp;do=diff</link>
        <description>CX gate (CNOT)

CX gate (controlled-X, also called CNOT or controlled-NOT) is a two-qubit gate that flips the target qubit if and only if the control qubit is $\lvert 1\rangle$, and does nothing otherwise. It is the standard entangling gate in quantum computing.

$$\text{CX} = \begin{pmatrix}1 &amp; 0 &amp; 0 &amp; 0\\ 0 &amp; 1 &amp; 0 &amp; 0\\ 0 &amp; 0 &amp; 0 &amp; 1\\ 0 &amp; 0 &amp; 1 &amp; 0\end{pmatrix}$$

The rows and columns are ordered $\lvert 00\rangle, \lvert 01\rangle, \lvert 10\rangle, \lvert 11\rangle$$$\text{CX}\lvert 00\ran…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/cy-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>CY gate</title>
        <link>https://yanevskiv.com/cy-gate?rev=1781320400&amp;do=diff</link>
        <description>CY gate

CY gate (controlled-Y) is a two-qubit gate that applies a Pauli Y to the target qubit if and only if the control qubit is $\lvert 1\rangle$, and does nothing otherwise.

$$\text{CY} = \begin{pmatrix}1 &amp; 0 &amp; 0 &amp; 0\\ 0 &amp; 1 &amp; 0 &amp; 0\\ 0 &amp; 0 &amp; 0 &amp; -i\\ 0 &amp; 0 &amp; i &amp; 0\end{pmatrix}$$

The rows and columns are ordered $\lvert 00\rangle, \lvert 01\rangle, \lvert 10\rangle, \lvert 11\rangle$, with the first qubit as control and the second as target:
$$\text{CY}\lvert 00\rangle = \lvert 00\rangle \…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/cz-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>CZ gate</title>
        <link>https://yanevskiv.com/cz-gate?rev=1781320400&amp;do=diff</link>
        <description>CZ gate

CZ gate (controlled-Z) is a two-qubit gate that applies a Pauli Z to the target qubit if and only if the control qubit is $\lvert 1\rangle$, and does nothing otherwise. Because Z only adds a phase of $-1$ to $\lvert 1\rangle$, the gate is symmetric: either qubit can be treated as the control.$$\text{CZ} = \begin{pmatrix}1 &amp; 0 &amp; 0 &amp; 0\\ 0 &amp; 1 &amp; 0 &amp; 0\\ 0 &amp; 0 &amp; 1 &amp; 0\\ 0 &amp; 0 &amp; 0 &amp; -1\end{pmatrix}$$$\lvert 00\rangle, \lvert 01\rangle, \lvert 10\rangle, \lvert 11\rangle$$\lvert 11\rangle$$$…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/data-sharing-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Data sharing (OpenMP)</title>
        <link>https://yanevskiv.com/data-sharing-openmp?rev=1781320400&amp;do=diff</link>
        <description>Data sharing (OpenMP)

A local variable in a C function lives on the stack and is private to that call. When multiple threads run the same code, each gets its own stack, so locals are naturally separate. Variables declared outside a parallel region are different: all threads share the same memory location.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/deadlock-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Deadlock (MPI)</title>
        <link>https://yanevskiv.com/deadlock-mpi?rev=1781320400&amp;do=diff</link>
        <description>Deadlock (MPI)

The classic multithreaded deadlock: thread A holds mutex 1 and waits for mutex 2, while thread B holds mutex 2 and waits for mutex 1. Neither can proceed because each is blocked on a resource the other holds. MPI deadlocks follow the same pattern with blocking sends taking the place of mutex acquires. If process 0 calls</description>
    </item>
    <item rdf:about="https://yanevskiv.com/density-matrix?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Density matrix</title>
        <link>https://yanevskiv.com/density-matrix?rev=1781320400&amp;do=diff</link>
        <description>Density matrix

Density matrix (written as $\rho$) is a matrix representation of a quantum state.

It&#039;s a more general way to represent a quantum state compared to the state vector $\lvert\psi\rangle$. While a state vector can only represent pure states, a density matrix can represent mixed states as well, making it the correct tool for open quantum systems, noisy circuits, and statistical ensembles of quantum states.$\lvert\psi\rangle$$$\rho = \lvert\psi\rangle\langle\psi\rvert$$$\lvert 0\rangl…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/derived-datatypes-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Derived datatypes (MPI)</title>
        <link>https://yanevskiv.com/derived-datatypes-mpi?rev=1781320400&amp;do=diff</link>
        <description>Derived datatypes (MPI)

MPI&#039;s built-in types (MPI_INT, MPI_DOUBLE, etc.) describe contiguous arrays of a single type. When the data you want to send is scattered in memory — a column of a row-major matrix, alternating elements, fields from a struct — you have two options. The first is to copy the elements manually into a flat temporary buffer:</description>
    </item>
    <item rdf:about="https://yanevskiv.com/deutsch-jozsa?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Deutsch-Jozsa algorithm</title>
        <link>https://yanevskiv.com/deutsch-jozsa?rev=1781320400&amp;do=diff</link>
        <description>Deutsch-Jozsa algorithm

Deutsch-Jozsa algorithm is a quantum algorithm that determines whether a function $f:\{0,1\}^n \to \{0,1\}$ is constant or balanced using exactly one quantum query. It was proposed by David Deutsch and Richard Jozsa in 1992 as a generalization of Deutsch&#039;s algorithm to $n$$f$$2^n$$2^{n-1} + 1$$n + 1$$n$$\lvert 0\rangle^{\otimes n}$$\lvert 1\rangle$$n+1$$n$$n$$$\lvert 0\rangle^{\otimes n}\lvert 1\rangle \xrightarrow{H^{\otimes n+1}} \frac{1}{\sqrt{2^n}}\sum_{x=0}^{2^n-1}\…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/deutsch?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Deutsch&#039;s algorithm</title>
        <link>https://yanevskiv.com/deutsch?rev=1781320400&amp;do=diff</link>
        <description>Deutsch&#039;s algorithm

Deutsch&#039;s algorithm is the simplest quantum algorithm that demonstrates a quantum speedup over any classical algorithm. It determines whether a binary function $f:\{0,1\} \to \{0,1\}$ is constant (same output for both inputs) or balanced (different outputs for the two inputs) using only a single quantum query, whereas any classical algorithm requires two.$f$$U_f$$\lvert x\rangle\lvert y\rangle \mapsto \lvert x\rangle\lvert y \oplus f(x)\rangle$$f$$f(0)$$f(1)$$U_f$$\lvert 0\r…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/devops?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>DevOps</title>
        <link>https://yanevskiv.com/devops?rev=1781320400&amp;do=diff</link>
        <description>DevOps

DevOps is a set of practices and a cultural philosophy that aims to shorten the feedback loop between writing code and running it in production by breaking down the traditional separation between development and operations teams. The name is a portmanteau of development and operations.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/dirac-notation?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Dirac notation</title>
        <link>https://yanevskiv.com/dirac-notation?rev=1781320400&amp;do=diff</link>
        <description>Dirac notation

Dirac notation (or bra-ket notation) is a convenient way to name vectors in a Hilbert space $\mathcal{H}$ (via “kets”) and its dual space $\mathcal{H}^*$ (via “bras”). Kets are written as $\lvert\text{ket}\rangle$ and bras are written as $\langle\text{bra}\rvert$. The text inside a bra or ket has no intrinsic meaning — it is simply a label, much like naming a variable in programming.$\lvert\psi\rangle$$\mathbb{C}^2$$a, b \in \mathbb{C}$$$\lvert\psi\rangle = \begin{pmatrix}a\\b\en…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/do-while-0?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>do { ... } while (0)</title>
        <link>https://yanevskiv.com/do-while-0?rev=1781320400&amp;do=diff</link>
        <description>do { ... } while (0)

In C programming language,do { ... } while (0) is a loop which does a single iteration. A compiler will optimize it away completely, so the syntax produces no actual machine code.

Most commonly, it&#039;s used to make function-macros.

Example:


/*
 * - clearing psr.i is implicitly serialized (visible by next insn)
 * - setting psr.i requires data serialization
 * - we need a stop-bit before reading PSR because we sometimes
 *   write a floating-point register right before rea…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/docker?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>docker</title>
        <link>https://yanevskiv.com/docker?rev=1781320400&amp;do=diff</link>
        <description>docker

What is docker?

Docker is a tool for managing containers. Containers are somewhat like virtual machine instances except a lot more lightweight.

Think of an application e.g. a web app. You want to run the application, but you don&#039;t want to pollute your host OS with all the baggage that comes with it (libraries, dependencies, config files, services,</description>
    </item>
    <item rdf:about="https://yanevskiv.com/dynamic-array?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Dynamic array</title>
        <link>https://yanevskiv.com/dynamic-array?rev=1781320400&amp;do=diff</link>
        <description>Dynamic array

A dynamic array is a resizable sequence backed by a heap-allocated Array. It provides O(1) indexed access like a fixed array, but grows automatically when capacity is exceeded. When the backing array is full and a new element is appended, the implementation allocates a larger array (typically 2×), copies all elements over, and frees the old allocation. The amortised cost of appending is O(1) because the copying work is spread across all the inserts that preceded the resize.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/eat-your-own-dog-food?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Eating your own dog food</title>
        <link>https://yanevskiv.com/eat-your-own-dog-food?rev=1781320400&amp;do=diff</link>
        <description>Eating your own dog food

Eating your own dog food (or dogfooding) is the practice of using the product you are developing internally, before or alongside releasing it to external users. The phrase comes from a 1988 Microsoft email where a manager challenged his team to use the company&#039;s own Lanman networking software internally.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/eigenstate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Eigenstate</title>
        <link>https://yanevskiv.com/eigenstate?rev=1781320400&amp;do=diff</link>
        <description>Eigenstate

Eigenstate is refers to a quantum state associated with a quantum gate that remains unchanged after applying the gate.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/embedded-engineering?rev=1781515121&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T09:18:41+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Embedded engineering</title>
        <link>https://yanevskiv.com/embedded-engineering?rev=1781515121&amp;do=diff</link>
        <description>Embedded engineering

Embedded engineering is the discipline of writing software for microcontrollers (MCUs) and other resource-constrained hardware that is dedicated to a single task or a fixed set of tasks. Unlike general-purpose computing, an embedded system usually has no operating system, no display, and no user interacting with it directly — it just runs, often for years without being rebooted, inside some larger device.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/embedded-glossary?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Embedded engineering glossary</title>
        <link>https://yanevskiv.com/embedded-glossary?rev=1781320400&amp;do=diff</link>
        <description>Embedded engineering glossary

	* QNX (Quantum Network eXecutive) - A proprietary real-time operating system (RTOS)
	* Lock-free queue - An efficient MT-safe queue implemented only using atomic instructions with no spinlocks, semaphores or mutexes.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/eof?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>EOF</title>
        <link>https://yanevskiv.com/eof?rev=1781320400&amp;do=diff</link>
        <description>EOF

EOF is an acronym that stands for “End of file”

Shell

In shell, EOF is commonly used as a terminator in what is called a heredoc (“here document”).
It&#039;s when you want to supply a multiline text to a command to its standard output, using &lt;&lt;.



 $ cat &gt; hello.txt &lt;&lt; EOF
Here, you can write anything you like.
It&#039;s not over until you actually type E-O-F.
You can cancel with Ctrl + C.
EOF</description>
    </item>
    <item rdf:about="https://yanevskiv.com/eqn-electromagnetism?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>(WIP) Equations of Electromagnetism</title>
        <link>https://yanevskiv.com/eqn-electromagnetism?rev=1781320400&amp;do=diff</link>
        <description>(WIP) Equations of Electromagnetism

Electrostatics

Coulomb&#039;s law

Attractive force $Q_2$ feels thanks to $Q_1$&#039;s electric field:
$$\mathbf F_ = \frac{1}{4\pi\varepsilon_0}\frac{Q_1Q_2}{r^2}\mathbf r_{012}$$

Electric field

Electric field created by a single point charge $Q$:
$$\mathbf E = \frac{1}{4\pi\varepsilon_0}\frac{Q}{r^2}\mathbf r_0$$

Electric field created by multiple point charges $Q_1, Q_2, ..., Q_N$:
$$\mathbf E = \frac{1}{4\pi\varepsilon_0}\sum_{i=1}^{N}\frac{Q_i}{r^2_i}\mathbf r…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/errno.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>errno.h</title>
        <link>https://yanevskiv.com/errno.h?rev=1781320400&amp;do=diff</link>
        <description>errno.h

When a standard library function or system call fails, it tells you two things: the return value (NULL, -1, or similar) tells you that it failed, and errno.h tells you why. Without errno, you would know something went wrong but not whether the file did not exist, you lacked permission, or the disk was full.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/exit-status?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Exit status</title>
        <link>https://yanevskiv.com/exit-status?rev=1781320400&amp;do=diff</link>
        <description>Exit status

Exit status lets the user of your program know if the program ended in success or failure.

Commonly, 0 is success, any other value is failure (most commonly, failure is 1 -- a bit counter intuitive at first!)

Your users can inspect it with</description>
    </item>
    <item rdf:about="https://yanevskiv.com/false-sharing-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>False sharing (OpenMP)</title>
        <link>https://yanevskiv.com/false-sharing-openmp?rev=1781320400&amp;do=diff</link>
        <description>False sharing (OpenMP)

False sharing is a performance problem that occurs when two threads write to different variables that happen to occupy the same cache line. Cache lines are typically 64 bytes wide. The hardware cache-coherence protocol must keep that line consistent across cores, so every write by one thread invalidates the cached copy in the other and forces a round-trip to main memory. The threads are accessing distinct variables and no actual race condition exists, but performance coll…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/fdsa?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title></title>
        <link>https://yanevskiv.com/fdsa?rev=1781320400&amp;do=diff</link>
        <description>fdsafdsafdsafdas  fdsafdsafds</description>
    </item>
    <item rdf:about="https://yanevskiv.com/feature-branch?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Feature branch</title>
        <link>https://yanevskiv.com/feature-branch?rev=1781320400&amp;do=diff</link>
        <description>Feature branch

A feature branch is a git branch created for the development of a single feature or change, kept separate from the main branch until the work is complete and reviewed. The developer works on the branch in isolation, then opens a pull request to merge it back.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/feature-flag?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Feature flag</title>
        <link>https://yanevskiv.com/feature-flag?rev=1781320400&amp;do=diff</link>
        <description>Feature flag

A feature flag (also called a feature toggle or feature switch) is a conditional in the code that enables or disables a feature at runtime without deploying new code. The feature is deployed but dark; it is activated by changing a configuration value, not by a release.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/fenv.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>fenv.h</title>
        <link>https://yanevskiv.com/fenv.h?rev=1781320400&amp;do=diff</link>
        <description>fenv.h

fenv.h gives you access to the floating-point environment: the status flags that record when something unusual happened during a computation (overflow, division by zero, invalid result like NaN), and the rounding mode that controls how inexact results are rounded. Before C99 formalised this header, there was no standard way to check whether a computation had silently produced a NaN or infinity.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/fft?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>FFT</title>
        <link>https://yanevskiv.com/fft?rev=1781320400&amp;do=diff</link>
        <description>FFT

FFT (or Fast Fourier Transform) is an algorithm that computes DFT (or “Discrete Fourier Transform”). There are several FFT algorithms but the most popular one is called Cooley–Tukey FFT.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/float.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>float.h</title>
        <link>https://yanevskiv.com/float.h?rev=1781320400&amp;do=diff</link>
        <description>float.h

float.h tells you the hard limits of floating-point arithmetic on the platform you are compiling for: how many decimal digits double can represent reliably, the largest and smallest values, and machine epsilon. You reach for it when writing numerical code that needs to be correct across platforms rather than just on your development machine.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/flush-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Flush (OpenMP)</title>
        <link>https://yanevskiv.com/flush-openmp?rev=1781320400&amp;do=diff</link>
        <description>Flush (OpenMP)

C&#039;s volatile keyword tells the compiler that a variable can change outside normal program flow and must not be cached in a register: every read goes to memory and every write is committed immediately. OpenMP threads face a similar problem at a larger scale: the compiler and CPU are free to keep shared variables in registers or store-buffers, so one thread&#039;s writes may not be visible to another without explicit synchronisation.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/forward-list?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Forward list</title>
        <link>https://yanevskiv.com/forward-list?rev=1781320400&amp;do=diff</link>
        <description>Forward list

A forward list is a singly linked list with a single pointer to the head and no tail pointer. Each node holds a value and a next pointer; there is no prev. Traversal is one-directional: from head toward NULL. It is the minimal linked sequence — less memory per node than a</description>
    </item>
    <item rdf:about="https://yanevskiv.com/function-macro?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Function macro</title>
        <link>https://yanevskiv.com/function-macro?rev=1781320400&amp;do=diff</link>
        <description>Function macro

Function macro is a C preprocessor macro that looks like a function call when you use it.

This is a basic example with a single expression. sqr(x) looks and feels like a function even though it&#039;s a macro. A good habit to get into is to always enclose arguments into parenthesis when you define function macros. For example,</description>
    </item>
    <item rdf:about="https://yanevskiv.com/general-writing-guide?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>General writing guide</title>
        <link>https://yanevskiv.com/general-writing-guide?rev=1781320400&amp;do=diff</link>
        <description>General writing guide

General writing guide (this article) is a guide to writing articles in this wiki.

Audience

The intended audience is someone technically inclined — comfortable reading code and following a logical argument, but not necessarily with a formal background in every subject the wiki covers. Two things to keep in mind while writing:$\alpha$$e^{i\theta}$$H^\dagger = H$$$X = \begin{pmatrix} 0 &amp; 1 \\ 1 &amp; 0 \end{pmatrix}$$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/getopt.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>getopt.h</title>
        <link>https://yanevskiv.com/getopt.h?rev=1781320400&amp;do=diff</link>
        <description>getopt.h

Parsing argv by hand gets old fast once you have more than two flags. getopt.h is a POSIX/GNU header that provides getopt for short options (-v, -o file) and getopt_long for long options (--verbose, --output=file). It handles the argument loop, the option string, and the</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ghz-state-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>GHZ state (Qiskit)</title>
        <link>https://yanevskiv.com/ghz-state-qiskit?rev=1781320400&amp;do=diff</link>
        <description>GHZ state (Qiskit)

GHZ state implementation using Qiskit. The three-qubit GHZ state $(\lvert 000\rangle + \lvert 111\rangle)/\sqrt{2}$ is prepared by applying a Hadamard gate to the first qubit and then chaining CX gates to spread the superposition to the remaining qubits.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(3)
qc.h(0)      # |000&gt; -&gt; (|000&gt; + |100&gt;) / sqrt(2)
qc.cx(0, 1)  # -&gt; (|000&gt; + |110&gt;) / sqrt(2)
qc.cx(0, 2)  # -&gt; (|000&gt; + …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/gist-docker?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Docker (Reference)</title>
        <link>https://yanevskiv.com/gist-docker?rev=1781320400&amp;do=diff</link>
        <description>Docker (Reference)

This page includes a myriad docker commands for reference.

Basic

Containers

Run ubuntu:latest image (will do docker pull automatically if you don&#039;t have it)



docker run -it --rm ubuntu:latest


Images

Pull ubuntu:latest image</description>
    </item>
    <item rdf:about="https://yanevskiv.com/gist-git?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Git (Examples)</title>
        <link>https://yanevskiv.com/gist-git?rev=1781320400&amp;do=diff</link>
        <description>Git (Examples)

Basics

Creating a repository with an initial commit:



git init


Adding a file to the staging area:



git add file.txt


Un-adding a file from the staging area:



git restore --staged file.txt


Showing what&#039;s in the staging area:</description>
    </item>
    <item rdf:about="https://yanevskiv.com/gist-semaphores?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>(WIP) Semaphores (Examples)</title>
        <link>https://yanevskiv.com/gist-semaphores?rev=1781320400&amp;do=diff</link>
        <description>(WIP) Semaphores (Examples)

This page includes some examples of semaphores in multi-threading environments. The syntax is borrowed from EasyMT.

Basic

Synchronization

Two threads a() and b() alternate their execution regardless of the scheduler.

Output: $B$$B$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/git?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>git</title>
        <link>https://yanevskiv.com/git?rev=1781320400&amp;do=diff</link>
        <description>git

Git is a tool for managing repositories. Repositories are like folders, except it&#039;s easier to track the changes that happen inside them.

Think of a project you&#039;ve been working on e.g. a game in written in C++.

You&#039;ve been working on your game for weeks and now you have quite a bit of code. You&#039;re starting to be a little afraid of making changes</description>
    </item>
    <item rdf:about="https://yanevskiv.com/gitignore?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>.gitignore</title>
        <link>https://yanevskiv.com/gitignore?rev=1781320400&amp;do=diff</link>
        <description>.gitignore

.gitignore is a file 

You can ignore everything in a given di

F.A.Q.

How do I ignore a directory without making a commit?

Just put * in .gitignore of the directory you want to ignore (e.g. ./local directory) 



# ./local/.gitignore
# Ignore everything in directory `./local`

*</description>
    </item>
    <item rdf:about="https://yanevskiv.com/global-phase?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Global phase</title>
        <link>https://yanevskiv.com/global-phase?rev=1781320400&amp;do=diff</link>
        <description>Global phase

Global phase is a property of a quantum state that emerges from the mathematical description but is physically completely unobservable. Multiplying an entire quantum state by a complex number of unit magnitude $e^{i\phi}$ produces a state that is physically identical to the original in every possible measurement.$a = Ae^{i\alpha}$$b = Be^{i\beta}$$A, B \in \mathbb{R}$$\alpha, \beta \in (-\pi, \pi]$$$\lvert\psi\rangle = Ae^{i\alpha}\lvert 0\rangle + Be^{i\beta}\lvert 1\rangle$$$\lve…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/gnu-linux?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>GNU/Linux</title>
        <link>https://yanevskiv.com/gnu-linux?rev=1781320400&amp;do=diff</link>
        <description>GNU/Linux

GNU/Linux is a free operating system that replaced the older operating system called Unix. It&#039;s ubiquitous on servers and supercomputers. It&#039;s an increasingly popular choice for desktops, but not yet common. It&#039;s also the operating system behind SteamOS.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/goodharts-law?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Goodhart&#039;s law</title>
        <link>https://yanevskiv.com/goodharts-law?rev=1781320400&amp;do=diff</link>
        <description>Goodhart&#039;s law

Goodhart&#039;s law states that when a measure becomes a target, it ceases to be a good measure. It was formulated by British economist Charles Goodhart in 1975 in the context of monetary policy, but it applies broadly to any system where behaviour is optimised toward a metric.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/graph?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Graph</title>
        <link>https://yanevskiv.com/graph?rev=1781320400&amp;do=diff</link>
        <description>Graph

A graph is a structure consisting of a set of vertices (nodes) and a set of edges that connect pairs of vertices. Edges can be directed (one-way, like a one-way street) or undirected (bidirectional). Edges can carry a weight representing cost, distance, or capacity. Graphs model any relationship between entities: road networks, dependency graphs, social networks, circuit netlists, and state machines.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/greenspuns-tenth-rule?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Greenspun&#039;s tenth rule</title>
        <link>https://yanevskiv.com/greenspuns-tenth-rule?rev=1781320400&amp;do=diff</link>
        <description>Greenspun&#039;s tenth rule

Greenspun&#039;s tenth rule (despite there being no rules one through nine) is an aphorism by Philip Greenspun: “Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/grover?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Grover&#039;s algorithm</title>
        <link>https://yanevskiv.com/grover?rev=1781320400&amp;do=diff</link>
        <description>Grover&#039;s algorithm

Grover&#039;s algorithm is a quantum search algorithm that finds a marked element in an unstructured database of $N$ items in $O(\sqrt{N})$ queries. It was invented by Lov Grover in 1996 and provides a quadratic speedup over classical brute-force search, which requires $O(N)$$U_f$$\lvert x^*\rangle$$U_f\lvert x\rangle = -\lvert x\rangle$$x = x^*$$U_f\lvert x\rangle = \lvert x\rangle$$\lvert s\rangle = H^{\otimes n}\lvert 0\rangle^{\otimes n}$$\lvert x^*\rangle$$G$$U_f$$D = 2\lvert…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/gustafsons-law?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Gustafson&#039;s law</title>
        <link>https://yanevskiv.com/gustafsons-law?rev=1781320400&amp;do=diff</link>
        <description>Gustafson&#039;s law

Gustafson&#039;s law is a formula that predicts the speedup of a parallel program when the problem size is allowed to grow with the number of processors. It was proposed by John Gustafson in 1988 as a rebuttal to the pessimism of Amdahl&#039;s law. The key shift is moving from $T$$n$$\alpha$$1 - \alpha$$n$$n$$(1-\alpha)T$$n(1-\alpha)T$$\alpha T$$$T_1 = \alpha T + n(1 - \alpha)T = T\bigl(\alpha + n(1 - \alpha)\bigr)$$$$S(n) = \frac{T_1}{T} = \alpha + n(1 - \alpha) = n - \alpha(n - 1)$$$\fr…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/h-gate-cudaq?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hadamard gate (CUDA-Q)</title>
        <link>https://yanevskiv.com/h-gate-cudaq?rev=1781320400&amp;do=diff</link>
        <description>Hadamard gate (CUDA-Q)

Hadamard gate implementation using CUDA-Q.


// Compile: nvq++ main.cpp -o main
// Run:     ./main

#include &lt;cudaq.h&gt;

struct kernel {
    __qpu__ void operator()() {
        cudaq::qubit q;
        h(q);  // |0&gt; -&gt; |+&gt;
        mz(q);
    }
};

int main() {
    auto counts = cudaq::sample(kernel{});
    counts.dump();  // ~50% |0&gt;, ~50% |1&gt;
}</description>
    </item>
    <item rdf:about="https://yanevskiv.com/h-gate-custatevec?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hadamard gate (cuStateVec)</title>
        <link>https://yanevskiv.com/h-gate-custatevec?rev=1781320400&amp;do=diff</link>
        <description>Hadamard gate (cuStateVec)

Hadamard gate implementation using cuStateVec.


// Compile: nvcc main.cu -o main -lcustatevec
// Run:     ./main

#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;cuda_runtime.h&gt;
#include &lt;custatevec.h&gt;

int main() {
    const int nQubits = 1;
    const int dim = 1 &lt;&lt; nQubits;

    cuDoubleComplex h_sv[2] = {{1,0},{0,0}};  // |0&gt;
    cuDoubleComplex *d_sv;
    cudaMalloc(&amp;d_sv, dim * sizeof(cuDoubleComplex));
    cudaMemcpy(d_sv, h_sv, dim * sizeof(cuDoubleComplex), cu…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/h-gate-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hadamard gate (Qiskit)</title>
        <link>https://yanevskiv.com/h-gate-qiskit?rev=1781320400&amp;do=diff</link>
        <description>Hadamard gate (Qiskit)

Hadamard gate implementation using Qiskit.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(1)
qc.h(0)  # |0&gt; -&gt; |+&gt; = (|0&gt; + |1&gt;) / sqrt(2)
print(Statevector(qc))
# Statevector([0.70710678+0.j, 0.70710678+0.j], dims=(2,))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/h-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hadamard gate</title>
        <link>https://yanevskiv.com/h-gate?rev=1781320400&amp;do=diff</link>
        <description>Hadamard gate

Hadamard gate (or H gate) is a single-qubit gate that maps the computational basis states $\lvert 0\rangle$ and $\lvert 1\rangle$ to equal superpositions. It is the most commonly used gate for creating superposition and appears at the start of most quantum algorithms.
$$H = \frac{1}{\sqrt{2}}\begin{pmatrix}1 &amp; 1\\ 1 &amp; -1\end{pmatrix}$$$$H\lvert 0\rangle = \frac{\lvert 0\rangle + \lvert 1\rangle}{\sqrt{2}} = \lvert +\rangle \qquad H\lvert 1\rangle = \frac{\lvert 0\rangle - \lvert 1…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/harvard-architecture?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Harvard architecture</title>
        <link>https://yanevskiv.com/harvard-architecture?rev=1781320400&amp;do=diff</link>
        <description>Harvard architecture

Harvard archictecture is a type of computer archictecture. It&#039;s a type of architecture where code and data are kept in separate memories.

The Harvard architecture can be contrasted against von-Neumann archictecture. In the latter, code and data are both stored in the same working memory (RAM). The CPU has to fetch both the instructions and data by accessing the same memory bus, leading to what is known as von-Neumann bottleneck. This doesn&#039;t really matter, of course</description>
    </item>
    <item rdf:about="https://yanevskiv.com/hash-map?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hash map</title>
        <link>https://yanevskiv.com/hash-map?rev=1781320400&amp;do=diff</link>
        <description>Hash map

A hash map (also called a hash table) is a data structure that maps arbitrary keys to values in O(1) average time.

A hash function converts a key to an integer index into a backing Array of buckets. The ideal hash function distributes keys uniformly so that each bucket holds roughly one entry; when two keys hash to the same bucket, that is a</description>
    </item>
    <item rdf:about="https://yanevskiv.com/header-guard?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Header guard</title>
        <link>https://yanevskiv.com/header-guard?rev=1781320400&amp;do=diff</link>
        <description>Header guard

Header guards are a pattern used in C and C++ programming languages when writing header files. Header files (.h files) are files that are included in source files (.c and .cpp files) near the top (hence the name) using the #include &lt;...&gt;_</description>
    </item>
    <item rdf:about="https://yanevskiv.com/heap?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Heap</title>
        <link>https://yanevskiv.com/heap?rev=1781320400&amp;do=diff</link>
        <description>Heap

A heap is a Binary tree stored in an Array that maintains the heap property: in a max-heap, every parent is greater than or equal to its children, so the maximum element is always at the root. In a min-heap the relationship is reversed and the minimum is at the root. The tree is</description>
    </item>
    <item rdf:about="https://yanevskiv.com/hhl?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>HHL algorithm</title>
        <link>https://yanevskiv.com/hhl?rev=1781320400&amp;do=diff</link>
        <description>HHL algorithm

HHL algorithm (Harrow-Hassidim-Lloyd algorithm) is a quantum algorithm for solving systems of linear equations $Ax = b$ where $A$ is an $N\times N$ sparse Hermitian matrix. Proposed in 2009, it achieves an exponential speedup over classical linear solvers under certain conditions.$O(Ns\kappa\log(1/\varepsilon))$$s$$\kappa$$\varepsilon$$O(\log(N)s^2\kappa^2/\varepsilon)$$N$$\lvert b\rangle$$A$$\lambda_j$$A$$\lvert\lambda_j\rangle \mapsto (C/\lambda_j)\lvert\lambda_j\rangle$$A^{-1}$…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/hilbert-space?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hilbert space</title>
        <link>https://yanevskiv.com/hilbert-space?rev=1781320400&amp;do=diff</link>
        <description>Hilbert space

Hilbert space is a complete inner product space. It is vector space that is equipped with an inner product such that the metric induced by the inner product is complete within the space. Completeness means that all Cauchy sequences converge within the same space. Hilbert space is a special case of the more general Banach space, both of which are concepts from functional analysis.$\mathbb{R}$$\mathbb{C}$$\lvert\psi\rangle$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/home?rev=1781515400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T09:23:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Home</title>
        <link>https://yanevskiv.com/home?rev=1781515400&amp;do=diff</link>
        <description>Home

Hi, I&#039;m Ivan! This website is my encyclopedia about various technical topics. The topics I cover on this wiki are mostly related to technology, but sometimes I also write about mathematics and physics. Three major topics on this website are: 1.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/hopf-fibration?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hopf fibration</title>
        <link>https://yanevskiv.com/hopf-fibration?rev=1781320400&amp;do=diff</link>
        <description>Hopf fibration

Hopf fibration is a map connecting the state vector representation of a qubit $\lvert\psi\rangle \in \mathbb{C}^2$ to a point on the Bloch sphere $(x, y, z) \in \mathbb{R}^3$. It explains why a qubit — an object living in the complex space $\mathbb{C}^2$ — can be visualized as a point on a real three-dimensional sphere.$a, b \in \mathbb{C}$$|a|^2 + |b|^2 = 1$$\mathbb{C}^2$$S^3$$S^3/U(1) \cong S^2$$\pi: S^3 \to S^2$$S^2$$S^3$$U(1)$$\pi$$\sigma_x, \sigma_y, \sigma_z$$$\pi:\mathbb{C…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/hotfix?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hotfix</title>
        <link>https://yanevskiv.com/hotfix?rev=1781320400&amp;do=diff</link>
        <description>Hotfix

A hotfix is an urgent patch applied directly to a production release to fix a critical bug, without going through the normal development cycle. The name reflects the intent: it is applied while the system is “hot” (running in production) and cannot wait for the next scheduled release.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/hsp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hidden subgroup problem</title>
        <link>https://yanevskiv.com/hsp?rev=1781320400&amp;do=diff</link>
        <description>Hidden subgroup problem

Hidden subgroup problem (HSP) is a class of problems that provides a unified framework for many quantum algorithms. The problem is: given a group $G$, a set $X$, and a function $f: G \to X$ that is constant on cosets of some subgroup $H \leq G$ and takes distinct values on different cosets, find the hidden subgroup $H$$\mathbb{Z}_2$$\mathbb{Z}_2^n$$\mathbb{Z}$$\mathbb{Z}_N$$G$$G$$\frac{1}{\sqrt{|H|}}\sum_{h\in H}\lvert x_0 h\rangle$$x_0$$G$$G$$H$$O(\log|G|)$$H$$G$$S_n$$D…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/hybrid-openmp-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hybrid MPI+OpenMP (MPI)</title>
        <link>https://yanevskiv.com/hybrid-openmp-mpi?rev=1781320400&amp;do=diff</link>
        <description>Hybrid MPI+OpenMP (MPI)

A naive parallel program launches one MPI rank per core. That works, but it means every rank keeps its own copy of the data (there is no shared address space between MPI processes), and the number of messages scales with total core count. A better model on a multi-core node is one MPI rank per node (or per socket), with OpenMP threads filling the cores within it. Inter-node communication goes through MPI; intra-node parallelism uses shared memory through OpenMP.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/i-gate-cudaq?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>I gate (CUDA-Q)</title>
        <link>https://yanevskiv.com/i-gate-cudaq?rev=1781320400&amp;do=diff</link>
        <description>I gate (CUDA-Q)

I gate implementation using CUDA-Q.


// Compile: nvq++ main.cpp -o main
// Run:     ./main

#include &lt;cudaq.h&gt;

struct kernel {
    __qpu__ void operator()() {
        cudaq::qubit q;
        h(q);   // prepare |+&gt;
        // identity is a no-op; the state is unchanged
        mz(q);
    }
};

int main() {
    auto counts = cudaq::sample(kernel{});
    counts.dump();  // ~50% |0&gt;, ~50% |1&gt;
}</description>
    </item>
    <item rdf:about="https://yanevskiv.com/i-gate-custatevec?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>I gate (cuStateVec)</title>
        <link>https://yanevskiv.com/i-gate-custatevec?rev=1781320400&amp;do=diff</link>
        <description>I gate (cuStateVec)

I gate implementation using cuStateVec.


// Compile: nvcc main.cu -o main -lcustatevec
// Run:     ./main

#include &lt;stdio.h&gt;
#include &lt;cuda_runtime.h&gt;
#include &lt;custatevec.h&gt;

int main() {
    const int nQubits = 1;
    const int dim = 1 &lt;&lt; nQubits;

    cuDoubleComplex h_sv[2] = {{1,0},{0,0}};  // |0&gt;
    cuDoubleComplex *d_sv;
    cudaMalloc(&amp;d_sv, dim * sizeof(cuDoubleComplex));
    cudaMemcpy(d_sv, h_sv, dim * sizeof(cuDoubleComplex), cudaMemcpyHostToDevice);

    cust…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/i-gate-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>I gate (Qiskit)</title>
        <link>https://yanevskiv.com/i-gate-qiskit?rev=1781320400&amp;do=diff</link>
        <description>I gate (Qiskit)

I gate implementation using Qiskit.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(1)
qc.h(0)   # prepare |+&gt;
qc.id(0)  # identity — state unchanged
print(Statevector(qc))
# Statevector([0.70710678+0.j, 0.70710678+0.j], dims=(2,))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/i-gate?rev=1781536969&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T15:22:49+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$I$ gate (Identity gate)</title>
        <link>https://yanevskiv.com/i-gate?rev=1781536969&amp;do=diff</link>
        <description>$I$ gate (Identity gate)

I gate (or identity gate) is a single-qubit quantum gate that leaves the state of a qubit unchanged. It is represented by the $2 \times 2$ identity matrix and drawn as a plain wire in quantum circuit diagrams.

$$I = \begin{pmatrix}1 &amp; 0\\ 0 &amp; 1\end{pmatrix}$$

The identity gate is trivial on its own but appears in multi-qubit notation to indicate that a qubit is carried through a time step without any operation being applied. For example, applying $H$$H \otimes I$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/i-state-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert i\rangle$ (Qiskit)</title>
        <link>https://yanevskiv.com/i-state-qiskit?rev=1781320400&amp;do=diff</link>
        <description>$\lvert i\rangle$ (Qiskit)

Plus-i state $\lvert i\rangle$ implementation using Qiskit. The $\lvert i\rangle$ state is prepared by applying a Hadamard gate followed by an S gate to $\lvert 0\rangle$.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(1)
qc.h(0)  # |0&gt; -&gt; |+&gt;
qc.s(0)  # |+&gt; -&gt; |i&gt; = (|0&gt; + i|1&gt;) / sqrt(2)
print(Statevector(qc))
# Statevector([0.70710678+0.j, 0.+0.70710678j], dims=(2,))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ifupdown?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>ifupdown</title>
        <link>https://yanevskiv.com/ifupdown?rev=1781320400&amp;do=diff</link>
        <description>ifupdown

ifupdown is the traditional network manager on GNU/Linux systems. It has since been replaced by systemd-networkd. 

It was especially commmon in Debian systems before Debian 12 (Bookworm).

The “if” part is short for “interface”. “up” and “down” refer to</description>
    </item>
    <item rdf:about="https://yanevskiv.com/incremental-build-model?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Incremental build model</title>
        <link>https://yanevskiv.com/incremental-build-model?rev=1781320400&amp;do=diff</link>
        <description>Incremental build model

The incremental build model is a software development lifecycle model in which the system is built and delivered in a series of increments, each adding functional capability to the previous one. The first increment delivers a working core; subsequent increments add features until the full system is complete.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/intro?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Intro</title>
        <link>https://yanevskiv.com/intro?rev=1781320400&amp;do=diff</link>
        <description>Intro

Hi, I&#039;m Ivan! This website is my encyclopedia about various technical topics. The topics I cover are mostly related to technology, but sometimes I also write about mathematics and physics.

I&#039;m an embedded software engineer, currently pivoting to high-performance engineering (HPC). I like working directly with hardware or low-level software.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/introduction-to-quantum-computing?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Introduction to quantum computing</title>
        <link>https://yanevskiv.com/introduction-to-quantum-computing?rev=1781320400&amp;do=diff</link>
        <description>Introduction to quantum computing

Quantum computing is a theory of programming a quantum computer.

If you&#039;re reading this article, you&#039;re likely curious about quantum computing and would like to learn more. How does a quantum computer work? What makes it different from a classical computer? How exactly do you program it? If you don&#039;t have a background in physics quantum computing may initially seem math-heavy and rather difficult to understand. An assumption I&#039;m going to make is that the reade…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/inttypes.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>inttypes.h</title>
        <link>https://yanevskiv.com/inttypes.h?rev=1781320400&amp;do=diff</link>
        <description>inttypes.h

inttypes.h solves a portability trap that bites you the first time you try to printf a uint64_t. On one platform uint64_t is unsigned long, so %lu works. On another it is unsigned long long, so you need %llu. Get it wrong and you get a compiler warning on one platform and silently wrong output on another. The format macros in this header expand to whichever specifier is correct for the current platform.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/iso646.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>iso646.h</title>
        <link>https://yanevskiv.com/iso646.h?rev=1781320400&amp;do=diff</link>
        <description>iso646.h

iso646.h defines macros that let you spell out operators in plain English: and for &amp;&amp;, or for ||, not for !, and so on. It exists because some older national character sets used the code points for &amp;, |, ~, and ! for other symbols, so alternative spellings were standardised in C95.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/iswap-gate-cudaq?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>iSWAP gate (CUDA-Q)</title>
        <link>https://yanevskiv.com/iswap-gate-cudaq?rev=1781320400&amp;do=diff</link>
        <description>iSWAP gate (CUDA-Q)

iSWAP gate implementation using CUDA-Q. The example prepares $\lvert 10\rangle$ and applies iSWAP to produce $i\lvert 01\rangle$.


// Compile: nvq++ main.cpp -o main
// Run:     ./main

#include &lt;cudaq.h&gt;

struct kernel {
    __qpu__ void operator()() {
        cudaq::qvector&lt;2&gt; q;
        x(q[0]);           // q[0]=|1&gt;, q[1]=|0&gt; =&gt; |10&gt;
        iswap(q[0], q[1]); // |10&gt; -&gt; i|01&gt;
        mz(q);
    }
};

int main() {
    auto counts = cudaq::sample(kernel{});
    counts.du…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/iswap-gate-custatevec?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>iSWAP gate (cuStateVec)</title>
        <link>https://yanevskiv.com/iswap-gate-custatevec?rev=1781320400&amp;do=diff</link>
        <description>iSWAP gate (cuStateVec)

iSWAP gate implementation using cuStateVec. The example prepares $\lvert 10\rangle$ and applies iSWAP to produce $i\lvert 01\rangle$.


// Compile: nvcc main.cu -o main -lcustatevec
// Run:     ./main

#include &lt;stdio.h&gt;
#include &lt;cuda_runtime.h&gt;
#include &lt;custatevec.h&gt;

int main() {
    const int nQubits = 2;
    const int dim = 1 &lt;&lt; nQubits;

    // Prepare |10&gt;: q0=1, q1=0 -&gt; index 2 (binary 10)
    cuDoubleComplex h_sv[4] = {0};
    h_sv[2] = make_cuDoubleComplex(1.0…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/iswap-gate-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>iSWAP gate (Qiskit)</title>
        <link>https://yanevskiv.com/iswap-gate-qiskit?rev=1781320400&amp;do=diff</link>
        <description>iSWAP gate (Qiskit)

iSWAP gate implementation using Qiskit. The example prepares $\lvert 10\rangle$ and applies iSWAP to produce $i\lvert 01\rangle$.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(2)
qc.x(1)        # q0=|0&gt;, q1=|1&gt; =&gt; |10&gt; in math ordering
qc.iswap(0, 1) # |10&gt; -&gt; i|01&gt;
print(Statevector(qc))
# Statevector([0.+0.j, 0.+1.j, 0.+0.j, 0.+0.j], dims=(2, 2))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/iswap-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>iSWAP gate</title>
        <link>https://yanevskiv.com/iswap-gate?rev=1781320400&amp;do=diff</link>
        <description>iSWAP gate

iSWAP gate is a two-qubit gate that swaps the $\lvert 01\rangle$ and $\lvert 10\rangle$ amplitudes while multiplying each by $i$, and leaves $\lvert 00\rangle$ and $\lvert 11\rangle$ unchanged.

$$\text{iSWAP} = \begin{pmatrix}1&amp;0&amp;0&amp;0\\ 0&amp;0&amp;i&amp;0\\ 0&amp;i&amp;0&amp;0\\ 0&amp;0&amp;0&amp;1\end{pmatrix}$$

$$\text{iSWAP}\lvert 01\rangle = i\lvert 10\rangle \qquad \text{iSWAP}\lvert 10\rangle = i\lvert 01\rangle$$

The factor of $i$ distinguishes iSWAP from the plain SWAP gate. SWAP permutes amplitudes without …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kanban?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Kanban</title>
        <link>https://yanevskiv.com/kanban?rev=1781320400&amp;do=diff</link>
        <description>Kanban

Kanban is a workflow management method that visualises work in progress and limits the amount of work allowed at each stage. The name comes from the Japanese word for “signboard”; the method originated in Toyota&#039;s manufacturing system in the 1940s and was adapted for software by David Anderson around 2007.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kdp20260110-1?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>KDP Midterm (2026-01-10) Question 1</title>
        <link>https://yanevskiv.com/kdp20260110-1?rev=1781320400&amp;do=diff</link>
        <description>KDP Midterm (2026-01-10) Question 1

Write and explain the Fine grain ticket algorithm implemented with $\text{FA}$ opeartion. If we replaced $\text{FA}$ with $\text{TS}$ (test-and-set) operation implemented in the following way, would it be possible to implement a fine-grained solution? If yes, implement it. Is the critical section entry fair? Why / why not?$\text{FA}$$\text{TS}$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kdp20260110-2?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>KDP Midterm (2026-01-10) Question 2</title>
        <link>https://yanevskiv.com/kdp20260110-2?rev=1781320400&amp;do=diff</link>
        <description>KDP Midterm (2026-01-10) Question 2

Consider a dining table that can seat at most $N$ people ($N &gt; 2$). A person may take some food, sit at the table (sitAtTable()), eat, leave the table (leaveTable()) and walk away. No person should eat alone i.e. sit at the table alone. Also, every person that takes food must necessarily sit down in order to eat. Create a solution for this probalom using a</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kdp20260218-1?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>KDP Exam (2026-02-18) Question 1</title>
        <link>https://yanevskiv.com/kdp20260218-1?rev=1781320400&amp;do=diff</link>
        <description>KDP Exam (2026-02-18) Question 1

Solve the dining philsophers problem by using signal and continue monitor discipline and by using covering condition technique. Ensure philosphers start eating in the order of their arrival.

Solution


#define N 5 /* number of philosophers */

monitor DiningPhilosophers {
    enum { THINKING, HUNGRY, EATING };
    int phil[N];
    cond delay[N];
    queue&lt;int&gt; q; 
    
    bool canEat(int id) {
        return (phil[(id - 1 + N) % N] != EATING) &amp;&amp; (phil[(id + 1)…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kdp20260218-2?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>KDP Exam (2026-02-18) Question 2</title>
        <link>https://yanevskiv.com/kdp20260218-2?rev=1781320400&amp;do=diff</link>
        <description>KDP Exam (2026-02-18) Question 2

The Roller Coaster Problem. Assume there are $N$ passengers and $M$ cars in one roller coaster. Passengers alternate between walking around the amusement park and riding the roller coaster. One car can take at most $K$ passengers where $K &lt; N$$K$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kdp20260218-3?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>(WIP) KDP Exam (2026-02-18) Question 3</title>
        <link>https://yanevskiv.com/kdp20260218-3?rev=1781320400&amp;do=diff</link>
        <description>(WIP) KDP Exam (2026-02-18) Question 3

Using synchronous message passing (synch_send, receive) write a distributed solution for The Dining Philosophers problem. In the distributed solution philosopher processes may only communicate with corresponding fork processes and fork processes may only communicate with corresponding philosopher processes.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-0?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert 0 \rangle$ (Zero state)</title>
        <link>https://yanevskiv.com/ket-0?rev=1781320400&amp;do=diff</link>
        <description>$\lvert 0 \rangle$ (Zero state)

The zero state $\lvert 0\rangle$ is one of the two computational basis states of a qubit. It is the quantum analogue of a classical 0 bit, and it is the standard initial state used in most quantum circuits. The other computational basis state is $$\lvert 0\rangle = \begin{pmatrix}1\\0\end{pmatrix}$$$\lvert 0\rangle$$(0, 0, 1)$$+1$$Z\lvert 0\rangle = \lvert 0\rangle$$\lvert 0\rangle$$\lvert +\rangle = (\lvert 0\rangle + \lvert 1\rangle)/\sqrt{2}$$I\lvert 0\rangle …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-00?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert 00\rangle$</title>
        <link>https://yanevskiv.com/ket-00?rev=1781320400&amp;do=diff</link>
        <description>$\lvert 00\rangle$

The  state is the two-qubit computational basis state where both qubits are $\lvert 0\rangle$. It is the tensor product $\lvert 0\rangle\otimes\lvert 0\rangle$ — a product state with no entanglement between the qubits. It is the default initial state of every qubit register in a quantum circuit.$$\lvert 00\rangle = \lvert 0\rangle\otimes\lvert 0\rangle = \begin{pmatrix}1\\0\\0\\0\end{pmatrix}$$$\lvert 00\rangle$$0$$H\otimes I$$\lvert 00\rangle$$\lvert 00\rangle$$I_0\lvert 00\…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-01?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert 01\rangle$</title>
        <link>https://yanevskiv.com/ket-01?rev=1781320400&amp;do=diff</link>
        <description>$\lvert 01\rangle$

The  state is a two-qubit computational basis state with qubit 0 in $\lvert 0\rangle$ and qubit 1 in $\lvert 1\rangle$. It is the tensor product $\lvert 0\rangle\otimes\lvert 1\rangle$ — an unentangled product state. It is reached from $\lvert 00\rangle$ by a single $X$ gate on qubit 1.

$$\lvert 01\rangle = \lvert 0\rangle\otimes\lvert 1\rangle = \begin{pmatrix}0\\1\\0\\0\end{pmatrix}$$

Measuring qubit 0 yields $0$ with certainty; measuring qubit 1 yields $1$$H\otimes I$$\l…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-1?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert 1\rangle$ (One state)</title>
        <link>https://yanevskiv.com/ket-1?rev=1781320400&amp;do=diff</link>
        <description>$\lvert 1\rangle$ (One state)

The one state $\lvert 1\rangle$ is one of the two computational basis states of a qubit. It is the quantum analogue of a classical 1 bit. The other computational basis state is $\lvert 0\rangle$.

$$\lvert 1\rangle = \begin{pmatrix}0\\1\end{pmatrix}$$

On the Bloch sphere, $\lvert 1\rangle$ corresponds to the south pole at coordinates $(0, 0, -1)$$-1$$Z\lvert 1\rangle = -\lvert 1\rangle$$\lvert 1\rangle$$\lvert -\rangle = (\lvert 0\rangle - \lvert 1\rangle)/\sqrt{2…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-10?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert 10\rangle$</title>
        <link>https://yanevskiv.com/ket-10?rev=1781320400&amp;do=diff</link>
        <description>$\lvert 10\rangle$

The  state is a two-qubit computational basis state with qubit 0 in $\lvert 1\rangle$ and qubit 1 in $\lvert 0\rangle$. It is the tensor product $\lvert 1\rangle\otimes\lvert 0\rangle$ — an unentangled product state. It is the SWAP of $\lvert 01\rangle$, reached from $\lvert 00\rangle$ by a single $X$ gate on qubit 0.

$$\lvert 10\rangle = \lvert 1\rangle\otimes\lvert 0\rangle = \begin{pmatrix}0\\0\\1\\0\end{pmatrix}$$

Measuring qubit 0 yields $1$$0$$H\otimes I$$\lvert 10\ra…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-11?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert 11\rangle$</title>
        <link>https://yanevskiv.com/ket-11?rev=1781320400&amp;do=diff</link>
        <description>$\lvert 11\rangle$

The  state is the two-qubit computational basis state where both qubits are in $\lvert 1\rangle$. It is the tensor product $\lvert 1\rangle\otimes\lvert 1\rangle$ — an unentangled product state. It is reached from $\lvert 00\rangle$ by $X$ on both qubits, and from $\lvert 10\rangle$ or $\lvert 01\rangle$ by $X$ on the remaining qubit.

$$\lvert 11\rangle = \lvert 1\rangle\otimes\lvert 1\rangle = \begin{pmatrix}0\\0\\0\\1\end{pmatrix}$$

Measuring either qubit yields $1$$H\oti…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-ghz?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>GHZ state</title>
        <link>https://yanevskiv.com/ket-ghz?rev=1781320400&amp;do=diff</link>
        <description>GHZ state

GHZ state (Greenberger-Horne-Zeilinger state) is a maximally entangled quantum state of three or more qubits. The three-qubit GHZ state is an equal superposition of all-zeros and all-ones.

$$\lvert\text{GHZ}\rangle = \frac{1}{\sqrt{2}}(\lvert 000\rangle + \lvert 111\rangle)$$

The GHZ state is named after Daniel Greenberger, Michael Horne, and Anton Zeilinger, who introduced it in 1989. It is a natural generalization of the two-qubit Bell state $\lvert\Phi^+\rangle$$0$$1$$n$$n \geq 2…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-minus-i?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert -i\rangle$ (Minus-i state)</title>
        <link>https://yanevskiv.com/ket-minus-i?rev=1781320400&amp;do=diff</link>
        <description>$\lvert -i\rangle$ (Minus-i state)

The minus-i state $\lvert -i\rangle$ (also written $\lvert -y\rangle$) is an equal superposition of $\lvert 0\rangle$ and $\lvert 1\rangle$ with a relative phase of $-i$. It is one of the six cardinal states on the Bloch sphere, sitting at the negative $y$-axis at coordinates $(0, -1, 0)$.

$$\lvert -i\rangle = \frac{1}{\sqrt{2}}(\lvert 0\rangle - i\lvert 1\rangle) = \frac{1}{\sqrt{2}}\begin{pmatrix}1\\-i\end{pmatrix}$$

On the Bloch sphere, $\lvert -i\rangle$…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-minus?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert -\rangle$ (Minus state)</title>
        <link>https://yanevskiv.com/ket-minus?rev=1781320400&amp;do=diff</link>
        <description>$\lvert -\rangle$ (Minus state)

The minus state $\lvert -\rangle$ is an equal superposition of $\lvert 0\rangle$ and $\lvert 1\rangle$ with a relative minus sign. It is one of the six cardinal states on the Bloch sphere, sitting at the negative $x$-axis at coordinates $(-1, 0, 0)$.

$$\lvert -\rangle = \frac{1}{\sqrt{2}}(\lvert 0\rangle - \lvert 1\rangle) = \frac{1}{\sqrt{2}}\begin{pmatrix}1\\-1\end{pmatrix}$$

On the Bloch sphere, $\lvert -\rangle$ is an eigenstate of the Pauli-X gate with eig…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-phi-minus?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert\Phi^-\rangle$ (Phi-minus state)</title>
        <link>https://yanevskiv.com/ket-phi-minus?rev=1781320400&amp;do=diff</link>
        <description>$\lvert\Phi^-\rangle$ (Phi-minus state)

The phi-minus state $\lvert\Phi^-\rangle$ is one of the four Bell states — the maximally entangled two-qubit states. It is an equal superposition of $\lvert 00\rangle$ and $\lvert 11\rangle$ with a relative minus sign. Like $\lvert\Phi^+\rangle$, both qubits always give the same outcome in the computational basis; the minus sign is only visible in phase-sensitive measurements.$$\lvert\Phi^-\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle - \lvert 11\rangle) …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-phi-plus?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert\Phi^+\rangle$ (Phi-plus state)</title>
        <link>https://yanevskiv.com/ket-phi-plus?rev=1781320400&amp;do=diff</link>
        <description>$\lvert\Phi^+\rangle$ (Phi-plus state)

The phi-plus state $\lvert\Phi^+\rangle$ is one of the four Bell states — the maximally entangled two-qubit states. It is an equal superposition of $\lvert 00\rangle$ and $\lvert 11\rangle$ with the same sign, meaning both qubits are always found in the same state when measured in the computational basis. The other $\Phi$$$\lvert\Phi^+\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle + \lvert 11\rangle) = \frac{1}{\sqrt{2}}\begin{pmatrix}1\\0\\0\\1\end{pmatrix…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-plus-i?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert +i\rangle$ (Plus-i state)</title>
        <link>https://yanevskiv.com/ket-plus-i?rev=1781320400&amp;do=diff</link>
        <description>$\lvert +i\rangle$ (Plus-i state)

The plus-i state $\lvert +i\rangle$ (also written $\lvert i\rangle$ or $\lvert y\rangle$) is an equal superposition of $\lvert 0\rangle$ and $\lvert 1\rangle$ with a relative phase of $+i$. It is one of the six cardinal states on the Bloch sphere, sitting at the positive $y$-axis at coordinates $(0, 1, 0)$.

$$\lvert +i\rangle = \frac{1}{\sqrt{2}}(\lvert 0\rangle + i\lvert 1\rangle) = \frac{1}{\sqrt{2}}\begin{pmatrix}1\\i\end{pmatrix}$$

On the Bloch sphere, $\…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-plus?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert +\rangle$ (Plus state)</title>
        <link>https://yanevskiv.com/ket-plus?rev=1781320400&amp;do=diff</link>
        <description>$\lvert +\rangle$ (Plus state)

The plus state $\lvert +\rangle$ is an equal superposition of $\lvert 0\rangle$ and $\lvert 1\rangle$ with equal positive amplitudes. It is one of the six cardinal states on the Bloch sphere, sitting at the positive $x$-axis at coordinates $(1, 0, 0)$.

$$\lvert +\rangle = \frac{1}{\sqrt{2}}(\lvert 0\rangle + \lvert 1\rangle) = \frac{1}{\sqrt{2}}\begin{pmatrix}1\\1\end{pmatrix}$$

On the Bloch sphere, $\lvert +\rangle$ is an eigenstate of the Pauli-X gate with eig…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-psi-minus?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert\Psi^-\rangle$ (Psi-minus state)</title>
        <link>https://yanevskiv.com/ket-psi-minus?rev=1781320400&amp;do=diff</link>
        <description>$\lvert\Psi^-\rangle$ (Psi-minus state)

The psi-minus state $\lvert\Psi^-\rangle$ is one of the four Bell states — the maximally entangled two-qubit states. It is the only antisymmetric Bell state: swapping the two qubits picks up a minus sign, $\text{SWAP}\lvert\Psi^-\rangle = -\lvert\Psi^-\rangle$. It is also called the singlet state$\Psi$$$\lvert\Psi^-\rangle = \frac{1}{\sqrt{2}}(\lvert 01\rangle - \lvert 10\rangle) = \frac{1}{\sqrt{2}}\begin{pmatrix}0\\1\\-1\\0\end{pmatrix}$$$\lvert\Psi^+\r…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-psi-plus?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert\Psi^+\rangle$ (Psi-plus state)</title>
        <link>https://yanevskiv.com/ket-psi-plus?rev=1781320400&amp;do=diff</link>
        <description>$\lvert\Psi^+\rangle$ (Psi-plus state)

The psi-plus state $\lvert\Psi^+\rangle$ is one of the four Bell states — the maximally entangled two-qubit states. It is an equal superposition of $\lvert 01\rangle$ and $\lvert 10\rangle$ with the same sign, meaning the two qubits always give opposite outcomes when measured in the computational basis. The other $\Psi$$$\lvert\Psi^+\rangle = \frac{1}{\sqrt{2}}(\lvert 01\rangle + \lvert 10\rangle) = \frac{1}{\sqrt{2}}\begin{pmatrix}0\\1\\1\\0\end{pmatrix}$…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ket-w?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>W state</title>
        <link>https://yanevskiv.com/ket-w?rev=1781320400&amp;do=diff</link>
        <description>W state

W state is an entangled three-qubit state that is an equal superposition over all configurations with exactly one qubit in state $\lvert 1\rangle$ and the others in $\lvert 0\rangle$.

$$\lvert W\rangle = \frac{1}{\sqrt{3}}(\lvert 001\rangle + \lvert 010\rangle + \lvert 100\rangle)$$

The W state was identified by Wolfgang Dür, Guifré Vidal, and J. Ignacio Cirac in 2000 as part of their classification of three-qubit entanglement. Unlike the $n$$n$$\lvert 1\rangle$$$\lvert W_n\rangle = \…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kpsewhich?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>kpsewhich</title>
        <link>https://yanevskiv.com/kpsewhich?rev=1781320400&amp;do=diff</link>
        <description>kpsewhich

kpsewhich is a LaTeX-related command. It&#039;s a diagnostic command that&#039;s used to look up the full path of a file you know the LaTeX compiler would use implicitly. In some way, it is similar to the which command, which shows the full path of a command if you would run it in the shell (e.g.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kraus-operator?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Kraus operator</title>
        <link>https://yanevskiv.com/kraus-operator?rev=1781320400&amp;do=diff</link>
        <description>Kraus operator

Kraus operators $\{K_k\}$ are a set of matrices used to represent a quantum channel — a completely positive trace-preserving (CPTP) map $\mathcal{E}$ that sends density matrices to density matrices. Any physically valid quantum channel can be expressed in Kraus form.$$\mathcal{E}(\rho) = \sum_k K_k\rho K_k^\dagger$$$\sum_k K_k^\dagger K_k = I$$\text{tr}(\mathcal{E}(\rho)) = \text{tr}(\rho) = 1$$K_k$$\mathcal{E}(\rho)$$1-p$$p$$X$$\lvert 0\rangle \leftrightarrow \lvert 1\rangle$$$K…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/landauers-principle?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Landauer&#039;s principle</title>
        <link>https://yanevskiv.com/landauers-principle?rev=1781320400&amp;do=diff</link>
        <description>Landauer&#039;s principle

Landauer&#039;s principle establishes the thermodynamic lower bound on energy required to erase information from a physical system (e.g. a computer register).

At temperature $T$, the minimum energy needed to erase information is:

$$E = (\text{bits erased}) \times k_B T \ln 2$$

Where $k_B$ is the Boltzman&#039;s constant.$S_0 = 64\times k_B\ln 2$$S_1 = 0$$\Delta S = S_0 - S_1$$Q = T \Delta S$$T = 300K$$$ E_\text{bit} \approx 2.9\times 10^{-21} J$$$$ E_\text{bit} \approx 0.018 \text…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/latex-syntax?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>LaTeX syntax</title>
        <link>https://yanevskiv.com/latex-syntax?rev=1781320400&amp;do=diff</link>
        <description>LaTeX syntax

For addition, you use the + symbol e.g. a + b = c:
$$ a + b = c$$

For subtraction, you use the - symbol e.g. a - b = c
$$ a - b = c$$

For multiplication, you just write ab or put a dot in between with \cdot (meaning: “centered dot”) like a \cdot b.
Using a * b$a * b$$$a\cdot b = c$$$a / b$$${a \over b} = c$$$$ a = b \pmod{N}$$$$e^{i\phi} = \cos(\phi) + i\sin(\phi)$$$$\ln(1 + x) = 1 + x + $$$$\int \iint \iiint \oint \oiint \oiiint$$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/latex?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>LaTeX</title>
        <link>https://yanevskiv.com/latex?rev=1781320400&amp;do=diff</link>
        <description>LaTeX

Latex (stylized as $\LaTeX$) is a markup language used to create scientific papers. It&#039;s the language used to produce PDF documents, like the ones you&#039;ll commonly see on arXiv.

Latex has a simple declarative syntax that looks like \command[opt1][opt2]...[optN]{arg1}{arg2}...{argN}</description>
    </item>
    <item rdf:about="https://yanevskiv.com/limits.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>limits.h</title>
        <link>https://yanevskiv.com/limits.h?rev=1781320400&amp;do=diff</link>
        <description>limits.h

limits.h tells you the integer type limits for the platform you are compiling on. You reach for it when you need to guard against overflow before it happens, or when you want to write code that works correctly regardless of whether long is 32 or 64 bits. Writing</description>
    </item>
    <item rdf:about="https://yanevskiv.com/lindbald-master-equation?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lindbald master equation</title>
        <link>https://yanevskiv.com/lindbald-master-equation?rev=1781320400&amp;do=diff</link>
        <description>Lindbald master equation

Lindbald master equation is the equation that generalizes the Schrodinger equation.

The following is the equation written in terms of density matrix $\rho$.

$$\frac{d\rho}{dt} = -\frac{i}{\hbar}[H, \rho] + \sum_k\left(L_k^\dagger L_k - \frac{1}{2}\{L_k^\dagger L_k, \rho\}\right)$$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/lindblad-equation-qutip?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lindblad equation (QuTiP)</title>
        <link>https://yanevskiv.com/lindblad-equation-qutip?rev=1781320400&amp;do=diff</link>
        <description>Lindblad equation (QuTiP)

Lindblad equation implementation using QuTiP.

QuTiP&#039;s mesolve() integrates the full Lindblad master equation when the c_ops list is non-empty:

$$\frac{\mathrm{d}\rho}{\mathrm{d}t} = -\frac{i}{\hbar}[H,\,\rho] + \sum_k\!\left(L_k\rho L_k^\dagger - \frac{1}{2}\{L_k^\dagger L_k,\,\rho\}\right)$$

Each element of c_ops is a collapse operator $C_k$; QuTiP constructs the full dissipator term internally as $C_k\rho C_k^\dagger - \frac{1}{2}\{C_k^\dagger C_k, \rho\}$$k$$C_k …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/lindblad-equation?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lindblad equation</title>
        <link>https://yanevskiv.com/lindblad-equation?rev=1781320400&amp;do=diff</link>
        <description>Lindblad equation

Lindblad equation (also called the GKSL equation, after Gorini, Kossakowski, Sudarshan, and Lindblad) is the most general Markovian master equation for the density matrix $\rho$ of an open quantum system. It extends the von Neumann equation by adding a dissipator term that models incoherent processes — energy loss, dephasing, and other forms of coupling to an environment.$$\frac{\mathrm{d}\rho}{\mathrm{d}t} = -\frac{i}{\hbar}[H,\,\rho] + \sum_k\!\left(L_k\rho L_k^\dagger - \fr…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/linked-list?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Linked list</title>
        <link>https://yanevskiv.com/linked-list?rev=1781320400&amp;do=diff</link>
        <description>Linked list

A linked list is a sequence of nodes where each node holds a value and a pointer to the next node. The nodes need not be contiguous in memory; the pointer is what links them. The head pointer is the entry point; the last node&#039;s next pointer is NULL. Insertion and deletion at any position where you already hold a pointer costs O(1) — no elements shift — but reaching a position by index requires traversing from the head, costing O(n).</description>
    </item>
    <item rdf:about="https://yanevskiv.com/liskov-substitution-principle?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Liskov substitution principle</title>
        <link>https://yanevskiv.com/liskov-substitution-principle?rev=1781320400&amp;do=diff</link>
        <description>Liskov substitution principle

The Liskov substitution principle (LSP) states that if S is a subtype of T, then objects of type T may be replaced with objects of type S without altering the correctness of the program. It was formulated by Barbara Liskov in a 1987 keynote. It is the L in</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-algorithms?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of algorithms</title>
        <link>https://yanevskiv.com/list-of-algorithms?rev=1781513651&amp;do=diff</link>
        <description>List of algorithms

	* sorting-algorithms
	* dijkstra-algorithm</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-articles?rev=1781515396&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T09:23:16+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of articles</title>
        <link>https://yanevskiv.com/list-of-articles?rev=1781515396&amp;do=diff</link>
        <description>List of articles

	* List of tools
	* List of paths
	* List of commands
	* List of hardware
	* List of C headers
	* List of C concepts
	* List of C++ headers
	* List of C++ concepts
	* List of embedded engineering concepts
	* List of parallel computing concepts
	* List of quantum computing concepts
	* List of software engineering concepts
	* List of data structures
	* List of algorithms
	* List of miscellaneous topics
	* List of writing guides</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-c-concepts?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of C concepts</title>
        <link>https://yanevskiv.com/list-of-c-concepts?rev=1781513651&amp;do=diff</link>
        <description>List of C concepts

	* C standard library
	* #pragma once
	* do { ... } while (0)
	* Function macro
	* main() return
	* Exit status
	* Header guard
	* Embedded engineering glossary</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-c-headers?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of C headers</title>
        <link>https://yanevskiv.com/list-of-c-headers?rev=1781513651&amp;do=diff</link>
        <description>List of C headers

	* assert.h
	* complex.h
	* ctype.h
	* errno.h
	* fenv.h
	* float.h
	* inttypes.h
	* iso646.h
	* limits.h
	* locale.h
	* math.h
	* setjmp.h
	* signal.h
	* stdalign.h
	* stdarg.h
	* stdatomic.h
	* stdbit.h
	* stdbool.h
	* stdckdint.h
	* stddef.h
	* stdint.h
	* stdio.h
	* stdlib.h
	* stdmchar.h
	* stdnoreturn.h
	* string.h
	* tgmath.h
	* threads.h
	* time.h
	* uchar.h
	* wchar.h
	* wctype.h
	* curses.h
	* getopt.h</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-commands?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of commands</title>
        <link>https://yanevskiv.com/list-of-commands?rev=1781513651&amp;do=diff</link>
        <description>List of commands

	* List of util-linux commands
	* List of LaTeX commands
	* List of system commands
	* List of HPC commands</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-concepts-in-quantum-control?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of concepts in quantum control</title>
        <link>https://yanevskiv.com/list-of-concepts-in-quantum-control?rev=1781320400&amp;do=diff</link>
        <description>List of concepts in quantum control

	* List of optimal quantum control algorithms
	* list-of-hamiltonians
	* pulse-shaping
	* drag-pulse
	* rabi-cycle
	* spin-echo
	* optimal-pulse-control
	* rotating-wave-approximation</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-concepts-in-quantum-error-correction?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of concepts in quantum error correction</title>
        <link>https://yanevskiv.com/list-of-concepts-in-quantum-error-correction?rev=1781320400&amp;do=diff</link>
        <description>List of concepts in quantum error correction

	* List of quantum error correction codes
	* list-of-lindbald-operators
	* list-of-kraus-operators
	* Density matrix
	* Lindbald master equation
	* Kraus operator
	* lindbald-operator
	* list-of-lindbald-operators
	* quantum-channel
	* cptp-map
	* superoperator
	* fault-tolerance</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-concepts?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of concepts</title>
        <link>https://yanevskiv.com/list-of-concepts?rev=1781320400&amp;do=diff</link>
        <description>List of concepts

	* C
		* header-guards
		* #pragma once

	* C++
		* Name mangling
		* Rule of 5

	* Miscellaneous
			* Numbers every programmer should know</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-cpp-concepts?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of C++ concepts</title>
        <link>https://yanevskiv.com/list-of-cpp-concepts?rev=1781513651&amp;do=diff</link>
        <description>List of C++ concepts

	* Name mangling
	* Rule of 5
	* CRTP
	* constexpr</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-cpp-headers?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of C++ headers</title>
        <link>https://yanevskiv.com/list-of-cpp-headers?rev=1781513651&amp;do=diff</link>
        <description>List of C++ headers

C++98

	* &lt;algorithm&gt;
	* &lt;bitset&gt;
	* &lt;complex&gt;
	* &lt;deque&gt;
	* &lt;exception&gt;
	* &lt;fstream&gt;
	* &lt;functional&gt;
	* &lt;iomanip&gt;
	* &lt;ios&gt;
	* &lt;iosfwd&gt;
	* &lt;iostream&gt;
	* &lt;istream&gt;
	* &lt;iterator&gt;
	* &lt;limits&gt;
	* &lt;list&gt;
	* &lt;locale&gt;
	* &lt;map&gt;
	* &lt;memory&gt;
	* &lt;new&gt;
	* &lt;numeric&gt;
	* &lt;ostream&gt;
	* &lt;queue&gt;
	* &lt;set&gt;
	* &lt;sstream&gt;
	* &lt;stack&gt;
	* &lt;stdexcept&gt;
	* &lt;streambuf&gt;
	* &lt;string&gt;
	* &lt;typeinfo&gt;
	* &lt;utility&gt;
	* &lt;valarray&gt;
	* &lt;vector&gt;

C++11

	* &lt;array&gt;
	* &lt;atomic&gt;
	* &lt;chrono&gt;
	* &lt;codecvt&gt;
	* &lt;condition_var…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-data-structures?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of data structures</title>
        <link>https://yanevskiv.com/list-of-data-structures?rev=1781513651&amp;do=diff</link>
        <description>List of data structures

	* Array
	* Forward list
	* Linked list
	* Dynamic array
	* Stack
	* Queue
	* Circular buffer
	* Matrix
	* Binary tree
	* Heap
	* Red-black tree
	* B-tree
	* B+ tree
	* Hash map
	* Graph</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-embedded-engineering-concepts?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of embedded engineering concepts</title>
        <link>https://yanevskiv.com/list-of-embedded-engineering-concepts?rev=1781513651&amp;do=diff</link>
        <description>List of embedded engineering concepts

	* List of logic gates
	* rtos
	* xv6
	* riscv
	* x86-64
	* mcu
	* spi
	* uart
	* i2c
	* gpio
	* wcet
	* Harvard architecture</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-essential-quantum-computing-concepts?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of essential quantum computing concepts</title>
        <link>https://yanevskiv.com/list-of-essential-quantum-computing-concepts?rev=1781320400&amp;do=diff</link>
        <description>List of essential quantum computing concepts

	* List of quantum gates
	* List of quantum states
	* List of quantum algorithms
	* Qubit
	* Two qubits
	* Quantum register
	* Quantum gate
	* Born rule
	* Quantum state
	* State vector
	* Pauli gates
	* Global phase
	* Basis state
	* Eigenstate
	* relative-phase
	* clifford-gate
	* Hopf fibration
	* $\mathbb{CP}^1$
	* unitary-gate
	* quantum-measurement
	* Bloch sphere
	* Dirac notation
	* dagger-operation
	* matrix-transpose
	* complex-conjugate
	*…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-hardware?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of hardware</title>
        <link>https://yanevskiv.com/list-of-hardware?rev=1781513651&amp;do=diff</link>
        <description>List of hardware

	* ThinkPad
	* Arduino Uno R4 WiFi
	* weller-we-1010</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-headers-cpp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of headers in C++</title>
        <link>https://yanevskiv.com/list-of-headers-cpp?rev=1781320400&amp;do=diff</link>
        <description>List of headers in C++

&lt;https://en.cppreference.com/w/cpp/headers.html&gt;</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-hpc-commands?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of HPC commands</title>
        <link>https://yanevskiv.com/list-of-hpc-commands?rev=1781320400&amp;do=diff</link>
        <description>List of HPC commands

	* nvcc
	* cuobjdump</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-kdp-exercises?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of KDP exercises</title>
        <link>https://yanevskiv.com/list-of-kdp-exercises?rev=1781320400&amp;do=diff</link>
        <description>List of KDP exercises

	* KDP Midterm (2026-01-10) Question 1
	* KDP Midterm (2026-01-10) Question 2
	* KDP Exam (2026-02-18) Question 1
	* KDP Exam (2026-02-18) Question 2
	* (WIP) KDP Exam (2026-02-18) Question 3
	* kdp20260218-4</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-latex-commands?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of LaTeX commands</title>
        <link>https://yanevskiv.com/list-of-latex-commands?rev=1781320400&amp;do=diff</link>
        <description>List of LaTeX commands

	* pdflatex
	* kpsewhich</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-logic-gates?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of logic gates</title>
        <link>https://yanevskiv.com/list-of-logic-gates?rev=1781320400&amp;do=diff</link>
        <description>List of logic gates

	* and-gate
	* or-gate
	* not-gate
	* nand-gate
	* nor-gate</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-miscellaneous-quantum-computing-concepts?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of miscellaneous quantum computing concepts</title>
        <link>https://yanevskiv.com/list-of-miscellaneous-quantum-computing-concepts?rev=1781320400&amp;do=diff</link>
        <description>List of miscellaneous quantum computing concepts

	* schrodinger-picture
	* heisenberg-picture
	* interaction-picture
	* measurement-problem
	* intepretation-of-quantum-mechanics
	* copenhagen-interpretation
	* many-world-interpretation</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-miscellaneous-topics?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of miscellaneous topics</title>
        <link>https://yanevskiv.com/list-of-miscellaneous-topics?rev=1781513651&amp;do=diff</link>
        <description>List of miscellaneous topics

	* bytebeat
	* code-golf
	* List of KDP exercises</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-optimal-quantum-control-algorithms?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of optimal quantum control algorithms</title>
        <link>https://yanevskiv.com/list-of-optimal-quantum-control-algorithms?rev=1781320400&amp;do=diff</link>
        <description>List of optimal quantum control algorithms

	* grape
	* crab
	* goat</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-parallel-computing-concepts?rev=1781536038&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T15:07:18+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of parallel computing concepts</title>
        <link>https://yanevskiv.com/list-of-parallel-computing-concepts?rev=1781536038&amp;do=diff</link>
        <description>List of parallel computing concepts

	* introduction-to-parallel-computing
	* synchronization-primitve
	* SAXPY
	* Semaphore
	* mutex
	* Numbers every programmer should know
	* Amdahl&#039;s law
	* Gustafson&#039;s law
	* cache-coherence
	* cuda
	* OpenMP
	* MPI
	* queuing-theory
	* Lock-free queue
	* numa
	* false-sharing
	* ABA problem
	* Trace monoid
	* hazard-pointer
	* cache-coherence
	* Roofline model
	* numa
	* embarrassingly-parallel
	* fork-join-model
	* rcu
	* lock
	* lock-convoy
	* lock-content…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-paths?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of paths</title>
        <link>https://yanevskiv.com/list-of-paths?rev=1781513651&amp;do=diff</link>
        <description>List of paths

	* /bin
	* /dev
	* /boot
	* /etc
	* /home
	* /lib
	* /mnt
	* /opt
	* /proc
	* /root
	* /sbin
	* /srv
	* /tmp
	* /usr
	* /var</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-quantum-algorithms?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of quantum algorithms</title>
        <link>https://yanevskiv.com/list-of-quantum-algorithms?rev=1781320400&amp;do=diff</link>
        <description>List of quantum algorithms

	* Quantum Fourier transform
	* Quantum phase estimation
	* Shor&#039;s algorithm
	* Grover&#039;s algorithm
	* Deutsch-Jozsa algorithm
	* QAOA
	* VQE</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-quantum-computing-concepts?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of quantum computing concepts</title>
        <link>https://yanevskiv.com/list-of-quantum-computing-concepts?rev=1781513651&amp;do=diff</link>
        <description>List of quantum computing concepts

	* Qubit
	* Dirac notation
	* Born rule
	* Global phase
	* Bloch sphere
	* Quantum state
	* Quantum register
	* Quantum gate
	* Quantum circuit
	* Quantum algorithm
	* Quantum error correction
	* Schrödinger equation</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-quantum-computing-libraries?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of quantum computing libraries</title>
        <link>https://yanevskiv.com/list-of-quantum-computing-libraries?rev=1781320400&amp;do=diff</link>
        <description>List of quantum computing libraries

	* qiskit
	* q-sharp</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-quantum-error-correction-codes?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of quantum error correction codes</title>
        <link>https://yanevskiv.com/list-of-quantum-error-correction-codes?rev=1781320400&amp;do=diff</link>
        <description>List of quantum error correction codes

	* repetition-code
	* shor-code
	* surface-code</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-quantum-gates?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of quantum gates</title>
        <link>https://yanevskiv.com/list-of-quantum-gates?rev=1781320400&amp;do=diff</link>
        <description>List of quantum gates

	* $I$ gate (Identity gate)
	* $X$ gate (NOT gate)
	* Y gate
	* Z gate
	* Rotation gates
	* Rotation-X gate
	* Rotation-Y gate
	* Rotation-Z gate
	* S gate
	* T gate
	* Hadamard gate
	* Phase gate
	* Unitary gate
	* ccnot-gate
	* CX gate (CNOT)
	* SWAP gate
	* iSWAP gate</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-software-engineering-concepts?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of software engineering concepts</title>
        <link>https://yanevskiv.com/list-of-software-engineering-concepts?rev=1781513651&amp;do=diff</link>
        <description>List of software engineering concepts

	* Brooks&#039;s law
	* Parkinson&#039;s law
	* Kanban
	* Extreme programming
	* Agile
	* Test-driven development
	* CI/CD
	* DevOps
	* Blue-green deployment
	* Canary release
	* Unit test
	* Regression
	* Test automation
	* Kanban
	* Feature flag
	* Production
	* A/B testing
	* Hotfix
	* Feature branch
	* Eating your own dog food
	* Spike solution
	* SOLID
	* Liskov substitution principle
	* Smart-and-gets-things-done
	* DevOps
	* Incremental build model
	* Prototyp…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-software-engineering-tools?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of software engineering tools</title>
        <link>https://yanevskiv.com/list-of-software-engineering-tools?rev=1781320400&amp;do=diff</link>
        <description>List of software engineering tools

	* jira
	* confluence
	* ms-teams
	* harvestapp
	* notion</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-syntaxes?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of syntaxes</title>
        <link>https://yanevskiv.com/list-of-syntaxes?rev=1781320400&amp;do=diff</link>
        <description>List of syntaxes

	* c-syntax
	* cpp-syntax
	* LaTeX syntax</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-system-commands?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of system commands</title>
        <link>https://yanevskiv.com/list-of-system-commands?rev=1781320400&amp;do=diff</link>
        <description>List of system commands

	* ifupdown</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-tools?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of tools</title>
        <link>https://yanevskiv.com/list-of-tools?rev=1781513651&amp;do=diff</link>
        <description>List of tools

	* git
	* docker
	* Shell
	* tmux
	* ssh
	* cmake
	* nvim
	* gdb
	* clangd
	* Terminal
	* LaTeX
	* VPS
	* qemu
	* gcc
	* perf
	* nsight
	* valgrind
	* numactl</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-util-linux-commands?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of util-linux commands</title>
        <link>https://yanevskiv.com/list-of-util-linux-commands?rev=1781320400&amp;do=diff</link>
        <description>List of util-linux commands

util-linux is a collection of commands provided by the Linux Kernel Organization.

A similar set of commands is GNU core utilities. 

The following are commands provided by until-linux.
You can do man &lt;command&gt; or use the --help option to see what each command does.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-writing-guides?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of writing guides</title>
        <link>https://yanevskiv.com/list-of-writing-guides?rev=1781513651&amp;do=diff</link>
        <description>List of writing guides

	* General writing guide
	* Writing guide on quantum computing
	* Writing guide on parallel computing</description>
    </item>
    <item rdf:about="https://yanevskiv.com/locale.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>locale.h</title>
        <link>https://yanevskiv.com/locale.h?rev=1781320400&amp;do=diff</link>
        <description>locale.h

locale.h controls how your program formats and interprets culture-specific data: whether the decimal separator is . or ,, what the currency symbol is, which characters count as letters. By default a C program runs in the &quot;C&quot; locale — ASCII,</description>
    </item>
    <item rdf:about="https://yanevskiv.com/lock-free-queue?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lock-free queue</title>
        <link>https://yanevskiv.com/lock-free-queue?rev=1781320400&amp;do=diff</link>
        <description>Lock-free queue

A mutex-protected queue is the natural starting point for producer-consumer communication between threads. Under light load it works fine, but under high contention the lock becomes a bottleneck: a thread preempted while holding it stalls every other producer and consumer until it is scheduled again. A</description>
    </item>
    <item rdf:about="https://yanevskiv.com/main-return?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>main() return</title>
        <link>https://yanevskiv.com/main-return?rev=1781320400&amp;do=diff</link>
        <description>main() return

The return value of int main(); function is called the program&#039;s exit status.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/master-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Master (OpenMP)</title>
        <link>https://yanevskiv.com/master-openmp?rev=1781320400&amp;do=diff</link>
        <description>Master (OpenMP)

Master is an OpenMP directive that restricts execution of a block to thread 0. Unlike `single`, there is no implicit barrier. Other threads skip the block entirely and continue immediately, making it suitable for non-critical side effects like printing progress or updating a log counter where stalling the whole team would be wasteful.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/math-books?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Math books</title>
        <link>https://yanevskiv.com/math-books?rev=1781320400&amp;do=diff</link>
        <description>Math books

	* &lt;https://zb260.user.srcf.net/notes/III/modrep.pdf&gt;</description>
    </item>
    <item rdf:about="https://yanevskiv.com/math.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>math.h</title>
        <link>https://yanevskiv.com/math.h?rev=1781320400&amp;do=diff</link>
        <description>math.h

math.h is the standard mathematical function library for floating-point arithmetic. It covers trigonometry, exponentiation, logarithms, rounding, and a handful of utility functions. Every function operates on double by default; append f for float</description>
    </item>
    <item rdf:about="https://yanevskiv.com/mathematical-maturity?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Mathematical Maturity</title>
        <link>https://yanevskiv.com/mathematical-maturity?rev=1781320400&amp;do=diff</link>
        <description>Mathematical Maturity

Trivial example

One of the earliest awakenings of my mathematical maturity was when I was a kid, thinking one of the simplest equations there is:

$$ a\cdot x = b$$

I knew how to solve this 99% of the time:

$$x = b / a$$

Is this correct? Let&#039;s take the equation $2\cdot x = 6$$b = 0$$x = 0$$a = 0$$a = 0$$b = 3$$x$$0 = 3$$a = 0$$b = 0$$x$$0 = 0$$a\cdot x = b$$a\cdot x = b$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/matmul?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Matmul</title>
        <link>https://yanevskiv.com/matmul?rev=1781320400&amp;do=diff</link>
        <description>Matmul

Matmul is an algorithm in high-performance computing (HPC). It is a BLAS level 2 (“Basic Linear Algebra Subprograms”) algorithm.

Definition

Matrices

Let $\mathbf A\in\mathbb{R}^{A_\text{rows}\times A_\text{cols}}$ and $\mathbf B\in \mathbb R^{B_\text{rows}\times B_\text{cols}}$ be square matrices over real numbers and let $A_\text{rows} = B_\text{cols}$.

Matmul defined as a matrix multiplication $\mathbf A\cdot \mathbf B$$\mathbf C\in\mathbb{R}^{A_\text{rows}\times B_\text{cols}}$$$ …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/matrix?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Matrix</title>
        <link>https://yanevskiv.com/matrix?rev=1781320400&amp;do=diff</link>
        <description>Matrix

A matrix is a two-dimensional rectangular array of values organised in rows and columns.

In C, a matrix is stored as a flat Array in row-major order: all elements of row 0 come first, then row 1, and so on. The element at row i, column j of an M × N$y = Ax$$O(mn)$$C = AB$$O(mnk)$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/message-ordering-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Message ordering (MPI)</title>
        <link>https://yanevskiv.com/message-ordering-mpi?rev=1781320400&amp;do=diff</link>
        <description>Message ordering (MPI)

TCP guarantees that bytes sent on a stream arrive in order. If you send() “hello” and then send() “world” on the same socket, the receiver gets “hello” first. MPI provides the same guarantee for point-to-point messages: messages sent from process A to process B on the same communicator with the same tag arrive in the order they were sent. If A calls</description>
    </item>
    <item rdf:about="https://yanevskiv.com/minus-i-state-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert -i\rangle$ (Qiskit)</title>
        <link>https://yanevskiv.com/minus-i-state-qiskit?rev=1781320400&amp;do=diff</link>
        <description>$\lvert -i\rangle$ (Qiskit)

Minus-i state $\lvert -i\rangle$ implementation using Qiskit. The $\lvert -i\rangle$ state is prepared by applying a Hadamard gate followed by an $S^\dagger$ gate to $\lvert 0\rangle$.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(1)
qc.h(0)   # |0&gt; -&gt; |+&gt;
qc.sdg(0) # |+&gt; -&gt; |-i&gt; = (|0&gt; - i|1&gt;) / sqrt(2)
print(Statevector(qc))
# Statevector([0.70710678+0.j, 0.-0.70710678j], dims=(2,))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/minus-state-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert -\rangle$ (Qiskit)</title>
        <link>https://yanevskiv.com/minus-state-qiskit?rev=1781320400&amp;do=diff</link>
        <description>$\lvert -\rangle$ (Qiskit)

Minus state $\lvert -\rangle$ implementation using Qiskit. The $\lvert -\rangle$ state is prepared by applying an X gate followed by a Hadamard gate to $\lvert 0\rangle$.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(1)
qc.x(0)  # |0&gt; -&gt; |1&gt;
qc.h(0)  # |1&gt; -&gt; |-&gt; = (|0&gt; - |1&gt;) / sqrt(2)
print(Statevector(qc))
# Statevector([ 0.70710678+0.j, -0.70710678+0.j], dims=(2,))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/mixed-state?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Mixed state</title>
        <link>https://yanevskiv.com/mixed-state?rev=1781320400&amp;do=diff</link>
        <description>Mixed state

Mixed state is a quantum state that cannot be described by a single state vector $\lvert\psi\rangle$. It arises when a quantum system is entangled with its environment or when there is classical uncertainty about how the system was prepared. Mixed states are represented by density matrices $\rho$$\rho = \lvert\psi\rangle\langle\psi\rvert$$\text{tr}(\rho^2) = 1$$\lvert 0\rangle$$p$$\lvert 1\rangle$$1-p$$$\rho = p\lvert 0\rangle\langle 0\rvert + (1-p)\lvert 1\rangle\langle 1\rvert = \…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>MPI</title>
        <link>https://yanevskiv.com/mpi?rev=1781320400&amp;do=diff</link>
        <description>MPI

MPI (Message Passing Interface) is a standard for distributed-memory parallel programming in C, C++, and Fortran. Unlike OpenMP where you add pragmas and the threads share your program&#039;s memory, with MPI you launch N independent copies of your program, each with its own private address space, and they coordinate by explicitly sending and receiving messages. Because the communication model makes no assumption that processes share any hardware, MPI programs scale from a laptop to a cluster wi…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/multiqubit-gates?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Multiqubit gates</title>
        <link>https://yanevskiv.com/multiqubit-gates?rev=1781320400&amp;do=diff</link>
        <description>Multiqubit gates

Multiqubit gates are quantum gates that act on two or more qubits simultaneously. They are the mechanism by which entanglement is created and destroyed in a quantum circuit — a single-qubit gate acting on one qubit at a time can never entangle two qubits that started in a product state.$2 \times 2$$4 \times 4$$8 \times 8$$n$$2^n \times 2^n$$U$$U$$\lvert 1\rangle$$X$$X$$U$$CU$$4 \times 4$$\lvert 0\rangle$$U$$\lvert 1\rangle$$n$$\{H, T, \text{CX}\}$$\epsilon$$O(\log^c(1/\epsilon)…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/my-bookmarks?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>My bookmarks</title>
        <link>https://yanevskiv.com/my-bookmarks?rev=1781320400&amp;do=diff</link>
        <description>My bookmarks

C++

	* &lt;https://en.cppreference.com/w/&gt;
	* &lt;https://json.nlohmann.me/api/basic_json/&gt;

LaTeX

Online tools:

	* &lt;https://openai.com/index/introducing-prism/&gt;
	* &lt;https://www.mathcha.io/&gt;
	* &lt;https://www.overleaf.com/&gt;

Documentation PDFs:

	* &lt;https://pgfplots.sourceforge.net/pgfplots.pdf&gt;
	* &lt;https://www.bu.edu/math/files/2013/08/tikzpgfmanual.pdf&gt;
	* &lt;https://feog.github.io/chap1dm.pdf&gt;

Wikipedia

Related to mathematics:

	* &lt;https://en.wikipedia.org/wiki/Siamese_neural_network…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/name-mangling?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Name mangling</title>
        <link>https://yanevskiv.com/name-mangling?rev=1781320400&amp;do=diff</link>
        <description>Name mangling

Name mangling is how C++ compilers encode object types then and reconstruct the type back.

Let&#039;s say we got a following piece of C++ code.


namespace Hello {
    struct World {
      template &lt;typename T&gt; T add(T x, T y) {
          return x + y;
      }
    };
}</description>
    </item>
    <item rdf:about="https://yanevskiv.com/net-config?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Network Configuration</title>
        <link>https://yanevskiv.com/net-config?rev=1781320400&amp;do=diff</link>
        <description>Network Configuration

This article is about network configuration in GNU/Linux systems

ifupdown

Dynamic configurations

Dynamic configuration with ifupdown (IPv4)



# /etc/network/interfaces
iface ens3 inet dhcp


Dynamic configuration with ifupdwon (IPv6)</description>
    </item>
    <item rdf:about="https://yanevskiv.com/nih-syndrome?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>NIH syndrome</title>
        <link>https://yanevskiv.com/nih-syndrome?rev=1781320400&amp;do=diff</link>
        <description>NIH syndrome

NIH syndrome stands for “Not invented here” syndrome. It&#039;s when you deliberately avoid using a premade solution in favor of your own.

For example, you might prefer to implement your own dynamic array even though std::vector&lt;int&gt; already exist. The commonly given rationale is that you&#039;ll probably find the implementation you made easier to understand (you wrote it!) and you&#039;ll be able easily make it fit your needs.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/nisq?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>NISQ</title>
        <link>https://yanevskiv.com/nisq?rev=1781320400&amp;do=diff</link>
        <description>NISQ

NISQ (Noisy Intermediate-Scale Quantum) refers to the current era of quantum computing, characterized by devices with tens to a few thousand qubits that are too noisy for full fault-tolerant quantum error correction. The term was coined by John Preskill in 2018.$10^{-3}$$10^{-2}$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/nonblocking-collectives-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Non-blocking collectives (MPI)</title>
        <link>https://yanevskiv.com/nonblocking-collectives-mpi?rev=1781320400&amp;do=diff</link>
        <description>Non-blocking collectives (MPI)

Non-blocking point-to-point communication lets a process post a send or receive and continue computing while the transfer happens in the background (see blocking and non-blocking). Non-blocking collectives extend the same idea to collective operations. MPI-3 introduced variants that return immediately with a request handle rather than blocking until the operation completes.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/noon-state?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>NOON state</title>
        <link>https://yanevskiv.com/noon-state?rev=1781320400&amp;do=diff</link>
        <description>NOON state

NOON state is an entangled quantum state of two modes in which $N$ photons are in one mode and zero in the other, in an equal superposition with the reverse. It is written as:

$$\lvert N\!:\!0\rangle\!\rangle = \frac{1}{\sqrt{2}}\left(\lvert N\rangle_a\lvert 0\rangle_b + \lvert 0\rangle_a\lvert N\rangle_b\right)$$

NOON states arise naturally in quantum metrology and quantum lithography. Their key property is phase sensitivity that scales as $1/N$$1/\sqrt{N}$$\sqrt{N}$$\phi$$a$$N$$N…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/nowait-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Nowait (OpenMP)</title>
        <link>https://yanevskiv.com/nowait-openmp?rev=1781320400&amp;do=diff</link>
        <description>Nowait (OpenMP)

Nowait is an OpenMP clause that removes the implicit barrier at the end of a work-sharing construct. Threads that finish their portion of the work early proceed to the next statement immediately instead of waiting for stragglers. This is only safe when the subsequent code does not depend on the results of the current construct.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/numbers-every-programmer-should-know?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Numbers every programmer should know</title>
        <link>https://yanevskiv.com/numbers-every-programmer-should-know?rev=1781320400&amp;do=diff</link>
        <description>Numbers every programmer should know

Numbers every programmer should know is a short document listing latencies of various computer operations. The list is given by a computer scientist Jeff Dean.

It illustrates how various high-level operations exponentially take longer time to perform compared to various low-level operations.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/nvcc?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>nvcc</title>
        <link>https://yanevskiv.com/nvcc?rev=1781320400&amp;do=diff</link>
        <description>nvcc

nvcc (or Nvidia C/C++ compiler) is a C++ compiler created by Nvidia that adds CUDA kernel syntax.



 $ nvcc kernel.cu</description>
    </item>
    <item rdf:about="https://yanevskiv.com/one-sided-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>One-sided communication (MPI)</title>
        <link>https://yanevskiv.com/one-sided-mpi?rev=1781320400&amp;do=diff</link>
        <description>One-sided communication (MPI)

mmap with MAP_SHARED lets two processes on the same machine map the same physical memory. One process writes through its pointer and the other immediately sees the update — no explicit send or receive, no coordination required from the reader. One-sided MPI communication (also called</description>
    </item>
    <item rdf:about="https://yanevskiv.com/openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>OpenMP</title>
        <link>https://yanevskiv.com/openmp?rev=1781320400&amp;do=diff</link>
        <description>OpenMP

OpenMP is a shared-memory parallelism API for C, C++, and Fortran. If you have a loop that takes too long and you want it to use all the cores on your machine instead of just one, OpenMP is usually the shortest path there. It works via compiler directives ($s$$1/s$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/p-gate-cudaq?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Phase gate (CUDA-Q)</title>
        <link>https://yanevskiv.com/p-gate-cudaq?rev=1781320400&amp;do=diff</link>
        <description>Phase gate (CUDA-Q)

Phase gate implementation using CUDA-Q. The example applies $P(\pi/2) = S$ to $\lvert +\rangle$, rotating it to $\lvert i\rangle = \frac{1}{\sqrt{2}}(\lvert 0\rangle + i\lvert 1\rangle)$.


// Compile: nvq++ main.cpp -o main
// Run:     ./main

#include &lt;cudaq.h&gt;
#include &lt;cmath&gt;

struct kernel {
    __qpu__ void operator()() {
        cudaq::qubit q;
        h(q);                    // |0&gt; -&gt; |+&gt;
        r1(M_PI / 2.0, q);       // P(pi/2) = S gate
        mz(q);
    }
};

…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/p-gate-custatevec?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Phase gate (cuStateVec)</title>
        <link>https://yanevskiv.com/p-gate-custatevec?rev=1781320400&amp;do=diff</link>
        <description>Phase gate (cuStateVec)

Phase gate implementation using cuStateVec. The example applies $P(\pi/2) = S$ to $\lvert +\rangle$, rotating it to $\lvert i\rangle = \frac{1}{\sqrt{2}}(\lvert 0\rangle + i\lvert 1\rangle)$.


// Compile: nvcc main.cu -o main -lcustatevec
// Run:     ./main

#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;cuda_runtime.h&gt;
#include &lt;custatevec.h&gt;

int main() {
    const int nQubits = 1;
    const int dim = 1 &lt;&lt; nQubits;

    cuDoubleComplex h_sv[2] = {{1,0},{0,0}};  // |0&gt;…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/p-gate-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Phase gate (Qiskit)</title>
        <link>https://yanevskiv.com/p-gate-qiskit?rev=1781320400&amp;do=diff</link>
        <description>Phase gate (Qiskit)

Phase gate implementation using Qiskit. The example applies $P(\pi/2) = S$ to $\lvert +\rangle$, rotating it to $\lvert i\rangle = \frac{1}{\sqrt{2}}(\lvert 0\rangle + i\lvert 1\rangle)$.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
import numpy as np

qc = QuantumCircuit(1)
qc.h(0)               # |0&gt; -&gt; |+&gt;
qc.p(np.pi / 2, 0)    # P(pi/2) = S: |+&gt; -&gt; |i&gt;
print(Statevector(qc))
# Statevector([0.70710678+0.j, 0.+0.70710678j], dims=(2,))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/p-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Phase gate</title>
        <link>https://yanevskiv.com/p-gate?rev=1781320400&amp;do=diff</link>
        <description>Phase gate

Phase gate (or P gate) is a single-qubit gate that applies a phase shift $\phi$ to the $\lvert 1\rvert$ component of a qubit while leaving the $\lvert 0\rangle$ component unchanged. It is a rotation about the $z$-axis of the Bloch sphere.

$$P(\phi) = \begin{pmatrix}1 &amp; 0\\ 0 &amp; e^{i\phi}\end{pmatrix}$$

Applied to a general qubit $\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$, the phase gate multiplies the $\lvert 1\rangle$$e^{i\phi}$$$P(\phi)\lvert\psi\rangle = a\lvert 0\…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/parallel-computing-overview?rev=1781516094&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T09:34:54+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Overview</title>
        <link>https://yanevskiv.com/parallel-computing-overview?rev=1781516094&amp;do=diff</link>
        <description>Overview

Paradigms
 Paradigm  Memory model  API  Typical scale  Shared-memory  Common address space  OpenMP, pthreads  Single node  Distributed-memory  Private per process  MPI  Multi-node cluster  GPU  Host + device  CUDA, HIP, OpenCL  Single GPU  Hybrid  Mixed $S = \dfrac{1}{s + (1-s)/p}$$s$$p$$S = p - s(p-1)$$p$$\min(\pi,\; I \cdot \beta)$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/parallel-computing?rev=1781538462&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T15:47:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Parallel computing</title>
        <link>https://yanevskiv.com/parallel-computing?rev=1781538462&amp;do=diff</link>
        <description>Parallel computing

Parallel computing is a style of programming where a computation is broken into parts that run simultaneously across multiple processors, cores, or machines. The motivation is straightforward: a single core has a clock speed ceiling, and modern CPUs gain performance by adding more cores rather than running each core faster. To take advantage of that, programs have to be written with parallelism in mind.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/parallel-io-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Parallel I/O (MPI)</title>
        <link>https://yanevskiv.com/parallel-io-mpi?rev=1781320400&amp;do=diff</link>
        <description>Parallel I/O (MPI)

POSIX pwrite(fd, buf, n, offset) lets multiple processes write to different offsets in the same file without interfering: the offset is passed explicitly rather than shared, so there is no race on the file position. The straightforward approach in a parallel program is for each process to compute its own offset and call</description>
    </item>
    <item rdf:about="https://yanevskiv.com/parallel-loops-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Parallel loops (OpenMP)</title>
        <link>https://yanevskiv.com/parallel-loops-openmp?rev=1781320400&amp;do=diff</link>
        <description>Parallel loops (OpenMP)

The most common parallel pattern in C is a loop over independent array elements: each iteration writes to a different output location and doesn&#039;t read results that other iterations produce.


for (int i = 0; i &lt; N; i++)
    a[i] = i * 0.5;</description>
    </item>
    <item rdf:about="https://yanevskiv.com/parkinsons-law?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Parkinson&#039;s law</title>
        <link>https://yanevskiv.com/parkinsons-law?rev=1781320400&amp;do=diff</link>
        <description>Parkinson&#039;s law

Parkinson&#039;s law states that work expands to fill the time available for its completion. It was first articulated by C. Northcote Parkinson in a 1955 essay in The Economist, satirising bureaucratic growth in the British Civil Service.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/past-disclaimer?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Disclaimer</title>
        <link>https://yanevskiv.com/past-disclaimer?rev=1781320400&amp;do=diff</link>
        <description>Disclaimer

This website is not an authoritative source. It is written by one person -- me. It&#039;s not meant to serve as documentation or a definitive guide to the technology I talk about. I write about topics that interest me and I explain them in the way I understand them</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-bin?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/bin</title>
        <link>https://yanevskiv.com/path-bin?rev=1781320400&amp;do=diff</link>
        <description>/bin

/bin is the directory for essential user-facing command binaries that must be available before any other filesystem is mounted. It contains the tools needed to boot the system, enter single-user mode, and recover from a broken install: sh, ls,</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-boot?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/boot</title>
        <link>https://yanevskiv.com/path-boot?rev=1781320400&amp;do=diff</link>
        <description>/boot

/boot holds the files the bootloader needs to start the kernel: the kernel image itself, the initial RAM disk, and the bootloader configuration. Everything in /boot is read before the root filesystem is fully operational. Once the kernel is running and the system is up, nothing in</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-dev?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/dev</title>
        <link>https://yanevskiv.com/path-dev?rev=1781320400&amp;do=diff</link>
        <description>/dev

/dev is the directory that exposes hardware devices and kernel abstractions as files. Reading and writing a file in /dev communicates directly with a device driver. This is the “everything is a file” principle made concrete: a disk, a terminal, a random number generator, and a null sink all appear as regular file paths that ordinary</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-etc?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/etc</title>
        <link>https://yanevskiv.com/path-etc?rev=1781320400&amp;do=diff</link>
        <description>/etc

/etc holds system-wide configuration files. Every file in /etc is a plain text file or a directory of text files; no binaries live here. Editing a file in /etc changes the behaviour of the corresponding service or subsystem for all users on the machine. User-level configuration lives in dotfiles under</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-home?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/home</title>
        <link>https://yanevskiv.com/path-home?rev=1781320400&amp;do=diff</link>
        <description>/home

/home contains the personal directories of non-root users. Each user gets a subdirectory named after their login: /home/alice, /home/bob. The shell sets $HOME to this path at login, and programs use it as the default location for user-specific data and configuration. Dotfiles — files and directories whose names begin with</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-lib?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/lib</title>
        <link>https://yanevskiv.com/path-lib?rev=1781320400&amp;do=diff</link>
        <description>/lib

/lib holds the shared libraries required by the binaries in /bin and /sbin. These are the .so files the dynamic linker loads at runtime. The C standard library (libc.so.6), the dynamic linker itself (ld-linux.so.2), and kernel modules all live here. The constraint is the same as for</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-mnt?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/mnt</title>
        <link>https://yanevskiv.com/path-mnt?rev=1781320400&amp;do=diff</link>
        <description>/mnt

/mnt is the conventional location for temporarily mounting filesystems by hand. There is no daemon managing it and no automatic population — a sysadmin mounts something here, uses it, and unmounts it. It is a scratch space for one-off mounts: a USB drive being inspected, a disk image being repaired, another OS partition being accessed for recovery.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-opt?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/opt</title>
        <link>https://yanevskiv.com/path-opt?rev=1781320400&amp;do=diff</link>
        <description>/opt

/opt holds self-contained optional software packages that install outside the normal distribution package manager. Each package gets its own subdirectory, and inside it the layout mirrors the root hierarchy: bin/, lib/, share/, etc/. Nothing in</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-proc?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/proc</title>
        <link>https://yanevskiv.com/path-proc?rev=1781320400&amp;do=diff</link>
        <description>/proc

/proc is a virtual filesystem (procfs) with no backing storage on disk. Every file and directory in it is generated on the fly by the kernel when read. It is the primary interface for reading kernel state and per-process information from userspace, using ordinary</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-root?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/root</title>
        <link>https://yanevskiv.com/path-root?rev=1781320400&amp;do=diff</link>
        <description>/root

/root is the home directory of the root user (superuser). It is deliberately separate from /home — placing it directly on the root filesystem means it is available even if the /home partition fails to mount or does not exist. A sysadmin logging in for emergency recovery or single-user mode can always reach</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-sbin?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/sbin</title>
        <link>https://yanevskiv.com/path-sbin?rev=1781320400&amp;do=diff</link>
        <description>/sbin

/sbin holds system administration binaries: tools used to manage the machine that are typically run as root. The distinction from /bin is intent: /bin contains tools any user might need (ls, cat, cp), while /sbin contains tools for system configuration and maintenance (</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-srv?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/srv</title>
        <link>https://yanevskiv.com/path-srv?rev=1781320400&amp;do=diff</link>
        <description>/srv

/srv holds data that is served to the outside world by services running on this machine. The idea is to give web servers, FTP servers, and similar daemons a dedicated, clearly named location for their content, separate from system configuration in</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-tmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/tmp</title>
        <link>https://yanevskiv.com/path-tmp?rev=1781320400&amp;do=diff</link>
        <description>/tmp

/tmp is the system-wide directory for temporary files. Any process can create files here. The kernel cleans it on reboot; many distributions also run a periodic cleanup of files older than a few days. On most modern systems /tmp is a tmpfs mount, meaning it lives entirely in RAM (and swap) rather than on disk — writes to</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-usr?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/usr</title>
        <link>https://yanevskiv.com/path-usr?rev=1781320400&amp;do=diff</link>
        <description>/usr

/usr is the secondary hierarchy and holds the bulk of the system&#039;s installed software. On a fresh install the majority of disk space under / is consumed by /usr. It mirrors the top-level structure: /usr/bin for user binaries, /usr/lib for libraries,</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-var?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/var</title>
        <link>https://yanevskiv.com/path-var?rev=1781320400&amp;do=diff</link>
        <description>/var

/var holds variable data: files whose content grows and changes during normal system operation. Log files, mail spools, package manager caches, lock files, and runtime state all live here. Separating this from /usr (which is largely static after install) makes it practical to mount</description>
    </item>
    <item rdf:about="https://yanevskiv.com/pauli-gate-cudaq?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Pauli gates (CUDA-Q)</title>
        <link>https://yanevskiv.com/pauli-gate-cudaq?rev=1781320400&amp;do=diff</link>
        <description>Pauli gates (CUDA-Q)

Pauli gates implementation using CUDA-Q.


// Compile: nvq++ main.cpp -o main
// Run:     ./main

#include &lt;cudaq.h&gt;

struct apply_i { __qpu__ void operator()() { cudaq::qubit q;           mz(q); } };
struct apply_x { __qpu__ void operator()() { cudaq::qubit q; x(q);     mz(q); } };
struct apply_y { __qpu__ void operator()() { cudaq::qubit q; y(q);     mz(q); } };
struct apply_z { __qpu__ void operator()() { cudaq::qubit q; h(q); z(q); h(q); mz(q); } };

int main() {
    cu…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/pauli-gate-custatevec?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Pauli gates (cuStateVec)</title>
        <link>https://yanevskiv.com/pauli-gate-custatevec?rev=1781320400&amp;do=diff</link>
        <description>Pauli gates (cuStateVec)

Pauli gates implementation using cuStateVec.


// Compile: nvcc main.cu -o main -lcustatevec
// Run:     ./main

#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;cuda_runtime.h&gt;
#include &lt;custatevec.h&gt;

static void apply_and_print(custatevecHandle_t handle, cuDoubleComplex *d_sv,
                             cuDoubleComplex gate[4], const char *label) {
    cuDoubleComplex h_sv[2] = {{1,0},{0,0}};  // reset to |0&gt;
    cudaMemcpy(d_sv, h_sv, 2 * sizeof(cuDoubleComplex), cu…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/pauli-gate-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Pauli gates (Qiskit)</title>
        <link>https://yanevskiv.com/pauli-gate-qiskit?rev=1781320400&amp;do=diff</link>
        <description>Pauli gates (Qiskit)

Pauli gates implementation using Qiskit.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(4)
qc.id(0)  # |0&gt; -&gt; |0&gt;
qc.x(1)   # |0&gt; -&gt; |1&gt;
qc.y(2)   # |0&gt; -&gt; i|1&gt;
qc.h(3)
qc.z(3)   # |+&gt; -&gt; |-&gt;

for i, label in enumerate([&#039;I&#039;, &#039;X&#039;, &#039;Y&#039;, &#039;Z&#039;]):
    sub = QuantumCircuit(1)
    sub.append(qc.data[i].operation, [0])
    if label == &#039;Z&#039;:
        sub.h(0)
        sub.z(0)
    print(f&quot;{label}: {Statevector(sub)}&quot;)</description>
    </item>
    <item rdf:about="https://yanevskiv.com/pauli-gates?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Pauli gates</title>
        <link>https://yanevskiv.com/pauli-gates?rev=1781320400&amp;do=diff</link>
        <description>Pauli gates

Pauli gates are the four single-qubit gates $I$, $X$, $Y$, $Z$ corresponding to the identity and the three Pauli matrices. They form the basis of single-qubit quantum operations and appear throughout quantum error correction, where $X$, $Y$, and $Z$ represent the three fundamental error types a qubit can suffer.$$I = \begin{pmatrix}1 &amp; 0\\0 &amp; 1\end{pmatrix}\qquad
X = \begin{pmatrix}0 &amp; 1\\ 1 &amp; 0\end{pmatrix}\qquad
Y = \begin{pmatrix}0 &amp; -i \\ i &amp; 0\end{pmatrix}\qquad
Z = \begin{pmat…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/pdflatex?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>pdflatex</title>
        <link>https://yanevskiv.com/pdflatex?rev=1781320400&amp;do=diff</link>
        <description>pdflatex

pdflatex is the most common LaTeX compiler.

You compile latex source code by running pdflatex main.tex. This creates a PDF file main.pdf. It also creates a log file main.log and an auxiliary file main.aux used to build references. You can ignore these latter two and</description>
    </item>
    <item rdf:about="https://yanevskiv.com/perf?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>perf</title>
        <link>https://yanevskiv.com/perf?rev=1781320400&amp;do=diff</link>
        <description>perf

What is perf?

perf is a profiling and performance analysis tool built into the Linux kernel. It talks directly to the CPU&#039;s hardware performance monitoring unit (PMU) — a set of on-chip counters that can track things like retired instructions, cache misses, branch mispredictions, and stalled cycles — and lets you measure any of them against a running program.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/performance-model-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Performance model (MPI)</title>
        <link>https://yanevskiv.com/performance-model-mpi?rev=1781320400&amp;do=diff</link>
        <description>Performance model (MPI)

Every write() syscall has a fixed overhead regardless of how many bytes you write: there is a kernel crossing, buffer management, and bookkeeping before the first byte moves. For a local file the overhead is small relative to I/O cost, but over a network the per-message overhead can be much larger than the cost of moving the data itself. The $\alpha + \beta n$$\alpha$$\beta$$\alpha$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/persistent-communication-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Persistent communication (MPI)</title>
        <link>https://yanevskiv.com/persistent-communication-mpi?rev=1781320400&amp;do=diff</link>
        <description>Persistent communication (MPI)

HTTP/1.0 opened a new TCP connection for every request, paying a three-way handshake each time. HTTP/1.1 introduced keep-alive: one connection, many requests, the setup cost paid once. MPI persistent communication applies the same idea to message passing. In an iterative algorithm where the same process pair exchanges data every iteration with the same buffer and count — a halo exchange in a stencil code, for example —</description>
    </item>
    <item rdf:about="https://yanevskiv.com/playground?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title></title>
        <link>https://yanevskiv.com/playground?rev=1781320400&amp;do=diff</link>
        <description>\documentclass{standalone}

\begin{document}

\end{document}</description>
    </item>
    <item rdf:about="https://yanevskiv.com/plus-state-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert +\rangle$ (Qiskit)</title>
        <link>https://yanevskiv.com/plus-state-qiskit?rev=1781320400&amp;do=diff</link>
        <description>$\lvert +\rangle$ (Qiskit)

Plus state $\lvert +\rangle$ implementation using Qiskit. The $\lvert +\rangle$ state is prepared by applying a Hadamard gate to $\lvert 0\rangle$.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(1)
qc.h(0)  # |0&gt; -&gt; |+&gt; = (|0&gt; + |1&gt;) / sqrt(2)
print(Statevector(qc))
# Statevector([0.70710678+0.j, 0.70710678+0.j], dims=(2,))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/point-to-point-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Point-to-point communication (MPI)</title>
        <link>https://yanevskiv.com/point-to-point-mpi?rev=1781320400&amp;do=diff</link>
        <description>Point-to-point communication (MPI)

In a single-process C program, functions communicate through shared memory: one writes to a variable and another reads it. Across processes with separate address spaces — especially on different machines — that doesn&#039;t work. The low-level solution is sockets:</description>
    </item>
    <item rdf:about="https://yanevskiv.com/posix-headers?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>POSIX headers</title>
        <link>https://yanevskiv.com/posix-headers?rev=1781320400&amp;do=diff</link>
        <description>POSIX headers

POSIX headers are C programming language headers as defined by POSIX.

Links

	* &lt;https://pubs.opengroup.org/onlinepubs/9799919799/idx/head.html&gt;</description>
    </item>
    <item rdf:about="https://yanevskiv.com/pragma-once?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>#pragma once</title>
        <link>https://yanevskiv.com/pragma-once?rev=1781320400&amp;do=diff</link>
        <description>#pragma once

In C and C++ programming languages #pragma once is a non-standard preprocessor directive that is equivalent to header guards.

You just put #pragma once at the top, rather than wrapping the entire header within header guards.

Header guards:


// image.h
#ifndef __IMAGE_H__
#define __IMAGE_H__

struct Image {
    ...
};

#endif /* __IMAGE_H__ */</description>
    </item>
    <item rdf:about="https://yanevskiv.com/prefix-reductions-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Prefix reductions (MPI)</title>
        <link>https://yanevskiv.com/prefix-reductions-mpi?rev=1781320400&amp;do=diff</link>
        <description>Prefix reductions (MPI)

A prefix reduction (scan) turns an array of N values into N partial results, where each output element is the reduction of all input elements up to that index. The sequential exclusive prefix sum:


int offsets[N];
offsets[0] = 0;
for (int i = 1; i &lt; N; i++)
    offsets[i] = offsets[i-1] + counts[i-1];</description>
    </item>
    <item rdf:about="https://yanevskiv.com/probability-amplitude?rev=1781322581&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:49:41+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Probability amplitude</title>
        <link>https://yanevskiv.com/probability-amplitude?rev=1781322581&amp;do=diff</link>
        <description>Probability amplitude

Probability amplitude is a complex number associated with a possible outcome of a quantum measurement. The probability of that outcome is the squared modulus of the amplitude, a rule known as the Born rule.

Classical probability uses real numbers in $[0, 1]$$\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$$a$$b$$$P_0 = |a|^2 \qquad P_1 = |b|^2$$$$|a|^2 + |b|^2 = 1$$$n$$2^n$$\sum_x |c_x|^2 = 1$$\mathbb{C}^{2^n}$$c_1$$c_2$$|c_1 + c_2|^2$$|c_1|^2 + |c_2|^2$$\lvert 0\…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/probing-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Probing for messages (MPI)</title>
        <link>https://yanevskiv.com/probing-mpi?rev=1781320400&amp;do=diff</link>
        <description>Probing for messages (MPI)

A standard recv() on a socket requires a pre-allocated buffer. If the incoming message is larger than the buffer, data gets truncated or the call fails. The POSIX escape hatch is MSG_PEEK: pass it as a flag and recv() fills your buffer but leaves the data in the socket queue, letting you inspect the size before committing to a real receive.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/process-groups-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Process groups (MPI)</title>
        <link>https://yanevskiv.com/process-groups-mpi?rev=1781320400&amp;do=diff</link>
        <description>Process groups (MPI)

MPI_Comm_split partitions all processes by a color value, which works well when membership can be computed from a formula — even/odd rank, row and column in a grid. When the subset is defined by an explicit list of ranks with no clean formula,</description>
    </item>
    <item rdf:about="https://yanevskiv.com/production?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Production</title>
        <link>https://yanevskiv.com/production?rev=1781320400&amp;do=diff</link>
        <description>Production

Production is the live environment where software runs and serves real users. It is distinguished from development (a developer&#039;s local machine), staging (a production-like environment used for testing before release), and CI (the automated build environment).</description>
    </item>
    <item rdf:about="https://yanevskiv.com/prototype?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Prototype</title>
        <link>https://yanevskiv.com/prototype?rev=1781320400&amp;do=diff</link>
        <description>Prototype

A prototype in software engineering is a preliminary version of a system built to explore a design, validate an assumption, or demonstrate feasibility. It is intentionally incomplete and typically not intended for production use. The goal of a prototype is to reduce uncertainty before committing to a full implementation.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/pure-state?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Pure state</title>
        <link>https://yanevskiv.com/pure-state?rev=1781320400&amp;do=diff</link>
        <description>Pure state

Pure state is a quantum state that is completely described by a single state vector $\lvert\psi\rangle$. It carries the maximum possible information about a quantum system. When information about the system leaks into the environment the state becomes mixed — this process is called decoherence, and it is one of the primary challenges in quantum computing.$0\,\text{V}$$5\,\text{V}$$\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$$a$$b$$\lvert\psi\rangle$$\rho = \lvert\psi\rang…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/qaoa?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>QAOA</title>
        <link>https://yanevskiv.com/qaoa?rev=1781320400&amp;do=diff</link>
        <description>QAOA

QAOA (Quantum Approximate Optimization Algorithm) is a hybrid quantum-classical algorithm for combinatorial optimization problems. It was introduced by Edward Farhi, Jeffrey Goldstone, and Sam Gutmann in 2014 and is one of the leading candidates for near-term quantum advantage on $p$$(\boldsymbol\gamma, \boldsymbol\beta)$$\lvert s\rangle = H^{\otimes n}\lvert 0\rangle^{\otimes n}$$H_C$$H_B = \sum_i X_i$$p$$$\lvert\boldsymbol{\gamma},\boldsymbol{\beta}\rangle = e^{-i\beta_p H_B}e^{-i\gamma_…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/qft?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum Fourier transform</title>
        <link>https://yanevskiv.com/qft?rev=1781320400&amp;do=diff</link>
        <description>Quantum Fourier transform

Quantum Fourier transform (QFT) is the quantum analogue of the discrete Fourier transform (DFT). It maps a computational basis state $\lvert j\rangle$ to a superposition whose amplitudes encode the DFT of the input amplitudes, for $N = 2^n$ states on $n$$$\text{QFT}\lvert j\rangle = \frac{1}{\sqrt{N}}\sum_{k=0}^{N-1} e^{2\pi ijk/N}\lvert k\rangle$$$O(n^2)$$n$$O(N \log N) = O(n \cdot 2^n)$$n$$n(n+1)/2$$$R_k = P\!\left(\frac{2\pi}{2^k}\right) = \begin{pmatrix}1 &amp; 0 \\ 0 …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/qpe?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum phase estimation</title>
        <link>https://yanevskiv.com/qpe?rev=1781320400&amp;do=diff</link>
        <description>Quantum phase estimation

Quantum phase estimation (QPE) is a quantum algorithm that estimates the eigenvalue phase $\phi$ of a unitary operator $U$ given access to an eigenstate $\lvert u\rangle$ of $U$. It is one of the most important subroutines in quantum computing, used as a building block in $U\lvert u\rangle = e^{2\pi i\phi}\lvert u\rangle$$\phi \in [0,1)$$\phi$$n$$n$$O(2^n)$$U$$n$$\lvert 0\rangle^{\otimes n}$$\lvert u\rangle$$n$$U^{2^k}$$k = 0, 1, \ldots, n-1$$k$$U^{2^k}$$$\lvert 0\rangl…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-algorithm?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum algorithm</title>
        <link>https://yanevskiv.com/quantum-algorithm?rev=1781320400&amp;do=diff</link>
        <description>Quantum algorithm

Quantum algorithm is an algorithm designed to run on a quantum computer, exploiting quantum phenomena such as superposition, entanglement, and interference to solve certain problems faster than any known classical algorithm. Quantum algorithms are expressed as sequences of quantum gates applied to a quantum register, followed by measurements.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-circuit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum circuit</title>
        <link>https://yanevskiv.com/quantum-circuit?rev=1781320400&amp;do=diff</link>
        <description>Quantum circuit

Quantum circuit is a model of quantum computation in which a sequence of quantum gates is applied to a quantum register. Quantum circuits are the quantum analogue of classical digital circuits, but instead of Boolean logic gates acting on bits they use unitary matrices acting on qubits.$\lvert 0\rangle^{\otimes n}$$d$$n$$nd$$\{H, T, \text{CX}\}$$\varepsilon$$O(\text{polylog}(1/\varepsilon))$$\lvert 0\rangle$$\lvert 1\rangle$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-computing?rev=1781515121&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T09:18:41+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum computing</title>
        <link>https://yanevskiv.com/quantum-computing?rev=1781515121&amp;do=diff</link>
        <description>Quantum computing

Quantum computing is a model of computation that uses quantum-mechanical systems to store and process information. The fundamental unit is the Qubit, the quantum analog of a classical bit. A classical bit is either 0 or 1 at any given moment. A qubit can be in a superposition of both — and multiple qubits can be entangled, meaning their states are correlated in ways that have no classical analog. Those two properties, superposition and entanglement, are the source of quantum c…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-dummy-text?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum concepts</title>
        <link>https://yanevskiv.com/quantum-dummy-text?rev=1781320400&amp;do=diff</link>
        <description>Quantum concepts

A Qubit lives in a two-dimensional complex Hilbert space $\mathbb{C}^2$. You write its state in Dirac notation as $\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$, where $a$ and $b$ are complex numbers called probability amplitudes, constrained by $|a|^2 + |b|^2 = 1$. The two basis states $\lvert 0\rangle$ and $\lvert 1\rangle$ are the quantum analogs of classical 0 and 1, but before any measurement the qubit genuinely occupies both at once — the amplitudes are not a d…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-error-correction?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum error correction</title>
        <link>https://yanevskiv.com/quantum-error-correction?rev=1781320400&amp;do=diff</link>
        <description>Quantum error correction

Quantum error correction (QEC) is the set of techniques used to protect quantum information from errors caused by decoherence and imperfect gates. Unlike classical bits, which can be copied and checked against redundant copies, quantum states cannot be cloned — any measurement collapses the state. QEC works around this by encoding a single logical qubit into an entangled state of several physical qubits, allowing errors to be detected and corrected without learning anyt…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum gate</title>
        <link>https://yanevskiv.com/quantum-gate?rev=1781320400&amp;do=diff</link>
        <description>Quantum gate

A quantum gate is a unitary operation applied to one or more qubits. It is the quantum computing analog of a classical logic gate, but with two key differences: quantum gates are represented by matrices rather than truth tables, and they are always reversible — every quantum gate has an inverse.$n$$2^n \times 2^n$$U$$U^\dagger U = I$$\lvert\psi\rangle$$U\lvert\psi\rangle$$U$$U^\dagger$$2 \times 2$$U(\theta, \phi, \lambda)$$4 \times 4$$n$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-register?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum register</title>
        <link>https://yanevskiv.com/quantum-register?rev=1781320400&amp;do=diff</link>
        <description>Quantum register

Quantum register is a register made out of qubits. It is the quantum equivalent of a classical CPU register.

Classical CPU regsiters are made out of bits and are used to store number values. For example, a classical 16-bit register, like Intel 8086&#039;s $c = \frac{1}{\sqrt 2}(1 + i)$$|c_{63}|^2 = 0.75$$63$$\lvert\text{Qreg}\rangle$$\lvert\cdot\rangle$$$\begin{aligned}
\lvert\text{Qreg}\rangle
= \sum_{k = 0}^{k = 2^{16} - 1} c_k\lvert k\rangle
= (x_0 + i y_0)\lvert\text{0}\rangle …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-state?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum state</title>
        <link>https://yanevskiv.com/quantum-state?rev=1781320400&amp;do=diff</link>
        <description>Quantum state

A quantum state is a complete mathematical description of a quantum system. For a single qubit, a quantum state is a unit vector in a two-dimensional complex Hilbert space; for $n$ qubits, the state lives in a $2^n$-dimensional space formed by the tensor product of the individual qubit spaces.$\lvert\psi\rangle = \alpha\lvert 0\rangle + \beta\lvert 1\rangle$$\alpha, \beta \in \CC$$|\alpha|^2 + |\beta|^2 = 1$$|\alpha|^2$$|\beta|^2$$\lvert 0\rangle$$\lvert 1\rangle$$\rho$$\lvert 0\r…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/qubit-gates-in-c?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Qubit gate</title>
        <link>https://yanevskiv.com/qubit-gates-in-c?rev=1781320400&amp;do=diff</link>
        <description>Qubit gate

Simulation

In C99, a header &lt;complex.h&gt; is provided that implements complex numbers.

State

As we&#039;ve seen, a qubit is a two-state configuration with complex probability amplitudes distributed between the two states.
This gives us the following implementation of a single qubit:
$$\lvert\psi\rangle = \alpha\lvert 0\rangle + \beta\lvert 1\rangle,\qquad \alpha,\beta\in\mathbb C$$$$\lVert\psi\lVert^2 = |\alpha|^2 + |\beta|^2 = \alpha\bar{\alpha} + \beta\bar{\beta}$$$$\lvert\psi\rangle\r…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/qubit?rev=1781322406&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:46:46+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Qubit</title>
        <link>https://yanevskiv.com/qubit?rev=1781322406&amp;do=diff</link>
        <description>Qubit

Qubit (or quantum bit) is the basic unit of quantum information. The Hilbert space of a single qubit is $\mathbb{C}^2$, meaning two complex amplitudes to describe it, not one.

A classical bit can only be 0 or 1. A qubit can be in a superposition: a combination of $\lvert 0\rangle$$\lvert 1\rangle$$$\lvert\psi\rangle = \begin{pmatrix}a\\b\end{pmatrix} = a\underbrace{\begin{pmatrix}1\\ 0\end{pmatrix}}_{\lvert 0\rangle} + b\underbrace{\begin{pmatrix}0\\1\end{pmatrix}}_{\lvert 1\rangle} = a\…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/queue?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Queue</title>
        <link>https://yanevskiv.com/queue?rev=1781320400&amp;do=diff</link>
        <description>Queue

A queue is a first-in, first-out (FIFO) sequence.

Elements are added at the back (enqueue) and removed from the front (dequeue). A queue can be implemented over a Linked list with a head and tail pointer, over a Circular buffer for a bounded version, or as a lock-free queue for concurrent use.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/r-gate-cudaq?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rotation gates (CUDA-Q)</title>
        <link>https://yanevskiv.com/r-gate-cudaq?rev=1781320400&amp;do=diff</link>
        <description>Rotation gates (CUDA-Q)

Rotation gates implementation using CUDA-Q. The example applies $R_x(\pi/2)$ to $\lvert 0\rangle$, producing $\frac{1}{\sqrt{2}}(\lvert 0\rangle - i\lvert 1\rangle)$.


// Compile: nvq++ main.cpp -o main
// Run:     ./main

#include &lt;cudaq.h&gt;
#include &lt;cmath&gt;

struct kernel {
    __qpu__ void operator()() {
        cudaq::qubit q;
        rx(M_PI / 2.0, q);  // R_x(pi/2) on |0&gt;
        mz(q);
    }
};

int main() {
    auto counts = cudaq::sample(kernel{});
    counts.du…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/r-gate-custatevec?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rotation gates (cuStateVec)</title>
        <link>https://yanevskiv.com/r-gate-custatevec?rev=1781320400&amp;do=diff</link>
        <description>Rotation gates (cuStateVec)

Rotation gates implementation using cuStateVec. The example applies $R_x(\pi/2)$ to $\lvert 0\rangle$, producing $\frac{1}{\sqrt{2}}(\lvert 0\rangle - i\lvert 1\rangle)$.


// Compile: nvcc main.cu -o main -lcustatevec
// Run:     ./main

#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;cuda_runtime.h&gt;
#include &lt;custatevec.h&gt;

int main() {
    const int nQubits = 1;
    const int dim = 1 &lt;&lt; nQubits;

    cuDoubleComplex h_sv[2] = {{1,0},{0,0}};  // |0&gt;
    cuDoubleComp…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/r-gate-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rotation gates (Qiskit)</title>
        <link>https://yanevskiv.com/r-gate-qiskit?rev=1781320400&amp;do=diff</link>
        <description>Rotation gates (Qiskit)

Rotation gates implementation using Qiskit. The example applies $R_x(\pi/2)$ to $\lvert 0\rangle$, producing $\frac{1}{\sqrt{2}}(\lvert 0\rangle - i\lvert 1\rangle)$.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
import numpy as np

qc = QuantumCircuit(1)
qc.rx(np.pi / 2, 0)  # R_x(pi/2) on |0&gt;
print(Statevector(qc))
# Statevector([0.70710678+0.j, 0.        -0.70710678j], dims=(2,))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/rabi-cycles?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rabi oscillations</title>
        <link>https://yanevskiv.com/rabi-cycles?rev=1781320400&amp;do=diff</link>
        <description>Rabi oscillations

Rabi oscillations (or Rabi cycles) are periodic oscillations in the state of a driven two-level quantum system. When a qubit is driven by a resonant electromagnetic field, its population continuously oscillates between $\lvert 0\rangle$ and $\lvert 1\rangle$ at the Rabi frequency $\Omega$$\omega = \omega_0$$\omega_0$$\Omega$$\lvert 1\rangle$$\lvert 0\rangle$$$P_1(t) = \sin^2\!\left(\frac{\Omega t}{2}\right), \qquad P_0(t) = \cos^2\!\left(\frac{\Omega t}{2}\right)$$$\lvert 0\ra…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ramsey-interference?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Ramsey interferometry</title>
        <link>https://yanevskiv.com/ramsey-interference?rev=1781320400&amp;do=diff</link>
        <description>Ramsey interferometry

Ramsey interferometry is a technique for measuring the transition frequency of a quantum system with very high precision using two separated pulses. It was developed by Norman Ramsey in 1950 as an improvement on Rabi&#039;s continuous-drive spectroscopy, and it forms the basis of modern atomic clocks and qubit frequency calibration.$\pi/2$$T$$\pi/2$$\lvert +\rangle$$\lvert 0\rangle$$T$$\delta T$$\delta = \omega - \omega_0$$\omega$$\omega_0$$\pi/2$$$P_1(T) = \frac{1}{2}(1 - \cos…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/red-black-tree?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Red-black tree</title>
        <link>https://yanevskiv.com/red-black-tree?rev=1781320400&amp;do=diff</link>
        <description>Red-black tree

A red-black tree is a self-balancing binary search tree that maintains O(log n) height through a set of colour invariants enforced on every insert and delete. Each node is coloured red or black, and the invariants constrain how colours can be arranged: the root is black, red nodes can only have black children, and every path from any node to a descendant NULL leaf passes through the same number of black nodes. These rules together bound the height to at most $2 \log_2(n+1)$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/reduction-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Reduction (MPI)</title>
        <link>https://yanevskiv.com/reduction-mpi?rev=1781320400&amp;do=diff</link>
        <description>Reduction (MPI)

A reduction combines all elements of a collection into a single value using an associative operator. In sequential C, that is a loop:


double sum = 0.0;
for (int i = 0; i &lt; N; i++)
    sum += arr[i];


In a parallel program, each process holds a different slice of the data and computes a partial result. To get the global value, those partial results need to be combined.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/reduction-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Reduction (OpenMP)</title>
        <link>https://yanevskiv.com/reduction-openmp?rev=1781320400&amp;do=diff</link>
        <description>Reduction (OpenMP)

Summing an array in serial C is a straightforward accumulation loop:


double sum = 0.0;
for (int i = 0; i &lt; N; i++)
    sum += a[i];


Adding #pragma omp parallel for to this loop creates a race condition: multiple threads read sum</description>
    </item>
    <item rdf:about="https://yanevskiv.com/regression?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Regression</title>
        <link>https://yanevskiv.com/regression?rev=1781320400&amp;do=diff</link>
        <description>Regression

A regression is a bug that was not present in a previous version of the software and was introduced by a subsequent change. The term comes from the Latin regressus (going back): something that previously worked has gone back to being broken.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/rho-zero?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\rho_0$ (Zero state density matrix)</title>
        <link>https://yanevskiv.com/rho-zero?rev=1781320400&amp;do=diff</link>
        <description>$\rho_0$ (Zero state density matrix)

 is the density matrix of the zero state. As a pure state its density matrix carries no more information than the ket, but the density matrix representation is the right starting point for studying what happens to $\lvert 0\rangle$ when it couples to an environment — when the ket description breaks down.$$\rho_0 = \lvert 0\rangle\langle 0\rvert = \begin{pmatrix}1\\0\end{pmatrix}\begin{pmatrix}1 &amp; 0\end{pmatrix} = \begin{pmatrix}1 &amp; 0\\0 &amp; 0\end{pmatrix}$$$\l…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/roofline-model?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Roofline model</title>
        <link>https://yanevskiv.com/roofline-model?rev=1781320400&amp;do=diff</link>
        <description>Roofline model

The roofline model is a visual performance model that tells you whether a kernel is limited by compute throughput or memory bandwidth. It was introduced by Williams, Waterman, and Patterson in 2009. The model gives you a single number to characterize a kernel — its $$\text{AI} = \frac{\text{FLOP}}{\text{bytes transferred}}$$$\Pi$$\beta$$$P \leq \min\!\left(\Pi,\ \beta \cdot \text{AI}\right)$$$x$$y$$\beta$$\Pi$$$\text{AI}_{\text{ridge}} = \frac{\Pi}{\beta}$$$\mathbf{y} \leftarrow …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/rotation-gates?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rotation gates</title>
        <link>https://yanevskiv.com/rotation-gates?rev=1781320400&amp;do=diff</link>
        <description>Rotation gates

Rotation gates $R_x(\theta)$, $R_y(\theta)$, $R_z(\theta)$ are single-qubit gates that rotate the Bloch vector by angle $\theta$ about the $x$-, $y$-, and $z$-axes respectively. They are defined via the matrix exponential of the corresponding Pauli matrices:

$$R_x(\theta) = e^{-i\theta X/2} \qquad R_y(\theta) = e^{-i\theta Y/2} \qquad R_z(\theta) = e^{-i\theta Z/2}$$

Matrix form

Using $e^{-i\theta P/2} = \cos(\theta/2)I - i\sin(\theta/2)P$ (which follows from $P^2 = I$ for any…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ruin-theory?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Ruin theory (personal finance)</title>
        <link>https://yanevskiv.com/ruin-theory?rev=1781320400&amp;do=diff</link>
        <description>Ruin theory (personal finance)

This article is supposed to illustrate using Cramer-Lundberg model from actuarial science and applying to personal finance. This model was invented in 1930s for insurance companies. Insurance companies never seem to go bankrupt yet ordinary people are often get financial struggles. While it&#039;s easy to blame insurance companies for cheating at the game and ripping us off (and there is certainly a lot of truth to that), perhaps we can also learn the game they&#039;re play…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/rule-of-5?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rule of 5</title>
        <link>https://yanevskiv.com/rule-of-5?rev=1781320400&amp;do=diff</link>
        <description>Rule of 5

In C++, rule of 5

	* Destructor
* Copy constructor
* Move constructor
* Copy assignment operator
* Move assignment operator


#pragma once

struct Image {
public:
    Image();
    /* Todo */
};


Links

	* &lt;https://en.cppreference.com/w/cpp/language/rule_of_three.html&gt;</description>
    </item>
    <item rdf:about="https://yanevskiv.com/rwa?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rotating wave approximation</title>
        <link>https://yanevskiv.com/rwa?rev=1781320400&amp;do=diff</link>
        <description>Rotating wave approximation

Rotating wave approximation (RWA) is an approximation in quantum optics and quantum control that simplifies the Hamiltonian of a driven quantum system by discarding rapidly oscillating terms. It reduces the full time-dependent driven Hamiltonian to a simpler time-independent one in the rotating frame, making $\omega_0$$\omega$$\delta = \omega - \omega_0$$\omega + \omega_0$$\omega$$\rho \to e^{i\omega t Z/2}\rho e^{-i\omega t Z/2}$$$H_{\text{RWA}} = \frac{\hbar}{2}\be…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/rx-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rotation-X gate</title>
        <link>https://yanevskiv.com/rx-gate?rev=1781320400&amp;do=diff</link>
        <description>Rotation-X gate

 gate rotates a qubit by angle $\theta$ about the $x$-axis of the Bloch sphere. It is one of the three rotation gates and is defined as the matrix exponential of the Pauli-X operator:

$$R_x(\theta) = e^{-i\theta X/2} = \begin{pmatrix}\cos\dfrac{\theta}{2} &amp; -i\sin\dfrac{\theta}{2}\\[6pt] -i\sin\dfrac{\theta}{2} &amp; \cos\dfrac{\theta}{2}\end{pmatrix}$$

Applied to the computational basis states:

$$R_x(\theta)\lvert 0\rangle = \cos\tfrac{\theta}{2}\lvert 0\rangle - i\sin\tfrac{\th…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ry-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rotation-Y gate</title>
        <link>https://yanevskiv.com/ry-gate?rev=1781320400&amp;do=diff</link>
        <description>Rotation-Y gate

 gate rotates a qubit by angle $\theta$ about the $y$-axis of the Bloch sphere. It is one of the three rotation gates and is defined as the matrix exponential of the Pauli-Y operator:

$$R_y(\theta) = e^{-i\theta Y/2} = \begin{pmatrix}\cos\dfrac{\theta}{2} &amp; -\sin\dfrac{\theta}{2}\\[6pt] \sin\dfrac{\theta}{2} &amp; \cos\dfrac{\theta}{2}\end{pmatrix}$$

Applied to the computational basis states:

$$R_y(\theta)\lvert 0\rangle = \cos\tfrac{\theta}{2}\lvert 0\rangle + \sin\tfrac{\theta}…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/rz-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rotation-Z gate</title>
        <link>https://yanevskiv.com/rz-gate?rev=1781320400&amp;do=diff</link>
        <description>Rotation-Z gate

 gate rotates a qubit by angle $\theta$ about the $z$-axis of the Bloch sphere. It is one of the three rotation gates and is defined as the matrix exponential of the Pauli-Z operator:

$$R_z(\theta) = e^{-i\theta Z/2} = \begin{pmatrix}e^{-i\theta/2} &amp; 0\\[6pt] 0 &amp; e^{i\theta/2}\end{pmatrix}$$

Applied to the computational basis states:

$$R_z(\theta)\lvert 0\rangle = e^{-i\theta/2}\lvert 0\rangle \qquad R_z(\theta)\lvert 1\rangle = e^{i\theta/2}\lvert 1\rangle$$

The gate is dia…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/s-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>S gate</title>
        <link>https://yanevskiv.com/s-gate?rev=1781320400&amp;do=diff</link>
        <description>S gate

S gate (or  gate) is a single-qubit gate that adds a phase of $\pi/2$ to the $\lvert 1\rangle$ state while leaving $\lvert 0\rangle$ unchanged. It is a special case of the phase gate with $\phi = \pi/2$, and satisfies $S^2 = Z$.

$$S = \begin{pmatrix}1 &amp; 0\\ 0 &amp; i\end{pmatrix}$$

On the computational basis, $S\lvert 0\rangle = \lvert 0\rangle$ and $S\lvert 1\rangle = i\lvert 1\rangle$. On the Bloch sphere, $S$ is a $\pi/2$ rotation about the $z$-axis; it maps $\lvert +\rangle$$\lvert +i\…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/saxpy?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>SAXPY</title>
        <link>https://yanevskiv.com/saxpy?rev=1781320400&amp;do=diff</link>
        <description>SAXPY

SAXPY is an algorithm in high-performance computing (HPC).

Math

Vectors

Let $\mathbf{y}^{(t)}, \mathbf{x}^{(t)}\in\mathbb{R}^n$ be vectors over real numbers at some discrete time $t\in\mathbb{N}$ and let $a\in\mathbb{R}$ be a real parameter.

SAXPY is defined as a vector update of $\mathbf{y}$ at time $t+1$ according to the formula:

$$\mathbf{y}^{(t+1)} = a\mathbf{x}^{(t)} + \mathbf{y}^{(t)}$$

Elements
$\mathbf{y}^{(t)} = (y_0^{(t)}, y_1^{(t)}, \dots, y_n^{(t)})$$\mathbf{x}^{(t)} = (…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/scatter-and-gather-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Scatter and gather (MPI)</title>
        <link>https://yanevskiv.com/scatter-and-gather-mpi?rev=1781320400&amp;do=diff</link>
        <description>Scatter and gather (MPI)

The basic pattern for distributing work is: rank 0 holds the full dataset, divides it into N equal chunks, and sends one to each process. Without collectives, that is a loop of sends:


if (rank == 0)
    for (int i = 0; i &lt; size; i++)
        MPI_Send(&amp;data[i * chunk], chunk, MPI_INT, i, 0, MPI_COMM_WORLD);
else
    MPI_Recv(local, chunk, MPI_INT, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);</description>
    </item>
    <item rdf:about="https://yanevskiv.com/scheduling-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Scheduling (OpenMP)</title>
        <link>https://yanevskiv.com/scheduling-openmp?rev=1781320400&amp;do=diff</link>
        <description>Scheduling (OpenMP)

Scheduling in OpenMP controls how loop iterations are divided among threads. By default, parallel for splits iterations into roughly equal static chunks assigned to threads upfront. This works well when each iteration takes the same time. When iteration cost varies, static assignment leaves some threads idle while others are still running. A loop where some values of</description>
    </item>
    <item rdf:about="https://yanevskiv.com/schrodinger-equation-qutip?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Schrödinger equation (QuTiP)</title>
        <link>https://yanevskiv.com/schrodinger-equation-qutip?rev=1781320400&amp;do=diff</link>
        <description>Schrödinger equation (QuTiP)

Schrödinger equation implementation using QuTiP.

QuTiP&#039;s sesolve() (schrödinger equation solver) integrates the equation directly in state-vector form. It takes the Hamiltonian H, an initial ket psi0, and a time array tlist, then returns a list of ket vectors $\lvert\psi(t)\rangle$$$i\hbar\frac{\mathrm{d}}{\mathrm{d}t}\lvert\psi\rangle = H\lvert\psi\rangle$$$\langle O\rangle = \langle\psi(t)\lvert O\lvert\psi(t)\rangle$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/schrodinger-equation?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Schrödinger equation</title>
        <link>https://yanevskiv.com/schrodinger-equation?rev=1781320400&amp;do=diff</link>
        <description>Schrödinger equation

The Schrödinger equation is the equation of motion for a quantum state. In the qubit picture the state is a complex vector $\lvert\psi\rangle$ in a Hilbert space, and the equation is a first-order linear ODE on that vector. The generator of the evolution is a Hermitian operator $H$$$i\hbar\frac{\mathrm{d}}{\mathrm{d}t}\lvert\psi\rangle = H\lvert\psi\rangle$$$\lvert\psi\rangle$$t + dt$$t$$$\lvert\psi(t+dt)\rangle = U(t+dt,\,t)\,\lvert\psi(t)\rangle$$$dt$$U(t,t) = I$$U(t+dt, …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/sections-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Sections (OpenMP)</title>
        <link>https://yanevskiv.com/sections-openmp?rev=1781320400&amp;do=diff</link>
        <description>Sections (OpenMP)

Suppose you have a few independent operations — compress a buffer, encrypt a header, write a log — that share no data and could run simultaneously. A loop doesn&#039;t fit because the operations are distinct, not iterations of the same work.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/semaphore?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Semaphore</title>
        <link>https://yanevskiv.com/semaphore?rev=1781320400&amp;do=diff</link>
        <description>Semaphore

Semaphore is a synchronization primitive. It&#039;s used to control thread execution in multithreaded environments.

A semaphore acts like an integer. An integer supports two well-known opeartions: increment i++ and decrement i--. A semaphore works in a similar way, except a semaphore cannot be decremented below zero. This is because semaphore takes action to protect its value against bankrupcy by taking hostage of threads that attempt to make it negative.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/send-modes-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Send modes (MPI)</title>
        <link>https://yanevskiv.com/send-modes-mpi?rev=1781320400&amp;do=diff</link>
        <description>Send modes (MPI)

MPI_Send has a behaviour that surprises many first-time users: whether it blocks or returns immediately depends on message size and the implementation&#039;s internal buffer. For small messages, most implementations copy the data into an internal buffer and return right away. For messages larger than that buffer,</description>
    </item>
    <item rdf:about="https://yanevskiv.com/setjmp.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>setjmp.h</title>
        <link>https://yanevskiv.com/setjmp.h?rev=1781320400&amp;do=diff</link>
        <description>setjmp.h

setjmp.h provides setjmp and longjmp: a mechanism for jumping directly from a function back to an earlier point in the call stack, bypassing all the normal return chain in between. It is the C equivalent of throwing an exception that is caught several frames up — but without any of C++&#039;s object cleanup machinery, which makes it both simpler and more dangerous.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/shared-memory-windows-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Shared memory windows (MPI)</title>
        <link>https://yanevskiv.com/shared-memory-windows-mpi?rev=1781320400&amp;do=diff</link>
        <description>Shared memory windows (MPI)

On a multi-core node, MPI processes communicate through the messaging layer by default, even when they share the same physical memory. A send between two processes on the same node still involves serialisation overhead and memory copies that shared memory would avoid.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/shell?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Shell</title>
        <link>https://yanevskiv.com/shell?rev=1781320400&amp;do=diff</link>
        <description>Shell

What is a shell?

Shell is a program that lets you to run other programs in the terminal. 

Shell allows you to pass command line arguments, set environment variables and redirect the program&#039;s stardard input / output / error. It allows you to chain programs, such that output from one program is redirected as input to another program. It also allows you to run the programs in the background. Basically, a shell allows you to easily orchestrate programs in the terminal.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/shor?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Shor&#039;s algorithm</title>
        <link>https://yanevskiv.com/shor?rev=1781320400&amp;do=diff</link>
        <description>Shor&#039;s algorithm

Shor&#039;s algorithm is a quantum algorithm that factors large integers in polynomial time. It was invented by Peter Shor in 1994 and is one of the most consequential results in quantum computing, because it would break the RSA public-key cryptosystem if run on a sufficiently large fault-tolerant quantum computer.$O(e^{O(n^{1/3}\log^{2/3} n)})$$n$$O(n^3)$$O(n)$$N$$a$$\gcd(a, N) = 1$$r$$a^r \equiv 1 \pmod{N}$$r$$a^{r/2} \not\equiv -1 \pmod{N}$$\gcd(a^{r/2} \pm 1, N)$$N$$1/2$$x \in \…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/signal.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>signal.h</title>
        <link>https://yanevskiv.com/signal.h?rev=1781320400&amp;do=diff</link>
        <description>signal.h

signal.h is how your program hears from the OS when something happens outside its normal execution: the user pressed Ctrl-C, a timer expired, you divided by zero, or another process sent you a notification. Signals are asynchronous — they can arrive between any two instructions — which makes them tricky to handle correctly.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/simd-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>SIMD (OpenMP)</title>
        <link>https://yanevskiv.com/simd-openmp?rev=1781320400&amp;do=diff</link>
        <description>SIMD (OpenMP)

A modern CPU can add four floats in a single instruction rather than one, loading them into a wide register and operating on all four lanes simultaneously. This is SIMD (single instruction, multiple data), exposed on x86 as SSE/AVX and on ARM as NEON. The compiler attempts to use these instructions automatically (auto-vectorisation), but it can be blocked by pointer aliasing, non-unit strides, or conditionals it cannot prove safe.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/single-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Single (OpenMP)</title>
        <link>https://yanevskiv.com/single-openmp?rev=1781320400&amp;do=diff</link>
        <description>Single (OpenMP)

Single is an OpenMP directive that runs the enclosed block on exactly one thread, whichever arrives first. All other threads skip the block and wait at an implicit barrier at the end, so the whole team is synchronised before continuing. It is commonly used for initialisation, I/O, and task generation.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/single-qubit-gates?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Qubit gates</title>
        <link>https://yanevskiv.com/single-qubit-gates?rev=1781320400&amp;do=diff</link>
        <description>Qubit gates

Qubit gates (single-qubit gates) are $2 \times 2$ unitary matrices that act on a single Qubit. Every such gate corresponds to a rotation on the Bloch sphere. The most general single-qubit gate (up to global phase) is the U gate $U(\theta, \phi, \lambda)$, which spans all of $SU(2)$; every named single-qubit gate is a special case of it.$I$$X$$Y$$Z$$\pi$$x$$y$$z$$X$$\lvert 0\rangle \leftrightarrow \lvert 1\rangle$$Z$$\lvert 0\rangle$$\lvert 1\rangle$$Y = iXZ$$X^2 = Y^2 = Z^2 = I$$Z$$…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/smart-and-vapid?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Smart-and-gets-things-done</title>
        <link>https://yanevskiv.com/smart-and-vapid?rev=1781320400&amp;do=diff</link>
        <description>Smart-and-gets-things-done

Smart-and-gets-things-done is a hiring heuristic from Joel Spolsky&#039;s 2000 essay “The Guerrilla Guide to Interviewing”. Spolsky argued that the only two things that matter when hiring a software developer are whether they are smart and whether they actually get things done. All other interview criteria are either proxies for these two properties or irrelevant.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/solid?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>SOLID</title>
        <link>https://yanevskiv.com/solid?rev=1781320400&amp;do=diff</link>
        <description>SOLID

SOLID is a set of five object-oriented design principles intended to make code more understandable, maintainable, and extensible. The acronym was coined by Robert C. Martin (Uncle Bob).

S — Single responsibility principle

A class should have only one reason to change. In practice: a class that handles both data persistence and business logic is harder to change than one that does only persistence. When the database schema changes and the business rules change, they change independently,…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/spike-solution?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Spike solution</title>
        <link>https://yanevskiv.com/spike-solution?rev=1781320400&amp;do=diff</link>
        <description>Spike solution

A spike solution is a short, throwaway experiment written to explore a technical question or reduce uncertainty. The name comes from Extreme programming: Kent Beck used “spike” to mean driving something sharply through a problem to understand it, the way you drive a spike through wood to test the material.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ssh?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>ssh</title>
        <link>https://yanevskiv.com/ssh?rev=1781320400&amp;do=diff</link>
        <description>ssh

What is ssh?

SSH (Secure shell) is a tool that allows you to remotely control another computer from your own. 

Login without password

On the client, you should run the following command:



ssh-keyring


This command is going to generate two files in your</description>
    </item>
    <item rdf:about="https://yanevskiv.com/stack?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Stack</title>
        <link>https://yanevskiv.com/stack?rev=1781320400&amp;do=diff</link>
        <description>Stack

A stack is a last-in, first-out (LIFO) sequence. The only accessible element is the top; you push to add and pop to remove, always at the same end. A stack can be implemented over an Array (with a top index) or a Linked list (with insertions at the head). The array-backed version is more cache-friendly; the linked version avoids a fixed capacity.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/state-vector?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>State vector</title>
        <link>https://yanevskiv.com/state-vector?rev=1781320400&amp;do=diff</link>
        <description>State vector

State vector (written as ket $\lvert\psi\rangle$) is the vector representation of a quantum state.

Quantum state is often written as a linear combination of basis states where the coefficients are  probability amplitudes. For example, a qubit is often written in the following way using Dirac notation.$$\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$$$\mathbb{C}^2$$\mathbb{C}^2$$\lvert\psi\rangle$$\mathbb{C}^2$$$\lvert\psi\rangle = \begin{pmatrix}a\\b\end{pmatrix}\qquad a,…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/stdalign.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>stdalign.h</title>
        <link>https://yanevskiv.com/stdalign.h?rev=1781320400&amp;do=diff</link>
        <description>stdalign.h

stdalign.h (C11) gives you alignas and alignof — the convenient macro wrappers around the _Alignas and _Alignof keywords. Alignment controls where in memory an object is placed: a 16-byte-aligned object must start at an address divisible by 16. You need this most often for SIMD, where vector load instructions require specific alignment, and occasionally for hardware registers.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/stdarg.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>stdarg.h</title>
        <link>https://yanevskiv.com/stdarg.h?rev=1781320400&amp;do=diff</link>
        <description>stdarg.h

stdarg.h provides the machinery for writing variadic functions — functions that accept a variable number of arguments, like printf. Without it you would have no portable way to iterate over the unnamed arguments. It defines va_list, and the</description>
    </item>
    <item rdf:about="https://yanevskiv.com/stdatomic.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>stdatomic.h</title>
        <link>https://yanevskiv.com/stdatomic.h?rev=1781320400&amp;do=diff</link>
        <description>stdatomic.h

stdatomic.h (C11) gives you atomic types and operations for lock-free concurrent programming. An atomic operation completes without interruption: no other thread can observe the object in a half-updated state. This is the C standard&#039;s portable answer to compiler-specific builtins like</description>
    </item>
    <item rdf:about="https://yanevskiv.com/stdbit.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>stdbit.h</title>
        <link>https://yanevskiv.com/stdbit.h?rev=1781320400&amp;do=diff</link>
        <description>stdbit.h

Before C23, if you wanted to count the leading zeros in an integer or compute its population count, you either reached for GCC&#039;s __builtin_clz and __builtin_popcount, wrote a loop, or pulled in a platform-specific intrinsic. None of these were portable.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/stdbool.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>stdbool.h</title>
        <link>https://yanevskiv.com/stdbool.h?rev=1781320400&amp;do=diff</link>
        <description>stdbool.h

Before C99, every codebase had its own boolean convention. Some used int with 0 for false and non-zero for true, some #defined TRUE and FALSE, some used char. stdbool.h (C99) ends that by giving portable names to the convention the language already used:</description>
    </item>
    <item rdf:about="https://yanevskiv.com/stdckdint.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>stdckdint.h</title>
        <link>https://yanevskiv.com/stdckdint.h?rev=1781320400&amp;do=diff</link>
        <description>stdckdint.h

Signed integer overflow in C is undefined behaviour. Unsigned overflow wraps silently. Both have caused real security bugs — length calculations that overflow and produce a smaller allocation than expected, counters that wrap around to zero.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/stddef.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>stddef.h</title>
        <link>https://yanevskiv.com/stddef.h?rev=1781320400&amp;do=diff</link>
        <description>stddef.h

size_t, NULL, offsetof — you have seen these in practically every C codebase. They all come from stddef.h, which defines the handful of fundamental types and macros that the rest of the standard library depends on. Most headers pull it in transitively, so you often get it without including it directly.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/stdint.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>stdint.h</title>
        <link>https://yanevskiv.com/stdint.h?rev=1781320400&amp;do=diff</link>
        <description>stdint.h

Write int assuming it is 32 bits, run the code on a 16-bit microcontroller, and things break silently. stdint.h (C99) solves this by providing integer types with guaranteed widths, so you can write code that means exactly what it says regardless of platform.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/stdio.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>stdio.h</title>
        <link>https://yanevskiv.com/stdio.h?rev=1781320400&amp;do=diff</link>
        <description>stdio.h

printf(&quot;Hello, world\n&quot;) — nearly every C tutorial starts there, which means stdio.h is usually the first header anyone touches. It provides buffered file and console I/O: FILE, stdin/stdout/stderr, printf, scanf, fopen/fclose, and a whole family of read/write functions.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/stdlib.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>stdlib.h</title>
        <link>https://yanevskiv.com/stdlib.h?rev=1781320400&amp;do=diff</link>
        <description>stdlib.h

stdlib.h is the junk drawer of the C standard library. It covers dynamic memory allocation, process control, type conversions, random numbers, sorting, and searching — everything that did not fit cleanly into the other headers.


#include &lt;stdlib.h&gt;

// dynamic memory
void *p = malloc(1024);            // allocate 1024 bytes, uninitialized
void *z = calloc(16, sizeof(int)); // allocate and zero 16 ints
p = realloc(p, 2048);              // resize allocation
free(p);                    …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/stdmchar.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>stdmchar.h</title>
        <link>https://yanevskiv.com/stdmchar.h?rev=1781320400&amp;do=diff</link>
        <description>stdmchar.h

The older Unicode headers in C (&lt;wchar.h&gt;, &lt;uchar.h&gt;) have a common problem: they do not tell you how much output buffer space a conversion will need, they do not handle malformed input gracefully, and they do not support transcoding between arbitrary encodings.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/stdnoreturn.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>stdnoreturn.h</title>
        <link>https://yanevskiv.com/stdnoreturn.h?rev=1781320400&amp;do=diff</link>
        <description>stdnoreturn.h

If you have a die() or fatal() function that calls exit, the compiler does not automatically know it never returns. It will warn about missing return values in callers and may generate unnecessary dead-code paths. stdnoreturn.h (C11) defines the</description>
    </item>
    <item rdf:about="https://yanevskiv.com/string.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>string.h</title>
        <link>https://yanevskiv.com/string.h?rev=1781320400&amp;do=diff</link>
        <description>string.h

String manipulation in C means working directly with pointers into null-terminated byte arrays. string.h provides the standard set of functions for this: measuring lengths, copying, concatenating, comparing, searching, and operating on raw memory blocks. The string functions work on</description>
    </item>
    <item rdf:about="https://yanevskiv.com/strunk-and-white?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Strunk &amp; White</title>
        <link>https://yanevskiv.com/strunk-and-white?rev=1781320400&amp;do=diff</link>
        <description>Strunk &amp; White

Strunk &amp; White is a guide on writing text in the English language. The guide is contained in a book  titled “The Elements of Style”. It was written written by William Strunk Jr. in the 1910s and later expanded by E. B. White in the 1950s.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/swap-gate-cudaq?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>SWAP gate (CUDA-Q)</title>
        <link>https://yanevskiv.com/swap-gate-cudaq?rev=1781320400&amp;do=diff</link>
        <description>SWAP gate (CUDA-Q)

SWAP gate implementation using CUDA-Q. The example prepares $\lvert 10\rangle$ and applies SWAP to produce $\lvert 01\rangle$.


// Compile: nvq++ main.cpp -o main
// Run:     ./main

#include &lt;cudaq.h&gt;

struct kernel {
    __qpu__ void operator()() {
        cudaq::qvector&lt;2&gt; q;
        x(q[0]);          // q[0]=|1&gt;, q[1]=|0&gt; =&gt; |10&gt;
        swap(q[0], q[1]); // |10&gt; -&gt; |01&gt;
        mz(q);
    }
};

int main() {
    auto counts = cudaq::sample(kernel{});
    counts.dump();  …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/swap-gate-custatevec?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>SWAP gate (cuStateVec)</title>
        <link>https://yanevskiv.com/swap-gate-custatevec?rev=1781320400&amp;do=diff</link>
        <description>SWAP gate (cuStateVec)

SWAP gate implementation using cuStateVec. The example prepares $\lvert 10\rangle$ and applies SWAP to produce $\lvert 01\rangle$.


// Compile: nvcc main.cu -o main -lcustatevec
// Run:     ./main

#include &lt;stdio.h&gt;
#include &lt;cuda_runtime.h&gt;
#include &lt;custatevec.h&gt;

int main() {
    const int nQubits = 2;
    const int dim = 1 &lt;&lt; nQubits;

    // Prepare |10&gt;: q0=1, q1=0 -&gt; index 2 (binary 10)
    cuDoubleComplex h_sv[4] = {0};
    h_sv[2] = make_cuDoubleComplex(1.0, 0.…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/swap-gate-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>SWAP gate (Qiskit)</title>
        <link>https://yanevskiv.com/swap-gate-qiskit?rev=1781320400&amp;do=diff</link>
        <description>SWAP gate (Qiskit)

SWAP gate implementation using Qiskit. The example prepares $\lvert 10\rangle$ and applies SWAP to produce $\lvert 01\rangle$.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(2)
qc.x(1)       # q0=|0&gt;, q1=|1&gt; =&gt; |10&gt; in math ordering
qc.swap(0, 1) # |10&gt; -&gt; |01&gt;
print(Statevector(qc))
# Statevector([0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j], dims=(2, 2))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/swap-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>SWAP gate</title>
        <link>https://yanevskiv.com/swap-gate?rev=1781320400&amp;do=diff</link>
        <description>SWAP gate

SWAP gate is a two-qubit gate that exchanges the states of its two qubits. It is symmetric — neither qubit plays the role of control or target — and it is its own inverse: $\text{SWAP}^2 = I$.

$$\text{SWAP} = \begin{pmatrix}1&amp;0&amp;0&amp;0\\ 0&amp;0&amp;1&amp;0\\ 0&amp;1&amp;0&amp;0\\ 0&amp;0&amp;0&amp;1\end{pmatrix}$$

$$\text{SWAP}\lvert 00\rangle = \lvert 00\rangle \qquad \text{SWAP}\lvert 01\rangle = \lvert 10\rangle \qquad \text{SWAP}\lvert 10\rangle = \lvert 01\rangle \qquad \text{SWAP}\lvert 11\rangle = \lvert 11\rangle…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/syntax?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title></title>
        <link>https://yanevskiv.com/syntax?rev=1781320400&amp;do=diff</link>
        <description>[GitHub][gh]
fdsafdsa</description>
    </item>
    <item rdf:about="https://yanevskiv.com/t-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>T gate</title>
        <link>https://yanevskiv.com/t-gate?rev=1781320400&amp;do=diff</link>
        <description>T gate

T gate (or  gate, or  gate) is a single-qubit gate that adds a phase of $\pi/4$ to the $\lvert 1\rangle$ state while leaving $\lvert 0\rangle$ unchanged. It is a special case of the phase gate with $\phi = \pi/4$, and is the square root of the S gate: $T^2 = S$.

$$T = \begin{pmatrix}1 &amp; 0\\ 0 &amp; e^{i\pi/4}\end{pmatrix}$$

On the computational basis, $T\lvert 0\rangle = \lvert 0\rangle$ and $T\lvert 1\rangle = e^{i\pi/4}\lvert 1\rangle$. On the Bloch sphere, $T$ is a $\pi/4$ rotation abou…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/tasks-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Tasks (OpenMP)</title>
        <link>https://yanevskiv.com/tasks-openmp?rev=1781320400&amp;do=diff</link>
        <description>Tasks (OpenMP)

Tasks are the OpenMP mechanism for irregular parallelism. parallel for only handles loops with a known iteration count. For work like recursive algorithms, tree traversals, and producer-consumer patterns, #pragma omp task packages a unit of work that any idle thread in the current team can pick up and execute. Tasks are created inside a</description>
    </item>
    <item rdf:about="https://yanevskiv.com/terminal?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Terminal</title>
        <link>https://yanevskiv.com/terminal?rev=1781320400&amp;do=diff</link>
        <description>Terminal

Terminal is conceptually anything that looks like a keyboard + a screen attached to a teletype device (TTY). It gives humans the ability to use the teletype device.

When you type something in a terminal, the terminal sends your characters to the teletype device. When a teletype device responds, the terminal prints the result back to you. A terminal can also reinterpret the characters coming from the teletype device and change its behavior in some way (e.g. change cursor location or tu…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/test-automation?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Test automation</title>
        <link>https://yanevskiv.com/test-automation?rev=1781320400&amp;do=diff</link>
        <description>Test automation

Test automation is the practice of running tests programmatically rather than manually. Instead of a person clicking through an application to verify that features work, a program does it. The tests run on every change, give a pass/fail result within minutes, and never forget to check something.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/test-driven-development?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Test-driven development</title>
        <link>https://yanevskiv.com/test-driven-development?rev=1781320400&amp;do=diff</link>
        <description>Test-driven development

Test-driven development (TDD) is a practice where you write the test before you write the code. The test fails first — because the code does not exist yet — then you write the minimum code to make it pass, then you clean up. The cycle repeats for every new piece of behaviour.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/tgmath.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>tgmath.h</title>
        <link>https://yanevskiv.com/tgmath.h?rev=1781320400&amp;do=diff</link>
        <description>tgmath.h

Remembering to write sqrtf for float, sqrt for double, and sqrtl for long double is tedious and error-prone — forget the suffix and you silently get the wrong precision. tgmath.h (C99) provides type-generic wrappers that dispatch to the right variant based on the argument type, so you can just write</description>
    </item>
    <item rdf:about="https://yanevskiv.com/thinkpad?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>ThinkPad</title>
        <link>https://yanevskiv.com/thinkpad?rev=1781320400&amp;do=diff</link>
        <description>ThinkPad

X-series
x220ai</description>
    </item>
    <item rdf:about="https://yanevskiv.com/thread-affinity-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Thread affinity (OpenMP)</title>
        <link>https://yanevskiv.com/thread-affinity-openmp?rev=1781320400&amp;do=diff</link>
        <description>Thread affinity (OpenMP)

On a laptop or single-socket desktop, every core reaches the same RAM at the same speed. On a multi-socket server, each socket has its own bank of RAM (NUMA, non-uniform memory access): accessing local memory is fast, but crossing the inter-socket interconnect to reach the other socket&#039;s RAM costs roughly 2–3× more. By default, the OS is free to migrate threads between cores and sockets, silently moving a thread away from the data it allocated.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/thread.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>threads.h</title>
        <link>https://yanevskiv.com/thread.h?rev=1781320400&amp;do=diff</link>
        <description>threads.h

POSIX pthreads work great on Linux but are not available everywhere. threads.h (C11) provides a portable threading API — thread creation, mutexes, condition variables, and thread-local storage — with a standardised interface that any conforming C11 implementation must provide.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/three-qubit-gates?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Three-qubit gates</title>
        <link>https://yanevskiv.com/three-qubit-gates?rev=1781320400&amp;do=diff</link>
        <description>Three-qubit gates

Three-qubit gates are $8 \times 8$ unitary matrices acting on a three-qubit system. They appear in fault-tolerant quantum computation and quantum arithmetic circuits. Any three-qubit gate decomposes into two-qubit and single-qubit gates, though the decompositions can be deep.$\lvert 1\rangle$$$\text{CCX}\lvert c_1 c_2 t\rangle = \lvert c_1 c_2\rangle \otimes \lvert t \oplus (c_1 \wedge c_2)\rangle$$$\lvert 1\rangle$$T$$T$$T^\dagger$$H$$S$$T$$T$$T$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/three-qubits?rev=1781321871&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:37:51+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Three qubits</title>
        <link>https://yanevskiv.com/three-qubits?rev=1781321871&amp;do=diff</link>
        <description>Three qubits

Three-qubit system is a quantum system of three qubits. The Hilbert space is $\mathbb{C}^8$, meaning eight complex amplitudes to describe it, not three.

A single qubit needs two amplitudes; two qubits need four; three qubits need eight. The state space doubles with every qubit you add. That exponential growth is what makes quantum computers interesting.$$\lvert\psi\rangle = \begin{pmatrix}c_{000}\\c_{001}\\c_{010}\\c_{011}\\c_{100}\\c_{101}\\c_{110}\\c_{111}\end{pmatrix}, \qquad \…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/time-measurement-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Time measurement (MPI)</title>
        <link>https://yanevskiv.com/time-measurement-mpi?rev=1781320400&amp;do=diff</link>
        <description>Time measurement (MPI)

In a single-process program, clock_gettime(CLOCK_MONOTONIC, &amp;ts) gives the elapsed time from one CPU&#039;s perspective. In a parallel program, each process runs on a potentially different core with a clock that is not perfectly synchronised to the others. Timing on just one process gives its view of the wall time, which can be shorter than the actual parallel section if that process happens to finish early.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/time-measurement-openmp?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Time measurement (OpenMP)</title>
        <link>https://yanevskiv.com/time-measurement-openmp?rev=1781320400&amp;do=diff</link>
        <description>Time measurement (OpenMP)

Time measurement in OpenMP is done with omp_get_wtime(), which returns elapsed wall-clock time in seconds as a double. Calling it before and after a parallel region gives the actual time the user waited, which is what matters for speedup measurement. CPU time is not useful here: it sums across all threads and grows with thread count rather than shrinking.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/time.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>time.h</title>
        <link>https://yanevskiv.com/time.h?rev=1781320400&amp;do=diff</link>
        <description>time.h

Getting the current time is a one-liner. Timing how long something takes, converting between timezones, or formatting a timestamp all have more moving parts than you would expect. time.h provides the types and functions for all of it: time_t (seconds since the Unix epoch),</description>
    </item>
    <item rdf:about="https://yanevskiv.com/tmux?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>tmux</title>
        <link>https://yanevskiv.com/tmux?rev=1781320400&amp;do=diff</link>
        <description>tmux

What is tmux?

Tmux is a terminal multiplexer. It allows you to run multiple terminals in a single terminal. In this sense, it is an alternative to screen command.

Tmux runs a background session that you can attach to. It gives you the ability to create multiple windows within a session. Then it also gives you the ability to create multiple panes within a window, and tile them. Each pane contains a terminal. Thus, you can think of tmux as a</description>
    </item>
    <item rdf:about="https://yanevskiv.com/todo?rev=1781513749&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:55:49+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>To do</title>
        <link>https://yanevskiv.com/todo?rev=1781513749&amp;do=diff</link>
        <description>To do

This page contains articles which I&#039;m in the process of writing or plan to write about.

Website

The following are some features I need to implement on the site:

	* Editor:
		* Add: Live preview while editing (requires backend API support)
		*</description>
    </item>
    <item rdf:about="https://yanevskiv.com/toffoli-gate-cudaq?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Toffoli gate (CUDA-Q)</title>
        <link>https://yanevskiv.com/toffoli-gate-cudaq?rev=1781320400&amp;do=diff</link>
        <description>Toffoli gate (CUDA-Q)

Toffoli gate implementation using CUDA-Q. The example prepares $\lvert 110\rangle$ (both controls $\lvert 1\rangle$, target $\lvert 0\rangle$) and applies the Toffoli gate, flipping the target to produce $\lvert 111\rangle$.


// Compile: nvq++ main.cpp -o main
// Run:     ./main

#include &lt;cudaq.h&gt;

struct kernel {
    __qpu__ void operator()() {
        cudaq::qvector&lt;3&gt; q;
        x(q[0]);                          // q[0] = |1&gt;
        x(q[1]);                          …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/toffoli-gate-custatevec?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Toffoli gate (cuStateVec)</title>
        <link>https://yanevskiv.com/toffoli-gate-custatevec?rev=1781320400&amp;do=diff</link>
        <description>Toffoli gate (cuStateVec)

Toffoli gate implementation using cuStateVec. The example prepares $\lvert 110\rangle$ (both controls $\lvert 1\rangle$, target $\lvert 0\rangle$) and applies the Toffoli gate, flipping the target to produce $\lvert 111\rangle$.


// Compile: nvcc main.cu -o main -lcustatevec
// Run:     ./main

#include &lt;stdio.h&gt;
#include &lt;cuda_runtime.h&gt;
#include &lt;custatevec.h&gt;

int main() {
    const int nQubits = 3;
    const int dim = 1 &lt;&lt; nQubits;

    // Prepare |110&gt;: q0=1, q1=…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/toffoli-gate-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Toffoli gate (Qiskit)</title>
        <link>https://yanevskiv.com/toffoli-gate-qiskit?rev=1781320400&amp;do=diff</link>
        <description>Toffoli gate (Qiskit)

Toffoli gate implementation using Qiskit. The example prepares $\lvert 110\rangle$ (both controls $\lvert 1\rangle$, target $\lvert 0\rangle$) and applies the Toffoli gate, flipping the target to produce $\lvert 111\rangle$.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(3)
qc.x(0)         # q0 = |1&gt;
qc.x(1)         # q1 = |1&gt;  =&gt; state is |110&gt;
qc.ccx(0, 1, 2) # Toffoli: both controls |1&gt;, flip target -&gt; |111&gt;
print(St…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/topics?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Topics I plan to write about</title>
        <link>https://yanevskiv.com/topics?rev=1781320400&amp;do=diff</link>
        <description>Topics I plan to write about

Wikipedia

	* Trace theory
	* Pi calculus
	* History monoid

Concepts

	* Hazard pointer
	* ABA problem
	* Cache coherence (MSI MESI MOESI DragonFly)</description>
    </item>
    <item rdf:about="https://yanevskiv.com/trace-monoid?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Trace monoid</title>
        <link>https://yanevskiv.com/trace-monoid?rev=1781320400&amp;do=diff</link>
        <description>Trace monoid

A trace monoid (also called a free partially commutative monoid, or a Mazurkiewicz trace monoid after Antoni Mazurkiewicz who introduced them in 1977) is an algebraic structure that captures the notion of concurrent computation. The idea is simple: if two actions in a program do not share any data, the order in which you execute them should not matter. A trace monoid makes this precise by taking the set of all instruction sequences and declaring two sequences equivalent if one can …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/two-qubit-gates?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Two-qubit gates</title>
        <link>https://yanevskiv.com/two-qubit-gates?rev=1781320400&amp;do=diff</link>
        <description>Two-qubit gates

Two-qubit gates are $4 \times 4$ unitary matrices acting on a pair of qubits. Unlike single-qubit gates, they can create entanglement between qubits that were previously in a product state. Any two-qubit unitary can be decomposed into at most three $n$$\lvert +\rangle\lvert 0\rangle$$(c_x, c_y, c_z)$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/two-qubits?rev=1781321039&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:23:59+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Two qubits</title>
        <link>https://yanevskiv.com/two-qubits?rev=1781321039&amp;do=diff</link>
        <description>Two qubits

Two-qubit system is a quantum system of two qubits. The Hilbert space is $\mathbb{C}^4$, meaning four complex amplitudes to describe it, not two.

A single qubit needs two amplitudes; two qubits need four; three qubits need eight. The state space doubles with every qubit you add. That exponential growth is what makes quantum computers interesting.$$\lvert\psi\rangle = \begin{pmatrix}c_{00}\\c_{01}\\c_{10}\\c_{11}\end{pmatrix}, \qquad \lvert\psi\rangle = c_{00}\underbrace{\begin{pmatr…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/u-gate-cudaq?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>U gate (CUDA-Q)</title>
        <link>https://yanevskiv.com/u-gate-cudaq?rev=1781320400&amp;do=diff</link>
        <description>U gate (CUDA-Q)

U gate implementation using CUDA-Q. The example applies $U(\pi/2, 0, \pi) = H$ to $\lvert 0\rangle$ via its Euler decomposition, producing $\lvert +\rangle$.


// Compile: nvq++ main.cpp -o main
// Run:     ./main

#include &lt;cudaq.h&gt;
#include &lt;cmath&gt;

struct kernel {
    __qpu__ void operator()() {
        cudaq::qubit q;
        // U(theta, phi, lambda) via Euler decomposition: Rz(phi) Ry(theta) Rz(lambda)
        rz(0.0, q);           // phi   = 0
        ry(M_PI / 2.0, q);   …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/u-gate-custatevec?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>U gate (cuStateVec)</title>
        <link>https://yanevskiv.com/u-gate-custatevec?rev=1781320400&amp;do=diff</link>
        <description>U gate (cuStateVec)

U gate implementation using cuStateVec. The example applies $U(\pi/2, 0, \pi) = H$ to $\lvert 0\rangle$, producing $\lvert +\rangle$.


// Compile: nvcc main.cu -o main -lcustatevec
// Run:     ./main

#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;cuda_runtime.h&gt;
#include &lt;custatevec.h&gt;

int main() {
    const int nQubits = 1;
    const int dim = 1 &lt;&lt; nQubits;

    cuDoubleComplex h_sv[2] = {{1,0},{0,0}};  // |0&gt;
    cuDoubleComplex *d_sv;
    cudaMalloc(&amp;d_sv, dim * sizeof…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/u-gate-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>U gate (Qiskit)</title>
        <link>https://yanevskiv.com/u-gate-qiskit?rev=1781320400&amp;do=diff</link>
        <description>U gate (Qiskit)

U gate implementation using Qiskit. The example applies $U(\pi/2, 0, \pi) = H$ to $\lvert 0\rangle$, producing $\lvert +\rangle$.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
import numpy as np

qc = QuantumCircuit(1)
qc.u(np.pi / 2, 0, np.pi, 0)  # U(pi/2, 0, pi) = H
print(Statevector(qc))
# Statevector([0.70710678+0.j, 0.70710678+0.j], dims=(2,))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/u-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Unitary gate</title>
        <link>https://yanevskiv.com/u-gate?rev=1781320400&amp;do=diff</link>
        <description>Unitary gate

Unitary gate is the most general single-qubit unitary gate, parameterized by three real angles $\theta$, $\phi$, $\lambda$. Every single-qubit unitary (up to global phase) can be expressed as $U(\theta, \phi, \lambda)$ for some choice of these angles, making it the canonical representation of a single-qubit gate.$$U(\theta, \phi, \lambda) = \begin{pmatrix}\cos\dfrac{\theta}{2} &amp; -e^{i\lambda}\sin\dfrac{\theta}{2}\\[8pt] e^{i\phi}\sin\dfrac{\theta}{2} &amp; e^{i(\phi+\lambda)}\cos\dfrac…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/uchar.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>uchar.h</title>
        <link>https://yanevskiv.com/uchar.h?rev=1781320400&amp;do=diff</link>
        <description>uchar.h

wchar_t seemed like the solution to Unicode, but its encoding is implementation-defined — 16-bit UTF-16 on Windows, 32-bit UTF-32 on Linux — making it useless for writing portable Unicode code. uchar.h (C11) provides char16_t and char32_t</description>
    </item>
    <item rdf:about="https://yanevskiv.com/unit-test?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Unit test</title>
        <link>https://yanevskiv.com/unit-test?rev=1781320400&amp;do=diff</link>
        <description>Unit test

A unit test is a test that verifies a single, isolated unit of code — typically a function or a class method — in isolation from its dependencies. The goal is to make the test fast, deterministic, and precise about what it is testing.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/virtual-topologies-mpi?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Virtual topologies (MPI)</title>
        <link>https://yanevskiv.com/virtual-topologies-mpi?rev=1781320400&amp;do=diff</link>
        <description>Virtual topologies (MPI)

In a 2D stencil on a P×Q process grid, each process needs the ranks of its north, south, east, and west neighbors. Computing those ranks manually requires knowing the grid dimensions and handling wraparound explicitly:


int row = rank / Q,  col = rank % Q;
int north = ((row - 1 + P) % P) * Q + col;
int south = ((row + 1)     % P) * Q + col;</description>
    </item>
    <item rdf:about="https://yanevskiv.com/von-neumann-equation-qutip?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>von Neumann equation (QuTiP)</title>
        <link>https://yanevskiv.com/von-neumann-equation-qutip?rev=1781320400&amp;do=diff</link>
        <description>von Neumann equation (QuTiP)

von Neumann equation implementation using QuTiP.

QuTiP&#039;s mesolve() (master equation solver) integrates the Lindblad master equation. Passing an empty collapse-operator list c_ops=[] disables the dissipator, reducing it exactly to the von Neumann equation:$$\frac{\mathrm{d}\rho}{\mathrm{d}t} = -\frac{i}{\hbar}[H,\,\rho]$$$O$$\langle O\rangle = \mathrm{tr}(\rho\, O)$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/von-neumann-equation?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>von-Neumann equation</title>
        <link>https://yanevskiv.com/von-neumann-equation?rev=1781320400&amp;do=diff</link>
        <description>von-Neumann equation

von-Neumann equation is basically the Schrodinger equation where the quantum state is represented by a density matrix $\rho$, rather than a state vector $\lvert\psi\rangle$. It takes the following form.

$$\frac{\mathrm d\rho}{\mathrm dt} = -\frac{i}{\hbar}[H, \rho]$$

Where $H$ is the Hamiltonian and $\rho$ is the density matrix and they both vary in time. Meanwhile $i$$\hbar$$$\dot\rho = -\frac{i}{\hbar}[H, \rho]$$$[H, \rho]$$[H, \rho] = H\rho - \rho H$$$\dot\rho = -\frac…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/vps?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>VPS</title>
        <link>https://yanevskiv.com/vps?rev=1781320400&amp;do=diff</link>
        <description>VPS

What is a VPS?

VPS (Virtual private server) is a virtual computer that you can buy from a cloud provider. It can do almost anything a real computer can. A VPS slice is often a virtual machine (QEMU + KVM) given to you by a cloud privder, with GNU/Linux pre-installed.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/vqe?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>VQE</title>
        <link>https://yanevskiv.com/vqe?rev=1781320400&amp;do=diff</link>
        <description>VQE

VQE (Variational Quantum Eigensolver) is a hybrid quantum-classical algorithm for estimating the ground state energy of a quantum system. It was proposed in 2014 by Peruzzo et al. and is one of the most important algorithms for near-term NISQ devices, with applications in quantum chemistry and materials science.$\lvert\psi(\boldsymbol\theta)\rangle$$H$$E_0$$$E_0 \leq \langle\psi(\boldsymbol\theta)\rvert H\lvert\psi(\boldsymbol\theta)\rangle$$$\lvert\psi(\boldsymbol\theta)\rangle$$\boldsymbo…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/w-state-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>W state (Qiskit)</title>
        <link>https://yanevskiv.com/w-state-qiskit?rev=1781320400&amp;do=diff</link>
        <description>W state (Qiskit)

W state implementation using Qiskit. The three-qubit W state $\lvert W\rangle = (\lvert 001\rangle + \lvert 010\rangle + \lvert 100\rangle)/\sqrt{3}$ is prepared using the recursive decomposition $\lvert W_3\rangle = \frac{1}{\sqrt{3}}\lvert 1\rangle\lvert 00\rangle + \sqrt{\frac{2}{3}}\lvert 0\rangle\lvert W_2\rangle$.


import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(3)

# Step 1: Ry on q[0] to set amplitud…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/wchar.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>wchar.h</title>
        <link>https://yanevskiv.com/wchar.h?rev=1781320400&amp;do=diff</link>
        <description>wchar.h

If you need to work with non-ASCII text in C — printing accented characters to a terminal, comparing strings that contain Unicode letters, formatting locale-aware dates — you will eventually run into wchar_t. wchar.h (C95) provides wide character I/O and string functions for it: the wide-character mirror of</description>
    </item>
    <item rdf:about="https://yanevskiv.com/wctype.h?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>wctype.h</title>
        <link>https://yanevskiv.com/wctype.h?rev=1781320400&amp;do=diff</link>
        <description>wctype.h

isalpha(&#039;é&#039;) returns 0. The narrow character classification functions in &lt;ctype.h&gt; only handle ASCII (values 0-127); everything else is either wrong or undefined behaviour. wctype.h (C95) is the wide-character counterpart that works on the full Unicode character set via</description>
    </item>
    <item rdf:about="https://yanevskiv.com/wip-example?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>(WIP) Work in Progress</title>
        <link>https://yanevskiv.com/wip-example?rev=1781320400&amp;do=diff</link>
        <description>(WIP) Work in Progress</description>
    </item>
    <item rdf:about="https://yanevskiv.com/writing-guide-on-header-files?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Writing guide on header files</title>
        <link>https://yanevskiv.com/writing-guide-on-header-files?rev=1781320400&amp;do=diff</link>
        <description>Writing guide on header files

Writing guide on header files is a supplement to the writing guide specifically for articles about C and C++ header files.

The goal of a header article is not to replicate documentation. cppreference and the POSIX manual pages already do that exhaustively. An article here should give a programmer a genuine understanding of the header: why it exists, how it feels to use it, what it gets wrong, and how the key parts are implemented under the hood.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/writing-guide-on-parallel-computing?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Writing guide on parallel computing</title>
        <link>https://yanevskiv.com/writing-guide-on-parallel-computing?rev=1781320400&amp;do=diff</link>
        <description>Writing guide on parallel computing

Writing guide on parallel computing (this article) covers conventions specific to parallel computing articles in this wiki. Read the general writing guide first; this document supplements it.

The central challenge

Parallel computing articles fail in one consistent way: they explain what a primitive does before establishing why a C programmer would care. The reader lands on</description>
    </item>
    <item rdf:about="https://yanevskiv.com/writing-guide-on-quantum-computing?rev=1781513651&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T08:54:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Writing guide on quantum computing</title>
        <link>https://yanevskiv.com/writing-guide-on-quantum-computing?rev=1781513651&amp;do=diff</link>
        <description>Writing guide on quantum computing

Writing guide on quantum computing (this article) covers conventions specific to quantum computing articles in this wiki. Read General writing guide first for structure, paragraph, and code block conventions that apply across all articles.$H^\dagger = H$$(AB)^\dagger = B^\dagger A^\dagger$$\mathrm{tr}(ABC) = \mathrm{tr}(CAB)$$H$$X$$Y$$Z$$\rho$$[A, B] = AB - BA$$\{A, B\} = AB + BA$$\hbar$$\hbar = 1$$X$$\pi$$x$$L_k\rho L_k^\dagger$$L_k^\dagger\rho L_k$$[H,\rho] …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/x-gate-cudaq?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>X gate (CUDA-Q)</title>
        <link>https://yanevskiv.com/x-gate-cudaq?rev=1781320400&amp;do=diff</link>
        <description>X gate (CUDA-Q)

X gate implementation using CUDA-Q.


// Compile: nvq++ main.cpp -o main
// Run:     ./main

#include &lt;cudaq.h&gt;

struct kernel {
    __qpu__ void operator()() {
        cudaq::qubit q;
        x(q);  // |0&gt; -&gt; |1&gt;
        mz(q);
    }
};

int main() {
    auto counts = cudaq::sample(kernel{});
    counts.dump();  // 100% |1&gt;
}</description>
    </item>
    <item rdf:about="https://yanevskiv.com/x-gate-custatevec?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>X gate (cuStateVec)</title>
        <link>https://yanevskiv.com/x-gate-custatevec?rev=1781320400&amp;do=diff</link>
        <description>X gate (cuStateVec)

X gate implementation using cuStateVec.


// Compile: nvcc main.cu -o main -lcustatevec
// Run:     ./main

#include &lt;stdio.h&gt;
#include &lt;cuda_runtime.h&gt;
#include &lt;custatevec.h&gt;

int main() {
    const int nQubits = 1;
    const int dim = 1 &lt;&lt; nQubits;

    cuDoubleComplex h_sv[2] = {{1,0},{0,0}};  // |0&gt;
    cuDoubleComplex *d_sv;
    cudaMalloc(&amp;d_sv, dim * sizeof(cuDoubleComplex));
    cudaMemcpy(d_sv, h_sv, dim * sizeof(cuDoubleComplex), cudaMemcpyHostToDevice);

    cust…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/x-gate-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>X gate (Qiskit)</title>
        <link>https://yanevskiv.com/x-gate-qiskit?rev=1781320400&amp;do=diff</link>
        <description>X gate (Qiskit)

X gate implementation using Qiskit.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(1)
qc.x(0)  # |0&gt; -&gt; |1&gt;
print(Statevector(qc))
# Statevector([0.+0.j, 1.+0.j], dims=(2,))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/x-gate?rev=1781537002&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-15T15:23:22+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$X$ gate (NOT gate)</title>
        <link>https://yanevskiv.com/x-gate?rev=1781537002&amp;do=diff</link>
        <description>$X$ gate (NOT gate)

X gate (or Pauli-X gate, or quantum NOT gate) is a single-qubit gate that flips $\lvert 0\rangle$ to $\lvert 1\rangle$ and $\lvert 1\rangle$ to $\lvert 0\rangle$, making it the quantum analog of a classical NOT gate. It is one of the three Pauli gates.

$$X = \begin{pmatrix}0 &amp; 1\\ 1 &amp; 0\end{pmatrix}$$

The gate flips the computational basis states and leaves the Hadamard basis states ($\lvert +\rangle$$\lvert -\rangle$$$X\lvert 0\rangle = \lvert 1\rangle \qquad X\lvert 1\ra…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/x220-gpu-rendering-with-hyprland?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>GPU Rendering Artifacts on ThinkPad X220 with Hyprland — Diagnosis &amp; Fix</title>
        <link>https://yanevskiv.com/x220-gpu-rendering-with-hyprland?rev=1781320400&amp;do=diff</link>
        <description>GPU Rendering Artifacts on ThinkPad X220 with Hyprland — Diagnosis &amp; Fix

Hardware &amp; Software Context
  ------ Machine  Lenovo ThinkPad X220 (4291SWP)  GPU  Intel HD Graphics 3000 — Sandy Bridge, Gen 6  Kernel driver  i915  Mesa driver  crocus (Gallium3D for Intel Gen 4–8)</description>
    </item>
    <item rdf:about="https://yanevskiv.com/xp-programming?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Extreme programming</title>
        <link>https://yanevskiv.com/xp-programming?rev=1781320400&amp;do=diff</link>
        <description>Extreme programming

Extreme programming (XP) is a software development methodology introduced by Kent Beck in 1996. The core idea is to take practices that are known to work — testing, code review, frequent releases, collaboration — and push them to their logical extreme. If testing is good, test everything. If code review is good, review code continuously by having two people write it together.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/y-gate-cudaq?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Y gate (CUDA-Q)</title>
        <link>https://yanevskiv.com/y-gate-cudaq?rev=1781320400&amp;do=diff</link>
        <description>Y gate (CUDA-Q)

Y gate implementation using CUDA-Q.


// Compile: nvq++ main.cpp -o main
// Run:     ./main

#include &lt;cudaq.h&gt;

struct kernel {
    __qpu__ void operator()() {
        cudaq::qubit q;
        y(q);  // |0&gt; -&gt; i|1&gt;; global phase not observable at measurement
        mz(q);
    }
};

int main() {
    auto counts = cudaq::sample(kernel{});
    counts.dump();  // 100% |1&gt;
}</description>
    </item>
    <item rdf:about="https://yanevskiv.com/y-gate-custatevec?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Y gate (cuStateVec)</title>
        <link>https://yanevskiv.com/y-gate-custatevec?rev=1781320400&amp;do=diff</link>
        <description>Y gate (cuStateVec)

Y gate implementation using cuStateVec.


// Compile: nvcc main.cu -o main -lcustatevec
// Run:     ./main

#include &lt;stdio.h&gt;
#include &lt;cuda_runtime.h&gt;
#include &lt;custatevec.h&gt;

int main() {
    const int nQubits = 1;
    const int dim = 1 &lt;&lt; nQubits;

    cuDoubleComplex h_sv[2] = {{1,0},{0,0}};  // |0&gt;
    cuDoubleComplex *d_sv;
    cudaMalloc(&amp;d_sv, dim * sizeof(cuDoubleComplex));
    cudaMemcpy(d_sv, h_sv, dim * sizeof(cuDoubleComplex), cudaMemcpyHostToDevice);

    cust…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/y-gate-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Y gate (Qiskit)</title>
        <link>https://yanevskiv.com/y-gate-qiskit?rev=1781320400&amp;do=diff</link>
        <description>Y gate (Qiskit)

Y gate implementation using Qiskit.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(1)
qc.y(0)  # |0&gt; -&gt; i|1&gt;
print(Statevector(qc))
# Statevector([0.+0.j, 0.+1.j], dims=(2,))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/y-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Y gate</title>
        <link>https://yanevskiv.com/y-gate?rev=1781320400&amp;do=diff</link>
        <description>Y gate

Y gate (or Pauli-Y gate) is a single-qubit gate represented by the second Pauli matrix. It combines the actions of the X gate (bit flip) and the Z gate (phase flip), and additionally multiplies the amplitude by $i$. It is one of the three Pauli gates.

$$Y = \begin{pmatrix}0 &amp; -i \\ i &amp; 0\end{pmatrix}$$

The gate maps the computational basis states with an accompanying imaginary factor, and its eigenstates are the $Y$$$Y\lvert 0\rangle = i\lvert 1\rangle \qquad Y\lvert 1\rangle = -i\lver…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/yanevskiv-wiki?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Wiki</title>
        <link>https://yanevskiv.com/yanevskiv-wiki?rev=1781320400&amp;do=diff</link>
        <description>Wiki

This is a meta article about this website.

This website is my creation 

Challenges

Writing this website presents some unique challenges. How do I write down my notes but also make the information useful to the reader? If this website was only about putting my notes, I wouldn&#039;t have to use words at all. I could make articles where I just slap some links and call it a day. That would be useful to me, but not to the wider audience.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/z-gate-cudaq?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Z gate (CUDA-Q)</title>
        <link>https://yanevskiv.com/z-gate-cudaq?rev=1781320400&amp;do=diff</link>
        <description>Z gate (CUDA-Q)

Z gate implementation using CUDA-Q. The Z gate applied to $\lvert 0\rangle$ is invisible at measurement (it leaves $\lvert 0\rangle$ unchanged), so this example prepares $\lvert +\rangle$ first, applies Z, then rotates back to the computational basis to confirm the phase flip.


// Compile: nvq++ main.cpp -o main
// Run:     ./main

#include &lt;cudaq.h&gt;

struct kernel {
    __qpu__ void operator()() {
        cudaq::qubit q;
        h(q);  // |0&gt; -&gt; |+&gt;
        z(q);  // |+&gt; -&gt; |-…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/z-gate-custatevec?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Z gate (cuStateVec)</title>
        <link>https://yanevskiv.com/z-gate-custatevec?rev=1781320400&amp;do=diff</link>
        <description>Z gate (cuStateVec)

Z gate implementation using cuStateVec. The Z gate applied to $\lvert 0\rangle$ is invisible at measurement (it leaves $\lvert 0\rangle$ unchanged), so this example prepares $\lvert +\rangle$ first to make the phase flip observable via interference.


// Compile: nvcc main.cu -o main -lcustatevec
// Run:     ./main

#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;cuda_runtime.h&gt;
#include &lt;custatevec.h&gt;

int main() {
    const int nQubits = 1;
    const int dim = 1 &lt;&lt; nQubits;…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/z-gate-qiskit?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Z gate (Qiskit)</title>
        <link>https://yanevskiv.com/z-gate-qiskit?rev=1781320400&amp;do=diff</link>
        <description>Z gate (Qiskit)

Z gate implementation using Qiskit. The Z gate applied to $\lvert 0\rangle$ is invisible at measurement (it leaves $\lvert 0\rangle$ unchanged), so this example prepares $\lvert +\rangle$ first to make the phase flip observable via interference.


from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(1)
qc.h(0)  # |0&gt; -&gt; |+&gt;
qc.z(0)  # |+&gt; -&gt; |-&gt;
print(Statevector(qc))
# Statevector([ 0.70710678+0.j, -0.70710678+0.j], dims=(2,))</description>
    </item>
    <item rdf:about="https://yanevskiv.com/z-gate?rev=1781320400&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-06-13T03:13:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Z gate</title>
        <link>https://yanevskiv.com/z-gate?rev=1781320400&amp;do=diff</link>
        <description>Z gate

Z gate (or Pauli-Z gate, or phase flip gate) is a single-qubit gate that applies a phase flip to the $\lvert 1\rangle$ state while leaving $\lvert 0\rangle$ unchanged. It is the third Pauli gate and a special case of the phase gate with $\phi = \pi$.

$$Z = \begin{pmatrix}1 &amp; 0\\ 0 &amp; -1\end{pmatrix}$$

The gate leaves the computational basis states $\lvert 0\rangle$ and $\lvert 1\rangle$ as eigenstates, and swaps the Hadamard basis states:$$Z\lvert 0\rangle = \lvert 0\rangle \qquad Z\lve…</description>
    </item>
</rdf:RDF>
