Tuesday, November 9, 2021

Buiding graph via python module importing networkx,plotly

 (.env) [boris@fedora34server NUMPY]$ cat  graphYQ1011.py

import plotly.graph_objects as go

import networkx as nx

G = nx.random_geometric_graph(200, 0.125)

edge_x = []

edge_y = []

for edge in G.edges():

    x0, y0 = G.nodes[edge[0]]['pos']

    x1, y1 = G.nodes[edge[1]]['pos']

    edge_x.append(x0)

    edge_x.append(x1)

    edge_x.append(None)

    edge_y.append(y0)

    edge_y.append(y1)

    edge_y.append(None)

edge_trace = go.Scatter(

    x=edge_x, y=edge_y,

    line=dict(width=0.5, color='#888'),

    hoverinfo='none',

    mode='lines')

node_x = []

node_y = []

for node in G.nodes():

    x, y = G.nodes[node]['pos']

    node_x.append(x)

    node_y.append(y)

node_trace = go.Scatter(

    x=node_x, y=node_y,

    mode='markers',

    hoverinfo='text',

    marker=dict(

        showscale=True,

        # colorscale options

        #'Greys' | 'YlGnBu' | 'Greens' | 'YlOrRd' | 'Bluered' | 'RdBu' |

        #'Reds' | 'Blues' | 'Picnic' | 'Rainbow' | 'Portland' | 'Jet' |

        #'Hot' | 'Blackbody' | 'Earth' | 'Electric' | 'Viridis' |

        colorscale='YlGnBu',

        reversescale=True,

        color=[],

        size=10,

        colorbar=dict(

            thickness=15,

            title='Node Connections',

            xanchor='left',

            titleside='right'

        ),

        line_width=2))

node_adjacencies = []

node_text = []

for node, adjacencies in enumerate(G.adjacency()):

    node_adjacencies.append(len(adjacencies[1]))

    node_text.append('# of connections: '+str(len(adjacencies[1])))

node_trace.marker.color = node_adjacencies

node_trace.text = node_text

fig = go.Figure(data=[edge_trace, node_trace],

             layout=go.Layout(

                title='<br>Network graph made with Python',

                titlefont_size=16,

                showlegend=False,

                hovermode='closest',

                margin=dict(b=20,l=5,r=5,t=40),

                annotations=[ dict(

                    text="Python code: <a href='https://plotly.com/ipython-notebooks/network-graphs/'> https://plotly.com/ipython-notebooks/network-graphs/</a>",

                    showarrow=False,

                    xref="paper", yref="paper",

                    x=0.005, y=-0.002 ) ],

                xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),

                yaxis=dict(showgrid=False, zeroline=False, showticklabels=False))

                )

fig.show()



































































Wednesday, September 15, 2021

Linux versus Unix briefly

 Поскольку Linux - это просто ядро, стоит обсудить основные различия между ядром Linux и ядром  Unix. Существует три типа ядра: монолитное, микро и гибридное (сочетание монолитного и микро), как показано на изображении ниже.






В монолитной архитектуре ядра вся ОС работает в пространстве одного ядра. Оно единолично определяет высокоуровневый виртуальный интерфейс поверх компьютерного оборудования.Хотя ядро ​​Linux заимствует большинство своих характеристик от Unix / Unix-подобных ядер, однако между ними есть некоторые существенные различия. В архитектуре микроядра основные службы ОС работают в одном процессе, а другие службы - в разных процессах. В ядре µ почти минимальное количество механизмов включено в режим ядра. Эти механизмы включают базовый IPC (межпроцессное взаимодействие), планирование и низкоуровневое управление адресным пространством.С точки зрения размера исходного кода, как правило, микроядро меньше монолитного ядра.











Добавление / удаление функций ядра Предоставляет отличную функцию, с помощью которой компоненты ядра, такие как диски устройств, могут быть динамически добавлены и удалены как модули. Эта функция называется загружаемыми модулями ядра (LDM). Это избавляет от необходимости заново компилировать все ядро. Эта функция, в свою очередь, дает Linux большую гибкость.

Традиционное ядро систем Unix требует статической компоновки добавляемых новых систем. В Linux нет подсистемы потокового ввода-вывода. В большинство ядер Unix включена подсистема потокового ввода-вывода, которая оказывается желаемым интерфейсом для написания драйверов устройств, драйверов терминалов и т. д.

