Source code

001// Copyright (c) FIRST and other WPILib contributors.
002// Open Source Software; you can modify and/or share it under the terms of
003// the WPILib BSD license file in the root directory of this project.
004
005package org.wpilib.math.optimization;
006
007import java.util.ArrayList;
008import org.ejml.simple.SimpleMatrix;
009import org.wpilib.math.autodiff.Variable;
010import org.wpilib.math.autodiff.VariableBlock;
011import org.wpilib.math.autodiff.VariableMatrix;
012
013/** Constraint creation helper functions. */
014public final class Constraints {
015  /** Utility class. */
016  private Constraints() {}
017
018  // ==
019
020  /**
021   * Equality operator that returns an equality constraint for a double and a Variable.
022   *
023   * @param lhs Left-hand side.
024   * @param rhs Right-hand side.
025   * @return Equality constraints.
026   */
027  public static EqualityConstraints eq(double lhs, Variable rhs) {
028    return eq(new Variable(lhs), rhs);
029  }
030
031  /**
032   * Equality operator that returns an equality constraint for a Variable and a double.
033   *
034   * @param lhs Left-hand side.
035   * @param rhs Right-hand side.
036   * @return Equality constraints.
037   */
038  public static EqualityConstraints eq(Variable lhs, double rhs) {
039    return eq(lhs, new Variable(rhs));
040  }
041
042  /**
043   * Equality operator that returns an equality constraint for two Variables.
044   *
045   * @param lhs Left-hand side.
046   * @param rhs Right-hand side.
047   * @return Equality constraints.
048   */
049  public static EqualityConstraints eq(Variable lhs, Variable rhs) {
050    return new EqualityConstraints(new Variable[] {lhs.minus(rhs)});
051  }
052
053  /**
054   * Equality operator that returns an equality constraint for a double and a VariableBlock.
055   *
056   * @param lhs Left-hand side.
057   * @param rhs Right-hand side.
058   * @return Equality constraints.
059   */
060  public static EqualityConstraints eq(double lhs, VariableBlock rhs) {
061    return eq(new Variable(lhs), new VariableMatrix(rhs));
062  }
063
064  /**
065   * Equality operator that returns an equality constraint for a Variable and a VariableBlock.
066   *
067   * @param lhs Left-hand side.
068   * @param rhs Right-hand side.
069   * @return Equality constraints.
070   */
071  public static EqualityConstraints eq(Variable lhs, VariableBlock rhs) {
072    return eq(lhs, new VariableMatrix(rhs));
073  }
074
075  /**
076   * Equality operator that returns an equality constraint for a double and a VariableMatrix.
077   *
078   * @param lhs Left-hand side.
079   * @param rhs Right-hand side.
080   * @return Equality constraints.
081   */
082  public static EqualityConstraints eq(double lhs, VariableMatrix rhs) {
083    return eq(new Variable(lhs), rhs);
084  }
085
086  /**
087   * Equality operator that returns an equality constraint for a Variable and a VariableMatrix.
088   *
089   * @param lhs Left-hand side.
090   * @param rhs Right-hand side.
091   * @return Equality constraints.
092   */
093  public static EqualityConstraints eq(Variable lhs, VariableMatrix rhs) {
094    var constraints = new ArrayList<Variable>(rhs.rows() * rhs.cols());
095    for (int row = 0; row < rhs.rows(); ++row) {
096      for (int col = 0; col < rhs.cols(); ++col) {
097        constraints.add(lhs.minus(rhs.get(row, col)));
098      }
099    }
100
101    var array = new Variable[constraints.size()];
102    return new EqualityConstraints(constraints.toArray(array));
103  }
104
105  /**
106   * Equality operator that returns an equality constraint for a VariableBlock and a double.
107   *
108   * @param lhs Left-hand side.
109   * @param rhs Right-hand side.
110   * @return Equality constraints.
111   */
112  public static EqualityConstraints eq(VariableBlock lhs, double rhs) {
113    return eq(new VariableMatrix(lhs), new Variable(rhs));
114  }
115
116  /**
117   * Equality operator that returns an equality constraint for a VariableBlock and a Variable.
118   *
119   * @param lhs Left-hand side.
120   * @param rhs Right-hand side.
121   * @return Equality constraints.
122   */
123  public static EqualityConstraints eq(VariableBlock lhs, Variable rhs) {
124    return eq(new VariableMatrix(lhs), rhs);
125  }
126
127  /**
128   * Equality operator that returns an equality constraint for a VariableMatrix and a double.
129   *
130   * @param lhs Left-hand side.
131   * @param rhs Right-hand side.
132   * @return Equality constraints.
133   */
134  public static EqualityConstraints eq(VariableMatrix lhs, double rhs) {
135    return eq(lhs, new Variable(rhs));
136  }
137
138  /**
139   * Equality operator that returns an equality constraint for a VariableMatrix and a Variable.
140   *
141   * @param lhs Left-hand side.
142   * @param rhs Right-hand side.
143   * @return Equality constraints.
144   */
145  public static EqualityConstraints eq(VariableMatrix lhs, Variable rhs) {
146    var constraints = new ArrayList<Variable>(lhs.rows() * lhs.cols());
147    for (int row = 0; row < lhs.rows(); ++row) {
148      for (int col = 0; col < lhs.cols(); ++col) {
149        constraints.add(lhs.get(row, col).minus(rhs));
150      }
151    }
152
153    var array = new Variable[constraints.size()];
154    return new EqualityConstraints(constraints.toArray(array));
155  }
156
157  /**
158   * Equality operator that returns an equality constraint for two VariableBlocks.
159   *
160   * @param lhs Left-hand side.
161   * @param rhs Right-hand side.
162   * @return Equality constraints.
163   */
164  public static EqualityConstraints eq(VariableBlock lhs, VariableBlock rhs) {
165    return eq(new VariableMatrix(lhs), new VariableMatrix(rhs));
166  }
167
168  /**
169   * Equality operator that returns an equality constraint for a VariableBlock and a VariableMatrix.
170   *
171   * @param lhs Left-hand side.
172   * @param rhs Right-hand side.
173   * @return Equality constraints.
174   */
175  public static EqualityConstraints eq(VariableBlock lhs, VariableMatrix rhs) {
176    return eq(new VariableMatrix(lhs), rhs);
177  }
178
179  /**
180   * Equality operator that returns an equality constraint for a VariableMatrix and a VariableBlock.
181   *
182   * @param lhs Left-hand side.
183   * @param rhs Right-hand side.
184   * @return Equality constraints.
185   */
186  public static EqualityConstraints eq(VariableMatrix lhs, VariableBlock rhs) {
187    return eq(lhs, new VariableMatrix(rhs));
188  }
189
190  /**
191   * Equality operator that returns an equality constraint for a double[][] and a VariableBlock.
192   *
193   * @param lhs Left-hand side.
194   * @param rhs Right-hand side.
195   * @return Equality constraints.
196   */
197  public static EqualityConstraints eq(double[][] lhs, VariableBlock rhs) {
198    return eq(new VariableMatrix(lhs), new VariableMatrix(rhs));
199  }
200
201  /**
202   * Equality operator that returns an equality constraint for a SimpleMatrix and a VariableBlock.
203   *
204   * @param lhs Left-hand side.
205   * @param rhs Right-hand side.
206   * @return Equality constraints.
207   */
208  public static EqualityConstraints eq(SimpleMatrix lhs, VariableBlock rhs) {
209    return eq(new VariableMatrix(lhs), new VariableMatrix(rhs));
210  }
211
212  /**
213   * Equality operator that returns an equality constraint for a double array and a VariableMatrix.
214   *
215   * @param lhs Left-hand side.
216   * @param rhs Right-hand side.
217   * @return Equality constraints.
218   */
219  public static EqualityConstraints eq(double[][] lhs, VariableMatrix rhs) {
220    return eq(new VariableMatrix(lhs), rhs);
221  }
222
223  /**
224   * Equality operator that returns an equality constraint for a SimpleMatrix and a VariableMatrix.
225   *
226   * @param lhs Left-hand side.
227   * @param rhs Right-hand side.
228   * @return Equality constraints.
229   */
230  public static EqualityConstraints eq(SimpleMatrix lhs, VariableMatrix rhs) {
231    return eq(new VariableMatrix(lhs), rhs);
232  }
233
234  /**
235   * Equality operator that returns an equality constraint for a VariableBlock and a double array.
236   *
237   * @param lhs Left-hand side.
238   * @param rhs Right-hand side.
239   * @return Equality constraints.
240   */
241  public static EqualityConstraints eq(VariableBlock lhs, double[][] rhs) {
242    return eq(new VariableMatrix(lhs), new VariableMatrix(rhs));
243  }
244
245  /**
246   * Equality operator that returns an equality constraint for a VariableBlock and a SimpleMatrix.
247   *
248   * @param lhs Left-hand side.
249   * @param rhs Right-hand side.
250   * @return Equality constraints.
251   */
252  public static EqualityConstraints eq(VariableBlock lhs, SimpleMatrix rhs) {
253    return eq(new VariableMatrix(lhs), new VariableMatrix(rhs));
254  }
255
256  /**
257   * Equality operator that returns an equality constraint for a VariableMatrix and a double array.
258   *
259   * @param lhs Left-hand side.
260   * @param rhs Right-hand side.
261   * @return Equality constraints.
262   */
263  public static EqualityConstraints eq(VariableMatrix lhs, double[][] rhs) {
264    return eq(lhs, new VariableMatrix(rhs));
265  }
266
267  /**
268   * Equality operator that returns an equality constraint for a VariableMatrix and a SimpleMatrix.
269   *
270   * @param lhs Left-hand side.
271   * @param rhs Right-hand side.
272   * @return Equality constraints.
273   */
274  public static EqualityConstraints eq(VariableMatrix lhs, SimpleMatrix rhs) {
275    return eq(lhs, new VariableMatrix(rhs));
276  }
277
278  /**
279   * Equality operator that returns an equality constraint for two VariableMatrices.
280   *
281   * @param lhs Left-hand side.
282   * @param rhs Right-hand side.
283   * @return Equality constraints.
284   */
285  public static EqualityConstraints eq(VariableMatrix lhs, VariableMatrix rhs) {
286    assert lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols();
287
288    var constraints = new ArrayList<Variable>(lhs.rows() * lhs.cols());
289    for (int row = 0; row < lhs.rows(); ++row) {
290      for (int col = 0; col < lhs.cols(); ++col) {
291        constraints.add(lhs.get(row, col).minus(rhs.get(row, col)));
292      }
293    }
294
295    var array = new Variable[constraints.size()];
296    return new EqualityConstraints(constraints.toArray(array));
297  }
298
299  // <
300
301  /**
302   * Less-than comparison operator that returns an inequality constraint for a double and a
303   * Variable.
304   *
305   * @param lhs Left-hand side.
306   * @param rhs Right-hand side.
307   * @return Inequality constraints.
308   */
309  public static InequalityConstraints lt(double lhs, Variable rhs) {
310    return ge(rhs, new Variable(lhs));
311  }
312
313  /**
314   * Less-than comparison operator that returns an inequality constraint for a Variable and a
315   * double.
316   *
317   * @param lhs Left-hand side.
318   * @param rhs Right-hand side.
319   * @return Inequality constraints.
320   */
321  public static InequalityConstraints lt(Variable lhs, double rhs) {
322    return ge(new Variable(rhs), lhs);
323  }
324
325  /**
326   * Less-than comparison operator that returns an inequality constraint for two Variables.
327   *
328   * @param lhs Left-hand side.
329   * @param rhs Right-hand side.
330   * @return Inequality constraints.
331   */
332  public static InequalityConstraints lt(Variable lhs, Variable rhs) {
333    return ge(rhs, lhs);
334  }
335
336  /**
337   * Less-than comparison operator that returns an inequality constraint for a double and a
338   * VariableBlock.
339   *
340   * @param lhs Left-hand side.
341   * @param rhs Right-hand side.
342   * @return Inequality constraints.
343   */
344  public static InequalityConstraints lt(double lhs, VariableBlock rhs) {
345    return ge(new VariableMatrix(rhs), new Variable(lhs));
346  }
347
348  /**
349   * Less-than comparison operator that returns an inequality constraint for a Variable and a
350   * VariableBlock.
351   *
352   * @param lhs Left-hand side.
353   * @param rhs Right-hand side.
354   * @return Inequality constraints.
355   */
356  public static InequalityConstraints lt(Variable lhs, VariableBlock rhs) {
357    return ge(new VariableMatrix(rhs), lhs);
358  }
359
360  /**
361   * Less-than comparison operator that returns an inequality constraint for a double and a
362   * VariableMatrix.
363   *
364   * @param lhs Left-hand side.
365   * @param rhs Right-hand side.
366   * @return Inequality constraints.
367   */
368  public static InequalityConstraints lt(double lhs, VariableMatrix rhs) {
369    return ge(rhs, new Variable(lhs));
370  }
371
372  /**
373   * Less-than comparison operator that returns an inequality constraint for a Variable and a
374   * VariableMatrix.
375   *
376   * @param lhs Left-hand side.
377   * @param rhs Right-hand side.
378   * @return Inequality constraints.
379   */
380  public static InequalityConstraints lt(Variable lhs, VariableMatrix rhs) {
381    return ge(rhs, lhs);
382  }
383
384  /**
385   * Less-than comparison operator that returns an inequality constraint for a VariableBlock and a
386   * double.
387   *
388   * @param lhs Left-hand side.
389   * @param rhs Right-hand side.
390   * @return Inequality constraints.
391   */
392  public static InequalityConstraints lt(VariableBlock lhs, double rhs) {
393    return ge(new Variable(rhs), new VariableMatrix(lhs));
394  }
395
396  /**
397   * Less-than comparison operator that returns an inequality constraint for a VariableBlock and a
398   * Variable.
399   *
400   * @param lhs Left-hand side.
401   * @param rhs Right-hand side.
402   * @return Inequality constraints.
403   */
404  public static InequalityConstraints lt(VariableBlock lhs, Variable rhs) {
405    return ge(rhs, new VariableMatrix(lhs));
406  }
407
408  /**
409   * Less-than comparison operator that returns an inequality constraint for a VariableMatrix and a
410   * double.
411   *
412   * @param lhs Left-hand side.
413   * @param rhs Right-hand side.
414   * @return Inequality constraints.
415   */
416  public static InequalityConstraints lt(VariableMatrix lhs, double rhs) {
417    return ge(new Variable(rhs), lhs);
418  }
419
420  /**
421   * Less-than comparison operator that returns an inequality constraint for a VariableMatrix and a
422   * Variable.
423   *
424   * @param lhs Left-hand side.
425   * @param rhs Right-hand side.
426   * @return Inequality constraints.
427   */
428  public static InequalityConstraints lt(VariableMatrix lhs, Variable rhs) {
429    return ge(rhs, lhs);
430  }
431
432  /**
433   * Less-than comparison operator that returns an inequality constraint for two VariableBlocks.
434   *
435   * @param lhs Left-hand side.
436   * @param rhs Right-hand side.
437   * @return Inequality constraints.
438   */
439  public static InequalityConstraints lt(VariableBlock lhs, VariableBlock rhs) {
440    return ge(new VariableMatrix(rhs), new VariableMatrix(lhs));
441  }
442
443  /**
444   * Less-than comparison operator that returns an inequality constraint for a VariableBlock and a
445   * VariableMatrix.
446   *
447   * @param lhs Left-hand side.
448   * @param rhs Right-hand side.
449   * @return Inequality constraints.
450   */
451  public static InequalityConstraints lt(VariableBlock lhs, VariableMatrix rhs) {
452    return ge(rhs, new VariableMatrix(lhs));
453  }
454
455  /**
456   * Less-than comparison operator that returns an inequality constraint for a VariableMatrix and a
457   * VariableBlock.
458   *
459   * @param lhs Left-hand side.
460   * @param rhs Right-hand side.
461   * @return Inequality constraints.
462   */
463  public static InequalityConstraints lt(VariableMatrix lhs, VariableBlock rhs) {
464    return ge(new VariableMatrix(rhs), lhs);
465  }
466
467  /**
468   * Less-than comparison operator that returns an inequality constraint for a double array and a
469   * VariableBlock.
470   *
471   * @param lhs Left-hand side.
472   * @param rhs Right-hand side.
473   * @return Equality constraints.
474   */
475  public static InequalityConstraints lt(double[][] lhs, VariableBlock rhs) {
476    return lt(new VariableMatrix(lhs), new VariableMatrix(rhs));
477  }
478
479  /**
480   * Less-than comparison operator that returns an inequality constraint for a SimpleMatrix and a
481   * VariableBlock.
482   *
483   * @param lhs Left-hand side.
484   * @param rhs Right-hand side.
485   * @return Equality constraints.
486   */
487  public static InequalityConstraints lt(SimpleMatrix lhs, VariableBlock rhs) {
488    return lt(new VariableMatrix(lhs), new VariableMatrix(rhs));
489  }
490
491  /**
492   * Less-than comparison operator that returns an inequality constraint for a double array and a
493   * VariableMatrix.
494   *
495   * @param lhs Left-hand side.
496   * @param rhs Right-hand side.
497   * @return Equality constraints.
498   */
499  public static InequalityConstraints lt(double[][] lhs, VariableMatrix rhs) {
500    return lt(new VariableMatrix(lhs), rhs);
501  }
502
503  /**
504   * Less-than comparison operator that returns an inequality constraint for a SimpleMatrix and a
505   * VariableMatrix.
506   *
507   * @param lhs Left-hand side.
508   * @param rhs Right-hand side.
509   * @return Equality constraints.
510   */
511  public static InequalityConstraints lt(SimpleMatrix lhs, VariableMatrix rhs) {
512    return lt(new VariableMatrix(lhs), rhs);
513  }
514
515  /**
516   * Less-than comparison operator that returns an inequality constraint for a VariableBlock and a
517   * double array.
518   *
519   * @param lhs Left-hand side.
520   * @param rhs Right-hand side.
521   * @return Equality constraints.
522   */
523  public static InequalityConstraints lt(VariableBlock lhs, double[][] rhs) {
524    return lt(new VariableMatrix(lhs), new VariableMatrix(rhs));
525  }
526
527  /**
528   * Less-than comparison operator that returns an inequality constraint for a VariableBlock and a
529   * SimpleMatrix.
530   *
531   * @param lhs Left-hand side.
532   * @param rhs Right-hand side.
533   * @return Equality constraints.
534   */
535  public static InequalityConstraints lt(VariableBlock lhs, SimpleMatrix rhs) {
536    return lt(new VariableMatrix(lhs), new VariableMatrix(rhs));
537  }
538
539  /**
540   * Less-than comparison operator that returns an inequality constraint for a VariableMatrix and a
541   * double array.
542   *
543   * @param lhs Left-hand side.
544   * @param rhs Right-hand side.
545   * @return Equality constraints.
546   */
547  public static InequalityConstraints lt(VariableMatrix lhs, double[][] rhs) {
548    return lt(lhs, new VariableMatrix(rhs));
549  }
550
551  /**
552   * Less-than comparison operator that returns an inequality constraint for a VariableMatrix and a
553   * SimpleMatrix.
554   *
555   * @param lhs Left-hand side.
556   * @param rhs Right-hand side.
557   * @return Equality constraints.
558   */
559  public static InequalityConstraints lt(VariableMatrix lhs, SimpleMatrix rhs) {
560    return lt(lhs, new VariableMatrix(rhs));
561  }
562
563  /**
564   * Less-than comparison operator that returns an inequality constraint for two VariableMatrices.
565   *
566   * @param lhs Left-hand side.
567   * @param rhs Right-hand side.
568   * @return Inequality constraints.
569   */
570  public static InequalityConstraints lt(VariableMatrix lhs, VariableMatrix rhs) {
571    return ge(rhs, lhs);
572  }
573
574  // <=
575
576  /**
577   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a double
578   * and a Variable.
579   *
580   * @param lhs Left-hand side.
581   * @param rhs Right-hand side.
582   * @return Inequality constraints.
583   */
584  public static InequalityConstraints le(double lhs, Variable rhs) {
585    return ge(rhs, new Variable(lhs));
586  }
587
588  /**
589   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a Variable
590   * and a double.
591   *
592   * @param lhs Left-hand side.
593   * @param rhs Right-hand side.
594   * @return Inequality constraints.
595   */
596  public static InequalityConstraints le(Variable lhs, double rhs) {
597    return ge(new Variable(rhs), lhs);
598  }
599
600  /**
601   * Less-than-or-equal-to comparison operator that returns an inequality constraint for two
602   * Variables.
603   *
604   * @param lhs Left-hand side.
605   * @param rhs Right-hand side.
606   * @return Inequality constraints.
607   */
608  public static InequalityConstraints le(Variable lhs, Variable rhs) {
609    return ge(rhs, lhs);
610  }
611
612  /**
613   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a double
614   * and a VariableBlock.
615   *
616   * @param lhs Left-hand side.
617   * @param rhs Right-hand side.
618   * @return Inequality constraints.
619   */
620  public static InequalityConstraints le(double lhs, VariableBlock rhs) {
621    return ge(new VariableMatrix(rhs), new Variable(lhs));
622  }
623
624  /**
625   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a Variable
626   * and a VariableBlock.
627   *
628   * @param lhs Left-hand side.
629   * @param rhs Right-hand side.
630   * @return Inequality constraints.
631   */
632  public static InequalityConstraints le(Variable lhs, VariableBlock rhs) {
633    return ge(new VariableMatrix(rhs), lhs);
634  }
635
636  /**
637   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a double
638   * and a VariableMatrix.
639   *
640   * @param lhs Left-hand side.
641   * @param rhs Right-hand side.
642   * @return Inequality constraints.
643   */
644  public static InequalityConstraints le(double lhs, VariableMatrix rhs) {
645    return ge(rhs, new Variable(lhs));
646  }
647
648  /**
649   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a Variable
650   * and a VariableMatrix.
651   *
652   * @param lhs Left-hand side.
653   * @param rhs Right-hand side.
654   * @return Inequality constraints.
655   */
656  public static InequalityConstraints le(Variable lhs, VariableMatrix rhs) {
657    return ge(rhs, lhs);
658  }
659
660  /**
661   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a
662   * VariableBlock and a double.
663   *
664   * @param lhs Left-hand side.
665   * @param rhs Right-hand side.
666   * @return Inequality constraints.
667   */
668  public static InequalityConstraints le(VariableBlock lhs, double rhs) {
669    return ge(new Variable(rhs), new VariableMatrix(lhs));
670  }
671
672  /**
673   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a
674   * VariableBlock and a Variable.
675   *
676   * @param lhs Left-hand side.
677   * @param rhs Right-hand side.
678   * @return Inequality constraints.
679   */
680  public static InequalityConstraints le(VariableBlock lhs, Variable rhs) {
681    return ge(rhs, new VariableMatrix(lhs));
682  }
683
684  /**
685   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a
686   * VariableMatrix and a double.
687   *
688   * @param lhs Left-hand side.
689   * @param rhs Right-hand side.
690   * @return Inequality constraints.
691   */
692  public static InequalityConstraints le(VariableMatrix lhs, double rhs) {
693    return ge(new Variable(rhs), lhs);
694  }
695
696  /**
697   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a
698   * VariableMatrix and a Variable.
699   *
700   * @param lhs Left-hand side.
701   * @param rhs Right-hand side.
702   * @return Inequality constraints.
703   */
704  public static InequalityConstraints le(VariableMatrix lhs, Variable rhs) {
705    return ge(rhs, lhs);
706  }
707
708  /**
709   * Less-than-or-equal-to comparison operator that returns an inequality constraint for two
710   * VariableBlocks.
711   *
712   * @param lhs Left-hand side.
713   * @param rhs Right-hand side.
714   * @return Inequality constraints.
715   */
716  public static InequalityConstraints le(VariableBlock lhs, VariableBlock rhs) {
717    return ge(new VariableMatrix(rhs), new VariableMatrix(lhs));
718  }
719
720  /**
721   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a
722   * VariableBlock and a VariableMatrix.
723   *
724   * @param lhs Left-hand side.
725   * @param rhs Right-hand side.
726   * @return Inequality constraints.
727   */
728  public static InequalityConstraints le(VariableBlock lhs, VariableMatrix rhs) {
729    return ge(rhs, new VariableMatrix(lhs));
730  }
731
732  /**
733   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a
734   * VariableMatrix and a VariableBlock.
735   *
736   * @param lhs Left-hand side.
737   * @param rhs Right-hand side.
738   * @return Inequality constraints.
739   */
740  public static InequalityConstraints le(VariableMatrix lhs, VariableBlock rhs) {
741    return ge(new VariableMatrix(rhs), lhs);
742  }
743
744  /**
745   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a double
746   * array and a VariableBlock.
747   *
748   * @param lhs Left-hand side.
749   * @param rhs Right-hand side.
750   * @return Equality constraints.
751   */
752  public static InequalityConstraints le(double[][] lhs, VariableBlock rhs) {
753    return le(new VariableMatrix(lhs), new VariableMatrix(rhs));
754  }
755
756  /**
757   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a
758   * SimpleMatrix and a VariableBlock.
759   *
760   * @param lhs Left-hand side.
761   * @param rhs Right-hand side.
762   * @return Equality constraints.
763   */
764  public static InequalityConstraints le(SimpleMatrix lhs, VariableBlock rhs) {
765    return le(new VariableMatrix(lhs), new VariableMatrix(rhs));
766  }
767
768  /**
769   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a double
770   * array and a VariableMatrix.
771   *
772   * @param lhs Left-hand side.
773   * @param rhs Right-hand side.
774   * @return Equality constraints.
775   */
776  public static InequalityConstraints le(double[][] lhs, VariableMatrix rhs) {
777    return le(new VariableMatrix(lhs), rhs);
778  }
779
780  /**
781   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a
782   * SimpleMatrix and a VariableMatrix.
783   *
784   * @param lhs Left-hand side.
785   * @param rhs Right-hand side.
786   * @return Equality constraints.
787   */
788  public static InequalityConstraints le(SimpleMatrix lhs, VariableMatrix rhs) {
789    return le(new VariableMatrix(lhs), rhs);
790  }
791
792  /**
793   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a
794   * VariableBlock and a double array.
795   *
796   * @param lhs Left-hand side.
797   * @param rhs Right-hand side.
798   * @return Equality constraints.
799   */
800  public static InequalityConstraints le(VariableBlock lhs, double[][] rhs) {
801    return le(new VariableMatrix(lhs), new VariableMatrix(rhs));
802  }
803
804  /**
805   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a
806   * VariableBlock and a SimpleMatrix.
807   *
808   * @param lhs Left-hand side.
809   * @param rhs Right-hand side.
810   * @return Equality constraints.
811   */
812  public static InequalityConstraints le(VariableBlock lhs, SimpleMatrix rhs) {
813    return le(new VariableMatrix(lhs), new VariableMatrix(rhs));
814  }
815
816  /**
817   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a
818   * VariableMatrix and a double array.
819   *
820   * @param lhs Left-hand side.
821   * @param rhs Right-hand side.
822   * @return Equality constraints.
823   */
824  public static InequalityConstraints le(VariableMatrix lhs, double[][] rhs) {
825    return le(lhs, new VariableMatrix(rhs));
826  }
827
828  /**
829   * Less-than-or-equal-to comparison operator that returns an inequality constraint for a
830   * VariableMatrix and a SimpleMatrix.
831   *
832   * @param lhs Left-hand side.
833   * @param rhs Right-hand side.
834   * @return Equality constraints.
835   */
836  public static InequalityConstraints le(VariableMatrix lhs, SimpleMatrix rhs) {
837    return le(lhs, new VariableMatrix(rhs));
838  }
839
840  /**
841   * Less-than-or-equal-to comparison operator that returns an inequality constraint for two
842   * VariableMatrices.
843   *
844   * @param lhs Left-hand side.
845   * @param rhs Right-hand side.
846   * @return Inequality constraints.
847   */
848  public static InequalityConstraints le(VariableMatrix lhs, VariableMatrix rhs) {
849    return ge(rhs, lhs);
850  }
851
852  // >
853
854  /**
855   * Greater-than comparison operator that returns an inequality constraint for a double and a
856   * Variable.
857   *
858   * @param lhs Left-hand side.
859   * @param rhs Right-hand side.
860   * @return Inequality constraints.
861   */
862  public static InequalityConstraints gt(double lhs, Variable rhs) {
863    return ge(new Variable(lhs), rhs);
864  }
865
866  /**
867   * Greater-than comparison operator that returns an inequality constraint for a Variable and a
868   * double.
869   *
870   * @param lhs Left-hand side.
871   * @param rhs Right-hand side.
872   * @return Inequality constraints.
873   */
874  public static InequalityConstraints gt(Variable lhs, double rhs) {
875    return ge(lhs, new Variable(rhs));
876  }
877
878  /**
879   * Greater-than comparison operator that returns an inequality constraint for two Variables.
880   *
881   * @param lhs Left-hand side.
882   * @param rhs Right-hand side.
883   * @return Inequality constraints.
884   */
885  public static InequalityConstraints gt(Variable lhs, Variable rhs) {
886    return ge(lhs, rhs);
887  }
888
889  /**
890   * Greater-than comparison operator that returns an inequality constraint for a double and a
891   * VariableBlock.
892   *
893   * @param lhs Left-hand side.
894   * @param rhs Right-hand side.
895   * @return Inequality constraints.
896   */
897  public static InequalityConstraints gt(double lhs, VariableBlock rhs) {
898    return ge(new Variable(lhs), new VariableMatrix(rhs));
899  }
900
901  /**
902   * Greater-than comparison operator that returns an inequality constraint for a Variable and a
903   * VariableBlock.
904   *
905   * @param lhs Left-hand side.
906   * @param rhs Right-hand side.
907   * @return Inequality constraints.
908   */
909  public static InequalityConstraints gt(Variable lhs, VariableBlock rhs) {
910    return ge(lhs, new VariableMatrix(rhs));
911  }
912
913  /**
914   * Greater-than comparison operator that returns an inequality constraint for a double and a
915   * VariableMatrix.
916   *
917   * @param lhs Left-hand side.
918   * @param rhs Right-hand side.
919   * @return Inequality constraints.
920   */
921  public static InequalityConstraints gt(double lhs, VariableMatrix rhs) {
922    return ge(new Variable(lhs), rhs);
923  }
924
925  /**
926   * Greater-than comparison operator that returns an inequality constraint for a Variable and a
927   * VariableMatrix.
928   *
929   * @param lhs Left-hand side.
930   * @param rhs Right-hand side.
931   * @return Inequality constraints.
932   */
933  public static InequalityConstraints gt(Variable lhs, VariableMatrix rhs) {
934    return ge(lhs, rhs);
935  }
936
937  /**
938   * Greater-than comparison operator that returns an inequality constraint for a VariableBlock and
939   * a double.
940   *
941   * @param lhs Left-hand side.
942   * @param rhs Right-hand side.
943   * @return Inequality constraints.
944   */
945  public static InequalityConstraints gt(VariableBlock lhs, double rhs) {
946    return ge(new VariableMatrix(lhs), new Variable(rhs));
947  }
948
949  /**
950   * Greater-than comparison operator that returns an inequality constraint for a VariableBlock and
951   * a Variable.
952   *
953   * @param lhs Left-hand side.
954   * @param rhs Right-hand side.
955   * @return Inequality constraints.
956   */
957  public static InequalityConstraints gt(VariableBlock lhs, Variable rhs) {
958    return ge(new VariableMatrix(lhs), rhs);
959  }
960
961  /**
962   * Greater-than comparison operator that returns an inequality constraint for a VariableMatrix and
963   * a double.
964   *
965   * @param lhs Left-hand side.
966   * @param rhs Right-hand side.
967   * @return Inequality constraints.
968   */
969  public static InequalityConstraints gt(VariableMatrix lhs, double rhs) {
970    return ge(lhs, new Variable(rhs));
971  }
972
973  /**
974   * Greater-than comparison operator that returns an inequality constraint for a VariableMatrix and
975   * a Variable.
976   *
977   * @param lhs Left-hand side.
978   * @param rhs Right-hand side.
979   * @return Inequality constraints.
980   */
981  public static InequalityConstraints gt(VariableMatrix lhs, Variable rhs) {
982    return ge(lhs, rhs);
983  }
984
985  /**
986   * Greater-than comparison operator that returns an inequality constraint for two VariableBlocks.
987   *
988   * @param lhs Left-hand side.
989   * @param rhs Right-hand side.
990   * @return Inequality constraints.
991   */
992  public static InequalityConstraints gt(VariableBlock lhs, VariableBlock rhs) {
993    return ge(new VariableMatrix(lhs), new VariableMatrix(rhs));
994  }
995
996  /**
997   * Greater-than comparison operator that returns an inequality constraint for a VariableBlock and
998   * a VariableMatrix.
999   *
1000   * @param lhs Left-hand side.
1001   * @param rhs Right-hand side.
1002   * @return Inequality constraints.
1003   */
1004  public static InequalityConstraints gt(VariableBlock lhs, VariableMatrix rhs) {
1005    return ge(new VariableMatrix(lhs), rhs);
1006  }
1007
1008  /**
1009   * Greater-than comparison operator that returns an inequality constraint for a VariableMatrix and
1010   * a VariableBlock.
1011   *
1012   * @param lhs Left-hand side.
1013   * @param rhs Right-hand side.
1014   * @return Inequality constraints.
1015   */
1016  public static InequalityConstraints gt(VariableMatrix lhs, VariableBlock rhs) {
1017    return ge(lhs, new VariableMatrix(rhs));
1018  }
1019
1020  /**
1021   * Greater-than comparison operator that returns an inequality constraint for a double array and a
1022   * VariableBlock.
1023   *
1024   * @param lhs Left-hand side.
1025   * @param rhs Right-hand side.
1026   * @return Equality constraints.
1027   */
1028  public static InequalityConstraints gt(double[][] lhs, VariableBlock rhs) {
1029    return gt(new VariableMatrix(lhs), new VariableMatrix(rhs));
1030  }
1031
1032  /**
1033   * Greater-than comparison operator that returns an inequality constraint for a SimpleMatrix and a
1034   * VariableBlock.
1035   *
1036   * @param lhs Left-hand side.
1037   * @param rhs Right-hand side.
1038   * @return Equality constraints.
1039   */
1040  public static InequalityConstraints gt(SimpleMatrix lhs, VariableBlock rhs) {
1041    return gt(new VariableMatrix(lhs), new VariableMatrix(rhs));
1042  }
1043
1044  /**
1045   * Greater-than comparison operator that returns an inequality constraint for a double array and a
1046   * VariableMatrix.
1047   *
1048   * @param lhs Left-hand side.
1049   * @param rhs Right-hand side.
1050   * @return Equality constraints.
1051   */
1052  public static InequalityConstraints gt(double[][] lhs, VariableMatrix rhs) {
1053    return gt(new VariableMatrix(lhs), rhs);
1054  }
1055
1056  /**
1057   * Greater-than comparison operator that returns an inequality constraint for a SimpleMatrix and a
1058   * VariableMatrix.
1059   *
1060   * @param lhs Left-hand side.
1061   * @param rhs Right-hand side.
1062   * @return Equality constraints.
1063   */
1064  public static InequalityConstraints gt(SimpleMatrix lhs, VariableMatrix rhs) {
1065    return gt(new VariableMatrix(lhs), rhs);
1066  }
1067
1068  /**
1069   * Greater-than comparison operator that returns an inequality constraint for a VariableBlock and
1070   * a double array.
1071   *
1072   * @param lhs Left-hand side.
1073   * @param rhs Right-hand side.
1074   * @return Equality constraints.
1075   */
1076  public static InequalityConstraints gt(VariableBlock lhs, double[][] rhs) {
1077    return gt(new VariableMatrix(lhs), new VariableMatrix(rhs));
1078  }
1079
1080  /**
1081   * Greater-than comparison operator that returns an inequality constraint for a VariableBlock and
1082   * a SimpleMatrix.
1083   *
1084   * @param lhs Left-hand side.
1085   * @param rhs Right-hand side.
1086   * @return Equality constraints.
1087   */
1088  public static InequalityConstraints gt(VariableBlock lhs, SimpleMatrix rhs) {
1089    return gt(new VariableMatrix(lhs), new VariableMatrix(rhs));
1090  }
1091
1092  /**
1093   * Greater-than comparison operator that returns an inequality constraint for a VariableMatrix and
1094   * a double array.
1095   *
1096   * @param lhs Left-hand side.
1097   * @param rhs Right-hand side.
1098   * @return Equality constraints.
1099   */
1100  public static InequalityConstraints gt(VariableMatrix lhs, double[][] rhs) {
1101    return gt(lhs, new VariableMatrix(rhs));
1102  }
1103
1104  /**
1105   * Greater-than comparison operator that returns an inequality constraint for a VariableMatrix and
1106   * a SimpleMatrix.
1107   *
1108   * @param lhs Left-hand side.
1109   * @param rhs Right-hand side.
1110   * @return Equality constraints.
1111   */
1112  public static InequalityConstraints gt(VariableMatrix lhs, SimpleMatrix rhs) {
1113    return gt(lhs, new VariableMatrix(rhs));
1114  }
1115
1116  /**
1117   * Greater-than comparison operator that returns an inequality constraint for two
1118   * VariableMatrices.
1119   *
1120   * @param lhs Left-hand side.
1121   * @param rhs Right-hand side.
1122   * @return Inequality constraints.
1123   */
1124  public static InequalityConstraints gt(VariableMatrix lhs, VariableMatrix rhs) {
1125    return ge(lhs, rhs);
1126  }
1127
1128  // >=
1129
1130  /**
1131   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a double
1132   * and a Variable.
1133   *
1134   * @param lhs Left-hand side.
1135   * @param rhs Right-hand side.
1136   * @return Inequality constraints.
1137   */
1138  public static InequalityConstraints ge(double lhs, Variable rhs) {
1139    return ge(new Variable(lhs), rhs);
1140  }
1141
1142  /**
1143   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1144   * Variable and a double.
1145   *
1146   * @param lhs Left-hand side.
1147   * @param rhs Right-hand side.
1148   * @return Inequality constraints.
1149   */
1150  public static InequalityConstraints ge(Variable lhs, double rhs) {
1151    return ge(lhs, new Variable(rhs));
1152  }
1153
1154  /**
1155   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for two
1156   * Variables.
1157   *
1158   * @param lhs Left-hand side.
1159   * @param rhs Right-hand side.
1160   * @return Inequality constraints.
1161   */
1162  public static InequalityConstraints ge(Variable lhs, Variable rhs) {
1163    return new InequalityConstraints(new Variable[] {lhs.minus(rhs)});
1164  }
1165
1166  /**
1167   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a double
1168   * and a VariableBlock.
1169   *
1170   * @param lhs Left-hand side.
1171   * @param rhs Right-hand side.
1172   * @return Inequality constraints.
1173   */
1174  public static InequalityConstraints ge(double lhs, VariableBlock rhs) {
1175    return ge(new Variable(lhs), new VariableMatrix(rhs));
1176  }
1177
1178  /**
1179   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1180   * Variable and a VariableBlock.
1181   *
1182   * @param lhs Left-hand side.
1183   * @param rhs Right-hand side.
1184   * @return Inequality constraints.
1185   */
1186  public static InequalityConstraints ge(Variable lhs, VariableBlock rhs) {
1187    return ge(lhs, new VariableMatrix(rhs));
1188  }
1189
1190  /**
1191   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a double
1192   * and a VariableMatrix.
1193   *
1194   * @param lhs Left-hand side.
1195   * @param rhs Right-hand side.
1196   * @return Inequality constraints.
1197   */
1198  public static InequalityConstraints ge(double lhs, VariableMatrix rhs) {
1199    return ge(new Variable(lhs), rhs);
1200  }
1201
1202  /**
1203   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1204   * Variable and a VariableMatrix.
1205   *
1206   * @param lhs Left-hand side.
1207   * @param rhs Right-hand side.
1208   * @return Inequality constraints.
1209   */
1210  public static InequalityConstraints ge(Variable lhs, VariableMatrix rhs) {
1211    var constraints = new ArrayList<Variable>(rhs.rows() * rhs.cols());
1212    for (int row = 0; row < rhs.rows(); ++row) {
1213      for (int col = 0; col < rhs.cols(); ++col) {
1214        constraints.add(lhs.minus(rhs.get(row, col)));
1215      }
1216    }
1217
1218    var array = new Variable[constraints.size()];
1219    return new InequalityConstraints(constraints.toArray(array));
1220  }
1221
1222  /**
1223   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1224   * VariableBlock and a double.
1225   *
1226   * @param lhs Left-hand side.
1227   * @param rhs Right-hand side.
1228   * @return Inequality constraints.
1229   */
1230  public static InequalityConstraints ge(VariableBlock lhs, double rhs) {
1231    return ge(new VariableMatrix(lhs), new Variable(rhs));
1232  }
1233
1234  /**
1235   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1236   * VariableBlock and a Variable.
1237   *
1238   * @param lhs Left-hand side.
1239   * @param rhs Right-hand side.
1240   * @return Inequality constraints.
1241   */
1242  public static InequalityConstraints ge(VariableBlock lhs, Variable rhs) {
1243    return ge(new VariableMatrix(lhs), rhs);
1244  }
1245
1246  /**
1247   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1248   * VariableMatrix and a double.
1249   *
1250   * @param lhs Left-hand side.
1251   * @param rhs Right-hand side.
1252   * @return Inequality constraints.
1253   */
1254  public static InequalityConstraints ge(VariableMatrix lhs, double rhs) {
1255    return ge(lhs, new Variable(rhs));
1256  }
1257
1258  /**
1259   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1260   * VariableMatrix and a Variable.
1261   *
1262   * @param lhs Left-hand side.
1263   * @param rhs Right-hand side.
1264   * @return Inequality constraints.
1265   */
1266  public static InequalityConstraints ge(VariableMatrix lhs, Variable rhs) {
1267    var constraints = new ArrayList<Variable>(lhs.rows() * lhs.cols());
1268    for (int row = 0; row < lhs.rows(); ++row) {
1269      for (int col = 0; col < lhs.cols(); ++col) {
1270        constraints.add(lhs.get(row, col).minus(rhs));
1271      }
1272    }
1273
1274    var array = new Variable[constraints.size()];
1275    return new InequalityConstraints(constraints.toArray(array));
1276  }
1277
1278  /**
1279   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for two
1280   * VariableBlocks.
1281   *
1282   * @param lhs Left-hand side.
1283   * @param rhs Right-hand side.
1284   * @return Inequality constraints.
1285   */
1286  public static InequalityConstraints ge(VariableBlock lhs, VariableBlock rhs) {
1287    return ge(new VariableMatrix(lhs), new VariableMatrix(rhs));
1288  }
1289
1290  /**
1291   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1292   * VariableBlock and a VariableMatrix.
1293   *
1294   * @param lhs Left-hand side.
1295   * @param rhs Right-hand side.
1296   * @return Inequality constraints.
1297   */
1298  public static InequalityConstraints ge(VariableBlock lhs, VariableMatrix rhs) {
1299    return ge(new VariableMatrix(lhs), rhs);
1300  }
1301
1302  /**
1303   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1304   * VariableMatrix and a VariableBlock.
1305   *
1306   * @param lhs Left-hand side.
1307   * @param rhs Right-hand side.
1308   * @return Inequality constraints.
1309   */
1310  public static InequalityConstraints ge(VariableMatrix lhs, VariableBlock rhs) {
1311    return ge(lhs, new VariableMatrix(rhs));
1312  }
1313
1314  /**
1315   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a double
1316   * array and a VariableBlock.
1317   *
1318   * @param lhs Left-hand side.
1319   * @param rhs Right-hand side.
1320   * @return Equality constraints.
1321   */
1322  public static InequalityConstraints ge(double[][] lhs, VariableBlock rhs) {
1323    return ge(new VariableMatrix(lhs), new VariableMatrix(rhs));
1324  }
1325
1326  /**
1327   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1328   * SimpleMatrix and a VariableBlock.
1329   *
1330   * @param lhs Left-hand side.
1331   * @param rhs Right-hand side.
1332   * @return Equality constraints.
1333   */
1334  public static InequalityConstraints ge(SimpleMatrix lhs, VariableBlock rhs) {
1335    return ge(new VariableMatrix(lhs), new VariableMatrix(rhs));
1336  }
1337
1338  /**
1339   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a double
1340   * array and a VariableMatrix.
1341   *
1342   * @param lhs Left-hand side.
1343   * @param rhs Right-hand side.
1344   * @return Equality constraints.
1345   */
1346  public static InequalityConstraints ge(double[][] lhs, VariableMatrix rhs) {
1347    return ge(new VariableMatrix(lhs), rhs);
1348  }
1349
1350  /**
1351   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1352   * SimpleMatrix and a VariableMatrix.
1353   *
1354   * @param lhs Left-hand side.
1355   * @param rhs Right-hand side.
1356   * @return Equality constraints.
1357   */
1358  public static InequalityConstraints ge(SimpleMatrix lhs, VariableMatrix rhs) {
1359    return ge(new VariableMatrix(lhs), rhs);
1360  }
1361
1362  /**
1363   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1364   * VariableBlock and a double array.
1365   *
1366   * @param lhs Left-hand side.
1367   * @param rhs Right-hand side.
1368   * @return Equality constraints.
1369   */
1370  public static InequalityConstraints ge(VariableBlock lhs, double[][] rhs) {
1371    return ge(new VariableMatrix(lhs), new VariableMatrix(rhs));
1372  }
1373
1374  /**
1375   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1376   * VariableBlock and a SimpleMatrix.
1377   *
1378   * @param lhs Left-hand side.
1379   * @param rhs Right-hand side.
1380   * @return Equality constraints.
1381   */
1382  public static InequalityConstraints ge(VariableBlock lhs, SimpleMatrix rhs) {
1383    return ge(new VariableMatrix(lhs), new VariableMatrix(rhs));
1384  }
1385
1386  /**
1387   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1388   * VariableMatrix and a double array.
1389   *
1390   * @param lhs Left-hand side.
1391   * @param rhs Right-hand side.
1392   * @return Equality constraints.
1393   */
1394  public static InequalityConstraints ge(VariableMatrix lhs, double[][] rhs) {
1395    return ge(lhs, new VariableMatrix(rhs));
1396  }
1397
1398  /**
1399   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for a
1400   * VariableMatrix and a SimpleMatrix.
1401   *
1402   * @param lhs Left-hand side.
1403   * @param rhs Right-hand side.
1404   * @return Equality constraints.
1405   */
1406  public static InequalityConstraints ge(VariableMatrix lhs, SimpleMatrix rhs) {
1407    return ge(lhs, new VariableMatrix(rhs));
1408  }
1409
1410  /**
1411   * Greater-than-or-equal-to comparison operator that returns an inequality constraint for two
1412   * VariableMatrices.
1413   *
1414   * @param lhs Left-hand side.
1415   * @param rhs Right-hand side.
1416   * @return Inequality constraints.
1417   */
1418  public static InequalityConstraints ge(VariableMatrix lhs, VariableMatrix rhs) {
1419    assert lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols();
1420
1421    var constraints = new ArrayList<Variable>(lhs.rows() * lhs.cols());
1422    for (int row = 0; row < lhs.rows(); ++row) {
1423      for (int col = 0; col < lhs.cols(); ++col) {
1424        constraints.add(lhs.get(row, col).minus(rhs.get(row, col)));
1425      }
1426    }
1427
1428    var array = new Variable[constraints.size()];
1429    return new InequalityConstraints(constraints.toArray(array));
1430  }
1431
1432  /**
1433   * Helper function for creating bound constraints.
1434   *
1435   * @param l Lower bound.
1436   * @param x Variable to bound.
1437   * @param u Upper bound.
1438   * @return Inequality constraints.
1439   */
1440  public static InequalityConstraints bounds(double l, Variable x, double u) {
1441    return bounds(l, new VariableMatrix(x), u);
1442  }
1443
1444  /**
1445   * Helper function for creating bound constraints.
1446   *
1447   * @param l Lower bound.
1448   * @param x Variable to bound.
1449   * @param u Upper bound.
1450   * @return Inequality constraints.
1451   */
1452  public static InequalityConstraints bounds(double l, VariableMatrix x, double u) {
1453    var ineq1 = le(l, x).constraints;
1454    var ineq2 = le(x, u).constraints;
1455    var result = new Variable[ineq1.length + ineq2.length];
1456    System.arraycopy(ineq1, 0, result, 0, ineq1.length);
1457    System.arraycopy(ineq2, 0, result, ineq1.length, ineq2.length);
1458    return new InequalityConstraints(result);
1459  }
1460
1461  /**
1462   * Helper function for creating bound constraints.
1463   *
1464   * @param l Lower bound.
1465   * @param x Variable to bound.
1466   * @param u Upper bound.
1467   * @return Inequality constraints.
1468   */
1469  public static InequalityConstraints bounds(double l, VariableBlock x, double u) {
1470    return bounds(l, new VariableMatrix(x), u);
1471  }
1472}