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

66.67

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

﻿// ----------------------------------------------------------------------
// <copyright file="QPProblemValidator.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
{
    internal sealed class QPProblemValidator : IQPProblemConfiguration
    {
        public int? Size { get; private set; }

        private bool minimizingConfigured;
        private bool lowerBoundsConfigured;
        private bool upperBoundsConfigured;

        public IQPProblemConfiguration Minimizing(Matrix<double> matrixQ, Vector<double> vectorC)
        {
            if (matrixQ.ColumnCount != matrixQ.RowCount)
            {
                throw new QPEngineException("The matrix Q must be a square matrix.");
            }

            if (matrixQ.ColumnCount != vectorC.Count)
            {
                throw new QPEngineException("The vector c size must be equal to matrix Q columns/rows count.");
            }

            if (Size == null)
            {
                Size = vectorC.Count;
            }
            else if (Size != vectorC.Count)
            {
                throw new QPEngineException($"The vector c size must be {Size} and the matrix Q must be {Size}x{Size}.");
            }

            if (this.minimizingConfigured)
            {
                throw new QPEngineException($"Minimizing configuration method already called.");
            }

            this.minimizingConfigured = true;

            return this;
        }

        public IQPProblemConfiguration WithEquality(Matrix<double> matrixAEquality, Vector<double> vectorBEquality)
        {
            if (matrixAEquality.RowCount != vectorBEquality.Count)
            {
                throw new QPEngineException($"The matrix Aeq row count must be equal to the vector beq size.");
            }

            if (Size == null)
            {
                Size = matrixAEquality.ColumnCount;
            }
            else if (Size != matrixAEquality.ColumnCount)
            {
                throw new QPEngineException($"The matrix Aeq must have {Size} columns.");
            }

            return this;
        }

        public IQPProblemConfiguration WithInequality(Matrix<double> matrixAInequality, Vector<double> vectorBInequality)
        {
            if (matrixAInequality.RowCount != vectorBInequality.Count)
            {
                throw new QPEngineException($"The matrix Aineq row count must be equal to the vector bineq size.");
            }

            if (Size == null)
            {
                Size = matrixAInequality.ColumnCount;
            }
            else if (Size != matrixAInequality.ColumnCount)
            {
                throw new QPEngineException($"The matrix Aineq must have {Size} columns.");
            }

            return this;
        }

        public IQPProblemConfiguration WithLowerBounds(Vector<double> lowerBounds)
        {
            if (Size == null)
            {
                Size = lowerBounds.Count;
            }
            else if (Size != lowerBounds.Count)
            {
                throw new QPEngineException($"The lower bound must have {Size} size.");
            }

            if (this.lowerBoundsConfigured)
            {
                throw new QPEngineException($"WithLowerBounds configuration method already called.");
            }

            this.lowerBoundsConfigured = true;

            return this;
        }

        public IQPProblemConfiguration WithUpperBounds(Vector<double> upperBounds)
        {
            if (Size == null)
            {
                Size = upperBounds.Count;
            }
            else if (Size != upperBounds.Count)
            {
                throw new QPEngineException($"The upper bound must have {Size} size.");
            }

            if (this.upperBoundsConfigured)
            {
                throw new QPEngineException($"WithUpperBounds configuration method already called.");
            }

            this.upperBoundsConfigured = true;

            return this;
        }
    }
}

1	// ----------------------------------------------------------------------
2	// <copyright file="QPProblemValidator.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	internal sealed class QPProblemValidator : IQPProblemConfiguration
15	{
16	public int? Size { get; private set; }
17
18	private bool minimizingConfigured;
19	private bool lowerBoundsConfigured;
20	private bool upperBoundsConfigured;
21
22	public IQPProblemConfiguration Minimizing(Matrix<double> matrixQ, Vector<double> vectorC)
23	{
24	if (matrixQ.ColumnCount != matrixQ.RowCount)	3,366✔
25	{
NEW 26	throw new QPEngineException("The matrix Q must be a square matrix.");	×
27	}
28
29	if (matrixQ.ColumnCount != vectorC.Count)	3,366✔
30	{
NEW 31	throw new QPEngineException("The vector c size must be equal to matrix Q columns/rows count.");	×
32	}
33
34	if (Size == null)	3,366✔
35	{
36	Size = vectorC.Count;	1✔
37	}
38	else if (Size != vectorC.Count)	3,365✔
39	{
NEW 40	throw new QPEngineException($"The vector c size must be {Size} and the matrix Q must be {Size}x{Size}.");	×
41	}
42
43	if (this.minimizingConfigured)	3,366✔
44	{
NEW 45	throw new QPEngineException($"Minimizing configuration method already called.");	×
46	}
47
48	this.minimizingConfigured = true;	3,366✔
49
50	return this;	3,366✔
51	}
52
53	public IQPProblemConfiguration WithEquality(Matrix<double> matrixAEquality, Vector<double> vectorBEquality)
54	{
55	if (matrixAEquality.RowCount != vectorBEquality.Count)	1,124✔
56	{
NEW 57	throw new QPEngineException($"The matrix Aeq row count must be equal to the vector beq size.");	×
58	}
59
60	if (Size == null)	1,124✔
61	{
62	Size = matrixAEquality.ColumnCount;	1,123✔
63	}
64	else if (Size != matrixAEquality.ColumnCount)	1✔
65	{
NEW 66	throw new QPEngineException($"The matrix Aeq must have {Size} columns.");	×
67	}
68
69	return this;	1,124✔
70	}
71
72	public IQPProblemConfiguration WithInequality(Matrix<double> matrixAInequality, Vector<double> vectorBInequality)
73	{
74	if (matrixAInequality.RowCount != vectorBInequality.Count)	1,122✔
75	{
NEW 76	throw new QPEngineException($"The matrix Aineq row count must be equal to the vector bineq size.");	×
77	}
78
79	if (Size == null)	1,122✔
80	{
81	Size = matrixAInequality.ColumnCount;	1,122✔
82	}
NEW 83	else if (Size != matrixAInequality.ColumnCount)	×
84	{
NEW 85	throw new QPEngineException($"The matrix Aineq must have {Size} columns.");	×
86	}
87
88	return this;	1,122✔
89	}
90
91	public IQPProblemConfiguration WithLowerBounds(Vector<double> lowerBounds)
92	{
93	if (Size == null)	1,122✔
94	{
95	Size = lowerBounds.Count;	1,120✔
96	}
97	else if (Size != lowerBounds.Count)	2✔
98	{
NEW 99	throw new QPEngineException($"The lower bound must have {Size} size.");	×
100	}
101
102	if (this.lowerBoundsConfigured)	1,122✔
103	{
NEW 104	throw new QPEngineException($"WithLowerBounds configuration method already called.");	×
105	}
106
107	this.lowerBoundsConfigured = true;	1,122✔
108
109	return this;	1,122✔
110	}
111
112	public IQPProblemConfiguration WithUpperBounds(Vector<double> upperBounds)
113	{
114	if (Size == null)	1,121✔
115	{
NEW 116	Size = upperBounds.Count;	×
117	}
118	else if (Size != upperBounds.Count)	1,121✔
119	{
NEW 120	throw new QPEngineException($"The upper bound must have {Size} size.");	×
121	}
122
123	if (this.upperBoundsConfigured)	1,121✔
124	{
NEW 125	throw new QPEngineException($"WithUpperBounds configuration method already called.");	×
126	}
127
128	this.upperBoundsConfigured = true;	1,121✔
129
130	return this;	1,121✔
131	}
132	}
133	}

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