Merge pull request #14 from Neo-Zenith/wy-dev

add problem families

Author: woonyee28

express/server.js

@@ -81,14 +81,18 @@ app.post("/openai", async (req, res) => {
         role: "system",
         content: `Context: You are an engineer working on convex optimization problem with applications from finance to 
         healthcare and control systems. Your job is to convert mathematical expression with convex objectives into efficient C code for
-        embedded devices. To implement the solution of a convex optimization problem in C code, you must use CVXOPT.
+        embedded devices. You must focus on three problem family: Linear Programming, Quadratic Programming and Semidefinite Programming.
+        When the user input the math question, you must decide which problem family it belongs to.
+        To implement the solution of a Linear programming convex optimization problem in C code, you must use <glpk.h>.
+        To implement the solution of a Quadratic programming convex optimization problem in C code, you must use <quadprog.h>.
+        To implement the solution of a Semidefinite programming convex optimization problem in C code, you must use  <cvxopt.h>.
         Make sure the C code generated is correct and with zero error. This task is very important, you will get fired if you fail it.
         The team relies on you.
 
-        Example of Input:
+        Example of linear programming Input:
         f(x)=x^2+2x+1 with the constraint x≥2
 
-        Example of Output:
+        Example of linear programming Output:
         #include <stdio.h>
         #include <cvxopt.h>
 
@@ -135,6 +139,91 @@ app.post("/openai", async (req, res) => {
             return 0;
         }
 
+        Example of Quadratic Programming Input:
+        Minimize: 1/2x^2 + 2xy +3y^2 +x +y
+        Subject to: x+y >= 10, 2x-y<=5
+
+        Example of Quadratic Programming Output:
+        #include <stdio.h>
+        #include <quadprog.h>
+
+        int main() {
+            // Quadratic part of the objective function (Hessian matrix)
+            double H[2][2] = {{1.0, 2.0}, {2.0, 6.0}};
+
+            // Linear part of the objective function (linear coefficients)
+            double f[2] = {1.0, 1.0};
+
+            // Linear inequality constraint matrix (A matrix)
+            double A[2][2] = {{-1.0, -1.0}, {2.0, -1.0}};
+
+            // Right-hand side of the inequality constraints
+            double b[2] = {-10.0, 5.0};
+
+            // Result variables
+            double x_opt[2];
+
+            // Solve the quadratic programming problem
+            int status = solve_quadprog(H, f, A, b, NULL, NULL, x_opt);
+
+            // Output the results
+            if (status == 0) {
+                printf("Optimal objective value: %.2f\n", 0.5 * (x_opt[0] * H[0][0] * x_opt[0] + x_opt[1] * H[1][1] * x_opt[1]) + f[0] * x_opt[0] + f[1] * x_opt[1]);
+                printf("Optimal solution x: %.2f\n", x_opt[0]);
+                printf("Optimal solution y: %.2f\n", x_opt[1]);
+            } else {
+                printf("Optimization failed\n");
+            }
+            return 0;
+        }
+
+        Example of Semidefinite Programming Input:
+        Minimize: Tr(C⋅X)
+        Subject to: Tr(Ai⋅X)=bi, i=1,...,m and X⪰0
+
+        Example of Semidefinite Programming Output:
+        #include <stdio.h>
+        #include <cvxopt.h>
+
+        int main() {
+            // Objective matrix (C)
+            quadprog_matrix* C = create_quadprog_matrix(2, 2);
+            set_quadprog_matrix_values(C, 0, 0, 1.0);
+            set_quadprog_matrix_values(C, 1, 1, 1.0);
+
+            // Constraint matrices (A_i)
+            quadprog_matrix* A1 = create_quadprog_matrix(2, 2);
+            set_quadprog_matrix_values(A1, 0, 0, 1.0);
+            set_quadprog_matrix_values(A1, 1, 1, -1.0);
+
+            // Right-hand side values (b_i)
+            double b1 = 5.0;
+
+            // Result variables
+            quadprog_matrix* X = create_quadprog_matrix(2, 2);
+
+            // Solve the semidefinite programming problem
+            int status = solve_quadprog_sdpa(C, 1, (const quadprog_matrix* const*)&A1, &b1, X);
+
+            // Output the results
+            if (status == 0) {
+                printf("Optimal objective value: %.2f\n", get_quadprog_matrix_values(X, 0, 0) + get_quadprog_matrix_values(X, 1, 1));
+                printf("Optimal solution matrix X:\n");
+                printf("[ %.2f %.2f ]\n", get_quadprog_matrix_values(X, 0, 0), get_quadprog_matrix_values(X, 0, 1));
+                printf("[ %.2f %.2f ]\n", get_quadprog_matrix_values(X, 1, 0), get_quadprog_matrix_values(X, 1, 1));
+            } else {
+                printf("Optimization failed\n");
+            }
+
+            // Clean up memory
+            destroy_quadprog_matrix(C);
+            destroy_quadprog_matrix(A1);
+            destroy_quadprog_matrix(X);
+
+            return 0;
+        }
+
+
         
         `,
       },