16332377818

Committed 16 Jul 2025 11:21PM UTC coverage: 77.815%. First build

Build # 16332377818

Build Type

push

github

Committed by

xaviersolau

Commit Message

Initial import.

Run Details

235 of 302 new or added lines in 10 files covered. (77.81%)

235 of 302 relevant lines covered (77.81%)

671207.23 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.3

/src/libs/SoloX.QPSolver/Impl/QPProblem.cs

﻿// ----------------------------------------------------------------------
// <copyright file="QPProblem.cs" company="Xavier Solau">
// Copyright © 2025 Xavier Solau.
// Licensed under the MIT license.
// See LICENSE file in the project root for full license information.
// </copyright>
// ----------------------------------------------------------------------

using MathNet.Numerics.LinearAlgebra;
using SoloX.QPSolver.Exceptions;

namespace SoloX.QPSolver.Impl
{
    /// <summary>
    /// Implement Quadratic Programming Problem definition.
    /// </summary>
    internal sealed class QPProblem : IQPProblem
    {
        private QPProblem(
            int size,
            Matrix<double> matrixQ,
            Vector<double> vectorC,
            Matrix<double> matrixAEquality,
            Vector<double> vectorBEquality,
            Matrix<double> matrixAInequality,
            Vector<double> vectorBInequality,
            Vector<double>? lowerBounds,
            Vector<double>? upperBounds)
        {
            Size = size;
            MatrixQ = matrixQ;
            VectorC = vectorC;
            MatrixAEquality = matrixAEquality;
            VectorBEquality = vectorBEquality;
            MatrixAInequality = matrixAInequality;
            VectorBInequality = vectorBInequality;
            LowerBounds = lowerBounds;
            UpperBounds = upperBounds;
        }

        /// <inheritdoc/>
        public int Size { get; }

        /// <inheritdoc/>
        public Matrix<double> MatrixQ { get; }

        /// <inheritdoc/>
        public Vector<double> VectorC { get; }

        /// <inheritdoc/>
        public Matrix<double> MatrixAEquality { get; }

        /// <inheritdoc/>
        public Vector<double> VectorBEquality { get; }

        /// <inheritdoc/>
        public Matrix<double> MatrixAInequality { get; }

        /// <inheritdoc/>
        public Vector<double> VectorBInequality { get; }

        /// <inheritdoc/>
        public Vector<double>? LowerBounds { get; }

        /// <inheritdoc/>
        public Vector<double>? UpperBounds { get; }

        /// <summary>
        /// Create and configure a Quadratic Programming problem.
        /// </summary>
        /// <param name="configure">Configuration handler.</param>
        /// <returns>The configured problem.</returns>
        /// <exception cref="QPEngineException"></exception>
        public static IQPProblem Create(Action<IQPProblemConfiguration> configure)
        {
            ArgumentNullException.ThrowIfNull(configure);

            var validator = new QPProblemValidator();
            configure(validator);

            if (validator.Size == null)
            {
                throw new QPEngineException("Unable to evaluate QP problem size.");
            }

            var size = validator.Size.Value;

            var initializer = new QPProblemInitializer();
            configure(initializer);

            var matrixQ = initializer.MatrixQ ?? Matrix<double>.Build.Sparse(size, size, 0.0);
            var vectorC = initializer.VectorC ?? Vector<double>.Build.Sparse(size, 0.0);

            var matrixAEquality = initializer.MatrixAEquality ?? Matrix<double>.Build.Sparse(0, size);
            var vectorBEquality = initializer.VectorBEquality ?? Vector<double>.Build.Sparse(0);

            // Prepare inequality matrices
            var matrixAInequality = initializer.MatrixAInequality ?? Matrix<double>.Build.Sparse(0, size);
            var vectorBInequality = initializer.VectorBInequality ?? Vector<double>.Build.Sparse(0);

            var lowerBounds = initializer.LowerBounds;
            var upperBounds = initializer.UpperBounds;

            return new QPProblem(
                size,
                matrixQ,
                vectorC,
                matrixAEquality,
                vectorBEquality,
                matrixAInequality,
                vectorBInequality,
                lowerBounds,
                upperBounds);
        }
    }
}

