Downloads & Free Reading Options - Results

This paper improves the algorithms based on supporting halfspaces and quadratic programming for convex set intersection problems in our earlier paper in several directions. First, we give conditions so that much smaller quadratic programs (QPs) and approximate projections arising from partially solving the QPs are sufficient for multiple-term superlinear convergence for nonsmooth problems. Second, we identify additional regularity, which we call the second order supporting hyperplane property (SOSH), that gives multiple-term quadratic convergence. Third, we show that these fast convergence results carry over for the convex inequality problem. Fourth, we show that infeasibility can be detected in finitely many operations. Lastly, we explain how we can use the dual active set QP algorithm of Goldfarb and Idnani to get useful iterates by solving the QPs partially, overcoming the problem of solving large QPs in our algorithms.

We present a new programming paradigm which can be useful, in particular, for implementing window interfaces and parallel algorithms. This paradigm allows a user to define operators which can contain nested operators. The new paradigm is called operator-oriented. One of the goals of this paradigm is to escape the complexity of objects definitions inherent in many object-oriented languages and to move to transparent algorithms definitions.

We present a new programming paradigm which can be useful, in particular, for implementing window interfaces and parallel algorithms. This paradigm allows a user to define operators which can contain nested operators. The new paradigm is called operator-oriented. One of the goals of this paradigm is to escape the complexity of objects definitions inherent in many object-oriented languages and to move to transparent algorithms definitions.

The objective of this project was to write computer code to perform linear programming and quadratic programming minimization tasks, for eventual inclusion in a robotic control system. The basic concept underlying the project is this: given a description of a robot and a description of an object in the robot's surrounding in terms of a series of inequalities, the minimization code can find the minimum distance between the robot and the object. The linear programming algorithm minimizes the infinity norm, while the quadratic programming algorithm mimimizes the euclidian norm. The programming language 'C' was used to implement both programming algorithms, due to its natural speed, combined with the ability to use different floating point libraries at will. An added advantage of using 'C' on the sun workstations is the ability to make use of the 68881 floating point coprocessor on the Sun 3 computers, which provides dramatic speed increases over using floating point libraries. Each programming algorithm was implemented as a function, along with its supporting subroutines. For ease of development, each algorithm was developed in a separate program. However, there should be no difficulty in incorporating either the linear programming algorithm or the quadratic programming algorithm into a larger section of code when implementing a robotic control system.

Programming Computer Vision with Python Tools and algorithms for analyzing images terjemahan Indonesia

This report results from a contract tasking ILOG as follows: Several promising areas will be investigated: more efficient use of linear programming. new and more powerful relaxation techniques use of column generation techniques integration of graph theoretic algorithms use of randomization to search branch-and-bound trees and symmetry breaking. Techniques that are developed will be tested on challenging problems where current constraint programming technology is limited.