Превентивный подход или подход без вытеснения Обычно ядро ​​Linux не является вытесняющим. Однако в последнее время ОС реального времени Linux начала использовать вытесняющие ядра. Некоторые системы Unix полностью вытесняют.Например, Solaris 2.x. и т.п.

Поток ядра Linux использует поток ядра только для периодического запуска некоторого кода ядра. Многие Unix-подобные операционные системы используют поток ядра для переключения контекста процесса. Способы обработки многопоточной среды Благодаря многопоточности создается несколько независимых потоков выполнения, которые называются облегченными процессами (LWP). В Linux LWP создается путем вызова функции clone (). Эти процессы в Linux могут совместно использовать физическую память, открытые файлы, адресное пространство и т. д. В Unix LWP основан на потоках ядра.

В Linux нет подсистемы потокового ввода-вывода. В большинство ядер Unix включена подсистема потокового ввода-вывода, которая оказывается желаемым интерфейсом для написания драйверов устройств, драйверов терминалов и т. д.

Способы обработки многопоточной среды - 
Благодаря многопоточности создается несколько независимых потоков выполнения, которые называются облегченными процессами (LWP). В Linux LWP создается путем вызова функции clone (). Эти процессы в Linux могут совместно использовать физическую память, открытые файлы, адресное пространство и т. д. В Unix LWP основан на потоках ядра.

Примеры

До сих пор в этой лекции мы видели общие основные различия между Linux и Unix. 
Эти различия могут быть более конкретными, если мы сравним их точные версии. Давайте посмотрим на это на нескольких примерах.

Солярис против Linux
Solaris, которая теперь называется Oracle Solaris, - это операционная система семейства Unix. Давайте сравним Linux с Solaris.
Linux поддерживает больше системных архитектур, чем Solaris. Следовательно, Linux более портативен.
Говоря о стабильности и интеграции оборудования, Solaris, похоже, здесь лучше. Linux также быстрее развивается по сравнению с Solaris.
Между ними есть несколько других технических различий, но здесь мы ограничиваем наше сравнение только производительностью.

MacOS против Linux
MacOS - это сертифицированная ОС Unix. У него есть собственное ядро ​​под названием XNU. 
Он используется в компьютерах Apple, которые считаются самыми надежными.MacOS относительно легко настроить. С другой стороны, Linux дешевле и предлагает много программного обеспечения с открытым исходным кодом по сравнению с проприетарными решениями Apple. Кроме того, Linux более гибок, поскольку его можно запускать практически на любом оборудовании, тогда как MacOS может работать только на оборудовании Apple. Например, айфоны.MacOS использует HFS + в качестве файловой системы по умолчанию, тогда как Linux использует ext4.

Ссылки

https://www.softwaretestinghelp.com/unix-vs-linux/




Tuesday, September 14, 2021

Solving one problem from YandexQ as 14/09/2021

 















[boris@fedora34server ~]$ cat  yandexPlot.py

import matplotlib.pyplot as plt

from matplotlib.ticker import (MultipleLocator, FormatStrFormatter,

                               AutoMinorLocator)

import numpy as np

x = np.linspace(0, 30, 30)

y1 = np.cos(np.cos(np.cos(np.cos(x))))

y2 = np.sin(np.sin(np.sin(np.sin(x))))

fig, ax = plt.subplots(figsize=(8, 6))

ax.set_title("Графики зависимостей: y1, y2", fontsize=16)

ax.set_xlabel("x", fontsize=14)        

ax.set_ylabel("y1, y2", fontsize=14)

ax.grid(which="major", linewidth=1.2)

ax.grid(which="minor", linestyle="--", color="gray", linewidth=0.5)

ax.scatter(x, y1, c="red", label="y1")

ax.plot(x, y2, label="y2")

ax.legend()

ax.xaxis.set_minor_locator(AutoMinorLocator())

ax.yaxis.set_minor_locator(AutoMinorLocator())

ax.tick_params(which='major', length=10, width=2)

ax.tick_params(which='minor', length=5, width=1)


plt.show()

[boris@fedora34server ~]$ python  yandexPlot.py


















Next iteration

[boris@fedora34server ~]$ cat  yandexPlot5.py

import numpy as np # import numpy package

import matplotlib.pyplot as plt # import matplotlib.pyplot package

x = np.arange(0,9 * np.pi, 0.1) # create x array of angels from range 0 to 9*3.14

y = np.cos(np.cos(np.cos(np.cos(x)))) -   np.sin(np.sin(np.sin(np.sin(x)))) 

plt.plot(x, y) # plot grah 

plt.title(" Graphical Representation of sine function")

