DEV Community: seng

Python bytearray

seng — Thu, 23 Oct 2025 05:06:37 +0000

Python bytearray

Overview

bytearray is an important built-in class in Python that represents a mutable sequence of bytes.

1. Basic Characteristics

bytearray is similar to bytes, but unlike bytes, bytearray is mutable.

# Create a bytearray
ba = bytearray(b'Hello')
print(ba)  # Output: bytearray(b'Hello')
print(type(ba))  # Output: <class 'bytearray'>

2. Methods to Create bytearray

Create from bytes object

ba1 = bytearray(b'Hello')
print(ba1)  # bytearray(b'Hello')

Create from string (encoding required)

ba2 = bytearray('Hello', 'utf-8')
print(ba2)  # bytearray(b'Hello')

Create empty bytearray of specified length

ba3 = bytearray(5)
print(ba3)  # bytearray(b'\x00\x00\x00\x00\x00')

Create from iterable object

ba4 = bytearray([65, 66, 67, 68])  # ASCII: A, B, C, D
print(ba4)  # bytearray(b'ABCD')

3. Mutability Demonstration

# bytes is immutable (will cause error)
b = b'Hello'
# b[0] = 74  # TypeError: 'bytes' object does not support item assignment

# bytearray is mutable
ba = bytearray(b'Hello')
ba[0] = 74  # ASCII code for 'J'
print(ba)  # bytearray(b'Jello')

4. Common Operations

Add elements

ba = bytearray(b'Hello')
ba.append(33)  # ASCII code for '!'
print(ba)  # bytearray(b'Hello!')

Extend bytearray

ba = bytearray(b'Hello')
ba.extend(b' World')
print(ba)  # bytearray(b'Hello World')

Convert to other types

ba = bytearray(b'Hello')
# Convert to bytes
bytes_obj = bytes(ba)
print(bytes_obj)  # b'Hello'

# Convert to string
string = ba.decode('utf-8')
print(string)  # 'Hello'

The Projection and Selection Operations in Relational Algebra with Fortran

seng — Tue, 21 Oct 2025 05:40:20 +0000

Projection is used to vertically filter and select columns in a table.The Selection operation can be used to filter rows that satisfy a certain condition in a table.

program learn
    implicit none
    integer,dimension(2,3)::a
    integer,dimension(2,3)::b
    integer,dimension(24)::c
    integer,dimension(4,6)::d
    integer::i,j
    integer::k
    a=reshape([1,2,66,89,74,79],[2,3],order=[1,2])
    b=reshape([1,2,76,99,84,59],[2,3],order=[1,2])
    write (*,120) 'aid','a1','a2','bid','b1','b2'
    c=[((a(i,:),b(j,:),i=1,2),j=1,2)]
    d=reshape(c,[4,6],order=[2,1])
    write (*,110) c
    write  (*,*) "---------"
    write (*,110) d(2,:)
    write  (*,*) "---------"
    write (*,110) d(:,2)
    write  (*,*) "---------"
    write  (*,*) "b1>70 and a2<70"
    write (*,120) 'aid','a1','a2','bid','b1','b2'
    !b1>70 and a2<90 Selection
    k=1
    do
       if (d(k,5)>70 .and. d(k,3)<79) write (*,110) d(k,:)
       k=k+1
       if (k>4) exit
    end do
    write (*,120) 'aid','a1','a2','bid','b1','b2'
    !b1>70 and a2<90 Projection and Selection
    write  (*,*) "b1>70 and a2<70 and aid=bid"
    write (*,120) 'aid','a1','a2','b1','b2'
    k=1
    do
       if (d(k,5)>70 .and. d(k,3)<79 .and. d(k,1)==d(k,4)) write (*,110) d(k,1:3),d(k,5:6)
       k=k+1
       if (k>4) exit
    end do
    110 format (6(I3))
    120 format (6(A3))
end program learn

an introduction to Simulated Annealing

seng — Sun, 19 Oct 2025 23:20:36 +0000

Simulated Annealing is a probability-based algorithm used for global optimization, inspired by the process of metal annealing.
It simulates the changes in the atomic state of metals during the cooling process after being heated.
Throughout the search process, the algorithm is controlled by a temperature parameter. When the temperature is very high, the algorithm may accept worse solutions rather than better ones. As the temperature decreases, it increasingly prefers better solutions.

The algorithm can be described as follows:



1. Initialization:
- Initial solution x
- Initial temperature T = T0
- Cooling coefficient α (0 < α < 1)
- Minimum temperature Tmin