Stochastic semidefinite programs (SSDP's) are a new class of optimization problems with a wide variety applications proposed by the PI and his doctoral students. The broad objective of this project was to develop applications of and algorithms for SSDP's. We have developed five classes of novel applications, and three classes of new algorithms. We have proved the convergence and polynomial complexity of the algorithms. We have also identified two new classes of optimization problems which may be useful for future research.

Stochastic semidefinite programs (SSDP's) are a new class of optimization problems with a wide variety applications proposed by the PI and his doctoral students. The broad objective of this project was to develop applications of and algorithms for SSDP's. We have developed five classes of novel applications, and three classes of new algorithms. We have proved the convergence and polynomial complexity of the algorithms. We have also identified two new classes of optimization problems which may be useful for future research.

Stochastic semidefinite programs (SSDP's) are a new class of optimization problems with a wide variety applications proposed by the PI and his doctoral students. The broad objective of this project was to develop applications of and algorithms for SSDP's. We have developed five classes of novel applications, and three classes of new algorithms. We have proved the convergence and polynomial complexity of the algorithms. We have also identified two new classes of optimization problems which may be useful for future research.

Motivated by Bland's linear-programming generalization of the renowned Edmonds-Karp efficient refinement of the Ford-Fulkerson maximum-flow algorithm, we discuss three closely-related natural augmentation rules for linear and integer-linear optimization. In several nice situations, we show that polynomially-many augmentation steps suffice to reach an optimum. In particular, when using "discrete steepest-descent augmentations" (i.e., directions with the best ratio of cost improvement per unit 1-norm length), we show that the number of augmentation steps is bounded by the number of elements in the Graver basis of the problem matrix, giving the first ever strongly polynomial-time algorithm for $N$-fold integer-linear optimization. Our results also improve on what is known for such algorithms in the context of linear optimization (e.g., generalizing the bounds of Kitahara and Mizuno for the number of steps in the simplex method) and are closely related to research on the diameters of polytopes and the search for a strongly polynomial-time simplex or augmentation algorithm.

The main purpose of this work is to give explicit sparsity-preserving SOR(Successive Overrelaxation) algorithms for the solution of separable quadratic and linear programming problems. The principal and computationally distinguishing feature of the present SOR algorithms is that they preserve the sparsity structure of the problem and do not require the computation of the product of the constraint matrix by its transpose as is the case in earlier SOR algorithms for linear and quadratic programming. (Author)

Genetic Algorithms and Genetic Programming: Modern Concepts and Practical Applications discusses algorithmic developments in the context of genetic algorithms (GAs) and genetic programming (GP). It applies the algorithms to significant combinatorial optimization problems and describes structure identification using HeuristicLab as a platform for al

Bibliography: p. 20-22

ai how i fail

ADA066345

ADA066345

The design of algorithm plays an important role in operations research in general and dynamic programming in particular. In most dynamic programming algorithms, formalism of computing, data structure and complexity analysis does not appear. One of the objectives of this research is to provide such a formalism. Converging branch, diverging branch, feed-forward loop and feedback loop systems are considered. In each case, first, a high level algorithm followed by the detailed computer algorithm is described. Formulas for storage and computational complexities for each computer algorithm are derived. Finally algorithms are implemented on VAX-11/780 computers using UCSD PASCAL. (Author)

We consider the 0-1 Penalized Knapsack Problem (PKP). Each item has a profit, a weight and a penalty and the goal is to maximize the sum of the profits minus the greatest penalty value of the items included in a solution. We propose an exact approach relying on a procedure which narrows the relevant range of penalties, on the identification of a core problem and on dynamic programming. The proposed approach turns out to be very effective in solving hard instances of PKP and compares favorably both to commercial solver CPLEX 12.5 applied to the ILP formulation of the problem and to the best available exact algorithm in the literature. Then we present a general inapproximability result and investigate several relevant special cases which permit fully polynomial time approximation schemes (FPTASs).

The class $(r,2)$-CSP, or simply Max 2-CSP, consists of constraint satisfaction problems with at most two $r$-valued variables per clause. For instances with $n$ variables and $m$ binary clauses, we present an $O(n r^{5+19m/100})$-time algorithm which is the fastest polynomial-space algorithm for many problems in the class, including Max Cut. The method also proves a treewidth bound $\tw(G) \leq (13/75+o(1))m$, which gives a faster Max 2-CSP algorithm that uses exponential space: running in time $\Ostar{2^{(13/75+o(1))m}}$, this is fastest for most problems in Max 2-CSP. Parametrizing in terms of $n$ rather than $m$, for graphs of average degree $d$ we show a simple algorithm running time $\Ostar{2^{(1-\frac{2}{d+1})n}}$, the fastest polynomial-space algorithm known. In combination with ``Polynomial CSPs'' introduced in a companion paper, these algorithms also allow (with an additional polynomial-factor overhead in space and time) counting and sampling, and the solution of problems like Max Bisection that escape the usual CSP framework. Linear programming is key to the design as well as the analysis of the algorithms.

Outline: 1) Introduction * Optimal control * Dynamic programming (DP). 2) Path Planning * Discrete planning as optimal control * Dijkstra's algorithm & its problems * Continuous DP & the Hamilton-Jacobi (HJ) PDE * The fast marching method (FMM): Dijkstra's for continuous spaces. 3) Algorithms for Static HJ PDEs * Four alternatives * FMM pros & cons. 4) Generalizations * Alternative action norms * Multiple objective planning.

Outline: 1) Introduction * Optimal control * Dynamic programming (DP). 2) Path Planning * Discrete planning as optimal control * Dijkstra's algorithm & its problems * Continuous DP & the Hamilton-Jacobi (HJ) PDE * The fast marching method (FMM): Dijkstra's for continuous spaces. 3) Algorithms for Static HJ PDEs * Four alternatives * FMM pros & cons. 4) Generalizations * Alternative action norms * Multiple objective planning.