plt.xlabel("x axis ")

plt.ylabel("y axis ")

plt.show() # show plotted graph






























Thursday, September 2, 2021

HTML CONVERSION

Условие Расшифровать пример на умножение, если буквой Ч зашифрованы чётные числа, а буквой Н – нечётные.
Решение Запишем пример в виде

(строчные буквы соответствуют чётным цифрам, а прописные – нечётным).
A < 5,так как Abc·d – трёхзначное число. Но A > 1, так как Abc·d – четырёхзначное число.Следовательно,A=3,d=2,j = 6. Abc·6 = 3·Abc·2 = 3·jKl < 2000 < fGhj, поэтому e = 8, f = 2.
Из нечётности K следует, что c > 5. Так как j = 6, то b < 6, но b ≠ 0 (иначе цифра K была бы чётной). Таким образом, для Abc имеется четыре варианта: 326, 328, 346, 348. Умножая на 28, находим единственное решение: 348·28 = 9744.
Ответ 348·28 = 9744.

Thursday, August 5, 2021

Python Wrapper for C++ solving the recent YandexQ problem

 Problem itself

ABCDEF is a six-digit number. They are all different and are arranged from left to right in ascending order. The number is a complete square.

(.env) [boris@fedora33server VOICE]$ cat Strike.h

#pragma once

#include <cstddef>

#include <cstdio>

namespace abc {

    class Strike {

    public:

        double *mem;

        long fftSize;

        Strike(long fftSize);

        ~Strike();

        long filter(long freq);

        long CaughIt(int n);

    };

}

(.env) [boris@fedora33server VOICE]$ cat Strike.cpp

#include <cstdio>

#include <cstddef>

#include <string>

#include "Strike.h"

namespace abc

    Strike::Strike(long fftSize) {

        printf("c++ constructor of Strike\n");

        this->fftSize=fftSize;

        mem=new double[fftSize];

        } 

    Strike::~Strike() { delete [] mem; } 

    long Strike::filter(long freq) {

        printf("c++ Strike filter method\n");

        return (CaughIt(1000));

    }

    long Strike::CaughIt(int n) 

    { 

     for (int i=200; i < n; i++)

     {

     std::string ans = std::to_string(i*i);

      if ((int(ans[0])< int(ans[1])) && \ 

         (int(ans[1]) < int(ans[2])) && \

         (int(ans[2]) < int(ans[3])) && \

         (int(ans[3]) < int(ans[4])) && \

         (int(ans[4]) < int(ans[5])))    

             return (i*i);

     }

    }

}

(.env) [boris@fedora33server VOICE]$ cat strikeWrapper.cpp

#include <Python.h>

#include <cstdio>

#include <string.h>

#include "Strike.h"

using abc::Strike;

typedef struct {

    PyObject_HEAD

    Strike * ptrObj;

} PyStrike;

static PyModuleDef volumemodule = {

    PyModuleDef_HEAD_INIT,

    "volume",

    "Example module that wrapped a C++ object",

    -1,

    NULL, NULL, NULL, NULL, NULL

};

static int PyStrike_init(PyStrike *self, PyObject *args, PyObject *kwds)

// initialize PyStrike Object

{

    long fftSize;

    if (! PyArg_ParseTuple(args, "l", &fftSize))

        return -1;

    self->ptrObj=new Strike(fftSize);

    return 0;

}

static void PyStrike_dealloc(PyStrike * self)

// destruct the object

{

    delete self->ptrObj;

    Py_TYPE(self)->tp_free(self);

}

static PyObject * PyStrike_filter(PyStrike* self, PyObject* args)

{

    long freq;

    long retval;

    if (! PyArg_ParseTuple(args, "l", &freq))

        return Py_False;

    retval = (self->ptrObj)->filter(freq);

    return Py_BuildValue("l",retval);

}

static PyMethodDef PyStrike_methods[] = {

    { "filter", (PyCFunction)PyStrike_filter,METH_VARARGS,"filter the mem volume" },

    {NULL}  /* Sentinel */

};

static PyTypeObject PyStrikeType = { PyVarObject_HEAD_INIT(NULL, 0)

                                    "volume.Strike"   /* tp_name */

                                };

PyMODINIT_FUNC PyInit_volume(void)

// create the module