1	// ----------------------------------------------------------------------
2	// <copyright file="QPProblem.cs" company="Xavier Solau">
3	// Copyright © 2025 Xavier Solau.
4	// Licensed under the MIT license.
5	// See LICENSE file in the project root for full license information.
6	// </copyright>
7	// ----------------------------------------------------------------------
8
9	using MathNet.Numerics.LinearAlgebra;
10	using SoloX.QPSolver.Exceptions;
11
12	namespace SoloX.QPSolver.Impl
13	{
14	/// <summary>
15	/// Implement Quadratic Programming Problem definition.
16	/// </summary>
17	internal sealed class QPProblem : IQPProblem
18	{
19	private QPProblem(
20	int size,
21	Matrix<double> matrixQ,
22	Vector<double> vectorC,
23	Matrix<double> matrixAEquality,
24	Vector<double> vectorBEquality,
25	Matrix<double> matrixAInequality,
26	Vector<double> vectorBInequality,
27	Vector<double>? lowerBounds,
28	Vector<double>? upperBounds)
29	{
30	Size = size;
31	MatrixQ = matrixQ;
32	VectorC = vectorC;
33	MatrixAEquality = matrixAEquality;
34	VectorBEquality = vectorBEquality;
35	MatrixAInequality = matrixAInequality;
36	VectorBInequality = vectorBInequality;
37	LowerBounds = lowerBounds;
38	UpperBounds = upperBounds;
39	}	3,366✔
40
41	/// <inheritdoc/>
42	public int Size { get; }
43
44	/// <inheritdoc/>
45	public Matrix<double> MatrixQ { get; }
46
47	/// <inheritdoc/>
48	public Vector<double> VectorC { get; }
49
50	/// <inheritdoc/>
51	public Matrix<double> MatrixAEquality { get; }
52
53	/// <inheritdoc/>
54	public Vector<double> VectorBEquality { get; }
55
56	/// <inheritdoc/>
57	public Matrix<double> MatrixAInequality { get; }
58
59	/// <inheritdoc/>
60	public Vector<double> VectorBInequality { get; }
61
62	/// <inheritdoc/>
63	public Vector<double>? LowerBounds { get; }
64
65	/// <inheritdoc/>
66	public Vector<double>? UpperBounds { get; }
67
68	/// <summary>
69	/// Create and configure a Quadratic Programming problem.
70	/// </summary>
71	/// <param name="configure">Configuration handler.</param>
72	/// <returns>The configured problem.</returns>
73	/// <exception cref="QPEngineException"></exception>
74	public static IQPProblem Create(Action<IQPProblemConfiguration> configure)
75	{
76	ArgumentNullException.ThrowIfNull(configure);	3,366✔
77
78	var validator = new QPProblemValidator();	3,366✔
79	configure(validator);	3,366✔
80
81	if (validator.Size == null)	3,366✔
82	{
NEW 83	throw new QPEngineException("Unable to evaluate QP problem size.");	×
84	}
85
86	var size = validator.Size.Value;	3,366✔
87
88	var initializer = new QPProblemInitializer();	3,366✔
89	configure(initializer);	3,366✔
90
91	var matrixQ = initializer.MatrixQ ?? Matrix<double>.Build.Sparse(size, size, 0.0);	3,366✔
92	var vectorC = initializer.VectorC ?? Vector<double>.Build.Sparse(size, 0.0);	3,366✔
93
94	var matrixAEquality = initializer.MatrixAEquality ?? Matrix<double>.Build.Sparse(0, size);	3,366✔
95	var vectorBEquality = initializer.VectorBEquality ?? Vector<double>.Build.Sparse(0);	3,366✔
96
97	// Prepare inequality matrices
98	var matrixAInequality = initializer.MatrixAInequality ?? Matrix<double>.Build.Sparse(0, size);	3,366✔
99	var vectorBInequality = initializer.VectorBInequality ?? Vector<double>.Build.Sparse(0);	3,366✔
100
101	var lowerBounds = initializer.LowerBounds;	3,366✔
102	var upperBounds = initializer.UpperBounds;	3,366✔
103
104	return new QPProblem(	3,366✔
105	size,	3,366✔
106	matrixQ,	3,366✔
107	vectorC,	3,366✔
108	matrixAEquality,	3,366✔
109	vectorBEquality,	3,366✔
110	matrixAInequality,	3,366✔
111	vectorBInequality,	3,366✔
112	lowerBounds,	3,366✔
113	upperBounds);	3,366✔
114	}
115	}
116	}

xaviersolau / QPSolver / 16332377818

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous