DEV Community: Priscila Gutierres

Zeros of Polynomial Equations in the Complex Plane

Priscila Gutierres — Sat, 20 Dec 2025 19:52:48 +0000

Abstract

In this article we will discuss Laguerre's algorithm for finding zeros of polynomial equations of degree n in the complex plane. We will derive a particular case and analyze convergence for simple roots. We will discuss and verify some examples using the implemented algorithm, showing some of its virtues and limitations.

1. Introduction

The problem of finding zeros of a polynomial of degree n has substantially influenced the development of mathematics through the centuries and is still quite important in practical and theoretical applications.

Currently, the study of polynomials of the form

\sum_{i=0}^n a_i z^i \quad (1)

does not play a central role in mathematics or applied mathematics. In particular, many of the problems that arise are linearized and solved using linear algebra tools and fast Fourier transforms, which may involve roots of polynomial equations.

However, equations of this type are still of interest in some areas of applied mathematics and algorithms continue to be developed and studied.

As was proven in 1827 by Abel, for polynomials of degree equal to or greater than 4 it is not possible to find a formula to obtain the exact solution, and therefore, any problem that requires the solution of such a polynomial requires us to use numerical methods.

In the present article we discuss Laguerre's method in the complex plane and an implementation of it with some different types of polynomials.

2. Theorical Results

2.1 Initial Definitions and Theorems

Definition 1: We say that an algorithm has convergence order

\alpha

at root

\eta

if,

\lim_{n \rightarrow \infty} \frac{|z_{n+1} - \eta|}{|z_n - \eta|^\alpha} = C \quad (2)

Definition 2: A numerical method is said to be global if it does not require an initial value sufficiently close to the zero of the polynomial to converge, otherwise we say it is local.

Theorem 1: Let p(z) be a polynomial of degree n, n > 1, with complex coefficients. Then p(z) has n complex roots.

Theorem 2: Let p(z) be a normalized polynomial with degree m > 4 and let

{p_i : i \in {1,...,l}}

be the set of roots. For

u_0 \in \mathbb{C} \setminus P

with

p'(u_0) \neq 0

p''(u_0) \neq 0

the sequence

L_p(u_0) = (u_n)_{n \in \mathbb{N}}

defined by:

u_{n + 1} = u_{n} - \frac{m}{q(u_{n}) + s(u_{n})r(u_{n})} \quad (3)

with

\in \mathbb{N}

and

\frac{p'(z)}{p(z)}

\sqrt{(m-1)(mt(z) - q^2(z))}

where

q^2(z) - \frac{p''(z)}{p(z)}

and

\left\lbrace \begin{array}{ll} 1, & \text{if } (\text{Re}\, q(z))(\text{Re}\, r(z)) + (\text{Im}\, q(z))(\text{Im}\, r(z)) \geq 0 \ \ -1, & \text{otherwise} \end{array} \right.

, with

q(u_n) + s(u_n)r(u_n) \neq 0

If there exists a simple root

\in P

such that

$∣u0−p∣≤12m−1min⁡∣p−pi∣,p∈P|u_0 - p| \leq \frac{1}{2m-1} \min{|p - p_i|, p \in P}$

then

L_p(u_0)

converges to the limit p and

$∣un−p∣≤λn∣u0−p∣|u_n - p| \leq \lambda^n|u_0 - p|$

with

\lambda = \frac{15} {16}

for all

\in \mathbb{N} \setminus {0}

If all roots of p(z) are simple, then in 2.,

\mu_p = \min{|p - p_i|, p \in P \setminus {p_i}}

can be replaced by the lower bound

\frac{1}{d_0} \max_{1 \leq j \leq \binom{m}{2}} |d_j|)^{-\frac{1}{2}} < \min{\mu_p | p \in P}

with coefficients

d_j

of the polynomial

D_p(z) = \prod_{1 \leq i < k \leq m}(z - (p_i - p_k)^2) = \sum_{j=0}^{\binom{m}{2}} d_j z^j \quad (4)

These coefficients can be calculated using only coefficients of p(z). All roots of p(z) are simple if, and only if,

d_0 \neq 0

Theorem 3: Let

\sum_{i=0}^{n} a_i z^i

be a polynomial. We can evaluate its value at a point using the following procedure:

P_0(z) = a_n

P_i(z) = a_{n-i} + zP_{i-1}(z), \quad i \in {1,...,n}

The proof is immediate, simply rewriting the polynomial.

