Problem Complexity And Method Efficiency In Optimization Pdf
File Name: problem complexity and method efficiency in optimization .zip
Skip to Main Content. A not-for-profit organization, IEEE is the world's largest technical professional organization dedicated to advancing technology for the benefit of humanity.
- Algorithmic efficiency
- Problem Complexity and Method Efficiency in Optimization
- SIAM Review
- SIAM Review
See similar material that would be shelved with this item, across all Hopkins libraries.
Download to read the full article text. Reprints and Permissions. Darzentas, J.
In computer science , algorithmic efficiency is a property of an algorithm which relates to the number of computational resources used by the algorithm. An algorithm must be analyzed to determine its resource usage, and the efficiency of an algorithm can be measured based on the usage of different resources.
Algorithmic efficiency can be thought of as analogous to engineering productivity for a repeating or continuous process. For maximum efficiency we wish to minimize resource usage. However, different resources such as time and space complexity cannot be compared directly, so which of two algorithms is considered to be more efficient often depends on which measure of efficiency is considered most important.
For example, bubble sort and timsort are both algorithms to sort a list of items from smallest to largest. If large lists must be sorted at high speed for a given application, timsort is a better choice; however, if minimizing the memory footprint of the sorting is more important, bubble sort is a better choice. The importance of efficiency with respect to time was emphasised by Ada Lovelace in as applying to Charles Babbage 's mechanical analytical engine:.
One essential object is to choose that arrangement which shall tend to reduce to a minimum the time necessary for completing the calculation" . Early electronic computers were severely limited both by the speed of operations and the amount of memory available.
In some cases it was realized that there was a space—time trade-off , whereby a task could be handled either by using a fast algorithm which used quite a lot of working memory, or by using a slower algorithm which used very little working memory.
The engineering trade-off was then to use the fastest algorithm which would fit in the available memory. Modern computers are significantly faster than the early computers, and have a much larger amount of memory available Gigabytes instead of Kilobytes.
Nevertheless, Donald Knuth emphasised that efficiency is still an important consideration:. An algorithm is considered efficient if its resource consumption, also known as computational cost, is at or below some acceptable level.
Roughly speaking, 'acceptable' means: it will run in a reasonable amount of time or space on an available computer, typically as a function of the size of the input. Since the s computers have seen dramatic increases in both the available computational power and in the available amount of memory, so current acceptable levels would have been unacceptable even 10 years ago.
In fact, thanks to the approximate doubling of computer power every 2 years , tasks that are acceptably efficient on modern smartphones and embedded systems may have been unacceptably inefficient for industrial servers 10 years ago. Computer manufacturers frequently bring out new models, often with higher performance.
Software costs can be quite high, so in some cases the simplest and cheapest way of getting higher performance might be to just buy a faster computer, provided it is compatible with an existing computer.
There are many ways in which the resources used by an algorithm can be measured: the two most common measures are speed and memory usage; other measures could include transmission speed, temporary disk usage, long-term disk usage, power consumption, total cost of ownership , response time to external stimuli, etc. Many of these measures depend on the size of the input to the algorithm, i.
They might also depend on the way in which the data is arranged; for example, some sorting algorithms perform poorly on data which is already sorted, or which is sorted in reverse order. As detailed below, the way in which an algorithm is implemented can also have a significant effect on actual efficiency, though many aspects of this relate to optimization issues. In the theoretical analysis of algorithms , the normal practice is to estimate their complexity in the asymptotic sense.
For example, bubble sort may be faster than merge sort when only a few items are to be sorted; however either implementation is likely to meet performance requirements for a small list. Typically, programmers are interested in algorithms that scale efficiently to large input sizes, and merge sort is preferred over bubble sort for lists of length encountered in most data-intensive programs. For new versions of software or to provide comparisons with competitive systems, benchmarks are sometimes used, which assist with gauging an algorithms relative performance.
If a new sort algorithm is produced, for example, it can be compared with its predecessors to ensure that at least it is efficient as before with known data, taking into consideration any functional improvements.
Benchmarks can be used by customers when comparing various products from alternative suppliers to estimate which product will best suit their specific requirements in terms of functionality and performance.
For example, in the mainframe world certain proprietary sort products from independent software companies such as Syncsort compete with products from the major suppliers such as IBM for speed. Some benchmarks provide opportunities for producing an analysis comparing the relative speed of various compiled and interpreted languages for example   and The Computer Language Benchmarks Game compares the performance of implementations of typical programming problems in several programming languages.
Even creating " do it yourself " benchmarks can demonstrate the relative performance of different programming languages, using a variety of user specified criteria.
This is quite simple, as a "Nine language performance roundup" by Christopher W. Cowell-Shah demonstrates by example. Implementation issues can also have an effect on efficiency, such as the choice of programming language, or the way in which the algorithm is actually coded,  or the choice of a compiler for a particular language, or the compilation options used, or even the operating system being used.
In many cases a language implemented by an interpreter may be much slower than a language implemented by a compiler. There are other factors which may affect time or space issues, but which may be outside of a programmer's control; these include data alignment , data granularity , cache locality , cache coherency , garbage collection , instruction-level parallelism , multi-threading at either a hardware or software level , simultaneous multitasking , and subroutine calls.
Some processors have capabilities for vector processing , which allow a single instruction to operate on multiple operands ; it may or may not be easy for a programmer or compiler to use these capabilities. Algorithms designed for sequential processing may need to be completely redesigned to make use of parallel processing , or they could be easily reconfigured. Another problem which can arise in programming is that processors compatible with the same instruction set such as x or ARM may implement an instruction in different ways, so that instructions which are relatively fast on some models may be relatively slow on other models.
This often presents challenges to optimizing compilers , which must have a great amount of knowledge of the specific CPU and other hardware available on the compilation target to best optimize a program for performance. In the extreme case, a compiler may be forced to emulate instructions not supported on a compilation target platform, forcing it to generate code or link an external library call to produce a result that is otherwise incomputable on that platform, even if it is natively supported and more efficient in hardware on other platforms.
This is often the case in embedded systems with respect to floating-point arithmetic , where small and low-power microcontrollers often lack hardware support for floating-point arithmetic and thus require computationally expensive software routines to produce floating point calculations.
For computers whose power is supplied by a battery e. As of [update] , power consumption is growing as an important metric for computational tasks of all types and at all scales ranging from embedded Internet of things devices to system-on-chip devices to server farms.
This trend is often referred to as green computing. Analyze the algorithm, typically using time complexity analysis to get an estimate of the running time as a function of the size of the input data. The result is normally expressed using Big O notation. This is useful for comparing algorithms, especially when a large amount of data is to be processed. More detailed estimates are needed to compare algorithm performance when the amount of data is small, although this is likely to be of less importance.
Algorithms which include parallel processing may be more difficult to analyze. Use a benchmark to time the use of an algorithm. Many programming languages have an available function which provides CPU time usage.
For long-running algorithms the elapsed time could also be of interest. Results should generally be averaged over several tests. Run-based profiling can be very sensitive to hardware configuration and the possibility of other programs or tasks running at the same time in a multi-processing and multi-programming environment. This sort of test also depends heavily on the selection of a particular programming language, compiler, and compiler options, so algorithms being compared must all be implemented under the same conditions.
This section is concerned with the use of memory resources registers , cache , RAM , virtual memory , secondary memory while the algorithm is being executed. As for time analysis above, analyze the algorithm, typically using space complexity analysis to get an estimate of the run-time memory needed as a function as the size of the input data.
Early electronic computers, and early home computers, had relatively small amounts of working memory. In the late s , it is typical for personal computers to have between 4 and 32 GB of RAM, an increase of over million times as much memory.
Current computers can have relatively large amounts of memory possibly Gigabytes , so having to squeeze an algorithm into a confined amount of memory is much less of a problem than it used to be. But the presence of four different categories of memory can be significant:. An algorithm whose memory needs will fit in cache memory will be much faster than an algorithm which fits in main memory, which in turn will be very much faster than an algorithm which has to resort to virtual memory.
Because of this, cache replacement policies are extremely important to high-performance computing, as are cache-aware programming and data alignment. To further complicate the issue, some systems have up to three levels of cache memory, with varying effective speeds. Different systems will have different amounts of these various types of memory, so the effect of algorithm memory needs can vary greatly from one system to another. In the early days of electronic computing, if an algorithm and its data wouldn't fit in main memory then the algorithm couldn't be used.
Nowadays the use of virtual memory appears to provide much memory, but at the cost of performance. If an algorithm and its data will fit in cache memory, then very high speed can be obtained; in this case minimizing space will also help minimize time.
This is called the principle of locality , and can be subdivided into locality of reference , spatial locality and temporal locality.
An algorithm which will not fit completely in cache memory but which exhibits locality of reference may perform reasonably well. In ubiquitous systems, halving the instructions executed can double the battery life and big data sets bring big opportunities for better software and algorithms: Reducing the number of operations from N x N to N x log N has a dramatic effect when N is large The following competitions invite entries for the best algorithms based on some arbitrary criteria decided by the judges:.
From Wikipedia, the free encyclopedia. Not to be confused with optimization, which is discussed in program optimization , optimizing compiler , loop optimization , object code optimizer , etc..
Further information: Memory hierarchy. Retrieved 14 December Retrieved 18 September Knowledge and Information Systems. October Archived from the original PDF on 3 March Retrieved 23 February Computer science. Computer architecture Embedded system Real-time computing Dependability. Network architecture Network protocol Network components Network scheduler Network performance evaluation Network service.
Interpreter Middleware Virtual machine Operating system Software quality. Programming paradigm Programming language Compiler Domain-specific language Modeling language Software framework Integrated development environment Software configuration management Software library Software repository. Control variable Software development process Requirements analysis Software design Software construction Software deployment Software maintenance Programming team Open-source model.
Model of computation Formal language Automata theory Computability theory Computational complexity theory Logic Semantics. Algorithm design Analysis of algorithms Algorithmic efficiency Randomized algorithm Computational geometry. Discrete mathematics Probability Statistics Mathematical software Information theory Mathematical analysis Numerical analysis Theoretical computer science.
Database management system Information storage systems Enterprise information system Social information systems Geographic information system Decision support system Process control system Multimedia information system Data mining Digital library Computing platform Digital marketing World Wide Web Information retrieval. Cryptography Formal methods Security services Intrusion detection system Hardware security Network security Information security Application security.
Interaction design Social computing Ubiquitous computing Visualization Accessibility. Concurrent computing Parallel computing Distributed computing Multithreading Multiprocessing.
Natural language processing Knowledge representation and reasoning Computer vision Automated planning and scheduling Search methodology Control method Philosophy of artificial intelligence Distributed artificial intelligence.
Supervised learning Unsupervised learning Reinforcement learning Multi-task learning Cross-validation.
Problem Complexity and Method Efficiency in Optimization
Table of contents. Please choose whether or not you want other users to be able to see on your profile that this library is a favorite of yours. Finding libraries that hold this item You may have already requested this item. Please select Ok if you would like to proceed with this request anyway. WorldCat is the world's largest library catalog, helping you find library materials online.
Complexity control in the topology optimization of continuum structures. A general mesh independent filter as a mean to control the complexity of topology optimization designed structures is discussed. A new mesh-independent filter, applied over the move-limits of the sequential linear programming is proposed, and it is shown that its use alleviates common problems in the continuum topology optimization, like checkerboarding, mesh dependency, as well as effects associated to non-structured meshes, like numerical anisotropy. The structural optimization formulation adopted in this work is the minimization of a penalized function of the volume, with constraints on the compliance of each load case. Aspects of this penalized objective function are discussed, and several numerical examples are shown.
Skip to search form Skip to main content You are currently offline. Some features of the site may not work correctly. DOI:
We hope this content on epidemiology, disease modeling, pandemics and vaccines will help in the rapid fight against this global problem. Click on title above or here to access this collection. Sign in Help View Cart. Article Tools. Add to my favorites.
In computer science , algorithmic efficiency is a property of an algorithm which relates to the number of computational resources used by the algorithm. An algorithm must be analyzed to determine its resource usage, and the efficiency of an algorithm can be measured based on the usage of different resources. Algorithmic efficiency can be thought of as analogous to engineering productivity for a repeating or continuous process. For maximum efficiency we wish to minimize resource usage. However, different resources such as time and space complexity cannot be compared directly, so which of two algorithms is considered to be more efficient often depends on which measure of efficiency is considered most important.
About this article
Skip to search Skip to main content. Reporting from:. Your name. Your email. Send Cancel. Check system status. Toggle navigation Menu.
Skip to Main Content.