Quicksort Algorithm Research Articles

A modality separation approach for facial sketch synthesis

AbstractThe technology for face‐to‐sketch synthesis transforms optical face images into a sketch‐style format. However, traditional style losses are insufficient to discern the modal differences between optical and sketch domain images, leading to unclear images. At the same time, generated images lack clarity due to traditional approaches' disregard for high‐frequency texture. To address these issues, a modality separation approach for facial sketch synthesis is proposed. First, a modality separation structure is proposed, using a quicksort algorithm to merge features of optical and sketch images as target modality (positive samples), ensuring the generated images' feature distribution matches real sketches. By controlling the Euclidean distance between generated images (anchors) and both target and filtered modality (positive and negative samples), irrelevant information is effectively filtered out. Next, an edge‐promoting module feeds processed blurry sketch images into the discriminator to enhance robustness. Lastly, a detail optimization module uses Laplacian filtering to extract high‐frequency texture from optical face images for local enhancement. Experimental validation on CUHK, AR, and XM2VTS datasets shows that this method outperforms mainstream sketch face synthesis methods in terms of Fréchet inception distance and learned perceptual image patch similarity, producing more realistic and natural images with richer texture details.

The Performances of Sorting Algorithms by Using Assembly Language

In many programs the data have to be sorted according to one or more criteria. Algorithmics offers us specific algorithms classified according to the order of complexity. But from this point to the realization of a concrete and efficient program for a specific set of data there is a long way. The choice between performance and flexibility of an application is not easy. This paper presents an experimental study that tracks the time performance of assembly language implementations in relation to C and Rust in cases of Bubble Sort, Insertion Sort and Quick Sort algorithms. Conclusions as well as future research directions are also included.

Refinement of Parallel Algorithms Down to LLVM: Applied to Practically Efficient Parallel Sorting

We present a stepwise refinement approach to develop verified parallel algorithms, down to efficient LLVM code. The resulting algorithms’ performance is competitive with their counterparts implemented in C++. Our approach is backwards compatible with the Isabelle Refinement Framework, such that existing sequential formalizations can easily be adapted or re-used. As case study, we verify a parallel quicksort algorithm that is competitive to unverified state-of-the-art algorithms.

A new approach to Mergesort algorithm: Divide smart and conquer

It is well known that comparison-based algorithms cannot run faster than O(nlogn). Therefore the running times of Mergesort, Heapsort, and Quicksort algorithms are asymptotically optimal. As well as asymptotic running times, how fast sorting algorithms work in practice has gained importance lately. One algorithm is preferred, if it is slightly more efficient than another, due to the rapid increase in data generation. In this study, we consider the Mergesort algorithm with a different approach. Unlike the Mergesort algorithm, we do not perform unconditional division. Instead, we divide the input array into ascending and descending sub-arrays. Then, we merge the sub-arrays obtained as a result of the division by slightly modifying the classical Merge function. As a result of these two operations, we obtain three new sorting algorithms depending on how we get ascending and descending sub-arrays. Among these three algorithms, the third one, which is our main proposed algorithm, is more important both theoretically and practically. In this algorithm, we divide the input array into alternately ascending and descending sub-arrays. Moreover, the terms of the sub-arrays do not have to be consecutive terms of the input array. The asymptotic running time of our proposed algorithm is O(nlogn) in the worst case and O(n) in the best case. In practice, the proposed algorithm performs better than the classical Mergesort algorithm in arrays with Gaussian and Uniform distributions of various sizes. In an array of four million, it provided a 17% improvement in the Gaussian distribution compared to the classical Mergesort algorithm. In addition, it provided a 29% improvement in the Uniform distribution of the same size. The proposed algorithm performs also much better than traditional sorting algorithms in real data collected from various sources.

Programming Language Selection for The Development of Deep Learning Library