Theorem 4 (Horner's Algorithm for Polynomial Division): Let

P_n(z) = (z-r)P_{n-1}(z)

be a polynomial.

Then, if

P_{n-1}(z) = b_0 + b_1z + b_2z^2 + ... + b_{n-1}z^{n-1}

, we have:

b_{n-1} = a_n, \quad b_{n-2} = a_{n-1} + rb_{n-1}, \quad b_0 = a_1 + rb_1

To prove this result, simply equate the coefficients on both sides.

2.2 Laguerre's Method

Let

P_n(z)

be a polynomial of degree

\geq 1

By Theorem 1, we have

P_n(z) = (z - z_1)(z - z_2)...(z - z_n) \quad (5)

therefore,

\log|P_n| = \sum_1^n \log|z - z_i| \quad (6)

and then,

\frac{d\log|P_n|}{dz} = \sum_1^n \frac{1}{(z - z_i)} = \frac{P_n'}{P_n} \quad (7)

-\frac{d^2\log|P_n|}{dz^2} = \sum_1^n \frac{1}{(z - z_i)^2} = -\frac{P_n''}{P_n} \quad (8)

We define equations (7) and (8) as G and H, respectively, we have

H = G^2 - R

where

\frac{P_n''}{P_n}

To proceed, we will assume that the sought root

z_1

is isolated from the others by a distance, such that

z_1 \quad (9)

z_i, \quad i \in {2,...,n} \quad (10)

Thus,

\frac{1}{a} + \frac{n-1}{b} = G \quad (11)

\frac{1}{a^2} + \frac{n-1}{b^2} = H \quad (12)

And therefore,

\frac{n}{G \pm \sqrt{(n-1)(nH - G^2)}} \quad (13)

Such that we take

max⁡±(n−1)(nH−G2)\max{\pm\sqrt{(n-1)(nH - G^2)}}

so that the step has the smallest possible size.

Since the factor inside the root can be negative, a can be a complex number.

If the root of the polynomial is simple, it is proven that the method converges cubically. If the root is multiple, we have linear convergence.

Theorem 2 determines for each simple root a disk centered on it, such that for all initial values in this neighborhood the convergence of the root is guaranteed.

Thus, this method offers the possibility of convergence to a complex root and if the polynomial has only real roots, it is guaranteed that the method converges independently of the given initial point, therefore convergence in this case is global.

3. Algorithm

The algorithm was developed in C language and designed to run on compilers like GCC that support the C99 and C11 standards. In these standards, the complex.h library is implemented with functions for working with complex numbers in a simple and elegant way.

Using some of the results from the section above, the necessary libraries were built for calculating the value of the polynomial at a point, polynomial division, and the method's algorithm.

The evalpoly.h and deflation.h libraries were developed from Theorems 3 and 4, respectively, just as the main algorithm, laguerre.h, was made according to what was developed in the second part of the previous section.

Rounding errors occur mainly when the deflate (deflation.h) and evalpoly (evalpoly.h) functions are called. Therefore, the calculations were done with long double to try to minimize rounding errors.

4. Results and Discussion

Several tests were performed, among which those listed in the table below.

For low-degree polynomials, we note that the precision of the solution is remarkable, allowing, for example, to calculate the square root approximation with up to 13 decimal places of precision.

We can note, according to the results obtained, that for roots with multiplicity less than or equal to 10, the algorithm behaves exceptionally well, since it was not developed with this type of problem in mind. From higher degrees onwards, we begin to notice problems such as divergence of the polynomial solution, which could not be circumvented by increasing the maximum number of iterations (since, as this method converges linearly for multiple roots, we expect to need a large number of iterations for this type of problem).

For polynomials with simple roots and slightly higher degrees

n > 10

we notice better behavior, but as shown in the penultimate and last polynomials in the table, the algorithm diverged in calculating the last root, finding only 13 of 14 existing roots.

We also note that as the degree of the polynomial increases considerably, the precision drops drastically.

Test Results Table

5. Conclusion

For a first implementation, the algorithm presents good performance, but with more time and in a longer project it would be possible to considerably improve its performance, since in its current state it could not be used in a production environment to solve high-performance problems (such as in software like Mathematica or MATLAB).
The complete project can be found here.

References

Pan Y., Victor, Solving a Polynomial Equation: Some History and Recent Progress, SIAM Review, Vol. 39, No. 2 (Jun., 1997), pp. 187-220.
Ahlfors, Lars, Complex Analysis, McGraw-Hill, 1979.
Moller, Herbert, Convergence and visualization of Laguerre's rootfinding algorithm, January 9, 2015.
Acton S. Forman, Numerical Methods that work, The Mathematical Association of America, 1990.
Kiusalaas, Jaan, Numerical Methods in Engineering with Python 3, Cambridge, 2013.

Feature Engineering for Code Quality Evaluation

Priscila Gutierres — Sun, 21 Sep 2025 08:35:50 +0000

Our key here is to transform source code files into somthing measurable, in order to provide meaningful insights and find patterns to identify potential vulnerabilities and general bugs due to coding practices.

Some common measurements are:

Number of code lines
Number of nested functions
Number of recursions
Number of defined functions
number of defined classes
- number of defined methods inside a class
Cyclomatic Complexity

Cyclomatic complexity is an important metric, published by T.J. McCabe in 1976, to illustrate how to manage and control source code complexity independently of the size, relying on only the structure to quantify it.
As an example, we can evaluate two pieces following pieces of Python code.

 if price > 200:
    if recurring_customer:
        if season == 'summer'
            discount = 0.3
        else discount = 0.15
else:
    discount = 0.01

the following graph represents the code:

Using the usual definition for cyclomatic complexity,

M = E - N + 2P, where

E, is the number of edges of the graph
N, is the number of nodes of the graph
P, is number of connected components

we get a cyclomatic complexity number of M = 10 - 8 + 2(1) = 4.

if price > 200:
    if recurring_customer:
        if season == 'summer':
            discount = 0.3
        else: 
            discount = 0.15
    else: 
        discount = 0.01

Getting again a cyclomatic complexity number M=10−8+2(1) = 4.

Cyclomatic complexity is directly related to the number of decision points (branches) in the code.
Although the structure of the paths has changed, the number of decisions (if statements) has remained the same (3). Therefore, the number of independent paths that need to be tested is still four.

pylint can be used to automatically calculate it in this experiment.

Back to the main discussion, the number of features were kept at a bare minimum in order to ensure that one can use simple tools like grep, awk, cut, sed and pylint (in the case of a Python code) to extract all the needed features.

After getting a dataset created using your code base data, with columns representing all the described features and lines your source code files, you can use PCA as explained in my PCA article to optimize the number of the features.
K-Means (example here) can be applied to evaluate the result creating a heat map and grouping similar code to have a better overview about the main structure of your code base.

Enhancing Upper Limb Rehabilitation with Unsupervised Machine Learning Models

Priscila Gutierres — Sun, 18 May 2025 11:39:24 +0000

Introduction

This article proposes a support system designed to assist healthcare professionals in upper limb motor rehabilitation. The system analyzes patient movement data collected through AR/VR-based games like e-Puzzle, which captures joint angle measurements (shoulderLangle, elbowRangle, etc.) and movement patterns during rehabilitation sessions. By employing unsupervised machine learning techniques - including K-Means clustering and Self-Organizing Maps (SOM) for patient classification, combined with Principal Component Analysis (PCA) for dimensionality reduction, the system identifies distinct movement patterns and provides quantitative assessments of rehabilitation progress.
The processed data is then visualized through an interactive dashboard, enabling physicians to monitor patient evolution and optimize treatment protocols based on data-driven insights.
The architecture follows a client-server model where movement data from multiple treatment sessions is centrally processed and stored. This approach addresses the need for comprehensive movement analysis noted in the study's motivation, while overcoming limitations of traditional rehabilitation methods that lack detailed performance tracking. The system's analytical capabilities are particularly valuable for identifying subtle variations in movement amplitude (ADM) that may indicate recovery progress or the need for treatment adjustment, ultimately supporting clinical decision-making in motor rehabilitation.

Key contributions of this work include:

A client-server architecture, which processes data collected from the patient’s device, enabling multiple treatment sessions across different patients to communicate with a centralized data storage layer.
Unsupervised learning models (K-means and Self Organizing Maps) classify patients into clusters based on movement amplitude—low, medium, and normal range. With larger datasets, the system can refine cluster accuracy, enhancing pattern detection and providing deeper insights for healthcare professionals.
An interactive dashboard visualizes patient performance metrics and rehabilitation progress over time, presenting processed movement data (including joint angles and amplitude measurements) through intuitive visualizations. The interface provides healthcare professionals with immediate access to quantitative analyses - such as cluster classifications and variance trends - in a single centralized view.

Applications in Motor Rehabilitation

This article presents a client-server system for motor rehabilitation that collects upper limb movement data through AR/VR-based games like e-puzzle, tracking joint angles and movement amplitudes (shoulderLangle, elbowRange, etc.) using unsupervised learning methods (K-means, SOM). These techniques automatically cluster patients into distinct movement pattern groups, as demonstrated by the three clusters identified in the study (low, medium, and normal range of motion). Clinical annotations of movement quality (e.g., "improved" or "regressed") combined with existing goniometric assessments could enable predictive models to track recovery progress and potentially offer real-time feedback during rehabilitation sessions.

Unsupervised Machine Learning Methods

We now present the analytical framework developed to classify upper limb movement patterns in motor rehabilitation, focusing on three core techniques: Principal Component Analysis (PCA), K-Means clustering, and Self-Organizing Maps (SOM). The methods were applied to movement data collected from AR/VR-based rehabilitation sessions (e.g., e-Puzzle), with the goal of identifying distinct patient clusters based on kinematic features such as joint angles (shoulderLangle, elbowRange) and movement amplitude (ADM).

Principal Component Analysis (PCA) was first employed to reduce the dimensionality of the dataset while preserving its essential structure. The analysis revealed that the first three principal components (PCA1, PCA2, PCA3) accounted for 78.14% of the total variance in movement patterns, with PCA1 alone explaining 39.34%. This reduction allowed for efficient visualization and processing of the data without significant loss of meaningful information. The components primarily captured variations in shoulder and elbow movements, highlighting their importance in distinguishing between different rehabilitation profiles.

The K-Means clustering algorithm was applied to categorize patients based on their movement characteristics during rehabilitation sessions. To determine the optimal number of clusters, the elbow method was employed by calculating the sum of squared errors (SSE) for cluster solutions ranging from k=1 to k=9. The resulting showed a distinct elbow point at k=3, indicating this as the most appropriate number of clusters to capture the natural grouping in the movement data while avoiding overfitting. This finding was further validated using the jump method, which similarly identified three clusters as optimal.

The resulting patient groups - classified as low, medium, and high movement ranges - demonstrated clear separation across key biomechanical features. Particularly notable differences appeared in shoulderRangle and shoulderLTransv measurements, with Cluster 0 showing significantly higher variance in these parameters compared to Clusters 1 and 2. This variability pattern suggests that patients in Cluster 0 exhibited more diverse movement strategies during rehabilitation exercises. The cluster centroids revealed progressive improvement in movement amplitude across the three groups, providing physicians with an objective framework for assessing rehabilitation progress and customizing treatment plans.

The visualization below presents the final K-Means clustering results, showing the distribution of patients across the three movement pattern groups and their characteristic kinematic profiles. This quantitative classification system enables more precise tracking of recovery trajectories and supports data-driven adjustments to therapy protocols.

The Self-Organizing Map (SOM) analysis revealed three distinct clusters of patient movement patterns during upper limb rehabilitation. This method does not rely on a number of clusters provided by the user and is a good choice to compare the results obteined by it to K-Means. The topological mapping preserved nonlinear relationships in the kinematic data, with particular differentiations visible in features like medianelbowRangle and mediankneeLangle. Below, we have the results using SOM.

Cluster 1 showed higher median values across most movement features, while Cluster 2 displayed more restricted ranges , suggesting varying rehabilitation progress levels among patients.

Patient Performance Visualization Dashboard

The interactive dashboard serves as the primary interface for healthcare professionals to monitor and evaluate patient progress during upper limb rehabilitation. Designed for intuitive use, it presents processed movement data collected from AR/VR sessions (e.g., e-Puzzle) through multiple visualization components that highlight key biomechanical metrics and rehabilitation trends.

The dashboard displays filtered movement signals using Savitzky-Golay filter smoothing to remove noise while preserving clinically relevant patterns in joint angle measurements.
We are using cluster analysis results from K-Means algorithm, which is visually represented, showing how individual patients align with the three identified movement pattern groups (low, medium, and normal range). Box plots and amplitude graphs provide statistical summaries of movement characteristics, enabling quick assessment of patient performance relative to their cluster group.
The interface allows selection of specific sessions for detailed review, with all quantitative metrics (medians, variances) accessible in a unified view. Designed with clinical usability in mind, the dashboard transforms complex movement analytics into actionable insights, supporting data-driven adjustments to rehabilitation protocols. Future enhancements could incorporate longitudinal progress tracking and predictive analytics based on the accumulated session data.

Conclusion

This article presents a comprehensive support system that enhances upper limb motor rehabilitation through advanced data analytics and interactive visualization. The integration of unsupervised machine learning techniques—such as PCA for dimensionality reduction, K-Means clustering for patient classification, and SOM provides a robust way for identifying distinct movement profiles and assessing rehabilitation outcomes.
The interactive dashboard synthesizes these analytical insights into an intuitive interface, empowering healthcare professionals to make data-driven decisions and tailor rehabilitation protocols effectively.
Together, these innovations address critical gaps in traditional rehabilitation methods, offering a sophisticated tool for monitoring recovery, detecting subtle movement variations, and optimizing therapeutic interventions.
This system not only advances the field of motor rehabilitation but also demonstrates the transformative potential of combining immersive technologies with machine learning to improve clinical decision-making and patient outcomes.

This article is based on my master's dissertation "Treatment Support System for Upper Limb Motor Rehabilitation" , Universidade de São Paulo, 2024. It is a FOSS project.

PCA & K-Means clustering made simple (with the math behind it) using iris dataset

Priscila Gutierres — Fri, 09 Aug 2024 20:44:04 +0000

PCA

The great tutorial made by Jonathon Shlens explain the basis of it, deriving the Linear Algebra motivation. It comes from the Spectral Theorem, as the SVD theorem being a consequence of it. A consequence of this choice is that when using this algorithm, we assume that our problem is linear. The final decomposition will throw an orthogonal basis.
The theorem is enunciated below:

The fact that the SVD can be derived from the assumption of linearity justifies the use of PCA for data that is well-modeled by linear relationships.

Other assumption is that larger associated variances
have an important structure to our problem and lower variances just represent some kind of noise, but this is not always true.
There are scenarios where the lower variance components might encapsulate subtle but crucial patterns or nuances within the data. These could be related to rare events, outliers, unbalanced data or complex interactions that are not readily apparent in the high-variance components. Neglecting these lower variance components can lead to a loss of valuable information and potentially inaccurate or incomplete insights.

It's crucial to approach the interpretation of PCA results with a degree of skepticism and not automatically dismiss the lower variance components as irrelevant. A thorough examination of their potential significance is often advisable, particularly in domains where subtle details matter or where the data exhibits complex, non-linear relationships.
PCA offers a powerful tool for dimensionality reduction and data exploration, but it's important to be mindful of its inherent assumptions and limitations.

K-Means Clustering

Next up is K-Means, a clustering algorithm acting as some "flower sorting machine", automatically grouping the given flowers based on their similarities, and helping us to discover patterns we might have missed.

One of the many clustering techniques used is K-Means, which partitions a dataset into k distinct groups by minimizing the sum of the squares of the distances between the data points and the respective center of each of them, named centroids. We may say that a successful clustering result in a group of points that are related to each other in our dataset.
Summarizing the algorithm, we initialize all the given points by creating k empty clusters and normalizing all the following points, and random centroids are associated within each cluster.
Then, we assign to each cluster the points whose centroid is closest, recalculating the following centroid so that it is at the average of each of the created clusters.
These steps are repeated until a predefined maximum number of iterations or when they no longer move.

Cluster analysis aims to identify groups of objects with similarities in order to discover a distribution of patterns in datasets.
The clustering problem is characterized by discovering groups and identifying distributions and patterns in the data. In this process, there are no predefined classes and desirable relationships that have to be valid between the data being mined.

Note that here we are not using a method like Elbow to estimate the number of clusters because we have the previous information telling us that are 3 different classes of flowers.
Although in this specific case we have prior knowledge about the number of flower classes, in many real scenarios this information is not available. In these cases, techniques such as the Elbow method or other cluster evaluation metrics, such as the silhouette coefficient, can be used to estimate the ideal number of clusters.

Evaluating the results

And how to evaluate our result? To visualize all the groups within their properties, we extracted the original features creating bar charts to see the mean value of them.

After running K-means and assigning each data point to a cluster, we calculate the average (mean) value for each feature within each cluster. This give us a summary of the typical characteristics of the data points within each group we got.
Then, ploting a bar chart where each cluster is represented by a group of bars and where each bar within a group corresponds to a specific feature, we may start analysing our results. Its height represents the average value of that feature for that cluster.

If the clusters are well-separated, you should see clear differences in the bar heights between clusters for at least some of the features. This indicates that the clusters capture distinct patterns in the data.

This method is most effective when the features are numerical and have meaningful interpretations.
If the features are categorical or have vastly different scales, other visualization techniques or evaluation metrics might be more appropriate.

To illustrate all the above concepts, I created this notebook using iris dataset as a complete example.

Como aplicar para vagas de grandes empresas americanas começando do zero

Priscila Gutierres — Wed, 14 Feb 2024 13:38:37 +0000

O foco desse texto não é sobre competências técnicas, e sim como aplicar para uma vaga que, mesmo que seja focada no mercado brasileiro, seja de uma empresa americana que exija comunicação em inglês.
Ao longo de todo esse tempo indicando pessoas para vagas na Red Hat, eu tenho visto sistematicamente vários tipos de erros que podem fazer com que a pessoa não seja chamada para a fase de entrevistas, e o mais recorrente é mandar o CV em português, por exemplo.
Além disso, muitas pessoas como eu quando comecei, já tiveram um contato com a lingua inglesa, porém não tem fluência ao falar e se sentem inseguras ao se expressar em inglês.
Soma-se a isso alguns possíveis outros fatores, como limitações financeiras e até a introversão.
Se você ainda está em um estágio muito inicial, eu estimaria que esse é um projeto pessoal de no mínimo um ano de muita dedicação.

Para começar, adquira um bom livro de gramática completamente em inglês, mesmo que você não tenha vocabulário.
Eu utilizei o Essential Grammar in Use, que eu comprei em um sebo por menos de 20 reais.
Mesmo que você comece traduzindo palavra por palavra, você consegue ganhar vocabulário com essa tarefa cumulativa.
Além disso, troque o idioma de todos os seus dispositivos para o inglês e comece a entender as letras das músicas que você gosta. Só fazendo isso você já vai ganhar um vocabulário enorme.
Para o próximo passo, comece a ler textos em inglês e a assistir vídeos em inglês com as legendas automáticas em inglês, não em português. Isso ajuda MUITO no listening.
Depois de um longo tempo em todas essas etapas, vem o chefão final: o speaking.
Se você é uma pessoa tímida ou neurodivergente, que além de ser dura não tem energia pra ter um professor particular e ter que interagir com um estranho, a modernidade tem a solução para o seu problema: o app ELSA, que está disponível para iOS e Android.
Eu tenho usado esse app há mais de um ano e tenho tido resultados incríveis, minha desenvoltura tem melhorado muito desde que comecei a utilizá-lo. Ele é crucial pra você se sentir confortável em uma entrevista em inglês, sem suar frio e sem saber que expressão você pode usar pra expressar as suas ideias.A versão paga do app é de aproximadamente 40 reais por mês e você pode praticar à vontade, é muito menos limitado que o Cambly e super efetivo.

E resumo da ópera... Fazendo tudo isso, dedicando-se, com certeza você conseguirá se sair bem em uma entrevista nesse aspecto. E lembre-se do essencial: não nativos cometem erros (às vezes grosseiros) e estrangeiros não se importam muito com isso, até porque você pode muitas vezes ter um conhecimento maior em línguas do que ele, que provavelmente só consegue se expressar em um único idioma.

Python decorators - a quick introduction

Priscila Gutierres — Sat, 06 Jan 2024 23:37:36 +0000

A decorator is a function that takes a function as input and returns another function, adding functionalities or replacing the entire fuction itself.
It is applied when the function is defined.

from functools import wraps
def timethis(func):
    ''' this decorator reports execution time '''
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(func.__name__, end -start)
        return result
    return wrapper

According to the official documentation, @functools.wraps is a convenience function for invoking update_wrapper() as a function decorator when defining a wrapper function.
If you forget to use @wraps, the decorated function will lose its name, docstring, annotations and calling signature.
Using @wraps , we can inject code to be executed alongside a given function, without losing function metadata.
In the given example, we start counting time before executing the original function, then stopping when it returns and print the time interval.

from time import sleep

@timethis
def timer(seconds):
    ''' creat a timer'''
    time.sleep(seconds)

Defining a more useful decorator taking arguments (mandatory or optional)

Let's code a logging decorator to our timer function

import logging
def logged(level, name = None, message = None):
     ''' add logging '''
     def decorate(func):
        logname = name if name else func.__module__
        log = logging.getLogger(logname)
        logmsg = message if message else func.__name__
        @wraps(func)
        def wrapper(*args,**kwargs):
            log.log(level, logmsg)
            return func(*args, **kwargs)
        return wrapper
     return decorate

Decorating the function

@logged(logging.CRITICAL, 'example')
def timer(seconds):
    sleep(seconds)

In this example, we have a decorator taking our custom arguments and then returning a decorator. This decorator then is applied to the function we want to decorate.

def logged(func = None, *, level = logging.DEBUG, name = None, message = None):
     ''' add logging '''
     if func is None:
         return partial(logged, level=level, name=name, message=message)

     def decorate(func):
        logname = name if name else func.__module__
        log = logging.getLogger(logname)
        logmsg = message if message else func.__name__
        @wraps(func)
        def wrapper(*args,**kwargs):
            log.log(level, logmsg)
            return func(*args, **kwargs)
        return wrapper
     return decorate

To create a decorator that takes no arguments, and avoid the calling conventions between decorators without any arguments and decorators with arguments, we use partial to return a new partial object which when called behaves like func called with the positional arguments args and keyword.

Can a decorator be defined as a class?

Also, decorators can be defined as classes and can be applied to class and static methods.

In fact, a decorator can be defined as a class, like @property, with a get, a set and a del method.

There are a lot more about decorators.
To really understand how decorators work you need to understand the variable scoping, closures, mtaclasses and descriptors.
I strong recommend you to read Fluent Python and Python Cookbook.

A recipe made to create your first PR for the Fedora Project

Priscila Gutierres — Thu, 19 Oct 2023 11:47:05 +0000

Step 0: Creating your Fedora account and installing Fedora

Go to https://accounts.fedoraproject.org, and click on Register following the next steps to create your Fedora account.
Go to Fedora download page, download and install the latest Fedora version.
Alternatively, create a Fedora container using podman.

Step 1: Set up your Fedora environment

Install and configure your packaging tools

I strong recommend you to install the development tools group:

dnf install @development-tools

Step 2: Find some package needing an update

First of all, you have to create your Bugzilla account When a package needs an update, an automatic bz is created, so you can use a query like this one below:

Then, clone it using fedpkg. For example, for python-pluggy we have:

fedpkg clone --anonymous python-pluggy

Step 3: Making your own changes

Go to Fedora Packager Sources, fork the project and change your remote origin.

It didn't work for me cloning the project directly from my own fork, I had problems when trying to upload my changes.

cd ./python-pluggy
git remote remove origin

Then, add your remote origin

git remote add origin https://src.fedoraproject.org/forks/<your_fedora_user>/rpms/python-pluggy.git

Check the project's github page. In this case,looking at the Changelog, the latest version is 1.3.0 .
Open the specfile with your favorite editor:

cd ./python-pluggy
code python-pluggy.spec

Change the Version string:

Version:        1.3.0

You also need to change the Release string to 1, because is the first build of this new version:

Release:        1%{?dist}

Now we are going to download the sources to create our local build:

spectool -g <your_package>.spec

Create your local mockbuild:

fedpkg mockbuild

Step 4: Checking results & troubleshooting

If you get an output like that:

(...)
Finish: build phase for python-pluggy-1.3.0-1.fc40.src.rpm
INFO: Done(/home/priscila/Fedora/packages/fedpkg/python-pluggy/python-pluggy-1.3.0-1.fc40.src.rpm) Config(fedora-rawhide-x86_64) 0 minutes 30 seconds
INFO: Results and/or logs in: /home/priscila/Fedora/packages/fedpkg/python-pluggy/results_python-pluggy/1.3.0/1.fc40
INFO: Cleaning up build root ('cleanup_on_success=True')
Start: clean chroot
Finish: clean chroot
Finish: run

Go to the next step :-)

Otherwise, is time to debug what is going on.
Common issues are:

A new BuildRequirement is needed: if apparently a package is missing during the build time, check for new dependencies in the Changelog.
A test is failing: in this case, you need to debug the source code. Is absolutely necessary have a strong knowledge about the programming languages in the package you are working on
If nothing works and you are still in trouble.
Note that some tests are not supported by koji during the build time.
A new patch is needed: this article covers this case.

Step 5: Finish editing the specfile

Now that everything is working as expected, you have to add the changelog to the specfile:

%changelog
* Tue Oct 17 2023 Priscila Gutierres <pgutier@redhat.com> - 1.3.0-1
- Update to 1.3.0.

Add the sources:

fedpkg new-sources --offline pluggy-1.3.1.tar.gz

Add and commit the changes using git

Step 6: Creating your Pull Request

As a non-maintainer, you can't upload the sources, so when creating your PR, the checking pipeline will fail.
To fix it, ask the maintainer to upload the sources.
And.. Congrats! You have your first Fedora contribution :-)