2. while T > Tmin:
 for i = 1 to k (number of iterations per temperature):
 Generate new solution x' = neighbor(x)
 Calculate energy change ΔE = f(x') - f(x)
 if ΔE < 0:
 Accept new solution x = x'
 else:
 Accept x = x' with probability exp(-ΔE/T)
 Cool down T = α * T



3. Return the best solution found

A new solution is always accepted when ΔE < 0, meaning the algorithm is moving downhill.

Otherwise, it is attempting to move uphill.

This uphill move is accepted on the condition that a uniformly distributed random number in the interval [0, 1] is less than exp(-ΔE / T).


import math

import random

def simulated_annealing(initial_solution, cost_func, neighbor_func, T0, alpha, Tmin):

    current = initial_solution

    current_cost = cost_func(current)

    T = T0



    while T > Tmin:

        for _ in range(100):  # Number of iterations per temperature

            new_solution = neighbor_func(current)

            new_cost = cost_func(new_solution)

            delta = new_cost - current_cost



            if delta < 0 or random.random() < math.exp(-delta / T):

                current = new_solution

                current_cost = new_cost



        T *= alpha  # Cooling down



    return current, current_cost

# Example: Finding the minimum of a function

def cost(x):

    return x**2  # Simple quadratic function

def neighbor(x):

    return x + random.uniform(-1, 1)

best_solution, best_cost = simulated_annealing(10, cost, neighbor, 100, 0.95, 0.1)

print(f"Best solution: {best_solution}, Best cost: {best_cost}")

Compute the Reverse Polish Notation using Perl

seng — Sat, 18 Oct 2025 14:08:31 +0000

use feature "switch";  
    # Construct operator priority data  
    %priority_of_operation=(  
    '+'=>1,  
    '-'=>1,  
    '*'=>2,  
    '/'=>2,  
    '('=>0,  
    ')'=>0  
    );  
    # Expression to be calculated  
    $prepare_exec="5.98+((1+2211.12)*4)-3";  
    $prepare_endexpres=$prepare_exec;  
    # Convert to Reverse Polish Notation  
    # Create operator stack for storing operators  
    @operationstack=qw();  
    $exeexpress=$prepare_endexpres;  
    $result="";  
    print "String to scan: $exeexpress\n";    
    while (length($exeexpress)>0)  
    {  
    # Scan expression sequentially, if current character is a number, output it directly  
    if ($exeexpress =~ /^(\d+)/ | $exeexpress =~/^((\d+)\.(\d*))/){  
       print "Number: $1\n";      
       $result.=($1." ");     
       print "Expression: $result\n";  
       $exeexpress=substr($exeexpress,length($1),length($exeexpress)-length($1));  
       print "String to scan: $exeexpress\n";     
    }  
    # If current operator is '(', push directly to stack     
    elsif($exeexpress =~ /^\(+?/){     
       print "Operator: (\n";      
       print "Operator ( pushed to stack\n";    
       push @operationstack,"(";    
       print "Current operator stack: @operationstack\n";  
       print "Expression: $result\n";     
       $exeexpress=substr($exeexpress,1,length($exeexpress)-1);     
       print "String to scan: $exeexpress\n";        
    }     
    # If it's ')', pop and output operators sequentially until encountering first '(', first '(' is popped but not output     
    elsif($exeexpress =~ /^\)+?/){     
        print "Operator: )\n";           
        $temp=pop @operationstack;  
        while ($temp ne "(") {     
           $result.=($temp." ");     
           print "Operator $temp popped, expression: $result\n";  
           $temp=pop @operationstack;    
           print "Current operator stack: @operationstack\n";   
        }           
        $exeexpress=substr($exeexpress,1,length($exeexpress)-1);         
        print "String to scan: $exeexpress\n";          
    }   
    # If it's arithmetic operator, compare priority of top stack element with current element. If priority of top stack element operator >= priority of current element, pop and output operators sequentially until priority of top stack element < priority of current element, then push current element to stack;   
    elsif($exeexpress =~/^(\+|\-|\*|\/)?(.*)$/)  
    {  
        print "Operator: $1\n";   
        print "Current operator stack: @operationstack\n";   
        $curoperation=$1    ;   
        $topoperation=pop @operationstack;  
        push @operationstack,$topoperation;       
        if ($topoperation){  
            if ($priority_of_operation{$curoperation}>$priority_of_operation{$topoperation})  
            {  
                # If this character's priority is higher than the operator at top of operator stack, push this operator to stack  
                push @operationstack,$curoperation;       
                print "Operator $curoperation pushed to stack\n";  
                $exeexpress=substr($exeexpress,1,length($exeexpress)-1);      
                print "String to scan: $exeexpress\n";               

            }  
            else{  
    # If priority of top stack element operator >= priority of current element, pop and output operators sequentially until priority of top stack element < priority of current element, then push current element to stack;   
                while ($priority_of_operation{$curoperation}<=$priority_of_operation{$topoperation})  
                {  
                    $topoperation=pop @operationstack;    
                    if (not $topoperation) {  
                        last;  
                    }  
                    $result.=($topoperation." ");  
                    print "Operator $topoperation popped, expression: $result\n";  
                }  
                push @operationstack,$curoperation;  
                $exeexpress=substr($exeexpress,1,length($exeexpress)-1);      
                print "String to scan: $exeexpress\n";               
            }  
        }  
        else{  
                push @operationstack,$curoperation;  
                print "Expression: $result\n";   
                $exeexpress=substr($exeexpress,1,length($exeexpress)-1);      
                print "String to scan: $exeexpress\n";               
        }  
        print "Current operator stack: @operationstack\n";  
    }  

    }  
    while ((scalar @operationstack)>0){  
        $result.=pop @operationstack;  
    }  
    print "Expression: $result\n";   
    $mycode=$result;  
    @waitingexe=split (" ",$mycode);  
    $mylength= scalar  @waitingexe;  
    print "Reverse Polish Notation to calculate: $mycode\n";  
    print "Starting Reverse Polish Notation calculation\n";  
    @exestack=qw();  
    # Output current stack contents  
    print "Current stack contents: @exestack\n";  
    for ($i=0;$i<$mylength;$i++){  
    # Start Reverse Polish Notation calculation  
     $myvar=$waitingexe[$i];  
     print "Element read: $myvar   =>";  
     given ($myvar){  
        when ("+") { $num2=pop @exestack;$num1=pop @exestack; $result=$num1+$num2;push @exestack,$result;print "$num1+$num2=$result, $num2 and $num1 popped, $result pushed\n";}  
        when ("-") { $num2=pop @exestack;$num1=pop @exestack; $result=$num1-$num2;push @exestack,$result;print "$num1-$num2=$result, $num2 and $num1 popped, $result pushed\n";}  
        when ("*") { $num2=pop @exestack;$num1=pop @exestack; $result=$num1*$num2;push @exestack,$result;print "$num1*$num2=$result, $num2 and $num1 popped, $result pushed\n";}  
        when ("/") { $num2=pop @exestack;$num1=pop @exestack; $result=$num1/$num2;push @exestack,$result;print "$num1/$num2=$result, $num2 and $num1 popped, $result pushed\n";}  
        # Numbers pushed directly to stack  
        default    {push @exestack,$myvar;print "$myvar pushed to stack\n";}  
    }  
        # Output current stack contents  
        print "Current stack contents: @exestack=>";  
    }  
    $endresult=pop @exestack;  
    print "Result: $endresult\n";  

    sub trim  
    {  
            my $string = shift;  
            $string =~ s/^\s+//;  
            $string =~ s/\s+$//;  
            return $string;  
    }

The above code evaluates a mathematical expression.
We will use the following example to illustrate the computation process.
The infix expression "5 + ((1 + 2) * 4) - 3" is written in Reverse Polish Notation as:

5 1 2 + 4 * + 3 -

The table below illustrates the step-by-step evaluation of this RPN expression from left to right.

Input	Action	Stack	Comment
5	Push	5
1	Push	5, 1
2	Push	5, 1, 2
+	Addition	5, 3	Pop (1, 2); push result (3)
4	Push	5, 3, 4
*	Multiplication	5, 12	Pop (3, 4); push result (12)
+	Addition	17	Pop (5, 12); push result (17)
3	Push	17, 3
-	Subtraction	14	Pop (17, 3); push result (14)

When the calculation is complete, only one operand remains in the stack, which is the final result of the expression: 14.

how to use JAX library for matrix manipulation

seng — Sat, 18 Oct 2025 13:53:30 +0000

SPMD

JAX supports the Single-Program Multi-Data (SPMD) paradigm. This allows the same computation to be performed across multiple devices. JAX doesn't require that all data is partitioned across the same devices. This means data can be distributed over different devices such as GPUs, CPUs, and TPUs for parallel processing.
jax.jit

The jax.jit function improves the computational efficiency by applying Just-In-Time (JIT) compilation to a JAX function. The effectiveness of jax.jit stems from a fundamental principle that each function is decomposed into a sequence of primitive operations, where every element represents a fundamental unit of computation.

import jax.numpy as jnp
from jax import jit

# Define matrices
a = jnp.array([[1, 2], [3, 4]])
b = jnp.array([[5, 6], [7, 8]])

print("Matrix A:")
print(a)
print("\nMatrix B:")
print(b)

# Matrix addition
matrix_sum = a + b
print("\nMatrix Addition (A + B):")
print(matrix_sum)

# Element-wise matrix multiplication
elementwise = a * b
print("\nElement-wise Multiplication (A * B):")
print(elementwise)

# Matrix dot product
dot_product = jnp.dot(a, b)
# Or use the @ operator
dot_product_alt = a @ b
print("\nMatrix Dot Product (A @ B):")
print(dot_product)

# Matrix transposition
transpose = a.T
print("\nMatrix A Transpose:")
print(transpose)

# Inverse matrix
try:
    inv = jnp.linalg.inv(a)
    print("\nInverse of Matrix A:")
    print(inv)
except:
    print("\nMatrix A is not invertible")

# Determinant
det = jnp.linalg.det(a)
print("\nDeterminant of Matrix A:")
print(det)

# SPMD and JIT compilation example
@jit
def matrix_operations(x, y):
    """Matrix operation function using JIT compilation"""
    dot = x @ y
    transpose = x.T
    return dot, transpose

# Using the JIT compiled function
result_dot, result_transpose = matrix_operations(a, b)
print("\nJIT Compiled Results:")
print("Dot Product:")
print(result_dot)
print("Transpose:")
print(result_transpose)