Project management is an important body of knowledge and practices that comprises the planning, organisation and control of resources to achieve one or more pre-determined objectives. In this paper, we introduce ProjectManagement, a new R package that provides the necessary tools to manage projects in a broad sense, and illustrate its use by examples.
Project management is an important body of knowledge and practices that comprises the planning, organisation and control of resources to achieve one or more pre-determined objectives. The most commonly used methods for project planning are PERT (Program Evaluation and Review Technique model) and CPM (Critical Path Method). PERT/CPM analyses the tasks involved in completing a project, especially the time needed to complete each task, and computes the minimum time needed to complete the total project. Through the data obtained in the analysis of the project, PERT/CPM identifies the critical activities, which are those for which any disturbance in its duration modifies the minimum time of execution of the project. Also, it obtains the times that can be assigned to non-critical activities, called slacks, in addition to their fixed durations, to give them flexibility. Project management often deals with the problem of redistribution of resources. Sometimes it is convenient to reduce the time of an activity by increasing the assigned costs. Other times, when the availability of resources is limited in a period of time, it may be necessary to level the use of those resources. These situations require a re-planning of the project.
Even with good project management, once the project has been carried out and the actual durations of the activities are known, there can be a delay in the completion time of the project. When the delay generates an additional cost, ways are needed to distribute the cost of the delay among the different tasks involved. To solve this problem we can use cooperative game theory and rules based on bankruptcy problems.
The essential elements related to project management can be found in Castro et al. (2007) or in Hillier and Lieberman (2001). Project management techniques have been widely used in all fields of engineering. Hall (2012) reviews the impact that such techniques have in various fields and their broad business opportunities. Their fields of application vary from classical construction and engineering to information technology and software development, including modern agile methods. Schmitz et al. (2019) also argue the usefulness of traditional project management techniques in the context of agile methodology. Evdokimov et al. (2018) include a case study that shows the current relevance of project management techniques in software development. Özdamar and Ulusoy (1995) present a survey of the problem of resource constraints. To distribute the delay cost of the project among the activities, Brânzei et al. (2002) provide two rules using, respectively, a game theoretical and a bankruptcy-based approach, and Bergantiños et al. (2018) introduce and analyse a consistent rule based on the Shapley value.
A well-known project management software is Microsoft Project. This tool is designed to create and control a project, through the allocation of resources to tasks, the management of budget and workloads, as well as monitoring developments. Microsoft Project is not open source and its license is fee-based. Other project management applications have been created as free software, such as OpenProj, PpcProject or ProMes (Gregoriou et al. 2013). In Salas-Morera et al. (2013) we can see a useful comparison of these applications.
The aforementioned tools are written in Java or Phyton. To the best of our knowledge, there are only two packages in R available for project management. PlotPrjNetworks (Muñoz 2015) and plan (Kelley 2018) are packages that offer the user the creation of a Gantt diagram for the visualization of the project structure. In our opinion, a tool was missing to manage a project from its development to its control. We believe that such a tool would be useful for the user community because it could be integrated with other tools developed in R, it could be easily modified to suit the specific needs of each user, and it could be wrapped into a graphical interface.
In this paper, we introduce
ProjectManagement
The paper is organized as follows. First, we recall the basic definitions of project management and present different ways to distribute the delay cost when durations are assumed to be known and when they are random variables. Then, we provide a description of ProjectManagement. Finally, we illustrate the use of the package by way of examples.
In this section we discuss the basic concepts of deterministic and stochastic projects with a special focus on allocating the delay cost among the project activities. The aim of this section is to provide a brief (and quick) survey of the methodologies implemented in the R package ProjectManagement that we introduce later, as well as to indicate the main bibliographical sources in which interested readers can deepen their knowledge of each of these methodologies.
Let
A deterministic project
In a deterministic project
Given a node
It is easy to see that
We define the slack
If the slack for an activity is equal to
The independent slack of an activity is the maximum time that the
activity duration can be increased without affecting the times of others
activities
Given the slack of an activity, we define the latest start time as the
latest time that an activity can start without delaying the project
Besides the schedule of a project, we can manage the resources allocated
to the activities. The minimal cost expediting or MCE method
(Kelley 1961) considers that the duration of some activities can be
reduced by increasing the resources allocated to them and thus the
implementation costs. An MCE problem is a tuple
Two other interesting problems that arise from the management of
resources are the levelling and the allocation (Hegazy 1999). These
problems take into account that in order for activities to be carried
out in the estimated time, a certain level of resources must be used.
The problem of levelling of resources is to find a schedule that allows
to execute the project in its minimum duration time
Once the project is completed, we can know the actual (observed)
duration of the activities and, therefore, whether there has been a
delay in the project, that is, whether the actual duration of the
project has been different than expected. We define a deterministic
project with delays as a tuple
We denote by
In a deterministic project with delays
The Proportional rule for deterministic scheduling problems with delays
The Truncated Proportional rule for deterministic scheduling problems
with delays
In Bergantiños et al. (2018), the problem of allocating the delay costs is addressed
in the context of cooperative game theory using a Shapley rule. As we
illustrate later in an example, the Shapley rule allocates the delay
costs in a more sensible way than the proportional rules, at least in
some cases. It is much more costly to compute it but, in general, the
extra effort is worthwhile. A TU-game is a pair
Since its introduction by Shapley (1953), the Shapley value has proved to be one of the most important rules in cooperative game theory and to have applications in many practical problems (see, for instance, Moretti and Patrone (2008)).
Bergantiños et al. (2018) define the Shapley rule for deterministic projects with
delays
The calculation of the Shapley value has, in general, an exponential complexity. In this context, its exact calculation is impossible in practice, even for a moderate number of activities. As an alternative to exact calculation, Castro et al. (2009) proposed an estimate of the Shapley value in polynomial time using a sampling process. In practical terms, this estimate is a reasonable solution.
Next, we introduce a generalization of the model and the rules described
above. It follows the results in Gonçalves-Dosantos et al. (2020b). If instead of
A stochastic project with delays is a tuple
The Stochastic Proportional rule for deterministic scheduling problems
with delays
The Stochastic Truncated Proportional rule for deterministic scheduling
problems with delays
Also, we can extend the Shapley rule to the stochastic context. Let us
see two extensions of the rule. The Shapley rule for stochastic projects
with delays
As an alternative to the previous rule, the Shapley rule in two steps
for stochastic projects with delays
In general, the calculation of
ProjectManagement is a new R package that allows the user to address different tasks in project management. The user can obtain the duration of a project and a schedule of activities, and can plot this schedule for a better understanding of the problem. When the actual durations of each activity are observed, the package proposes several allocations of the delay cost, if there was any, among the activities. In the stochastic context, the package estimates the average duration of the project and plots the density functions of the following random variables: duration of the project, and early and last times of the activities. As in the deterministic case, it can make an allocation of the delay cost, if any.
The following dependencies of the package must be taken into account: triangle (Carnell 2019), plotly (Sievert 2020), igraph (Csardi and Nepusz 2006), kappalab (Grabisch et al. 2015), GameTheory (Cano-Berlanga 2017) and lpSolveAPI (lp_solve et al. 2020). The first one is used for calculations with triangular distributions, the second one to plot interactive graphics, the third one to plot graphs, the next two are related to game-theoretic concepts and the last one to solve linear programming problems.
The functions incorporated in the package can be seen in Table
1. Note that for projects of more than delay.pert
and delay.stochastic.pert
will
approximate the Shapley value through a sampling process. Table
2 describes the complete list of parameters used by
the functions. Tables 3, 4, 5, and 6
state which arguments use each function.
Function | Description |
dag.plot |
Plots the AON graph of a project. |
delay.pert |
Calculates the delay cost of a deterministic project and allocates it among the activities. |
delay.stochastic.pert |
Calculates the delay cost of a stochastic project and allocates it among the activities. |
early.time |
Calculates the earliest start time for each activity. |
last.time |
Calculates the latest completion time for each activity. |
levelling.resources |
Calculates the schedule of the project so that the consumption of resources is as uniform as possible. |
mce |
Calculates the costs per activity needed to accelerate the project. |
organize |
Relabels the activities of a project (if |
rebuild |
Builds a type |
resource.allocation |
Calculates the project schedule so that resource consumption does not exceed the maximum available per time period. |
schedule.pert |
Calculates the duration of a project and the schedule of each activity, and plots the schedule and the AON graph. |
stochastic.pert |
Calculates the average duration of a stochastic project, the criticality index of each activity, and the density functions of the duration of the project, early times and last times. |
ProjectManagement allows the user to plot the activities on nodes
graph of the Project (AON). Originally, in the PERT methodology,
projects are represented by activities on arcs graphs (AOA). This is the
representation we have used in this paper up to now. Both AON and AOA
representations are widely used in the literature, each having some
advantages over the other in particular circumstances. For automatically
drawing the network of a project, the AON representation is more
appropriate because it is computationally much more efficient. This is
why we have incorporated it into the dag.plot
function. This
representation will be useful mainly for the user to check that he has
entered the precedence matrices correctly, which are the ones that
really characterize the project.
ProjectManagement also allows the user to choose from four different types of immediate precedences between the activities.
The relationships between the types of dependencies are as follows: Type
The user can indicate types "prec1and2"
parameter
(see Table 2) using the values "prec3and4"
using
Parameter | Description |
duration |
Vector with the expected duration for each activity. |
prec1and2 |
Matrix indicating precedence type matrix(0) ). |
prec3and4 |
Matrix indicating precedence type matrix(0) ). |
observed.duration |
Vector with the actual duration for each activity. |
delta |
Value indicating the maximum time that the project can take without delay (see equation (1)). This value is only used with the default cost function. |
distribution |
Vector with the distribution function of the duration for each activity. It can be normal, triangular, exponential, uniform, beta, t-Student, F distribution, chi-squared, gamma, Weibull, binomial, Poisson, geometric, hypergeometric, and empirical. |
values |
Matrix with the arguments of the distribution function of the duration for each activity. By rows the activities, and by columns the arguments. |
percentile |
Value used to calculate the maximum time allowed for the |
duration of the project without delay. This value is only used if no delta value is assigned. |
|
compilations |
Number of simulations that the function uses for estimation (Default=1000 ). |
cost.funtion |
Delay cost function. If this value is not added, the package uses equation (1). |
early.times |
Vector with the early time for each activity. |
PRINT |
Logical parameter indicating if the schedule and the AON graph are depicted (Default=TRUE ). |
plot.activities.times |
Vector of selected activities from which it is shown the distribution of their early and last times (Default=NULL ). |
minimum.durations |
Vector with the minimum duration an activity can take even if the resources are increased. |
critical.activities |
Vector with the critical activities to represent them in a different color in the AON graph (Default=NULL ). |
duration.project |
Value indicating the minimum time sought in the project (Default=NULL ). |
activities.costs |
Vector indicating the cost of accelerating a unit of time the duration for each activity. |
resources |
Vector indicating the necessary resources for each activity per period of time. |
int |
Value indicating the duration of each period of time (Default=1). |
max.resources |
Value indicating the maximum number of resources that can be used in each period of time. |
Function | duration |
prec1and2 |
prec3and4 |
observed.duration |
delta |
---|---|---|---|---|---|
dag.plot |
|||||
delay.pert |
|||||
delay.stochastic.pert |
|||||
early.time |
|||||
last.time |
|||||
levelling.resources |
|||||
mce |
|||||
organize |
|||||
resource.allocation |
|||||
schedule.pert |
|||||
stochastic.pert |
Function | distribution |
values |
percentile |
cost.function |
compilations |
---|---|---|---|---|---|
dag.plot |
|||||
delay.pert |
|||||
delay.stochastic.pert |
|||||
early.time |
|||||
last.time |
|||||
levelling.resources |
|||||
mce |
|||||
organize |
|||||
resource.allocation |
|||||
schedule.pert |
|||||
stochastic.pert |
Function | early.times |
PRINT |
plot.activities.times |
minimum.durations |
critical.activities |
---|---|---|---|---|---|
dag.plot |
|||||
delay.pert |
|||||
delay.stochastic.pert |
|||||
early.time |
|||||
last.time |
|||||
levelling.resources |
|||||
mce |
|||||
organize |
|||||
resource.allocation |
|||||
schedule.pert |
|||||
stochastic.pert |
Function | duration.project |
activities.costs |
resources |
int |
max.resources |
---|---|---|---|---|---|
dag.plot |
|||||
delay.pert |
|||||
delay.stochastic.pert |
|||||
early.time |
|||||
last.time |
|||||
levelling.resources |
|||||
mce |
|||||
organize |
|||||
resource.allocation |
|||||
schedule.pert |
|||||
stochastic.pert |
ProjectManagement is available for download from CRAN. To use the package you will need to load it at the beginning of the session, usually by typing
> library("ProjectManagement")
Next we analyse the following deterministic project with
1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | |
---|---|---|---|---|---|---|---|---|---|---|
Immediate precedence type 1 | - | - | - | 2 | 3 | 3 | 1, 4 | 2 | 5, 8 | 6 |
Immediate precedence type 2 | - | - | - | - | 4 | - | - | - | - | - |
Immediate precedence type 3 | - | - | - | - | - | 8 | - | - | - | - |
Immediate precedence type 4 | - | - | - | - | - | - | 9 | - | - | - |
Durations | 2 | 1.5 | 1 | 4.5 | 2 | 2.5 | 3 | 4 | 2 | 5 |
We start by introducing the data set characterizing the project. We use
the function dag.plot
for depicting its AON graph. Figure
2 shows it; the green blocks contain the activities and
the precedences are represented by arrows. The blocks
> prec1and2<-matrix(0,nrow=10,ncol=10)
> prec1and2[1,7]<-1; prec1and2[2,4]<-1; prec1and2[2,8]<-1; prec1and2[3,5]<-1;
> prec1and2[3,6]<-1; prec1and2[4,7]<-1; prec1and2[5,9]<-1; prec1and2[6,10]<-1;
> prec1and2[8,9]<-1; prec1and2[4,5]<-2
> prec3and4<-matrix(0,nrow=10,ncol=10)
> prec3and4[8,6]<-3; prec3and4[9,7]<-4
> dag.plot(prec1and2,prec3and4)
Using schedule.pert
, we obtain the project schedule, i.e. the minimum
time needed to complete all activities and the early and last times.
Also, we can plot the schedule. Let us see it:
> duration<-c(2,1.5,1,1.5,2,2.5,3,4,2,5)
> schedule.pert(duration,prec1and2,prec3and4)
`Total duration of the project`
[1] 10.5
[[2]]
Activities |
Duration |
Earliest start time |
Latest start time |
Earliest completion time |
1 |
2.0 |
0.0 |
5.5 |
2.0 |
2 |
1.5 |
0.0 |
0.0 |
1.5 |
3 |
1.0 |
0.0 |
2.0 |
1.0 |
4 |
1.5 |
1.5 |
6.0 |
3.0 |
5 |
2.0 |
1.5 |
6.5 |
3.5 |
6 |
2.5 |
2.0 |
3.0 |
5.5 |
7 |
3.0 |
3.0 |
7.5 |
6.0 |
8 |
4.0 |
1.5 |
1.5 |
5.5 |
9 |
2.0 |
5.5 |
8.5 |
7.5 |
10 |
5.0 |
5.5 |
5.5 |
10.5 |
Activities |
Latest completion time |
Slack |
Free Slack |
Independent Slack |
1 |
7.5 |
5.5 |
1.0 |
0.0 |
2 |
1.5 |
0.0 |
0.0 |
0.0 |
3 |
3.0 |
2.0 |
0.0 |
0.0 |
4 |
7.5 |
4.5 |
0.0 |
0.0 |
5 |
8.5 |
5.0 |
2.0 |
0.0 |
6 |
5.5 |
2.0 |
2.0 |
0.0 |
7 |
10.5 |
4.5 |
4.5 |
0.0 |
8 |
5.5 |
0.0 |
0.0 |
0.0 |
9 |
10.5 |
3.0 |
3.0 |
0.0 |
10 |
10.5 |
0.0 |
0.0 |
0.0 |
[[3]]
In this output we can see the total duration (10.5 units) of the project
as well as other relevant information for each activity. Figure
3 depicts the different times of each activity using a
colour coding. If we click on the points on the graph, a label indicates
which activity and time it belongs to. Also, if we double click on a
section of the legend we can see the data related to it, as in Figure
4 with the last times for each activity (another double
click restarts the graph). In the output, the plot depicted in Figure
3 is saved as an object on
Next, suppose we are interested in shortening the duration of the
project. The mce
function is used for this purpose. Let us use the
function with the following input data: the minimum duration for each
activity even if the resources are increased
> minimum.durations<-c(1,1,0.5,1,1,2,2,3,1,3)
> activities.costs<-c(1,2,1,1,3,2,1,2,3,5)
> mce(duration,minimum.durations,prec1and2,prec3and4,
activities.costs,duration.project=NULL)
necessary negative increase
1: 0.5
Read 1 item
Project duration =
[1] 10.0 9.5 9.0 8.5 8.0 7.5 7.0
Estimated durations = Costs per solution =
2.0 |
2.0 |
2.0 |
2.0 |
2.0 |
2.0 |
2.0 |
1.5 |
1.5 |
1.0 |
1.0 |
1.0 |
1.0 |
1.0 |
1.0 |
1.0 |
1.0 |
1.0 |
1.0 |
1.0 |
1.0 |
1.5 |
1.5 |
1.5 |
1.5 |
1.5 |
1.5 |
1.5 |
2.0 |
2.0 |
2.0 |
2.0 |
2.0 |
2.0 |
2.0 |
2.5 |
2.5 |
2.5 |
2.5 |
2.5 |
2.5 |
2.5 |
3.0 |
3.0 |
3.0 |
3.0 |
3.0 |
3.0 |
3.0 |
3.5 |
3.0 |
3.0 |
3.0 |
3.0 |
3.0 |
3.0 |
2.0 |
2.0 |
2.0 |
2.0 |
2.0 |
2.0 |
2.0 |
5.0 |
5.0 |
5.0 |
4.5 |
4.0 |
3.5 |
3.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
|||
0.0 |
0.0 |
1.0 |
1.0 |
1.0 |
1.0 |
1.0 |
|||
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
|||
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
|||
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
|||
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
|||
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
|||
1.0 |
2.0 |
2.0 |
2.0 |
2.0 |
2.0 |
2.0 |
|||
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
0.0 |
|||
0.0 |
0.0 |
0.0 |
2.5 |
5.0 |
7.5 |
10 |
The parameter duration.project=NULL
means that we do not indicate a
minimum duration of the project, so the function asks us for a decrease
of the duration of the project to obtain all possible solutions. We have
considered it convenient a decrease of
Suppose now that to complete the project each activity needs the amount
of resources
levelling.resources
in such a way
> resources<-c(6,6,6,3,4,2,1,2,3,1)
> levelling.resources(duration,prec1and2,prec3and4,resources,int=0.5)
Earliest start times =
[1] 3.5 0.0 2.0 2.0 6.5 3.0 5.5 1.5 8.5 5.5
Resources by period=
[1] 6 6 6 2 11 11 7 10 10 10 10 2 2 6 6 6 6 4 4 4 4
As we can see, the function returns the new earliest start times of the
activities and the resources consumed in each period with the new
schedule, where time periods start at
To conclude with the analysis of resources, consider that the maximum
amount of resources available in each period is resource.allocation
function in this situation.
> max.resources<-10
> resource.allocation(duration,prec1and2,prec3and4,resources,
max.resources,int=0.5)
Project duration =
[1] 11
Earliest start times =
[1] 6.0 0.0 1.5 2.5 4.0 2.5 8.0 1.5 6.0 5.5
Resources by period =
[1] 6 6 6 8 8 7 7 7 8 8 6 5 10 10 10 10 2 2 2 2 2 1
With the new restriction, the minimum duration of the project becomes
Continuing the example, we now analyse the allocation of delays. The
function delay.pert
shows if there has been a delay in the project
and, in that case, allocates it among the activities. Let us see it
using the delay cost function
and the (observed) actual durations
> observed.duration<-c(2.5,1.5,2,2,2,6,4,6,3,5.5)
> cost.function<-function(x){return(max(x-10.5,0))}
> delay.pert(duration,prec1and2,prec3and4,observed.duration,
delta=NULL,cost.function)
There has been a delay of = 3
1 |
2 |
3 |
4 |
5 |
|
The proportional payment |
0.15000 |
0.00000 |
0.30000 |
0.15000 |
0.00000 |
The truncated proportional payment |
0.15789 |
0.00000 |
0.31579 |
0.15789 |
0.00000 |
Shapley rule |
0.00000 |
0.00000 |
0.33333 |
0.00000 |
0.00000 |
6 |
7 |
8 |
9 |
10 |
|
The proportional payment |
1.05000 |
0.30000 |
0.60000 |
0.30000 |
0.15000 |
The truncated proportional payment |
0.94737 |
0.31579 |
0.63158 |
0.31579 |
0.15789 |
Shapley rule |
1.08333 |
0.00000 |
1.08333 |
0.00000 |
0.50000 |
The output shows that there is a delay in the project of delay.pert
does not calculate the Shapley rule; instead, it asks the
user if he wants to calculate an estimate of its value.
Let us now assume that we are in a stochastic context, with additional
information on planned durations being random variables. Using the
function stochastic.pert
with the following random variables to
describe the duration of the activities
plot.activities.times=c(7,8)
we indicate the activities for which we
want to estimate the densities of their earliest and latest start and
completion times; in this example we have requested only such densities
for activities
> values<-matrix(c(1,3,2,2/3,0,0,1/2,5/4,5/4,1/4,5/2,7/4,1,3,2,1,5,3/2,
1,7,1,3,5,4,1/2,3,5/2,1,8,6),nrow=10,ncol=3,byrow=T)
> distribution<-c("TRIANGLE","EXPONENTIAL",rep("TRIANGLE",8))
> stochastic.pert(prec1and2,prec3and4,distribution,values,percentile=0.95,
plot.activities.times=c(7,8))
Average duration of the project = 10.64242
Percentile duration of the project = 14.21999
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
|
Criticality index by activity |
0.6 |
88 |
11.4 |
2 |
0.1 |
11.3 |
2.6 |
86 |
4 |
93.4 |
In the output we can see the average duration of the project and the
percentile duration of the project. The percentile duration of the
project shows the value of such that the probability that the duration
of the project is smaller than percentile=0.95
. In addition, we obtain the criticality index by
activity, that is, the proportion of times that an activity is critical.
An activity is critical when it has zero slack. Figure 7
plots estimations of the density function of the project duration, the
earliest start time and the latest completion time of activities
We proceed now to the allocation of the delay cost in the stochastic
model using the function delay.stochastic.pert
. To be able to compare
the results, we will use the same delay cost function as in the
deterministic case. As expected, there are noticeable differences in the
allocations between the two models, as the stochastic model makes use of
more complex information.
> delay.stochastic.pert(prec1and2,prec3and4,distribution,values,
observed.duration,percentile=NULL,delta=NULL,cost.function)
Total delay of the stochastic project = 3
1 |
2 |
3 |
4 |
5 |
|
Stochastic Shapley rule |
0.07238 |
-0.07569 |
0.56946 |
0.07440 |
0.07238 |
Stochastic Shapley rule 2 |
0.00693 |
0.03470 |
0.51967 |
0.01363 |
0.00731 |
The proportional payment |
0.15000 |
0.00000 |
0.30000 |
0.15000 |
0.00000 |
The truncated proportional payment |
0.15789 |
0.00000 |
0.31579 |
0.15789 |
0.00000 |
6 |
7 |
8 |
9 |
10 |
|
Stochastic Shapley rule |
1.66514 |
0.08271 |
0.11897 |
0.07256 |
0.34769 |
Stochastic Shapley rule 2 |
1.62101 |
0.02287 |
0.25006 |
0.01046 |
0.51336 |
The proportional payment |
1.05000 |
0.30000 |
0.60000 |
0.30000 |
0.15000 |
The truncated proportional payment |
0.94737 |
0.31579 |
0.63158 |
0.31579 |
0.15789 |
Finally, to illustrate the runtime of previously used functions, Table
8 shows the time (in seconds) needed to compute several
problems. We have selected a variety of projects with
Activities | 2 | 4 | 6 | 8 | 10 |
---|---|---|---|---|---|
delay.pert |
|||||
delay.stochastic.pert |
|||||
early.time |
|||||
last.time |
|||||
levelling.resources |
|||||
mce |
|||||
organize |
|||||
resources.allocation |
|||||
schedule.pert |
|||||
stochastic.pert |
This work has been supported by the MINECO grant MTM2017-87197-C3-1-P and by the Xunta de Galicia through the ERDF (Grupos de Referencia Competitiva ED431C-2016-015 and Centro Singular de Investigación de Galicia ED431G/01). The comments of an anonymous reviewer have helped us to improve this paper significantly.
PlotPrjNetworks, plan, ProjectManagement, triangle, plotly, igraph, kappalab, GameTheory, lpSolveAPI
Distributions, GraphicalModels, Optimization, WebTechnologies
This article is converted from a Legacy LaTeX article using the texor package. The pdf version is the official version. To report a problem with the html, refer to CONTRIBUTE on the R Journal homepage.
Text and figures are licensed under Creative Commons Attribution CC BY 4.0. The figures that have been reused from other sources don't fall under this license and can be recognized by a note in their caption: "Figure from ...".
For attribution, please cite this work as
Gonçalves-Dosantos, et al., "ProjectManagement: an R Package for Managing Projects", The R Journal, 2020
BibTeX citation
@article{RJ-2020-009, author = {Gonçalves-Dosantos, Juan Carlos and García-Jurado, Ignacio and Costa, Julian}, title = {ProjectManagement: an R Package for Managing Projects}, journal = {The R Journal}, year = {2020}, note = {https://rjournal.github.io/}, volume = {12}, issue = {1}, issn = {2073-4859}, pages = {419-436} }