Recently, deep learning has become very successful in various applications, leading to an increasing need for software tools to keep up with the rapid pace of innovation in deep learning research. As a result, we suggested the development of a software library related to deep learning that would be useful for researchers and practitioners in academia and industry for their research endeavors. The programming language is the core of deep learning library development, so this paper describes the selection stage to find the most suitable programming language for developing a deep learning library based on two criteria, including coverage on many projects and the ability to handle high-dimensional array processing. We addressed the comparison of programming languages with two approaches. First, we looked for the most demanding programming languages for AI Jobs by conducting a data-driven approach against the data gathered from several Job-Hunting Platforms. Then, we found the findings that imply Python, C++, and Java as the top three. After that, we compared the three most widely used programming languages by calculating interval time to three different programs that contain an array of exploitation processes. Based on the result of the experiments that were executed in the computer terminal, Java outperformed Python and C++ in two of the three experiments conducted with 5,4047 milliseconds faster than C++ and 231,1639 milliseconds faster than Python to run quick sort algorithm for arrays that contain 100.000 integer values.

Using an Artificial Physarum polycephalum Colony for Threshold Image Segmentation

Traditional artificial intelligence algorithms are prone to falling into local optima when solving threshold segmentation problems. Here, a novel artificial Physarum polycephalum colony algorithm is proposed to help us solve the difficult problem. First, the algorithm methodology of an artificial Physarum polycephalum colony algorithm is described to search for the optimal solutions by expansion and contraction of a lot of artificial hyphae. Different artificial Physarum polycephalum can learn from each other and produce more hyphae in expansion. In contraction, the artificial Physarum polycephalum colony can select the best hyphae with high fitness through a quick sort algorithm, but the other hyphae with low fitness will be absorbed and disappear. Second, a fitness function is modeled based on Kapur’s entropy for the proposed artificial Physarum polycephalum colony algorithm to search for optimal threshold segmentation solutions. Third, a series of benchmark experiments are implemented to test the proposed artificial Physarum polycephalum colony algorithm, and some state-of-the-art approaches are employed for comparison. The experimental results verified that the proposed algorithm can obtain better accuracy and convergence speed, and is not easier to fall into the local optimal solution too early.

A enhanced control strategy for capacitance voltage equalization in modular multilevel converter

In searching for the optimal control strategy of sub-module capacitance voltage equalization of Modular Multilevel Converter (MMC), the most important issue is how to address the significant increase in computing time of the controller, switching frequency of the sub-module, device switching loss and MMC fault rate led by the increase in the number of sub-modules of the upper/lower bridge arm of the MMC. Therefore, this paper proposes a control strategy based on the retaining factor method + improved quick sort, namely, an improved quick sort algorithm is used to sort the sub-module capacitance voltages to reduce the amount of computation of the MMC controller; at the same time, a retaining factor is introduced to participate in the improved quick sort to significantly reduce the switching frequency of the sub-module. MMC of large ship grid-connected photovoltaic power system is taken as a research object in this paper, a 31-level MMC model is built in Matlab/Simulink. Simulation results verify that the improved quick sort has a good rapidity compared to the algorithms of bubble sort, quick sort, bidirectional bubble sort, and improved merge sort, that the retention factor method has a good frequency reduction effect, and that the proposed retention factor + improved quick sort can provide a good performance compared to improved quick sort and retention factor + improved merge sort under conditions of the normal operation and introducing disturbance.

Penerapan Algoritma Gronsfeld Dengan Pembangkit Kunci Quicksort Untuk Mengamankan Pesan Rahasia

The numerous issues often encountered in securing confidential messages revolve around message leaks. Message leaks occur through various means, such as eavesdropping. Eavesdropping happens when unauthorized parties manage to access and obtain information from ongoing communications. One way to maintain the confidentiality of secret messages is through encryption and decryption, known as cryptography, achieved by transforming the original message (plaintext) into a secret message (ciphertext). In this study, the results of the encrypted character ciphertext are v, v, w, ^, ™, ʽ, ¦, ¥, -, ¼, Ý, ó, ⁒, x, [], ", [], #, S, a, I, p, p. These findings can serve as an alternative solution to safeguard message confidentiality, ensuring only the message owner and those with knowledge of the key can access it. The Gronsfeld Cipher cryptographic method can also enhance the security of the Quicksort algorithm, a cryptographic algorithm, by generating a more randomized text message that does not reveal patterns connecting it to the original text message.