{

    PyObject* m;

    PyStrikeType.tp_new = PyType_GenericNew;

    PyStrikeType.tp_basicsize=sizeof(PyStrike);

    PyStrikeType.tp_dealloc=(destructor) PyStrike_dealloc;

    PyStrikeType.tp_flags=Py_TPFLAGS_DEFAULT;

    PyStrikeType.tp_doc="Strike objects";

    PyStrikeType.tp_methods=PyStrike_methods;

    //~ PyStrikeType.tp_members=Noddy_members;

    PyStrikeType.tp_init=(initproc)PyStrike_init;

    if (PyType_Ready(&PyStrikeType) < 0)

        return NULL;

    m = PyModule_Create(&volumemodule);

    if (m == NULL)

        return NULL;

    Py_INCREF(&PyStrikeType);

    PyModule_AddObject(m, "Strike", (PyObject *)&PyStrikeType); 

    return m;

}

(.env) [boris@fedora33server VOICE]$ cat setup.py

from distutils.core import setup, Extension

setup(name='volumePkg', version='1.0',  \

      ext_modules=[Extension('volume', ['strikeWrapper.cpp','Strike.cpp'])])

$ python setup.py install

running install

running build

running build_ext

building 'volume' extension

creating build

creating build/temp.linux-x86_64-3.9

gcc -pthread -Wno-unused-result -Wsign-compare -DDYNAMIC_ANNOTATIONS_ENABLED=1 -DNDEBUG -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -fPIC -I/home/boris/VOICE/.env/include -I/usr/include/python3.9 -c Strike.cpp -o build/temp.linux-x86_64-3.9/Strike.o

gcc -pthread -Wno-unused-result -Wsign-compare -DDYNAMIC_ANNOTATIONS_ENABLED=1 -DNDEBUG -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -fPIC -I/home/boris/VOICE/.env/include -I/usr/include/python3.9 -c strikeWrapper.cpp -o build/temp.linux-x86_64-3.9/strikeWrapper.o

creating build/lib.linux-x86_64-3.9

g++ -pthread -shared -Wl,-z,relro -Wl,--as-needed -Wl,-z,now -g -Wl,-z,relro -Wl,--as-needed -Wl,-z,now -g build/temp.linux-x86_64-3.9/Strike.o build/temp.linux-x86_64-3.9/strikeWrapper.o -L/usr/lib64 -o build/lib.linux-x86_64-3.9/volume.cpython-39-x86_64-linux-gnu.so

running install_lib

copying build/lib.linux-x86_64-3.9/volume.cpython-39-x86_64-linux-gnu.so -> /home/boris/VOICE/.env/lib64/python3.9/site-packages

running install_egg_info

Removing /home/boris/VOICE/.env/lib64/python3.9/site-packages/volumePkg-1.0-py3.9.egg-info

Writing /home/boris/VOICE/.env/lib64/python3.9/site-packages/volumePkg-1.0-py3.9.egg-info



A

Wednesday, July 7, 2021

Solution via C++ code for #25 from 16052021 Eugene Djobs's stream

Пусть M – сумма делителей, максимально приближенных к квадратному корню числа, не считая единицы и самого числа. Квадратный корень в качестве делителя не рассматривать. Если нет делителей, отличных oт квадратного корня, единицы и самого числа, значение M считается равным 0. Напишите программу, которая перебирает целые числа, большие 710017, в порядке возрастания и ищет среди них такие, для которых значение M кратно 10 и больше M для предыдущего найденного числа.. Вывести первые 5 найденных чисел и соответствующие им значения M.

Замена 710017 на 713000218 и 5 на 100

Python code for original task

[boris@fedora33server FORWARD]$ cat dba25160521.py

numbers = []

M=0