Outline: 1) Introduction * Optimal control * Dynamic programming (DP). 2) Path Planning * Discrete planning as optimal control * Dijkstra's algorithm & its problems * Continuous DP & the Hamilton-Jacobi (HJ) PDE * The fast marching method (FMM): Dijkstra's for continuous spaces. 3) Algorithms for Static HJ PDEs * Four alternatives * FMM pros & cons. 4) Generalizations * Alternative action norms * Multiple objective planning.

For paving the way to novel applications in quantum simulation, computation, and technology, increasingly large quantum systems have to be steered with high precision. It is a typical task amenable to numerical optimal control to turn the time course of pulses, i.e. piecewise constant control amplitudes, iteratively into an optimised shape. Here, we present the first comparative study of optimal control algorithms for a wide range of finite-dimensional applications. We focus on the most commonly used algorithms: GRAPE methods which update all controls concurrently, and KROTOV-type methods which do so sequentially. Guidelines for their use are given and open research questions are pointed out. --- Moreover we introduce a novel unifying algorithmic framework, DYNAMO (dynamic optimisation platform) designed to provide the quantum-technology community with a convenient MATLAB-based toolset for optimal control. In addition, it gives researchers in optimal-control techniques a framework for benchmarking and comparing new proposed algorithms to the state-of-the-art. It allows for a mix-and-match approach with various types of gradients, update and step-size methods as well as subspace choices. Open-source code including examples is made available at http://qlib.info.