Fixed Point Results in Fuzzy Strong Controlled Metric Spaces with an Application to the Domain Words

In this manuscript, we introduce the notions of fuzzy strong controlled metric spaces, fuzzy strong controlled quasi-metric spaces, and non-Archimedean fuzzy strong controlled quasi-metric spaces and generalize the famous Banach contraction principle. We prove several fixed point results in the context of non-Archimedean fuzzy strong controlled quasi-metric space. Furthermore, we use our main result to obtain the existence of a solution for a recurrence problem linked with the study of Quicksort algorithms.

Adaptive Order-of-Addition Experiments via the Quick-Sort Algorithm

The order-of-addition (OofA) experiment has received a great deal of attention in the recent literature. The primary goal of the OofA experiment is to identify the optimal order in a sequence of m components. All the existing methods are model-dependent and are limited to small number of components. The appropriateness of the resulting optimal order heavily depends on (a) the correctness of the underlying assumed model, and (b) the goodness of model fitting. Moreover, these methods are not applicable to deal with large m (e.g., ). With this in mind, this article proposes an efficient adaptive methodology, building upon the quick-sort algorithm, to explore the optimal order without any model specification. Compared to the existing work, the run sizes of the proposed method needed to achieve the optimal order are much smaller. Theoretical supports are given to illustrate the effectiveness of the proposed method. The proposed method is able to obtain the optimal order for large m (e.g., ). Numerical experiments are used to demonstrate the effectiveness of the proposed method.

Implementasi Algoritma Quicksort Untuk Pembangkitan Kunci Algoitma RSA Pada Pengamanan Data Audio

The RSA algorithm has two keys, namely the public key and the private key. This algorithm has security which lies in the difficulty in calculating discrete algorithms. Both encryption and decryption keys are integers. The RSA algorithm is a type of asymmetric cryptography algorithm, which consists of two keys, namely the public key for encryption and the private key for decryption. In the RSA algorithm, the distributed key is a public key which is not required to be kept secret while the private key is either stored or not distributed. Everyone who has the public key can perform the encryption process but the results of the encryption can only be read by the person who has the private key. To increase the strength of the algorithm, the key used to perform the encryption and decryption process will be modified first using a randomization algorithm, namely the Quicksort Algorithm. The Quicksort algorithm is a sorting algorithm developed by Tony Hoare, the average sorting performance is O (n log n) to sort n items. The purpose of using the Quicksort algorithm is to make the resulting key more difficult to guess, making it difficult for cryptanalysts to read the message or information.

Rapid Person Re-Identification via Sub-space Consistency Regularization

Person Re-Identification (ReID) matches pedestrian across disjoint cameras. Existing ReID methods adopting real-value feature descriptors have achieved high accuracy, but they are low in efficiency due to the slow Euclidean distance computation as well as complex quick-sort algorithms. Recently, some works propose to yield binary encoded person descriptors which instead only require fast Hamming distance computation and simple counting-sort algorithms. However, the performances of such binary encoded descriptors, especially with short code (e.g, 32 and 64 bits), are hardly satisfactory given the sparse binary space. To strike a balance between the model accuracy and efficiency, we propose a novel Sub-space Consistency Regularization (SCR) algorithm that can speed up the ReID procedure by 0.25 times than real-value features under same dimensions whilst maintain a competitive accuracy, especially under short codes. SCR transforms real-value features vector (e.g, 2048 float32) with short binary codes (e.g, 64 bits) by first dividing real-value features vector into M sub-spaces, each with C clustered centroids. Thus the distance between two samples can be expressed as the summation of respective distance to the centroids, which can be sped up by offline calculation and maintained via a look-up-table. On the other side, these real-value centroids help to achieve significantly higher accuracy than using binary code. Lastly, we convert the distance look-up-table to be integer and apply the counting-sort algorithm to speed up the ranking stage. We also propose a novel consistency regularization with an iterative framework. Experimental results on Market-1501 and DukeMTMC-reID show promising and exciting results. Under short code, our proposed SCR enjoys Real-value-level accuracy and Hashing-level speed.