Manipulação de portas no Arduino usando registradores e operações lógicas

Priscila Gutierres — Sat, 02 Sep 2023 01:07:38 +0000

Cada porta no Atmega328p possui três registradores principais: DDRx (Data Direction Register), para setar o modo das portas;
PORTx, usado para escrever na saída digital da porta;
PINx, usado pelo buffer de entrada para que possamos ler o seu estado.

Irei usar o registrador DDRB para fins de ilustração, porém todos os outros casos são análogos.

O registrador DDRx (DDRB, por exemplo) assim como PORTx e PINx, possui 8 bits, e cada um dos bits controla uma das portas, como mostra o diagrama a seguir:

7	6	5	...
DDx7	DDx6	DDx5	...

#define DDB 7
#define DDB 6
#define DDB 5
.
.
.

Assim, para configurar a porta 3 como saída, fazemos um shift à esquerda:

1 << DDB3

de forma que agora DDRB tem o seguinte valor:

7	6	5	4	3	2	1	0
0	0	0	0	1	0	0	0

A operação OU (|) sempre resulta em 1 quando um dos operandos é 1, bit a bit, como descrito na tabela de operações lógicas de |:

11111111 | 10100000 = 11111111

10011110 | 00001001 = 1001111

Sempre que queremos modificar apenas um bit no registrador DDRB para ligado, ou seja uma das oito portas como entrada ou saída, podemos modificar apenas o bit da porta correspondente para ligado (1), com a seguinte operação:

