Minimizing the makespan on a single machine with flexible maintenances and jobs’ release dates

This paper addresses the production scheduling problem on a single machine with flexible periodic preventive maintenances (PM), where jobs’ release dates are also considered. Both resumable and non-resumable cases are studied. For the resumable case, it is proved that the problem can be solved in polynomial time with Earliest Release Date (ERD) rule. For the non-resumable case, it is proved to be NP-Hard in strong sense. And, a mixed integer programming (MIP) mathematical model is provided. Then, an effective heuristic ERD-LPT based on the properties of optimal solution is proposed. Meanwhile, a branch-and-bound algorithm (B and B) that utilizes several dominance rules is developed to search the optimal schedule for small-to-medium sized problems. Computational results indicate that the proposed heuristic is highly accurate and the two algorithms are complementary in dealing with different sized problems. Furthermore, the improvement of the integration between production scheduling and PM is significant compared with the First-in-First-out (FIFO) rule which is adopted commonly in industry.     

Parallel batch scheduling of equal-length jobs with release and due dates

In this paper we study parallel batch scheduling problems with bounded batch capacity and equal-length jobs in a single and parallel machine environment. It is shown that the feasibility problem 1|p-batch,b<n,r _j ,p _j =p,C _j ≤d _j |− can be solved in O(n ²) time and that the problem of minimizing the maximum lateness can be solved in O(n ²log n) time. For the parallel machine problem P|p-batch,b<n,r _j ,p _j =p,C _j ≤d _j |− an O(n ³log n)-time algorithm is provided, which can also be used to solve the problem of minimizing the maximum lateness in O(n ³log ² n) time.     

Minimizing the earliness–tardiness costs on a single machine

In this paper the one-machine scheduling problem with linear earliness and tardiness costs is considered. The cost functions are job dependent and asymmetric. The problem consists of two sub-problems. The first one is to find a sequence of jobs and the second one is to find the job completion times that are optimal for the given sequence. We consider the second sub-problem and propose an algorithm solving the problem in O(nlogn)$\mathrm{O}(n\log n)$ time.     

Block approach—tabu search algorithm for single machine total weighted tardiness problem