On Intuitionistic Fuzzy Quasi Metric Space

In this article the fixed point of intuitionistic fuzzy quasi metric space instabilities on two metrics dx(f, g) and Dx(f, g) on complicity space X have been studied and presented in details depended on (0,1]-fuzzy contractive map. The illustrative example is proposed to explain the present results using quick sort algorithm.

Node localization algorithm for wireless sensor networks based on static anchor node location selection strategy

To better solve the contradiction between the localization accuracy, localization coverage, and the location of anchor nodes in wireless sensor networks, a node localization algorithm for wireless sensor networks based on static anchor node location selection strategy is proposed in this paper. Firstly, collect the signal strength between wireless sensor network nodes, judge whether there is a connection between nodes according to the set signal strength threshold, and convert the node distribution diagram into the node connection relationship diagram, that is, the topology diagram. Then, the closeness centrality value of each node is calculated by using the closeness centrality algorithm, and the obtained closeness centrality values are sorted in descending order, the node with the largest closeness centrality value is the first anchor node, the closeness centrality values are traversed at equal intervals, and the optimal equal interval is selected by using the quick sort algorithm, and the selected nodes are used as the other anchor nodes. Finally, other unknown nodes in the network are located according to the location of anchor nodes. Simulation results show that the proposed algorithm is superior to the existing typical algorithms in localization accuracy and localization coverage.

Co-Design of Multicore Hardware and Multithreaded Software for Thread Performance Assessment on an FPGA

Multicore and multithreaded architectures increase the performance of computing systems. The increase in cores and threads, however, raises further issues in the efficiency achieved in terms of speedup and parallelization, particularly for the real-time requirements of Internet of things (IoT)-embedded applications. This research investigates the efficiency of a 32-core field-programmable gate array (FPGA) architecture, with memory management unit (MMU) and real-time operating system (OS) support, to exploit the thread level parallelism (TLP) of tasks running in parallel as threads on multiple cores. The research outcomes confirm the feasibility of the proposed approach in the efficient execution of recursive sorting algorithms, as well as their evaluation in terms of speedup and parallelization. The results reveal that parallel implementation of the prevalent merge sort and quicksort algorithms on this platform is more efficient. The increase in the speedup is proportional to the core scaling, reaching a maximum of 53% for the configuration with the highest number of cores and threads. However, the maximum magnitude of the parallelization (66%) was found to be bounded to a low number of two cores and four threads. A further increase in the number of cores and threads did not add to the improvement of the parallelism.

Implementasi Algoritma Quicksort Untuk Pembangkitan Kunci Algoritma Elgamal Pada Pengamanan Data File Dokumen

A valid document is an important article containing information. Typically, documents are written on paper and the information is written in ink either by hand or using electronic media. For that we need a security system to secure the contents of the documents contained therein. In this research, a cryptographic method is used that will ensure the security of a document file. In this research, there is a security process that uses the Elgamal algorithm method as a solution to the implementation of the Quicksort algorithm method for document files. The results of this study indicate that the visual basic application can determine whether document files are safe or not. Using this method can help by securing the contents of a document file so that it is not known easily. Quicksort implementation that uses the Elgamal algorithm will be implemented using the visual basic application as evidence of the results of securing document files safely

CPP11sort: A parallel quicksort based on C++ threading

SummaryA new efficient implementation of the multithreaded quicksort algorithm called CPP11sort is presented. This implementation is built exclusively upon the threading primitives of the C++ programming language itself. The performance of CPP11sort is evaluated and compared with its mainstream competitors provided by GNU, Intel, and Microsoft. It is shown that out of the considered implementations, CPP11sort mostly yields the shortest sorting times and is the only one that is portable to any conforming C++ implementation without a need of external libraries or nonstandard compiler extensions. The experimental evaluation with various input data distributions resulted in parallel speedup between 16.1 and 44.2 on a 56‐core server and between 6.8 and 14.5 on a 10‐core workstation with enabled hyperthreading.