DDRB = DDRB | (1 << DDB3)

temos agora que o bit relativo a DDB3 está ligado (1).
A operação & sempre resulta em 0 quando um dos operandos é 1 ou 0, de forma que essa operação é muito conveniente quando queremos desligar um bit (ou seja, setar uma posição para 0):

11111111 & 10100000 = 10100000

11111111 & 00001000 = 00001000

11111111 & 00000000 = 00000000

Assim, para desligar o bit relativo a DDB3, podemos fazer:

DDRB = DDRB & (1 << DDB3)

de forma que desligamos o bit relativo a porta 3 no registrador DDRB.

Criando um hello world para micro controladores Atmel usando o avr-gcc

Priscila Gutierres — Sun, 13 Aug 2023 16:00:29 +0000

Afinal, o que é um Arduino?
De forma simpllificada, o arduino é um jeito muito simples de se usar microcontroladores da família Atmel.
Nesse texto, eu proponho a criação de um hello world (blink) utilizando apenas o avr-gcc e a libc de microcontroladores RISC no lugar de utilizar a Arduino-IDE e suas bibliotecas.

#ifndef F_CPU
#define F_CPU 4000000L
#endif

#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
    PORTB = 0b00000001;
    DDRB = 0b00000000;

    while(1)
    {
        ! PORTB;
        _delay_ms(125);
    }

    return 0;
}