This paper studies the problem of finding a (1+eps)-approximation to positive semidefinite programs. These are semidefinite programs in which all matrices in the constraints and objective are positive semidefinite and all scalars are non-negative. Previous work (Jain and Yao, FOCS'11) gave an NC algorithm that requires at least Omega((1/eps)^13\log^{13}n) iterations. The algorithm performs at least Omega(n^\omega) work per iteration, where n is the dimension of the matrices involved, since each iteration involves computing spectral decomposition. We present a simpler NC parallel algorithm that requires O((1/eps)^4 \log^4 n \log(1/eps)) iterations. Moreover, if the positive SDP is provided in a factorized form, the total work of our algorithm can be bounded by \otilde(n+M), where M is the total number of nonzero entries in the factorization. Our algorithm is a generalization of Young's algorithm and analysis techniques for positive linear programs (Young, FOCS'01) to the semidefinite programming setting.

This paper studies the problem of finding a (1+eps)-approximation to positive semidefinite programs. These are semidefinite programs in which all matrices in the constraints and objective are positive semidefinite and all scalars are non-negative. Previous work (Jain and Yao, FOCS'11) gave an NC algorithm that requires at least Omega((1/eps)^13\log^{13}n) iterations. The algorithm performs at least Omega(n^\omega) work per iteration, where n is the dimension of the matrices involved, since each iteration involves computing spectral decomposition. We present a simpler NC parallel algorithm that requires O((1/eps)^4 \log^4 n \log(1/eps)) iterations. Moreover, if the positive SDP is provided in a factorized form, the total work of our algorithm can be bounded by \otilde(n+M), where M is the total number of nonzero entries in the factorization. Our algorithm is a generalization of Young's algorithm and analysis techniques for positive linear programs (Young, FOCS'01) to the semidefinite programming setting.

http://uf.catalog.fcla.edu/uf.jsp?st=UF024909362&ix=pm&I=0&V=D&pm=1

In this paper, we consider the following inverse maintenance problem: given $A \in \mathbb{R}^{n\times d}$ and a number of rounds $r$, we receive a $n\times n$ diagonal matrix $D^{(k)}$ at round $k$ and we wish to maintain an efficient linear system solver for $A^{T}D^{(k)}A$ under the assumption $D^{(k)}$ does not change too rapidly. This inverse maintenance problem is the computational bottleneck in solving multiple optimization problems. We show how to solve this problem with $\tilde{O}(nnz(A)+d^{\omega})$ preprocessing time and amortized $\tilde{O}(nnz(A)+d^{2})$ time per round, improving upon previous running times for solving this problem. Consequently, we obtain the fastest known running times for solving multiple problems including, linear programming and computing a rounding of a polytope. In particular given a feasible point in a linear program with $d$ variables, $n$ constraints, and constraint matrix $A\in\mathbb{R}^{n\times d}$, we show how to solve the linear program in time $\tilde{O}(nnz(A)+d^{2})\sqrt{d}\log(\epsilon^{-1}))$. We achieve our results through a novel combination of classic numerical techniques of low rank update, preconditioning, and fast matrix multiplication as well as recent work on subspace embeddings and spectral sparsification that we hope will be of independent interest.

Mathematical programming is a branch of applied mathematics and has recently been used to derive new decoding approaches, challenging established but often heuristic algorithms based on iterative message passing. Concepts from mathematical programming used in the context of decoding include linear, integer, and nonlinear programming, network flows, notions of duality as well as matroid and polyhedral theory. This survey article reviews and categorizes decoding methods based on mathematical programming approaches for binary linear codes over binary-input memoryless symmetric channels.

The main purpose of this work is to give explicit sparsity-preserving SOR(Successive Overrelaxation) algorithms for the solution of separable quadratic and linear programming problems. The principal and computationally distinguishing feature of the present SOR algorithms is that they preserve the sparsity structure of the problem and do not require the computation of the product of the constraint matrix by its transpose as is the case in earlier SOR algorithms for linear and quadratic programming. (Author)

This is the third and final report on the work done for NASA Grant 5-403 on Algorithms and Programming Tools for Image Processing on the MPP:3. All the work done for this grant is summarized in the introduction. Work done since August 1986 is reported in detail. Research for this grant falls under the following headings: (1) fundamental algorithms for the MPP; (2) programming utilities for the MPP; (3) the Parallel Pascal Development System; and (4) performance analysis. In this report, the results of two efforts are reported: region growing, and performance analysis of important characteristic algorithms. In each case, timing results from MPP implementations are included. A paper is included in which parallel algorithms for region growing on the MPP is discussed. These algorithms permit different sized regions to be merged in parallel. Details on the implementation and peformance of several important MPP algorithms are given. These include a number of standard permutations, the FFT, convolution, arbitrary data mappings, image warping, and pyramid operations, all of which have been implemented on the MPP. The permutation and image warping functions have been included in the standard development system library.

This is the third and final report on the work done for NASA Grant 5-403 on Algorithms and Programming Tools for Image Processing on the MPP:3. All the work done for this grant is summarized in the introduction. Work done since August 1986 is reported in detail. Research for this grant falls under the following headings: (1) fundamental algorithms for the MPP; (2) programming utilities for the MPP; (3) the Parallel Pascal Development System; and (4) performance analysis. In this report, the results of two efforts are reported: region growing, and performance analysis of important characteristic algorithms. In each case, timing results from MPP implementations are included. A paper is included in which parallel algorithms for region growing on the MPP is discussed. These algorithms permit different sized regions to be merged in parallel. Details on the implementation and peformance of several important MPP algorithms are given. These include a number of standard permutations, the FFT, convolution, arbitrary data mappings, image warping, and pyramid operations, all of which have been implemented on the MPP. The permutation and image warping functions have been included in the standard development system library.

Donald Knuth is one of the greatest and most impactful computer scientists and mathematicians ever. He is the recipient in 1974 of the Turing Award, considered the Nobel Prize of computing. He is the author of the multi-volume work, the magnum opus, The Art of Computer Programming. He made several key contributions to the rigorous analysis of the computational complexity of algorithms. He popularized asymptotic notation, that we all affectionately know as the big-O notation. He also created the TeX typesetting which most computer scientists, physicists, mathematicians, and scientists and engineers use to write technical papers and make them look

The main purpose of this work is to give explicit sparsity-preserving SOR(Successive Overrelaxation) algorithms for the solution of separable quadratic and linear programming problems. The principal and computationally distinguishing feature of the present SOR algorithms is that they preserve the sparsity structure of the problem and do not require the computation of the product of the constraint matrix by its transpose as is the case in earlier SOR algorithms for linear and quadratic programming. (Author)

The main purpose of this work is to give explicit sparsity-preserving SOR(Successive Overrelaxation) algorithms for the solution of separable quadratic and linear programming problems. The principal and computationally distinguishing feature of the present SOR algorithms is that they preserve the sparsity structure of the problem and do not require the computation of the product of the constraint matrix by its transpose as is the case in earlier SOR algorithms for linear and quadratic programming. (Author)

http://uf.catalog.fcla.edu/uf.jsp?st=UF021549200&ix=pm&I=0&V=D&pm=1

The main purpose of this work is to give explicit sparsity-preserving SOR(Successive Overrelaxation) algorithms for the solution of separable quadratic and linear programming problems. The principal and computationally distinguishing feature of the present SOR algorithms is that they preserve the sparsity structure of the problem and do not require the computation of the product of the constraint matrix by its transpose as is the case in earlier SOR algorithms for linear and quadratic programming. (Author)

Although large amounts of programming knowledge are available to human programmers in the form of books and articles, very little of this knowledge is available in a form suitable for use by a machine in performing programming tasks automatically. The principal goal of the research reported here is the explication of programming knowledge to a sufficient level of detail that it can be used effectively by a machine. The programming task considered in this experiment is that of constructing concrete implementations of abstract algorithms in the domain of symbolic programming. Knowledge about several aspects of symbolic programming has been expressed as a collection of four hundred refinement rules. The rules deal primarily with collections and mappings and ways of manipulating such structures, including several enumeration, sorting and searching techniques. The principal representation techniques covered include the representation of sets as linked lists and arrays (both ordered and unordered), and the representation of mappings as tables, sets of pairs, property list markings, and inverted mappings (indexed by range element). In addition to these general constructs, many low-level programming details are covered (such as the use of variables to store values).

Topics addressed include: data mapping and rotational algorithms for the Massively Parallel Processor (MPP); Parallel Pascal language; documentation for the Parallel Pascal Development system; and a description of the Parallel Pascal language used on the MPP.

The Next Generation (NextGen) transport aircraft configurations being investigated as part of the NASA Aeronautics Subsonic Fixed Wing Project have more control surfaces, or control effectors, than existing transport aircraft configurations. Conventional flight control is achieved through two symmetric elevators, two antisymmetric ailerons, and a rudder. The five effectors, reduced to three command variables, produce moments along the three main axes of the aircraft and enable the pilot to control the attitude and flight path of the aircraft. The NextGen aircraft will have additional redundant control effectors to control the three moments, creating a situation where the aircraft is over-actuated and where a simple relationship does not exist anymore between the required effector deflections and the desired moments. NextGen flight controllers will incorporate control allocation algorithms to determine the optimal effector commands and attain the desired moments, taking into account the effector limits. Approaches to solving the problem using linear programming and quadratic programming algorithms have been proposed and tested. It is of great interest to understand their relative advantages and disadvantages and how design parameters may affect their properties. In this paper, we investigate the sensitivity of the effector commands with respect to the desired moments and show on some examples that the solutions provided using the l2 norm of quadratic programming are less sensitive than those using the l1 norm of linear programming.

vi, 312 pages : 28 cm

This is CMPE 130 Course's Sylabus

In this thesis we study several computer implementations of the thinning algorithm, a new method for generating non-homogeneous Poisson processes. The method is valid for Poisson processes with any given intensity function. The basic thinning algorithm is modified to exploit several refinements which reduce computer execution time by approximately one-third. The basic and modified thinning programs are compared with the Poisson decomposition and gap-statistics algorithm, which is easily implemented for Poisson processes with intensity functions of the form exp(a sub 0 + a sub 1t + a sub 2 t-squared. The thinning programs are competitive in both execution time and computer memory requirements. One program implementation generates the events in a Poisson process one at a time; another program implements the algorithmic refinements which improve efficiency.

In this thesis we study several computer implementations of the thinning algorithm, a new method for generating non-homogeneous Poisson processes. The method is valid for Poisson processes with any given intensity function. The basic thinning algorithm is modified to exploit several refinements which reduce computer execution time by approximately one-third. The basic and modified thinning programs are compared with the Poisson decomposition and gap-statistics algorithm, which is easily implemented for Poisson processes with intensity functions of the form exp(a sub 0 + a sub 1t + a sub 2 t-squared. The thinning programs are competitive in both execution time and computer memory requirements. One program implementation generates the events in a Poisson process one at a time; another program implements the algorithmic refinements which improve efficiency.

We propose Chunks and Tasks, a parallel programming model built on abstractions for both data and work. The application programmer specifies how data and work can be split into smaller pieces, chunks and tasks, respectively. The Chunks and Tasks library maps the chunks and tasks to physical resources. In this way we seek to combine user friendliness with high performance. An application programmer can express a parallel algorithm using a few simple building blocks, defining data and work objects and their relationships. No explicit communication calls are needed; the distribution of both work and data is handled by the Chunks and Tasks library. This makes efficient implementation of complex applications that require dynamic distribution of work and data easier. At the same time, Chunks and Tasks imposes restrictions on data access and task dependencies that facilitates the development of high performance parallel back ends. We discuss the fundamental abstractions underlying the programming model, as well as performance and fault resilience considerations. We also present a pilot C++ library implementation for clusters of multicore machines and demonstrate its performance for sparse blocked matrix-matrix multiplication.

This paper investigates session programming and typing of benchmark examples to compare productivity, safety and performance with other communications programming languages. Parallel algorithms are used to examine the above aspects due to their extensive use of message passing for interaction, and their increasing prominence in algorithmic research with the rising availability of hardware resources such as multicore machines and clusters. We contribute new benchmark results for SJ, an extension of Java for type-safe, binary session programming, against MPJ Express, a Java messaging system based on the MPI standard. In conclusion, we observe that (1) despite rich libraries and functionality, MPI remains a low-level API, and can suffer from commonly perceived disadvantages of explicit message passing such as deadlocks and unexpected message types, and (2) the benefits of high-level session abstraction, which has significant impact on program structure to improve readability and reliability, and session type-safety can greatly facilitate the task of communications programming whilst retaining competitive performance.

This paper investigates session programming and typing of benchmark examples to compare productivity, safety and performance with other communications programming languages. Parallel algorithms are used to examine the above aspects due to their extensive use of message passing for interaction, and their increasing prominence in algorithmic research with the rising availability of hardware resources such as multicore machines and clusters. We contribute new benchmark results for SJ, an extension of Java for type-safe, binary session programming, against MPJ Express, a Java messaging system based on the MPI standard. In conclusion, we observe that (1) despite rich libraries and functionality, MPI remains a low-level API, and can suffer from commonly perceived disadvantages of explicit message passing such as deadlocks and unexpected message types, and (2) the benefits of high-level session abstraction, which has significant impact on program structure to improve readability and reliability, and session type-safety can greatly facilitate the task of communications programming whilst retaining competitive performance.

In this lecture, we will study various applications of the theory of Multiplicative Weights (MW). In this section, we brie�y review the general version of the MW algorithm that we studied in the previous lecture. The following sections then show how the theory can be applied to approximately solve zero-sum games and linear programs, and how it connects with the theory of boosting and approximation algorithms.

In this lecture, we will study various applications of the theory of Multiplicative Weights (MW). In this section, we brie�y review the general version of the MW algorithm that we studied in the previous lecture. The following sections then show how the theory can be applied to approximately solve zero-sum games and linear programs, and how it connects with the theory of boosting and approximation algorithms.

In this lecture, we will study various applications of the theory of Multiplicative Weights (MW). In this section, we brie�y review the general version of the MW algorithm that we studied in the previous lecture. The following sections then show how the theory can be applied to approximately solve zero-sum games and linear programs, and how it connects with the theory of boosting and approximation algorithms.

Several algorithms in linear and nonlinear programming have been developed and analyzed. A worst-case analysis of the steepest edge simplex method showed it to have exponential time-complexity. This algorithm was specialized for solving minimum cost network flow problems and a partial pricing variant was developed. After extensive testing on randomly generated large problems the method was found to be inferior to efficiently coded partial pricing variants of the 'standard' simplex method except for the max flow problem and the problem of finding a feasible flow. On the max flow problem the algorithm was compared with the Edmonds-Karp and Dinic algorithms and found to be superior. In quadratic programming, the use of the steepest edge (face) criterion for dropping constraints was found to be helpful. Dual methods were found to be even more efficient and their use in recursive quadratic programming algorithms for nonlinear programming problems is recommended. A numerically stable ellipsoid algorithm for linear programming was developed and analyzed. At present the main promise that this method holds is as a powerful theoretical tool. Several minimization algorithms for taking advantage of negative curvature were developed as was a curvilinear steplength algorithm which ensures convergence to a positive semidefinite point. (Author)