Example #1
0
def transform_matrix_frac(expr):
    assert len(expr.arg) == 2
    x, P = expr.arg
    n = dim(P, 0)

    M = epi_var(expr, "matrix_frac_M", size=(n+1,n+1))
    t = epi_var(expr, "matrix_frac")
    return t, [
        expression.eq_constraint(expression.index(M, 0, n, 0, n), P),
        expression.eq_constraint(expression.index(M, 0, n, n, n+1), x),
        expression.eq_constraint(expression.index(M, n, n+1, n, n+1), t),
        expression.semidefinite(M)]
Example #2
0
def transform_sigma_max(expr):
    X = only_arg(expr)
    m, n = dims(X)
    S = epi_var(expr, "sigma_max_S", size=(m+n, m+n))
    t = epi_var(expr, "sigma_max")
    t_In = expression.diag_vec(expression.multiply(expression.ones(n, 1), t))
    t_Im = expression.diag_vec(expression.multiply(expression.ones(m, 1), t))

    return t, [
        expression.eq_constraint(expression.index(S, 0, n, 0, n), t_In),
        expression.eq_constraint(expression.index(S, n, n+m, 0, n), X),
        expression.eq_constraint(expression.index(S, n, n+m, n, n+m), t_Im),
        expression.semidefinite(S)]
Example #3
0
def transform_matrix_frac(expr):
    assert len(expr.arg) == 2
    x, P = expr.arg
    n = dim(P, 0)

    M = epi_var(expr, "matrix_frac_M", size=(n + 1, n + 1))
    t = epi_var(expr, "matrix_frac")
    return t, [
        expression.eq_constraint(expression.index(M, 0, n, 0, n), P),
        expression.eq_constraint(expression.index(M, 0, n, n, n + 1), x),
        expression.eq_constraint(expression.index(M, n, n + 1, n, n + 1), t),
        expression.semidefinite(M)
    ]
Example #4
0
def transform_sigma_max(expr):
    X = only_arg(expr)
    m, n = dims(X)
    S = epi_var(expr, "sigma_max_S", size=(m + n, m + n))
    t = epi_var(expr, "sigma_max")
    t_In = expression.diag_vec(expression.multiply(expression.ones(n, 1), t))
    t_Im = expression.diag_vec(expression.multiply(expression.ones(m, 1), t))

    return t, [
        expression.eq_constraint(expression.index(S, 0, n, 0, n), t_In),
        expression.eq_constraint(expression.index(S, n, n + m, 0, n), X),
        expression.eq_constraint(expression.index(S, n, n + m, n, n + m),
                                 t_Im),
        expression.semidefinite(S)
    ]
Example #5
0
def transform_geo_mean(expr):
    w = [Fraction(x.a, x.b) for x in expr.geo_mean_params.w]
    w_dyad = [Fraction(x.a, x.b) for x in expr.geo_mean_params.w_dyad]
    tree = power_tools.decompose(w_dyad)

    t = epi_var(expr, "geo_mean")
    x = only_arg(expr)
    x_list = [expression.index(x, i, i+1) for i in range(len(w))]
    return t, gm_constrs(t, x_list, w)
Example #6
0
def transform_geo_mean(expr):
    w = [Fraction(x.a, x.b) for x in expr.geo_mean_params.w]
    w_dyad = [Fraction(x.a, x.b) for x in expr.geo_mean_params.w_dyad]
    tree = power_tools.decompose(w_dyad)

    t = epi_var(expr, "geo_mean")
    x = only_arg(expr)
    x_list = [expression.index(x, i, i + 1) for i in range(len(w))]
    return t, gm_constrs(t, x_list, w)
Example #7
0
def transform_norm_nuc(expr):
    X = only_arg(expr)
    m, n = dims(X)
    T = epi_var(expr, "norm_nuc", size=(m+n, m+n))

    obj = expression.multiply(
        expression.scalar_constant(0.5),
        expression.trace(T))
    return obj, [
        expression.semidefinite(T),
        expression.eq_constraint(expression.index(T, 0, m, m, m+n), X)]
Example #8
0
def transform_norm_nuc(expr):
    X = only_arg(expr)
    m, n = dims(X)
    T = epi_var(expr, "norm_nuc", size=(m + n, m + n))

    obj = expression.multiply(expression.scalar_constant(0.5),
                              expression.trace(T))
    return obj, [
        expression.semidefinite(T),
        expression.eq_constraint(expression.index(T, 0, m, m, m + n), X)
    ]
Example #9
0
def convert_index(expr):
    starts = []
    stops = []
    assert len(expr.key) == 2
    for i, key in enumerate(expr.key):
        size = expr.args[0].size[i]
        starts.append(index_value(key.start, size) if key.start else 0)
        stops.append(index_value(key.stop, size) if key.stop else size)

    assert len(expr.args) == 1
    return expression.index(convert_expression(expr.args[0]), starts[0],
                            stops[0], starts[1], stops[1])
Example #10
0
def convert_index(expr):
    starts = []
    stops = []
    assert len(expr.key) == 2
    for i, key in enumerate(expr.key):
        size = expr.args[0].size[i]
        starts.append(index_value(key.start, size) if key.start else 0)
        stops.append(index_value(key.stop, size) if key.stop else size)

    assert len(expr.args) == 1
    return expression.index(convert_expression(expr.args[0]),
                            starts[0], stops[0],
                            starts[1], stops[1])