for i in range(713000218, 10000000000):

    minDiv = 0

    for div in range(int(i**0.5),1,-1):

        if i % div == 0 and div**2 != i:

            minDiv = div

            break

    if minDiv != 0:

        currMV = (i // minDiv) + minDiv

    if currMV % 10 == 0 and currMV > M:

        numbers.append(i)

        print(i,currMV)

        M = currMV

    if len(numbers) == 100:

        break

Проверяем что для первых 5 найденных чисел программы дают те же результаты

[boris@fedora33server FORWARD]$ python dba25160521.py

713000221 67330

713000261 437190

713000269 11688590

713000279 23000040

713000571 237666860

[boris@fedora33server FORWARD]$ ./mainVector1

 Input start : 713000218

 Input depth : 5

713000221 67330 

713000261 437190 

713000269 11688590 

713000279 23000040 

713000571 237666860 


***************************
Теперь заменим 5 на 100
***************************

[boris@fedora33server FORWARD]$ cat procVector1.cpp

#include <iostream>

#include <vector>

#include <cstddef>

#include <cmath>

std::vector<std::vector<int> >  resultList(int m, int depth)

{

   std::vector<std::vector<int> > vec;

   std::vector<int> v1;

    int i,j,M,minDiv,currMV,div;

    M = 0;

    for (int i = m; i < 10000000000 ; i++) {

        minDiv = 0;    

        for (div = (int)sqrt(i); div > 1; div--)

        {

          if (i%div == 0 && div*div != i)

             {

              minDiv = div ;

              break ;

             }

         }

        if (minDiv != 0)

           currMV = (i/minDiv) + minDiv;

        if (currMV % 10 == 0 && currMV > M)

         {

           v1.push_back(i);

           v1.push_back(currMV);

           vec.push_back(v1);

           M = currMV;

           while (!v1.empty())

           {    

             v1.pop_back();

           }  

          }

        if (vec.size() == depth)

              break;

     }

 return vec;

}

[boris@fedora33server FORWARD]$ cat mainVector1.cpp

#include <iostream>

#include <vector>

#include <cstddef>

std::vector<std::vector<int> > resultList(int m,int n);

int main()

{

   int m,n;

   std::cout << " Input start : "; 

   std::cin >> m ; 

   std::cout << " Input depth : ";

   std::cin >> n ;

   std::vector<std::vector<int> > rez = resultList(m,n);

   // Displaying the 2D vector

    for (int i = 0; i < rez.size(); i++) {

       for (int j = 0; j < rez[i].size(); j++)

           std::cout << rez[i][j] << " ";

     std::cout << std::endl;

  }

}

Compilation via g++ on Fedora Linux 34

$ g++ procVector1.cpp  mainVector1.cpp -o mainVector1

[boris@fedora33server FORWARD]$ ./mainVector1
 Input start : 713000218
 Input depth : 100
713000221 67330 
713000261 437190 
713000269 11688590 
713000279 23000040 
713000571 237666860 
713001381 237667130 
713001441 237667150 
713001621 237667210 
713001651 237667220 
713001711 237667240 
713001831 237667280 
713001921 237667310 
713002011 237667340 
713002071 237667360 
713002161 237667390 
713002431 237667480 
713002611 237667540 
713002701 237667570 
713002881 237667630 
713003091 237667700 
713003241 237667750 
713003271 237667760 
713003451 237667820 
713003721 237667910 
713003901 237667970 
713004141 237668050 
713004231 237668080 
713004261 237668090 
713004351 237668120 
713004441 237668150 
713004771 237668260 
713005071 237668360 
713005311 237668440 
713005401 237668470 
713005701 237668570 
713005791 237668600 
713005941 237668650 
713006421 237668810 
713006661 237668890 
713006751 237668920 
713006961 237668990 
713007111 237669040 
713007231 237669080 
713007411 237669140 
713007651 237669220 
713007951 237669320 
713008221 237669410 
713008371 237669460 
713008641 237669550 
713008851 237669620 
713008911 237669640 
713009211 237669740 
713009481 237669830 
713009991 237670000 
713010021 237670010 
713010171 237670060 
713010531 237670180 
713010561 237670190 
713011281 237670430 
713011641 237670550 
713011731 237670580 
713011911 237670640 
713012151 237670720 
713012361 237670790 
713012451 237670820 
713012511 237670840 
713012721 237670910 
713012991 237671000 
713013141 237671050 
713013321 237671110 
713013771 237671260 
713013801 237671270 
713013891 237671300 
713014041 237671350 
713014131 237671380 
713014431 237671480 
713014611 237671540 
713015421 237671810 
713015481 237671830 
713015691 237671900 
713015781 237671930 
713016201 237672070 
713016321 237672110 
713016651 237672220 
713016831 237672280 
713016921 237672310 
713017131 237672380 
713017671 237672560 
713017761 237672590 
713017911 237672640 
713018091 237672700 
713018181 237672730 
713018211 237672740 
713018391 237672800 
713018571 237672860 
713019171 237673060 
713019261 237673090 
713019381 237673130 
713019621 237673210 
713019891 237673300 
 

Sunday, July 4, 2021

Creating Python Wrapper for one C++ procedure been inspired by Yandex Q news wire in Mathematics Version 2

 (.env) [boris@fedora33server YANDEXDBA]$ cat test.h

#pragma once

#include <cstddef>

#include <vector>

namespace abc {

std::vector<int>  catchList(int q,int m,int pw1,int pw2) ;

}  

(.env) [boris@fedora33server YANDEXDBA]$ cat test.cpp

#include <Python.h>

#include <iostream>

#include <vector>

#include <cmath>

#include "test.h"

#pragma GCC diagnostic ignored "-Wsign-compare"

namespace abc {

int digitSum(int n)  

{  

  int sum=0,m;    

  while(n>0)    

  {    

    m=n%10;    

    sum=sum+m;    

    n=n/10;    

  }    

return sum;  

}  

std::vector<int>  catchList(int k,int m,int pw1,int pw2) {

 std::vector<int> result;

 int j,z;

 for( j=k; j < m; ++j)

  {

    z = digitSum(j);

    if (pow(double(z),pw1) == pow(double(j),pw2))

              result.push_back(j);

  }

 return result;

 }

extern "C"{}

namespace {

static PyObject *caughtList(PyObject* self, PyObject* args)

{

   int p,n;

   int pwr1,pwr2;

  // Now four arguments pass through PyArg_ParseTuple

   if(!PyArg_ParseTuple(args,"iiii" ,&p,&n,&pwr1,&pwr2))

       return NULL;

   std::vector<int>numbers = abc::catchList(p,n,pwr1,pwr2);

   PyObject* result = PyList_New(numbers.size());

   for(int i = 0; i < numbers.size(); i++) {

     PyList_SetItem(result, i, PyLong_FromLong(numbers[i]));

   }

   return result;  

};

// Our Module's Function Definition struct

// We require this `NULL` to signal the end of our method

// definition

static PyMethodDef myMethods[] = {

   { "caughtList", caughtList, METH_VARARGS, "Calculate prime numbers" },

   { NULL, NULL, 0, NULL }

};

// Our Module Definition struct

static struct PyModuleDef myModule = {

   PyModuleDef_HEAD_INIT,

   "myModule",

   "Test Module",

   -1,

   myMethods

};

// Initializes our module using our above struct

PyMODINIT_FUNC PyInit_myModule(void)

{

   return PyModule_Create(&myModule);

};

} // namespace(.env) 

[boris@fedora33server YANDEXDBA]$ cat setup.py

from distutils.core import setup, Extension

import sysconfig

language = 'c++'

std = 'c++20'

default_compile_args = sysconfig.get_config_var('CFLAGS').split()

extra_compile_args = [f"-std={std}", "-Wall", "-Wextra", "-Werror", "-DNDEBUG", "-O3"]

setup(name = 'myModule', version = '1.0',  \

   ext_modules = [Extension('myModule', ['test.cpp'])])

(.env) [boris@fedora33server YANDEXDBA]$ python setup.py install

running install

running build

running build_ext

building 'myModule' extension

creating build

creating build/temp.linux-x86_64-3.9

gcc -pthread -Wno-unused-result -Wsign-compare -DDYNAMIC_ANNOTATIONS_ENABLED=1 -DNDEBUG -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -fstack-protector-strong -m64 -mtune=generic -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection -D_GNU_SOURCE -fPIC -fwrapv -fPIC -I/home/boris/YANDEXDBA/.env/include -I/usr/include/python3.9 -c test.cpp -o build/temp.linux-x86_64-3.9/test.o

creating build/lib.linux-x86_64-3.9

g++ -pthread -shared -Wl,-z,relro -Wl,--as-needed -Wl,-z,now -g -Wl,-z,relro -Wl,--as-needed -Wl,-z,now -g build/temp.linux-x86_64-3.9/test.o -L/usr/lib64 -o build/lib.linux-x86_64-3.9/myModule.cpython-39-x86_64-linux-gnu.so

running install_lib

copying build/lib.linux-x86_64-3.9/myModule.cpython-39-x86_64-linux-gnu.so -> /home/boris/YANDEXDBA/.env/lib64/python3.9/site-packages

running install_egg_info

Removing /home/boris/YANDEXDBA/.env/lib64/python3.9/site-packages/myModule-1.0-py3.9.egg-info

Writing /home/boris/YANDEXDBA/.env/lib64/python3.9/site-packages/myModule-1.0-py3.9.egg-info

(.env) [boris@fedora33server YANDEXDBA]$ cat MyProg1.py
import myModule
minV =  int(input("Input scaning start value :" ))
maxV =  int(input("Input scaning finish value :" ))
p1 = int(input("Input power for digitSum :" ))
p2 = int(input("Input power for Number to detect: " ))
print(myModule.caughtList(minV,maxV,p1,p2))