On-ramp merging strategy for connected and automated vehicles based on complete information static game

Improper handling of vehicle on-ramp merging may hinder traffic flow and contribute to lower fuel economy, while also increasing the risk of collisions. Cooperative control for connected and automated vehicles (CAVs) has the potential to significantly reduce negative environmental impact while also improve driving safety and traffic efficiency. Therefore, in this paper, we focus on the scenario of CAVs on-ramp merging and propose a centralized control method. Merging sequence (MS) allocation and motion planning are two key issues in this process. To deal with these problems, we first propose an MS allocation method based on a complete information static game whereby the mixed-strategy Nash equilibrium is calculated for an individual vehicle to select its strategy. The on-ramp merging problem is then formulated as a bi-objective (total fuel consumption and total travel time) optimization problem, to which optimal control based on Pontryagin's minimum principle (PMP) is applied to solve the motion planning issue. To determine the proper parameters in the bi-objective optimization problem, a varying-scale grid search method is proposed to explore possible solutions at different scales. In this method, an improved quicksort algorithm is designed to search for the Pareto front, and the (approximately) unbiased Pareto solution for the bi-objective optimization problem is finally determined as the optimal solution. The proposed on-ramp merging strategy is validated via numerical simulation, and comparison with other strategies demonstrates its effectiveness in terms of fuel economy and traffic efficiency. • MS allocation is modeled as a two-player game, where Pontryagin's minimum principle is used for control law calculation. • Illustrating in detail mixed-strategy Nash equilibrium of the game for MS allocation. • Proposing a varying-scale grid search algorithm to search for candidated parameters in the cost function.

"SMART HOME" MODELLİ ALİ MƏKTƏB LABORATORİYASINDA TEMPRATURUN QEYDƏ ALINMASI ÜÇÜN NİZAMLAMA ALOQRİTMİNİN İŞLƏNMƏSİ

Research work has been devoted to the measurement methods of temperature values in “Smart Home” type models and creation of algorithms by means of these methods. To solve the problem, most popular sorting algorithms were analysed and as a result fastest and most efficient methods were spotted among them. Chosen sorting algorithms were built and tested in c++ programming language. Quick sort algorithms were created in Arduino IDE and temperature data logger device was constructed. All of the sorted array elements were visualised in Excel Office software and working prinsiple and order of algorithms were explained. 3-Way QiuckSort method based on “Dutch National Flag” algorithm is tested for arrays which have lots of redundant elements. Key words: Arduino, sensors, QuickSort, sorting, parametrs, program code

RETRACTED: Mixed-mode database miner classifier: Parallel computation of graphical processing unit mining

Graphical processing unit (GPU) has gained more popularity among researchers in the field of decision making and knowledge discovery systems. However, most of the earlier studies have GPU memory utilization, computational time, and accuracy limitations. The main contribution of this paper is to present a novel algorithm called the Mixed Mode Database Miner (MMDBM) classifier by implementing multithreading concepts on a large number of attributes. The proposed method use the quick sort algorithm in GPU parallel computing to overcome the state of the art limitations. This method applies the dynamic rule generation approach for constructing the decision tree based on the predicted rules. Moreover, the implementation results are compared with both SLIQ and MMDBM using Java and GPU with the computed acceleration ratio time using the BP dataset. The primary objective of this work is to improve the performance with less processing time. The results are also analyzed using various threads in GPU mining using eight different datasets of UCI Machine learning repository. The proposed MMDBM algorithm have been validated on these chosen eight different dataset with accuracy of 91.3% in diabetes, 89.1% in breast cancer, 96.6% in iris, 89.9% in labor, 95.4% in vote, 89.5% in credit card, 78.7% in supermarket and 78.7% in BP, and simultaneously, it also takes less computational time for given datasets. The outcome of this work will be beneficial for the research community to develop more effective multi thread based GPU solution in GPU mining to handle large set of data in minimal processing time. Therefore, this can be considered a more reliable and precise method for GPU computing.