import cvxpy as cp

# Create two scalar optimization variables.
x = cp.Variable()
y = cp.Variable()

# Create two constraints.
constraints = [x + y == 1,
               x - y >= 1]

# Form objective.
obj = cp.Minimize((2*x - y)**2)

# Form and solve problem.
prob = cp.Problem(obj, constraints)
prob.solve()  # Returns the optimal value.
print(f'status: {prob.status}')
print(f'optimal value: {prob.value}')
print(f'optimal var: x_opt={x.value}, y_opt={y.value}')

# Replace the objective.
prob2 = cp.Problem(cp.Maximize(x + y), prob.constraints)
print("optimal value", prob2.solve())

# Replace the constraint (x + y == 1).
constraints = [x + y <= 3] + prob2.constraints[1:]
prob3 = cp.Problem(prob2.objective, constraints)
print("optimal value", prob3.solve())

import cvxpy as cp

x = cp.Variable()

# An infeasible problem.
prob = cp.Problem(cp.Minimize(x), [x >= 1, x <= 0])
prob.solve()
print("status:", prob.status)
print("optimal value", prob.value)

# An unbounded problem.
prob = cp.Problem(cp.Minimize(x))
prob.solve()
print("status:", prob.status)
print("optimal value", prob.value)

print(prob.status == 'optimal')
print(prob.status)

# A scalar variable.
a = cp.Variable()

# Vector variable with shape (5,).
x = cp.Variable(5)

# Matrix variable with shape (5, 1).
x = cp.Variable((5, 1))

# Matrix variable with shape (4, 7).
A = cp.Variable((4, 7))

# Solves a bounded least-squares problem.

import cvxpy as cp
import numpy as np

# Problem data.
m = 10
n = 5
np.random.seed(1)
A = np.random.randn(m, n)
b = np.random.randn(m)

# Construct the problem.
x = cp.Variable(n)
objective = cp.Minimize(cp.sum_squares(A@x - b))
constraints = [0 <= x, x <= 1]
prob = cp.Problem(objective, constraints)

print("Optimal value", prob.solve())
print("Optimal var")
print(x.value) # A numpy ndarray.


# Positive scalar parameter.
m = cp.Parameter(nonneg=True)

# Column vector parameter with unknown sign (by default).
c = cp.Parameter(5)

# Matrix parameter with negative entries.
G = cp.Parameter((4, 7), nonpos=True)

# Assigns a constant value to G.
G.value = -np.ones((4, 7))

# Create parameter, then assign value.
rho = cp.Parameter(nonneg=True)
rho.value = 2

# Initialize parameter with a value.
rho = cp.Parameter(nonneg=True, value=2)

import cvxpy as cp
import numpy as np
import matplotlib.pyplot as plt

# Problem data.
n = 15
m = 10
np.random.seed(1)
A = np.random.randn(n, m)
b = np.random.randn(n)
# gamma must be nonnegative due to DCP rules.
gamma = cp.Parameter(nonneg=True)

# Construct the problem.
x = cp.Variable(m)
err = cp.sum_squares(A@x - b)
reg = cp.norm(x, 1)
obj = cp.Minimize( err + gamma*reg )
prob = cp.Problem(obj)

# Construct a trade-off curve of ||Ax-b||^2 vs. ||x||_1
gamma_vals = np.logspace(-3, 3)
sq_penalty = []
l1_penalty = []
x_values = []

for val in gamma_vals:
    gamma.value = val
    prob.solve()
    # Use expr.value to get the numerical value of
    # an expression in the problem.
    sq_penalty.append(err.value)
    l1_penalty.append(reg.value)
    x_values.append(x.value)

# Plot trade-off curve.
plt.figure(figsize=(12,9), dpi=100)
plt.plot(l1_penalty, sq_penalty)
plt.xlabel(r'$||x||_1$')
plt.ylabel(r'$||Ax-b||_2^2$')
plt.title('Trade-Off Curve for LASSO')
plt.grid()
plt.show()

# Plot entries of x vs. gamma.
plt.figure(figsize=(12,9), dpi=100)
for i in range(m):
    plt.semilogx(gamma_vals, [xi[i] for xi in x_values])
plt.xlabel(r'$\gamma$')
plt.ylabel(r'$x_{i}$')
plt.title(r'Entries of $x$ vs. $\gamma$')
plt.grid()
plt.show()

gamma = cp.Parameter(nonneg=True)

# Construct the problem.
x = cp.Variable(m)
err = cp.sum_squares(A@x - b)
reg = cp.sum_squares(x)

obj = cp.Minimize( err + gamma*reg )
prob = cp.Problem(obj)

# Construct a trade-off curve of ||Ax-b||^2 vs. ||x||_1
gamma_vals = np.logspace(-3, 3)
sq_penalty = []
l2_penalty = []
x_values = []

for val in gamma_vals:
    gamma.value = val
    prob.solve()
    # Use expr.value to get the numerical value of
    # an expression in the problem.
    sq_penalty.append(err.value)
    l2_penalty.append(reg.value)
    x_values.append(x.value)

# Plot trade-off curve.
plt.figure(figsize=(12,9), dpi=100)
plt.plot(l2_penalty, sq_penalty)
plt.xlabel(r'$||x||_2^2$')
plt.ylabel(r'$||Ax-b||_2^2$')
plt.title('Trade-Off Curve for Ridge regression')
plt.grid()
plt.show()

# Plot entries of x vs. gamma.
plt.figure(figsize=(12,9), dpi=100)
for i in range(m):
    plt.semilogx(gamma_vals, [xi[i] for xi in x_values])
plt.xlabel(r'$\gamma$')
plt.ylabel(r'$x_{i}$')
plt.title(r'Entries of $x$ vs. $\gamma$')
plt.grid()
plt.show()