Quadratic programming
collapse all in page
Syntax
x = quadprog(H,f)
x = quadprog(H,f,A,b)
x = quadprog(H,f,A,b,Aeq,beq)
x = quadprog(H,f,A,b,Aeq,beq,lb,ub)
x = quadprog(H,f,A,b,Aeq,beq,lb,ub,x0)
x = quadprog(H,f,A,b,Aeq,beq,lb,ub,x0,options)
x = quadprog(problem)
[x,fval]= quadprog(___)
[x,fval,exitflag,output]= quadprog(___)
[x,fval,exitflag,output,lambda]= quadprog(___)
[wsout,fval,exitflag,output,lambda]= quadprog(H,f,A,b,Aeq,beq,lb,ub,ws)
Description
Solver for quadratic objective functions with linear constraints.
quadprog finds a minimum for a problem specified by
H, A, and Aeq are matrices, and f, b, beq, lb, ub, and x are vectors.
You can pass f, lb, and ub as vectors or matrices; see Matrix Arguments.
Note
quadprog
applies only to the solver-based approach. For a discussion of the two optimization approaches, see First Choose Problem-Based or Solver-Based Approach.
x = quadprog(H,f)
returns a vector x
that minimizes 1/2*x'*H*x+f'*x
. The input H
must be positive definite for the problem to have a finite minimum. If H
is positive definite, then the solution x = H\(-f)
.
example
x = quadprog(H,f,A,b)
minimizes 1/2*x'*H*x+f'*x
subject to the restrictions A*x
≤b
. The input A
is a matrix of doubles, and b
is a vector of doubles.
example
x = quadprog(H,f,A,b,Aeq,beq)
solves the preceding problem subject to the additional restrictions Aeq*x=beq
. Aeq
is a matrix of doubles, and beq
is a vector of doubles. If no inequalities exist, set A=[]
and b=[]
.
example
x = quadprog(H,f,A,b,Aeq,beq,lb,ub)
solves the preceding problem subject to the additional restrictions lb
≤x
≤ub
. The inputs lb
and ub
are vectors of doubles, and the restrictions hold for each x
component. If no equalities exist, set Aeq=[]
and beq=[]
.
Note
If the specified input bounds for a problem are inconsistent, the output x
is x0
and the output fval
is []
.
quadprog
resets components of x0
that violate the bounds lb
≤x
≤ub
to the interior of the box defined by the bounds. quadprog
does not change components that respect the bounds.
x = quadprog(H,f,A,b,Aeq,beq,lb,ub,x0)
solves the preceding problem starting from the vector x0
. If no bounds exist, set lb=[]
and ub=[]
. Some quadprog
algorithms ignore x0
; see x0.
Note
x0
is a required argument for the 'active-set'
algorithm.
example
x = quadprog(H,f,A,b,Aeq,beq,lb,ub,x0,options)
solves the preceding problem using the optimization options specified in options
. Use optimoptions to create options
. If you do not want to give an initial point, set x0=[]
.
example
x = quadprog(problem)
returns the minimum for problem
, a structure described in problem. Create the problem
structure using dot notation or the struct function. Alternatively, create a problem
structure from an OptimizationProblem
object by using prob2struct.
example
[x,fval]= quadprog(___)
, for any input variables, also returns fval
, the value of the objective function at x
:
fval = 0.5*x'*H*x + f'*x
example
[x,fval,exitflag,output]= quadprog(___)
also returns exitflag
, an integer that describes the exit condition of quadprog
, and output
, a structure that contains information about the optimization.
example
[x,fval,exitflag,output,lambda]= quadprog(___)
also returns lambda
, a structure whose fields contain the Lagrange multipliers at the solution x
.
example
[wsout,fval,exitflag,output,lambda]= quadprog(H,f,A,b,Aeq,beq,lb,ub,ws)
starts quadprog
from the data in the warm start object ws
, using the options in ws
. The returned argument wsout
contains the solution point in wsout.X
. By using wsout
as the initial warm start object in a subsequent solver call, quadprog
can work faster.
Examples
collapse all
Quadratic Program with Linear Constraints
Open Live Script
Find the minimum of
subject to the constraints
In quadprog
syntax, this problem is to minimize
,
where
subject to the linear constraints.
To solve this problem, first enter the coefficient matrices.
H = [1 -1; -1 2]; f = [-2; -6];A = [1 1; -1 2; 2 1];b = [2; 2; 3];
Call quadprog
.
[x,fval,exitflag,output,lambda] = ... quadprog(H,f,A,b);
Minimum found that satisfies the constraints.Optimization completed because the objective function is non-decreasing in feasible directions, to within the value of the optimality tolerance,and constraints are satisfied to within the value of the constraint tolerance.
Examine the final point, function value, and exit flag.
x,fval,exitflag
x = 2×1 0.6667 1.3333
fval = -8.2222
exitflag = 1
An exit flag of 1
means the result is a local minimum. Because H
is a positive definite matrix, this problem is convex, so the minimum is a global minimum.
Confirm that H
is positive definite by checking its eigenvalues.
eig(H)
ans = 2×1 0.3820 2.6180
Quadratic Program with Linear Equality Constraint
Open Live Script
Find the minimum of
subject to the constraint
In quadprog
syntax, this problem is to minimize
,
where
subject to the linear constraint.
To solve this problem, first enter the coefficient matrices.
H = [1 -1; -1 2]; f = [-2; -6];Aeq = [1 1];beq = 0;
Call quadprog
, entering []
for the inputs A
and b
.
[x,fval,exitflag,output,lambda] = ... quadprog(H,f,[],[],Aeq,beq);
Minimum found that satisfies the constraints.Optimization completed because the objective function is non-decreasing in feasible directions, to within the value of the optimality tolerance,and constraints are satisfied to within the value of the constraint tolerance.
Examine the final point, function value, and exit flag.
x,fval,exitflag
x = 2×1 -0.8000 0.8000
fval = -1.6000
exitflag = 1
An exit flag of 1
means the result is a local minimum. Because H
is a positive definite matrix, this problem is convex, so the minimum is a global minimum.
Confirm that H
is positive definite by checking its eigenvalues.
eig(H)
ans = 2×1 0.3820 2.6180
Quadratic Minimization with Linear Constraints and Bounds
Open Live Script
Find the x that minimizes the quadratic expression
where
, ,
subject to the constraints
, .
To solve this problem, first enter the coefficients.
H = [1,-1,1 -1,2,-2 1,-2,4];f = [2;-3;1];lb = zeros(3,1);ub = ones(size(lb));Aeq = ones(1,3);beq = 1/2;
Call quadprog
, entering []
for the inputs A
and b
.
x = quadprog(H,f,[],[],Aeq,beq,lb,ub)
Minimum found that satisfies the constraints.Optimization completed because the objective function is non-decreasing in feasible directions, to within the value of the optimality tolerance,and constraints are satisfied to within the value of the constraint tolerance.
x = 3×1 0.0000 0.5000 0.0000
Quadratic Minimization with Nondefault Options
Open Live Script
Set options to monitor the progress of quadprog
.
options = optimoptions('quadprog','Display','iter');
Define a problem with a quadratic objective and linear inequality constraints.
H = [1 -1; -1 2]; f = [-2; -6];A = [1 1; -1 2; 2 1];b = [2; 2; 3];
To help write the quadprog
function call, set the unnecessary inputs to []
.
Aeq = [];beq = [];lb = [];ub = [];x0 = [];
Call quadprog
to solve the problem.
x = quadprog(H,f,A,b,Aeq,beq,lb,ub,x0,options)
Iter Fval Primal Infeas Dual Infeas Complementarity 0 -8.884885e+00 3.214286e+00 1.071429e-01 1.000000e+00 1 -8.331868e+00 1.321041e-01 4.403472e-03 1.910489e-01 2 -8.212804e+00 1.676295e-03 5.587652e-05 1.009601e-02 3 -8.222204e+00 8.381476e-07 2.793826e-08 1.809485e-05 4 -8.222222e+00 3.064216e-14 1.352696e-12 7.525735e-13 Minimum found that satisfies the constraints.Optimization completed because the objective function is non-decreasing in feasible directions, to within the value of the optimality tolerance,and constraints are satisfied to within the value of the constraint tolerance.
x = 2×1 0.6667 1.3333
Quadratic Problem from prob2struct
Open Live Script
Create a problem
structure using a Problem-Based Optimization Workflow. Create an optimization problem equivalent to Quadratic Program with Linear Constraints.
x = optimvar('x',2);objec = x(1)^2/2 + x(2)^2 - x(1)*x(2) - 2*x(1) - 6*x(2);prob = optimproblem('Objective',objec);prob.Constraints.cons1 = sum(x) <= 2;prob.Constraints.cons2 = -x(1) + 2*x(2) <= 2;prob.Constraints.cons3 = 2*x(1) + x(2) <= 3;
Convert prob
to a problem
structure.
problem = prob2struct(prob);
Solve the problem using quadprog
.
[x,fval] = quadprog(problem)
Warning: Your Hessian is not symmetric. Resetting H=(H+H')/2.
Minimum found that satisfies the constraints.Optimization completed because the objective function is non-decreasing in feasible directions, to within the value of the optimality tolerance,and constraints are satisfied to within the value of the constraint tolerance.
x = 2×1 0.6667 1.3333
fval = -8.2222
Return quadprog
Objective Function Value
Open Live Script
Solve a quadratic program and return both the solution and the objective function value.
H = [1,-1,1 -1,2,-2 1,-2,4];f = [-7;-12;-15];A = [1,1,1];b = 3;[x,fval] = quadprog(H,f,A,b)
Minimum found that satisfies the constraints.Optimization completed because the objective function is non-decreasing in feasible directions, to within the value of the optimality tolerance,and constraints are satisfied to within the value of the constraint tolerance.
x = 3×1 -3.5714 2.9286 3.6429
fval = -47.1786
Check that the returned objective function value matches the value computed from the quadprog
objective function definition.
fval2 = 1/2*x'*H*x + f'*x
fval2 = -47.1786
Examine quadprog
Optimization Process
Open Live Script
To see the optimization process for quadprog
, set options to show an iterative display and return four outputs. The problem is to minimize
subject to
,
where
, .
Enter the problem coefficients.
H = [2 1 -1 1 3 1/2 -1 1/2 5];f = [4;-7;12];lb = zeros(3,1);ub = ones(3,1);
Set the options to display iterative progress of the solver.
options = optimoptions('quadprog','Display','iter');
Call quadprog
with four outputs.
[x fval,exitflag,output] = quadprog(H,f,[],[],[],[],lb,ub,[],options)
Iter Fval Primal Infeas Dual Infeas Complementarity 0 2.691769e+01 1.582123e+00 1.712849e+01 1.680447e+00 1 -3.889430e+00 0.000000e+00 8.564246e-03 9.971731e-01 2 -5.451769e+00 0.000000e+00 4.282123e-06 2.710131e-02 3 -5.499997e+00 0.000000e+00 1.221903e-10 6.939689e-07 4 -5.500000e+00 0.000000e+00 5.842173e-14 3.469847e-10 Minimum found that satisfies the constraints.Optimization completed because the objective function is non-decreasing in feasible directions, to within the value of the optimality tolerance,and constraints are satisfied to within the value of the constraint tolerance.
x = 3×1 0.0000 1.0000 0.0000
fval = -5.5000
exitflag = 1
output = struct with fields: message: 'Minimum found that satisfies the constraints....' algorithm: 'interior-point-convex' firstorderopt: 1.5921e-09 constrviolation: 0 iterations: 4 linearsolver: 'dense' cgiterations: []
Return quadprog
Lagrange Multipliers
Open Live Script
Solve a quadratic programming problem and return the Lagrange multipliers.
H = [1,-1,1 -1,2,-2 1,-2,4];f = [-7;-12;-15];A = [1,1,1];b = 3;lb = zeros(3,1);[x,fval,exitflag,output,lambda] = quadprog(H,f,A,b,[],[],lb);
Minimum found that satisfies the constraints.Optimization completed because the objective function is non-decreasing in feasible directions, to within the value of the optimality tolerance,and constraints are satisfied to within the value of the constraint tolerance.
Examine the Lagrange multiplier structure lambda
.
disp(lambda)
ineqlin: 12.0000 eqlin: [0x1 double] lower: [3x1 double] upper: [3x1 double]
The linear inequality constraint has an associated Lagrange multiplier of 12
.
Display the multipliers associated with the lower bound.
disp(lambda.lower)
5.0000 0.0000 0.0000
Only the first component of lambda.lower
has a nonzero multiplier. This generally means that only the first component of x
is at the lower bound of zero. Confirm by displaying the components of x
.
disp(x)
0.0000 1.5000 1.5000
Return Warm Start Object
Open Live Script
To speed subsequent quadprog
calls, create a warm start object.
options = optimoptions('quadprog','Algorithm','active-set');x0 = [1 2 3];ws = optimwarmstart(x0,options);
Solve a quadratic program using ws
.
H = [1,-1,1 -1,2,-2 1,-2,4];f = [-7;-12;-15];A = [1,1,1];b = 3;lb = zeros(3,1);tic[ws,fval,exitflag,output,lambda] = quadprog(H,f,A,b,[],[],lb,[],ws);
Minimum found that satisfies the constraints.Optimization completed because the objective function is non-decreasing in feasible directions, to within the value of the optimality tolerance,and constraints are satisfied to within the value of the constraint tolerance.<stopping criteria details>
toc
Elapsed time is 0.060411 seconds.
Change the objective function and solve the problem again.
f = [-10;-15;-20];tic[ws,fval,exitflag,output,lambda] = quadprog(H,f,A,b,[],[],lb,[],ws);
Minimum found that satisfies the constraints.Optimization completed because the objective function is non-decreasing in feasible directions, to within the value of the optimality tolerance,and constraints are satisfied to within the value of the constraint tolerance.<stopping criteria details>
toc
Elapsed time is 0.010756 seconds.
Input Arguments
collapse all
H
— Quadratic objective term
symmetric real matrix
Quadratic objective term, specified as a symmetric real matrix. H
represents the quadratic in the expression 1/2*x'*H*x+f'*x
. If H
is not symmetric, quadprog
issues a warning and uses the symmetrized version (H + H')/2
instead.
If the quadratic matrix H
is sparse, then by default, the 'interior-point-convex'
algorithm uses a slightly different algorithm than when H
is dense. Generally, the sparse algorithm is faster on large, sparse problems, and the dense algorithm is faster on dense or small problems. For more information, see the LinearSolver
option description and interior-point-convex quadprog Algorithm.
Example: [2,1;1,3]
Data Types: double
f
— Linear objective term
real vector
Linear objective term, specified as a real vector. f
represents the linear term in the expression 1/2*x'*H*x+f'*x
.
Example: [1;3;2]
Data Types: double
x0
— Initial point
real vector
Initial point, specified as a real vector. The length of x0
is the number of rows or columns of H.
x0
applies to the 'trust-region-reflective'
algorithm when the problem has only bound constraints. x0
also applies to the 'active-set'
algorithm.
Note
x0
is a required argument for the 'active-set'
algorithm.
If you do not specify x0
, quadprog
sets all components of x0
to a point in the interior of the box defined by the bounds. quadprog
ignores x0
for the 'interior-point-convex'
algorithm and for the 'trust-region-reflective'
algorithm with equality constraints.
Example: [1;2;1]
Data Types: double
options
— Optimization options
output of optimoptions
| structure such as optimset
returns
Optimization options, specified as the output of optimoptions
or a structure such as optimset
returns.
Some options are absent from the optimoptions
display. These options appear in italics in the following table. For details, see View Optimization Options.
All Algorithms
Algorithm | Choose the algorithm:
The |
Diagnostics | Display diagnostic information about the function to be minimized or solved. The choices are |
Display | Level of display (see Iterative Display):
The
|
MaxIterations | Maximum number of iterations allowed; a nonnegative integer.
For |
OptimalityTolerance | Termination tolerance on the first-order optimality; a nonnegative scalar.
See Tolerances and Stopping Criteria. For |
StepTolerance | Termination tolerance on
For |
'trust-region-reflective'
Algorithm Only
FunctionTolerance | Termination tolerance on the function value; a nonnegative scalar. The default value depends on the problem type: bound-constrained problems use For |
| Hessian multiply function, specified as a function handle. For large-scale structured problems, this function computes the Hessian matrix product W = hmfun(Hinfo,Y) where See Quadratic Minimization with Dense, Structured Hessian for an example that uses this option. For |
MaxPCGIter | Maximum number of PCG (preconditioned conjugate gradient) iterations; a positive scalar. The default is |
PrecondBandWidth | Upper bandwidth of the preconditioner for PCG; a nonnegative integer. By default, |
SubproblemAlgorithm | Determines how the iteration step is calculated. The default, |
TolPCG | Termination tolerance on the PCG iteration; a positive scalar. The default is |
TypicalX | Typical |
'interior-point-convex'
Algorithm Only
ConstraintTolerance | Tolerance on the constraint violation; a nonnegative scalar. The default is For |
LinearSolver | Type of internal linear solver in the algorithm:
|
'active-set'
Algorithm Only
ConstraintTolerance | Tolerance on the constraint violation; a nonnegative scalar. The default value is For |
ObjectiveLimit | A tolerance (stopping criterion) that is a scalar. If the objective function value goes below |
problem
— Problem structure
structure
Problem structure, specified as a structure with these fields:
| Symmetric matrix in 1/2*x'*H*x |
| Vector in linear term f'*x |
| Matrix in linear inequality constraints Aineq*x ≤bineq |
| Vector in linear inequality constraints Aineq*x ≤bineq |
| Matrix in linear equality constraints Aeq*x=beq |
| Vector in linear equality constraints Aeq*x=beq |
lb | Vector of lower bounds |
ub | Vector of upper bounds |
| Initial point for x |
| 'quadprog' |
| Options created using optimoptions or optimset |
The required fields are H
, f
, solver
, and options
. When solving, quadprog
ignores any fields in problem
other than those listed.
Note
You cannot use warm start with the problem
argument.
Data Types: struct
ws
— Warm start object
object created using optimwarmstart
Warm start object, specified as an object created using optimwarmstart. The warm start object contains the start point and options, and optional data for memory size in code generation. See Warm Start Best Practices.
Example: ws = optimwarmstart(x0,options)
Output Arguments
collapse all
x
— Solution
real vector
Solution, returned as a real vector. x
is the vector that minimizes 1/2*x'*H*x+f'*x
subject to all bounds and linear constraints. x
can be a local minimum for nonconvex problems. For convex problems, x
is a global minimum. For more information, see Local vs. Global Optima.
wsout
— Solution warm start object
QuadprogWarmStart
object
Solution warm start object, returned as a QuadprogWarmStart
object. The solution point is wsout.X
.
You can use wsout
as the input warm start object in a subsequent quadprog
call.
fval
— Objective function value at solution
real scalar
Objective function value at the solution, returned as a real scalar. fval
is the value of 1/2*x'*H*x+f'*x
at the solution x
.
exitflag
— Reason quadprog
stopped
integer
Reason quadprog
stopped, returned as an integer described in this table.
All Algorithms | |
| Function converged to the solution |
Number of iterations exceeded | |
| Problem is infeasible. Or, for |
| Problem is unbounded. |
| |
| Step size was smaller than |
| Nonconvex problem detected. |
| Unable to compute a step direction. |
| |
| Local minimum found; minimum is not unique. |
| Change in the objective function value was smaller than |
| Current search direction was not a direction of descent. No further progress could be made. |
| |
| Nonconvex problem detected; projection of H onto the nullspace of Aeq is not positive semidefinite. |
Note
Occasionally, the 'active-set'
algorithm halts with exit flag 0
when the problem is, in fact, unbounded. Setting a higher iteration limit also results in exit flag 0
.
output
— Information about optimization process
structure
Information about the optimization process, returned as a structure with these fields:
| Number of iterations taken |
| Optimization algorithm used |
| Total number of PCG iterations ( |
constrviolation | Maximum of constraint functions |
firstorderopt | Measure of first-order optimality |
linearsolver | Type of internal linear solver, |
message | Exit message |
lambda
— Lagrange multipliers at solution
structure
Lagrange multipliers at the solution, returned as a structure with these fields:
| Lower bounds |
| Upper bounds |
| Linear inequalities |
| Linear equalities |
For details, see Lagrange Multiplier Structures.
Algorithms
collapse all
'interior-point-convex'
The 'interior-point-convex'
algorithm attempts to follow a path that is strictly inside the constraints. It uses a presolve module to remove redundancies and to simplify the problem by solving for components that are straightforward.
The algorithm has different implementations for a sparse Hessian matrix H and for a dense matrix. Generally, the sparse implementation is faster on large, sparse problems, and the dense implementation is faster on dense or small problems. For more information, see interior-point-convex quadprog Algorithm.
'trust-region-reflective'
The 'trust-region-reflective'
algorithm is a subspace trust-region method based on the interior-reflective Newton method described in [1]. Each iteration involves the approximate solution of a large linear system using the method of preconditioned conjugate gradients (PCG). For more information, see trust-region-reflective quadprog Algorithm.
'active-set'
The 'active-set'
algorithm is a projection method, similar to the one described in [2]. The algorithm is not large-scale; see Large-Scale vs. Medium-Scale Algorithms. For more information, see active-set quadprog Algorithm.
Warm Start
A warm start object maintains a list of active constraints from the previous solved problem. The solver carries over as much active constraint information as possible to solve the current problem. If the previous problem is too different from the current one, no active set information is reused. In this case, the solver effectively executes a cold start in order to rebuild the list of active constraints.
Alternative Functionality
App
The Optimize Live Editor task provides a visual interface for quadprog
.
References
[1] Coleman, T. F., and Y. Li. “A Reflective Newton Method for Minimizing a Quadratic Function Subject to Bounds on Some of the Variables.” SIAM Journal on Optimization. Vol. 6, Number 4, 1996, pp. 1040–1058.
[2] Gill, P. E., W. Murray, and M. H. Wright. Practical Optimization. London: Academic Press, 1981.
[3] Gould, N., and P. L. Toint. “Preprocessing for quadratic programming.” Mathematical Programming. Series B, Vol. 100, 2004, pp. 95–132.
Extended Capabilities
C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.
Usage notes and limitations:
quadprog
supports code generation using either the codegen (MATLAB Coder) function or the MATLAB® Coder™ app. You must have a MATLAB Coder license to generate code.The target hardware must support standard double-precision floating-point computations. You cannot generate code for single-precision or fixed-point computations.
Code generation targets do not use the same math kernel libraries as MATLAB solvers. Therefore, code generation solutions can vary from solver solutions, especially for poorly conditioned problems.
quadprog
does not support the problem argument for code generation.[x,fval] = quadprog(problem) % Not supported
All
quadprog
input matrices such asA
,Aeq
,lb
, andub
must be full, not sparse. You can convert sparse matrices to full by using the full function.The
lb
andub
arguments must have the same number of entries as the number of columns inH
or must be empty[]
.If your target hardware does not support infinite bounds, use optim.coder.infbound.
For advanced code optimization involving embedded processors, you also need an Embedded Coder® license.
You must include options for
quadprog
and specify them using optimoptions. The options must include theAlgorithm
option, set to'active-set'
.options = optimoptions('quadprog','Algorithm','active-set');[x,fval,exitflag] = quadprog(H,f,A,b,Aeq,beq,lb,ub,x0,options);
Code generation supports these options:
Algorithm
— Must be'active-set'
ConstraintTolerance
MaxIterations
ObjectiveLimit
OptimalityTolerance
StepTolerance
Generated code has limited error checking for options. The recommended way to update an option is to use
optimoptions
, not dot notation.opts = optimoptions('quadprog','Algorithm','active-set');opts = optimoptions(opts,'MaxIterations',1e4); % Recommendedopts.MaxIterations = 1e4; % Not recommended
Do not load options from a file. Doing so can cause code generation to fail. Instead, create options in your code.
If you specify an option that is not supported, the option is typically ignored during code generation. For reliable results, specify only supported options.
For an example, see Generate Code for quadprog.
Version History
Introduced before R2006a
See Also
linprog | lsqlin | optimoptions | prob2struct | Optimize | optimwarmstart
Topics
- Solver-Based Optimization Problem Setup
- Optimization Results
- Quadratic Programming and Cone Programming
- Warm Start Best Practices
- Mixed-Integer Quadratic Programming Portfolio Optimization: Solver-Based
MATLAB Command
You clicked a link that corresponds to this MATLAB command:
Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.
Select a Web Site
Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .
You can also select a web site from the following list:
Americas
- América Latina (Español)
- Canada (English)
- United States (English)
Europe
- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)
- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- Deutsch
- English
- Français
- United Kingdom (English)
Asia Pacific
- Australia (English)
- India (English)
- New Zealand (English)
- 中国
- 日本 (日本語)
- 한국 (한국어)
Contact your local office