Problem of scheduling on a single machine to minimize total weighted tardiness of jobs can be described as follows: there are n jobs to be processed, each job has an integer processing time, a weight and a due date. The objective is to minimize the total weighted tardiness of jobs. The problem belongs to the class of NP-hard problems. Some new properties of the problem associated with the blocks have been presented and discussed. These properties allow us to propose a new fast local search procedure based on a tabu search approach with a specific neighborhood which employs blocks of jobs and a compound moves technique. A compound move consists in performing several moves simultaneously in a single iteration of algorithm and allows us to accelerate the convergence to good solutions. In the algorithm, we use an idea which decreases the complexity for the search of neighborhood from O(n³) to O(n²). Additionally, the neighborhood is reduced by using some elimination criteria. The method presented in this paper is deterministic one and has not any random element, as distinct from other effective but non-deterministic methods proposed for this problem, such as tabu search of Crauwels, H. A. J., Potts, C. N., & Van Wassenhove, L. N. (1998). Local search heuristics for the single machine total weighted tardiness Scheduling Problem. INFORMS Journal on Computing, 10(3), 341–350, iterated dynasearch of Congram, R. K., Potts C. N., & Van de Velde, S. L. (2002). An iterated dynasearch algorithm for the single-machine total weighted tardiness scheduling problem. INFORMS Journal on Computing, 14(1), 52–67 and enhanced dynasearch of Grosso, A., Della Croce, F., & Tadei, R. (2004). An enhanced dynasearch neighborhood for single-machine total weighted tardiness scheduling problem. Operations Research Letters, 32, 68–72. Computational experiments on the benchmark instances from OR-Library (http://people.brunel.ac.uk/mastjjb/jeb/info.html) are presented and compared with the results yielded by the best algorithms discussed in the literature. These results show that the algorithm proposed allows us to obtain the best known results for the benchmarks in a short time. The presented properties and ideas can be applied in any local search procedures.     

Scheduling deteriorating jobs on a single machine subject to breakdowns

We investigate the problem of scheduling a set of jobs to minimize the expected makespan or the variance of the makespan. The jobs are subject to deteriorations which are expressed as linear increments of the processing requirements. The machine is subject to preemptive-resume breakdowns with exponentially distributed uptimes and downtimes. It has been well known in the classical models that the expectation and variance of the makespan of deteriorating jobs can be minimized analytically by an index policy if no machine breakdowns are involved. Such basic features, however, change dramatically when breakdowns and deteriorations are present together. In this paper, we derive conditions for jobs to be processible in the sense that they will be eventually completed, and the characteristics of the time that a job occupies the machine. We further find that the expected makespan can still be minimized by a simple index policy that is independent of the breakdown process, but this is no longer the case for the variance of the makespan.     

Minimum number of tardy jobs in single machine scheduling with release dates—an improved algorithm

Scheduling of n-jobs on a single machine is studied here where each job i has a specified ready time, processing time and due date. It is assumed that early jobs have early due dates. An algorithm that minimizes the number of tardy jobs for this problem has been presented in Kise et al. [1]. We adopt the “blocks” concept to modify their algorithm to eliminate unnecessary computations. The improved algorithm developed here also employs a backward searching process for tardy jobs and uses a stopping rule for this search to further reduce the computational requirements.     

A bicriteria approach to minimize the total weighted number of tardy jobs with convex controllable processing times and assignable due dates

We study a single-machine scheduling problem in a flexible framework where both job processing times and due dates are decision variables to be determined by the scheduler. The model can also be applied for quoting delivery times when some parts of the jobs may be outsourced. We analyze the problem for two due date assignment methods and a convex resource consumption function. For each due date assignment method, we provide a bicriteria analysis where the first criterion is to minimize the total weighted number of tardy jobs plus due date assignment cost, and the second criterion is to minimize total weighted resource consumption. We consider four different models for treating the two criteria. Although the problem of minimizing a single integrated objective function can be solved in polynomial time, we prove that the three bicriteria models are NPmathcal{NP}-hard for both due date assignment methods. We also present special cases, which frequently occur in practice, and in which all four models are polynomially solvable.     

Minimizing weighted earliness–tardiness on parallel machines using hybrid metaheuristics

We consider the problem of scheduling a set of jobs on a set of identical parallel machines where the objective is to minimize the total weighted earliness and tardiness penalties with respect to a common due date. We propose a hybrid heuristic algorithm for constructing good solutions, combining priority rules for assigning jobs to machines and a local search with exact procedures for solving the one-machine subproblems. These solutions are then used in two metaheuristic frameworks, Path Relinking and Scatter Search, to obtain high quality solutions for the problem.The algorithms are tested on a large number of test instances to assess the efficiency of the proposed strategies.The results show that our algorithms consistently outperform the best reported results for this problem.     

Single machine weighted earliness–tardiness penalty problem with a common due date

In this paper, we have considered a class of single machine job scheduling problems where the objective is to minimize the weighted sum of earliness–tardiness penalties of jobs. The weights are job-independent but they depend on whether a job is early or tardy. The restricted version of the problem where the common due date is smaller than a critical value, is known to be NP-complete. While dynamic programming formulation runs out of memory for large problem instances, depth-first branch-and-bound formulation runs slow for large problems since it uses a tree search space. In this paper, we have suggested an algorithm to optimally solve large instances of the restricted version of the problem. The algorithm uses a graph search space. Unlike dynamic programming, the algorithm can output optimal solutions even when available memory is limited. It has been found to run faster than dynamic programming and depth-first branch-and-bound formulations and can solve much larger instances of the problem in reasonable time. New upper and lower bounds have been proposed and used. Experimental findings are given in detail.Scope and purposeA class of single machine problems arising out of scheduling jobs in JIT environment has been considered in this paper. The objective is to minimize the total weighted earliness–tardiness penalties of jobs. In this paper, we have presented a new algorithm and conducted extensive empirical runs to show that the new algorithm performs much better than the existing approaches in solving large instances of the problem.     

Sequencing a single machine with due dates and deadlines: an ILP-based approach to solve very large instances

We consider the problem of minimizing the weighted number of tardy jobs on a single machine where each job is also subject to a deadline that cannot be violated. We propose an exact method based on a compact integer linear programming formulation of the problem and an effective reduction procedure that allows to solve to optimality instances with up to 30,000 jobs in size, and up to 50,000 jobs in size for the special deadline-free case.     

Single‐machine scheduling problem with resource dependent release dates to minimise total resource‐consumption

This article considers the single‐machine scheduling problem to minimise the total resource consumption under the constraint that the makespan does not exceed a given limit, in which the release date of a job is a linear decreasing continuous function of the resource consumption. This problem is NP-hard in the strong sense. We design a simulated annealing (SA) algorithm to obtain the near-optimal solution with high quality. Two operators, right-move and left-move, are defined and their influences on the resource consumption are analysed. We use two operations, insert and swap, to generate the neighbourhood, and discuss how to calculate the change of total resource consumption. To evaluate the performance of the proposed algorithm, we relax the problem to an assignment problem, and obtain a lower bound by the Hungary method. And then, we improve its quality by Chu's method. Based on the settings that Janiak provided, we generate the random test data in our experiments to simulate the ingot preheating and hot-rolling process in steel mills. The accuracy and efficiency of the proposed SA algorithm are tested based on those data with problem sizes varying from 50 to 200 jobs. The computational results indicate that the SA approach is promising and capable of solving large-scale problems in a reasonable time.     

Earliness–tardiness minimization on a single machine to schedule preventive maintenance tasks: metaheuristic and exact methods

In this paper, we consider the problem of scheduling a set of M preventive maintenance tasks to be performed on M machines. The machines are assigned to execute production tasks. We aim to minimize the total preventive maintenance cost such that the maintenance tasks have to continuously be run during the schedule horizon. Such a constraint holds when the maintenance resources are not sufficient. We solve the problem by two exact methods and meta-heuristic algorithms. As exact procedures we used linear programming and branch and bound methods. As meta-heuristics, we propose a local search approach as well as a genetic algorithm. Computational experiments are performed on randomly generated instances to show that the proposed methods produce appropriate solutions for the problem. The computational results show that the deviation of the meta-heuristics solutions to the optimal one is very small, which confirms the effectiveness of meta-heuristics as new approaches for solving hard scheduling problems.     

A note on the paper “Minimizing total tardiness on parallel machines with preemptions” by Kravchenko and Werner (2012)

In this note, we point out two major errors in the paper “Minimizing total tardiness on parallel machines with preemptions” by Kravchenko and Werner (2012). More precisely, they claimed to have proved that both problems P|pmtn|∑T _j and P|r _j ,p _j =p,pmtn|∑T _j are $\mathcal{NP}$ -Hard. We give a counter-example to their proofs, letting the complexity of these two problems open.     

A tabu search heuristic for a sequence-dependent and time-dependent scheduling problem on a single machine

This paper introduces a tabu search heuristic for a production scheduling problem with sequence-dependent and time-dependent setup times on a single machine. The problem consists in scheduling a set of dependent jobs, where the transition between two jobs comprises an unrestricted setup that can be performed at any time, and a restricted setup that must be performed outside of a given time interval which repeats daily in the same position. The setup time between two jobs is thus a function of the completion time of the first job. The tabu search heuristic relies on shift and swap moves, and a surrogate objective function is used to speed-up the neighborhood evaluation. Computational experiments show that the proposed heuristic consistently finds better solutions in less computation time than a recent branch-and-cut algorithm. Furthermore, on instances where the branch-and-cut algorithm cannot find the optimal solution, the heuristic always identifies a better solution.     

Earliness–tardiness minimization on scheduling a batch processing machine with non-identical job sizes

This paper considers the scheduling problem of minimizing earliness–tardiness (E/T) on a single batch processing machine with a common due date. The problem is extended to the environment of non-identical job sizes. First, a mathematical model is formulated, which is tested effectively under IBM ILOG CPLEX using the constraint programming solver. Then several optimal properties are given to schedule batches effectively, and by introducing the concept of ARB (Attribute Ratio of Batch), it is proven that the ARB of each batch should be made as small as possible in order to minimize the objective, designed as the heuristic information for assigning jobs into batches. Based on these properties, a heuristic algorithm MARB (Minimum Attribute Ratio of Batch) for batch forming is proposed, and a hybrid genetic algorithm is developed for the problem under study by combining GA (genetic algorithm) with MARB. Experimental results demonstrate that the proposed algorithm outperforms other algorithms in the literature, both for small and large problem instances.     

Minimizing the number of late jobs in a stochastic setting using a chance constraint

We consider the single-machine scheduling problem of minimizing the number of late jobs. We omit here one of the standard assumptions in scheduling theory, which is that the processing times are deterministic. In this scheduling environment, the completion times will be stochastic variables as well. Instead of looking at the expected number of on time jobs, we present a new model to deal with the stochastic completion times, which is based on using a chance constraint to define whether a job is on time or late: a job is on time if the probability that it is completed by the deterministic due date is at least equal to a certain given minimum success probability. We have studied this problem for four classes of stochastic processing times. The jobs in the first three classes have processing times that follow: (i) A gamma distribution with shape parameter p _j and scale parameter β, where β is common to all jobs; (ii) A negative binomial distribution with parameters p _j and r, where r is the same for each job; (iii) A normal distribution with parameters p _j and σ _j ². The jobs in the fourth class have equally disturbed processing times, that is, the processing times consist of a deterministic part and a random component that is independently, identically distributed for each job. We show that the first two cases have a common characteristic that makes it possible to solve these problems in O(nlog n) time through the algorithm by Moore and Hodgson. To analyze the third and fourth problem we need the additional assumption that the due dates and the minimum success probabilities are agreeable. We show that under this assumption the third problem is -hard in the ordinary sense, whereas the fourth problem is solvable by Moore and Hodgson’s algorithm. We further indicate how the problem of maximizing the expected number of on time jobs (with respect to the standard definition) can be tackled if we add the constraint that the on time jobs are sequenced in a given order and when we require that the probability that a job is on time amounts to at least some given lower bound. Supported by EC Contract IST-1999-14186 (Project alcom-FT).     

Single-machine scheduling with no idle time and release dates to?minimize a regular criterion

We address the one-machine scheduling problem with release dates, in which the machine is subject to the non-idling constraint, i.e. no intermediate idle time is permitted between the jobs processed by the machine. The objective is to minimize a regular objective function. We describe a constraint programming approach for solving this type of problem exactly. Some necessary and/or sufficient conditions for obtaining non-idling semi-active, active and optimal schedules are described. We propose some propagation rules based on these properties. As an application, we apply the proposed method to the total (weighted) completion time problem, and we provide some experimental results to illustrate its effectiveness.     

A polynomial-time algorithm for a flow-shop batching problem with equal-length operations

A flow-shop batching problem with consistent batches is considered in which the processing times of all jobs on each machine are equal to p and all batch set-up times are equal to s. In such a problem, one has to partition the set of jobs into batches and to schedule the batches on each machine. The processing time of a batch B _i is the sum of processing times of operations in B _i and the earliest start of B _i on a machine is the finishing time of B _i on the previous machine plus the set-up time s. Cheng et al. (Naval Research Logistics 47:128–144, 2000) provided an O(n) pseudopolynomial-time algorithm for solving the special case of the problem with two machines. Mosheiov and Oron (European Journal of Operational Research 161:285–291, 2005) developed an algorithm of the same time complexity for the general case with more than two machines. Ng and Kovalyov (Journal of Scheduling 10:353–364, 2007) improved the pseudopolynomial complexity to \(O(\sqrt{n})\). In this paper, we provide a polynomial-time algorithm of time complexity O(log?³ n).     

Online Genetic Improvement on the java virtual machine with ECSELR

Online Genetic Improvement embeds the ability to evolve and adapt inside a target software system enabling it to improve at runtime without any external dependencies or human intervention. We recently developed a general purpose tool enabling Online Genetic Improvement in software systems running on the java virtual machine. This tool, dubbed ECSELR, is embedded inside extant software systems at runtime, enabling such systems to self-improve and adapt autonomously online. We present this tool, describing its architecture and focusing on its design choices and possible uses.     

A note on “minimizing makespan in three machine flow shop with deteriorating jobs”

This paper is a note on “minimizing makespan in three machine flow shop with deteriorating jobs” [J.-B. Wang, M.-Z. Wang, minimizing makespan in three machine flow shop with deteriorating jobs, Computers & Operation Research 40 (2013) 547–557]. Wang and Wang presented a branch-and-bound algorithm with several dominance properties and a lower bound; however, we think that the dominance properties may not be true as they are neither necessary nor sufficient. We first show by means of a counter-example that the published dominance properties are incorrect, and then present a necessary and sufficient condition for them to be true. Moreover, a simplifying remark is provided for the above dominance properties.