Nesse código simples, modificamos o registrador de dados da porta B (PORTB, definindo o estado da porta com o pullup ativo.
DDRB se refere ao registrador da direção dos bits da porta B, de forma que essa porta fica configurada como entrada.

    while(1)
    {
        ! PORTB;
        _delay_ms(125);
    }

Esse trecho de código alterna o estado da porta, de forma que o led embutido do arduino fique piscando após o delay.

Agora temos que usar o avr-gcc para o nosso microcontrolador presente no arduino:

avr-gcc -Os \
-DF=4000000 \
-mmcu = attiny2313a \
-c blink.c

avr-gcc -DF=4000000 \
-mmcu=attiny2313a \
-o blink blink.o

Os parâmetros DF e mmcu dependem do microcontrolador e mais informações podem ser encontradas respectivamente nos links AVR-Options e Arduino Memory Guide

Agora, o avr-objecopy cria o arquivo hexadecimal a partir do arquivo binário. Note que você poderia criar o arquivo executável diretamente caso exista somente um objeto a ser adicionado a esse executável:

avr-objcopy \ 
-j .text .data \ 
-O ihex blink.hex

Por fim, podemos usar o avrdude para fazer o flash no dispositivo destino:

avrdude -c arduino \
-p attiny2313a \
-P /dev/ttyACM0 \
-U flash:w:blink.hex

Eu criei um Makefile para simplificar todas essas etapas de forma mais limpa e didática.

O projeto inteiro está disponibilizado no meu Github.

Eu sugiro esse excelente livro ARDUINO - Guia Avançado para Projetos para quem quiser se aprofundar mais.

Recursão

Priscila Gutierres — Sun, 02 May 2021 16:57:05 +0000

"Você só entende recursão se você entende recursão"
Homer Simpson

Matematicamente, quando usamos recursão, estamos na verdade usando o Princípio da Indução Finita (PIF). O PIF é muito utilizado para resolver problemas discretos, que envolvem números naturais.
Por exemplo, dada a progressão aritmética,

Queremos mostrar que

Nesse exemplo, assumimos que a fórmula é válida para o caso trivial, o que é simples de demonstrar:

O próximo passo é considerar que sabendo resolver o problema para n-1 elementos, eu consigo também resolver para n:

A ideia da recursão, no sentido de resolver problemas computacionais, é dividir um problema original em subproblemas menores da mesma natureza (divisão) e depois combinar as soluções obtidas para gerar a solução do problema maior (conquista). No fundo, ao demonstrar qualquer teorema usando PIF, estamos aplicando essa mesma ideia.
Uma primeira implementação ingênua de um algoritmo recursivo de busca pode ser

int busca (int[] A, int valor, int n) {
if (n == 1) {
if (A[0] == valor)
    return 0;
else 
   return 1;
}
else {
if (A[n-1] == valor)
    return n-1;
else 
   return busca(A, valor, n-1);
   }
}

Caso base: o arranjo é unitário e o elemento é igual ou diferente do valor buscado
Hipótese indutiva:
Nessa implementação, primeiramente avaliamos se o vetor é unitário, e nesse caso, já retornamos o primeiro elemento caso seja encontrado, ou retornamos que ele não foi encontrado.
Caso contrário, eu avalio se a posição n-1 me fornece o valor procurado, e caso contrário, eu faço novamente uma busca binária para n-1 elementos, avaliando agora se n-2 (que agora é o penúltimo elemento) satisfaz a minha condição de busca, dividindo sucessivamente o problema até que a solução seja encontrada, retornando 0, ou eu termine com um vetor unitário que não seja o valor esperado, retornando assim 1.
É como se tivéssemos usando um dominó para em seguida derrubar toda a sequência dos mesmos.

Existe uma categoria sofisticada de algoritmos recursivos de busca, os chamados algoritmos de divisão e conquista, que costumam ser algoritmos muito eficientes e utilizam a o teorema de indução finita forte. Dessa vez, admitimos como hipótese de indução que já sabemos ordenar uma metade do problema dado, para a seguir provar que conseguimos ordenar a segunda metade.
As demonstração do Princípio da Indução Finita em suas várias formas equivalentes, pode ser encontrada em bons livros de análise ou em livros de algoritmos.
Assim, cada instância do problema é dividida em duas ou mais instâncias menores;
Cada instância menor é resolvida usando o próprio algoritmo que está sendo definido;
Um exemplo muito legal de algoritmo que utiliza essa estratégia é o algoritmo de busca binária.

E... é isso. Eu só gostaria de poder falar um pouco sobre essa extraordinária conexão que existe entre matemática e computação e que muitas vezes não fica muito evidente no dia-a-dia :-)