name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
baryonyx::itm::solver_inequalities_101coeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, false>::decrease_preference(baryonyx::sparse_matrix<int>::row_value*, baryonyx::sparse_matrix<int>::row_value*, long double) | void decrease_preference(sparse_matrix<int>::row_iterator begin,
sparse_matrix<int>::row_iterator end,
Float theta) noexcept
{
for (; begin != end; ++begin)
P[begin->value] *= theta;
} | fldt 0x8(%rsp)
movq 0x50(%rdi), %rax
cmpq %rdx, %rsi
je 0x335eb4
movslq (%rsi), %rcx
addq $0x8, %rsi
shlq $0x4, %rcx
fldt (%rax,%rcx)
fmul %st(1), %st
fstpt (%rax,%rcx)
jmp 0x335e9a
fstp %st(0)
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-101.cpp |
baryonyx::itm::solver_inequalities_101coeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, false>::select_variables(baryonyx::itm::solver_inequalities_101coeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, false>::rc_size const&, int, int) | int select_variables(const rc_size& sizes, int bkmin, int bkmax)
{
if (bkmin == bkmax)
return std::min(bkmin + sizes.c_size, sizes.r_size) - 1;
bkmin += sizes.c_size;
bkmax = std::min(bkmax + sizes.c_size, sizes.r_size);
for (int i = bkmin; i <= bkmax; ++i)
if (stop_iterating<Mode>(R[i].value, rng))
return i - 1;
return bkmax - 1;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x4(%rsi), %edi
leal (%rdi,%rdx), %eax
cmpl %ecx, %edx
jne 0x336048
movl (%rsi), %ecx
cmpl %eax, %ecx
cmovll %ecx, %eax
decl %eax
jmp 0x336094
movl (%rsi), %esi
addl %edi, %ecx
movslq %eax, %r14
leal -0x1(%rdi,%rdx), %ebp
movq %r14, %r12
cmpl %ecx, %esi
cmovll %esi, %ecx
shlq $0x5, %r12
movslq %ecx, %r15
cmpq %r15, %r14
jg 0x33608a
movq 0x8(%rbx), %rdi
movq 0x68(%rbx), %rax
fldt (%rax,%r12)
fstpt (%rsp)
callq 0x9098a
testb %al, %al
jne 0x33608a
incq %r14
incl %ebp
addq $0x20, %r12
jmp 0x336062
leal -0x1(%r15), %eax
cmpq %r15, %r14
cmovlel %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-101.cpp |
void baryonyx::itm::random_shuffle_unique<baryonyx::itm::solver_inequalities_101coeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, false>::rc_data*>(baryonyx::itm::solver_inequalities_101coeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, false>::rc_data*, baryonyx::itm::solver_inequalities_101coeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, false>::rc_data*, std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&) | inline void
random_shuffle_unique(iteratorT begin,
iteratorT end,
random_engine& rng) noexcept
{
auto ret = begin++;
for (; begin != end; ++begin) {
if (ret->value != begin->value) {
std::shuffle(ret, begin, rng);
ret = begin;
}
}
std::shuffle(ret, begin, rng);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x20(%rdi), %r15
cmpq %r14, %r15
je 0x3363b0
fldt (%rdi)
fldt (%r15)
addq $0x20, %r15
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x33639c
jnp 0x336384
addq $-0x20, %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0x336931
movq %r15, %rdi
jmp 0x336380
movq %r15, %rsi
movq %rbx, %rdx
callq 0x336931
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3363c3
movq %rax, %rdi
callq 0xeb9f
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
bool baryonyx::itm::solver_inequalities_101coeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, false>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, long double, long double, long double, long double) | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
Float obj_amp)
{
auto at_least_one_pi_changed{ false };
logger::log("push-update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
bx_expects(k < m);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto sizes =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
for (int i = 0; i != sizes.r_size; ++i)
R[i].value +=
obj_amp * c((std::get<0>(it) + R[i].id)->column, x);
calculator_sort<Mode>(R.get(), R.get() + sizes.r_size, rng);
int selected = select_variables(sizes, b[k].min, b[k].max);
logger::log("constraints {}: {} <= ", k, b[k].min);
for (int i = 0; i < sizes.r_size; ++i)
logger::log("{} ({} {}) ", R[i].f, R[i].value, R[i].id);
logger::log("<= {} => Selected: {}\n", b[k].max, selected);
auto pi_change = affect(*this,
x,
std::get<0>(it),
k,
selected,
sizes.r_size,
kappa,
delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x48(%rsp)
leaq 0x10(%rdi), %rbp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
fldt 0xe0(%rsp)
fldt 0xd0(%rsp)
fstpt 0x6c(%rsp)
fldt 0xc0(%rsp)
fstpt 0x60(%rsp)
fldt 0xb0(%rsp)
fstpt 0x54(%rsp)
fstpt 0x3c(%rsp)
cmpq 0x48(%rsp), %r14
je 0x33814d
movslq (%r14), %rbx
cmpl 0x88(%r12), %ebx
jge 0x338163
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
movl %ebx, %edx
callq 0x3de66
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
fldt 0x6c(%rsp)
movq %r12, %rdi
fstpt (%rsp)
callq 0x335e92
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
callq 0x335eb8
fldt 0x3c(%rsp)
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rdx
movl %eax, %esi
shlq $0x5, %rsi
xorl %r8d, %r8d
movq 0x68(%r12), %rdi
movq 0x80(%r12), %rcx
cmpq %r8, %rsi
je 0x3380df
movslq 0x14(%rdi,%r8), %r9
movq 0x8(%rcx), %r10
movslq 0x4(%rdx,%r9,8), %r9
shlq $0x4, %r9
fldt (%r10,%r9)
fmul %st(1), %st
fldt (%rdi,%r8)
faddp %st, %st(1)
fstpt (%rdi,%r8)
addq $0x20, %r8
jmp 0x3380b2
fstp %st(0)
movq 0x8(%r12), %rdx
movslq %eax, %rsi
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x335ff0
movq 0x70(%r12), %rax
imulq $0xc, %rbx, %rcx
leaq 0x30(%rsp), %rsi
movq %r12, %rdi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x336024
movl 0x30(%rsp), %r9d
movq 0x28(%rsp), %rdx
fldt 0x60(%rsp)
fstpt 0x10(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %ecx
movl %eax, %r8d
fldt 0x54(%rsp)
fstpt (%rsp)
callq 0x3360a1
fldt 0x3c(%rsp)
fstp %st(0)
orb %al, %r13b
addq $0x4, %r14
jmp 0x338035
andb $0x1, %r13b
movl %r13d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x120074(%rip), %rdi # 0x4581de
leaq 0x122309(%rip), %rsi # 0x45a47a
leaq 0x12b520(%rip), %rdx # 0x463698
leaq 0x12b5c8(%rip), %rcx # 0x463747
callq 0x2813f
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-101.cpp |
bool baryonyx::itm::solver_inequalities_101coeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, false>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, long double, long double, long double, long double) | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
Float obj_amp)
{
auto at_least_one_pi_changed{ false };
logger::log("push-update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
bx_expects(k < m);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto sizes =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
for (int i = 0; i != sizes.r_size; ++i)
R[i].value +=
obj_amp * c((std::get<0>(it) + R[i].id)->column, x);
calculator_sort<Mode>(R.get(), R.get() + sizes.r_size, rng);
int selected = select_variables(sizes, b[k].min, b[k].max);
logger::log("constraints {}: {} <= ", k, b[k].min);
for (int i = 0; i < sizes.r_size; ++i)
logger::log("{} ({} {}) ", R[i].f, R[i].value, R[i].id);
logger::log("<= {} => Selected: {}\n", b[k].max, selected);
auto pi_change = affect(*this,
x,
std::get<0>(it),
k,
selected,
sizes.r_size,
kappa,
delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x48(%rsp)
leaq 0x10(%rdi), %rbp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
fldt 0xe0(%rsp)
fldt 0xd0(%rsp)
fstpt 0x6c(%rsp)
fldt 0xc0(%rsp)
fstpt 0x60(%rsp)
fldt 0xb0(%rsp)
fstpt 0x54(%rsp)
fstpt 0x3c(%rsp)
cmpq 0x48(%rsp), %r14
je 0x338489
movslq (%r14), %rbx
cmpl 0x88(%r12), %ebx
jge 0x33849f
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
movl %ebx, %edx
callq 0x3de66
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
fldt 0x6c(%rsp)
movq %r12, %rdi
fstpt (%rsp)
callq 0x335e92
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
callq 0x335eb8
fldt 0x3c(%rsp)
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rdx
movl %eax, %esi
shlq $0x5, %rsi
xorl %r8d, %r8d
movq 0x68(%r12), %rdi
movq 0x80(%r12), %rcx
cmpq %r8, %rsi
je 0x33841b
movslq 0x14(%rdi,%r8), %r9
movq 0x8(%rcx), %r10
movslq 0x4(%rdx,%r9,8), %r9
shlq $0x4, %r9
fldt (%r10,%r9)
fmul %st(1), %st
fldt (%rdi,%r8)
faddp %st, %st(1)
fstpt (%rdi,%r8)
addq $0x20, %r8
jmp 0x3383ee
fstp %st(0)
movq 0x8(%r12), %rdx
movslq %eax, %rsi
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x335ff0
movq 0x70(%r12), %rax
imulq $0xc, %rbx, %rcx
leaq 0x30(%rsp), %rsi
movq %r12, %rdi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x336024
movl 0x30(%rsp), %r9d
movq 0x28(%rsp), %rdx
fldt 0x60(%rsp)
fstpt 0x10(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %ecx
movl %eax, %r8d
fldt 0x54(%rsp)
fstpt (%rsp)
callq 0x3360a1
fldt 0x3c(%rsp)
fstp %st(0)
orb %al, %r13b
addq $0x4, %r14
jmp 0x338371
andb $0x1, %r13b
movl %r13d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11fd38(%rip), %rdi # 0x4581de
leaq 0x121fcd(%rip), %rsi # 0x45a47a
leaq 0x12b1e4(%rip), %rdx # 0x463698
leaq 0x12b28c(%rip), %rcx # 0x463747
callq 0x2813f
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-101.cpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_101coeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, false>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, baryonyx::file_observer>::operator()(std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&, int, baryonyx::itm::default_cost_type<long double> const&, double) | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx.parameters;
auto norm_costs = normalize_costs<Float, Cost>(
m_ctx, original_costs, m_rng, variables);
const auto kappa_step = static_cast<Float>(p.kappa_step);
const auto kappa_max = static_cast<Float>(p.kappa_max);
const auto alpha = static_cast<Float>(p.alpha);
const auto theta = static_cast<Float>(p.theta);
const auto delta =
p.delta < 0
? compute_delta<Float, Cost>(m_ctx, norm_costs, theta, variables)
: static_cast<Float>(p.delta);
const auto pushing_k_factor = static_cast<Float>(p.pushing_k_factor);
const auto pushing_objective_amplifier =
static_cast<Float>(p.pushing_objective_amplifier);
const long int w_limit = static_cast<long int>(p.w);
Solver slv(
m_rng, length(constraints), variables, norm_costs, constraints);
compute_order compute(p.order, variables);
{
std::bernoulli_distribution choose_mutation(
m_ctx.parameters.init_policy_random);
bit_array empty_x;
switch (p.init_policy) {
case solver_parameters::init_policy_type::pessimistic_solve:
init_with_pre_solve<Cost, Mode>(
x, empty_x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::optimistic_solve:
init_with_pre_solve<Cost, Mode>(
empty_x, x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::bastert:
init_with_bastert<Cost, Mode>(x, original_costs, variables, 0);
break;
}
for (int i = 0, e = x.size(); i != e; ++i)
if (choose_mutation(m_rng))
x.invert(i);
}
bool start_push = false;
auto kappa = static_cast<Float>(p.kappa_min);
Observer obs("img", slv.m, slv.n, p.limit);
m_begin = std::chrono::steady_clock::now();
m_end = std::chrono::steady_clock::now();
compute.init(slv, x);
for (long int i = 0; i != p.limit; ++i) {
auto remaining = compute.run(slv, x, m_rng, kappa, delta, theta);
obs.make_observation(slv.ap, slv.P.get(), slv.pi.get());
if (remaining == 0) {
store_if_better(
x, original_costs.results(x, cost_constant), i);
best_remaining = remaining;
start_push = true;
break;
}
if (remaining < best_remaining) {
store_if_better(x, remaining, i);
best_remaining = remaining;
}
if (i > w_limit)
kappa += kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max) {
r.status = result_status::kappa_max_reached;
break;
}
if (is_timelimit_reached()) {
r.status = result_status::time_limit_reached;
break;
}
}
if (!start_push) {
r.status = result_status::limit_reached;
} else {
for (int push = 0; push < p.pushes_limit; ++push) {
auto remaining =
compute.push_and_run(slv,
x,
m_rng,
pushing_k_factor * kappa,
delta,
theta,
pushing_objective_amplifier);
if (remaining == 0)
store_if_better(x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - 1);
if (is_timelimit_reached())
break;
for (int iter = 0; iter < p.pushing_iteration_limit; ++iter) {
remaining =
compute.run(slv, x, m_rng, kappa, delta, theta);
if (remaining == 0) {
store_if_better(
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - iter - 1);
break;
}
if (iter > p.w)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
if (is_timelimit_reached())
break;
}
}
}
if (m_best.remaining_constraints == 0)
r.status = result_status::success;
if (!m_best.x.empty()) {
r.solutions.resize(1);
convert(m_best, r.solutions[0], variables);
}
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
vmovsd %xmm0, 0x88(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x60(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
leaq 0x70(%rsp), %rdi
movl %ecx, %esi
vzeroupper
callq 0x368ae
movq 0x10(%r14), %r12
movq 0x18(%r14), %rcx
leaq 0xb8(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebx, %r8d
callq 0x8d226
fldl 0x20(%r12)
fstpt 0xd8(%rsp)
vxorpd %xmm1, %xmm1, %xmm1
fldl 0x28(%r12)
fstpt 0xe4(%rsp)
fldl 0x30(%r12)
fstpt 0xcc(%rsp)
fldl 0x8(%r12)
vmovsd 0x10(%r12), %xmm0
fld %st(0)
fstpt 0x54(%rsp)
vucomisd %xmm0, %xmm1
jbe 0x33a090
movq 0x10(%r14), %rdi
leaq 0xb8(%rsp), %rsi
movl %ebx, %edx
fstpt (%rsp)
callq 0x8d304
fstpt 0x9c(%rsp)
jmp 0x33a0a9
fstp %st(0)
vmovsd %xmm0, 0xf8(%rsp)
fldl 0xf8(%rsp)
fstpt 0x9c(%rsp)
fldl 0x38(%r12)
fstpt 0x10c(%rsp)
fldl 0x40(%r12)
fstpt 0x100(%rsp)
vcvttsd2si 0xa0(%r12), %rax
movq 0x18(%r14), %rsi
movq %rax, 0x90(%rsp)
movq 0x8(%r15), %rax
subq (%r15), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq 0x150(%rsp), %rdi
leaq 0xb8(%rsp), %r8
movl %eax, %edx
movl %ebx, %ecx
movq %r15, %r9
callq 0x334dfe
movl 0xcc(%r12), %esi
leaq 0x118(%rsp), %rdi
movl %ebx, %edx
callq 0x38cd8
movq 0x10(%r14), %rax
movl %ebx, 0x98(%rsp)
vmovsd 0x48(%rax), %xmm0
vmovsd %xmm0, 0x48(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0x1e0(%rsp)
movl 0xd4(%r12), %eax
testl %eax, %eax
je 0x33a18b
cmpl $0x1, %eax
je 0x33a165
cmpl $0x2, %eax
jne 0x33a19c
movq 0x18(%r14), %rdx
leaq 0x1e0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
jmp 0x33a176
movq 0x18(%r14), %rdx
leaq 0x70(%rsp), %rdi
leaq 0x1e0(%rsp), %rsi
vmovsd 0x119eba(%rip), %xmm0 # 0x454038
movq %r13, %rcx
movq %r15, %r8
callq 0x8b497
jmp 0x33a19c
leaq 0x70(%rsp), %rdi
movq %r13, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x8b41f
leaq 0x70(%rsp), %r15
movq %r13, 0x80(%rsp)
xorl %ebx, %ebx
movl (%r15), %ebp
cmpl %ebx, %ebp
je 0x33a1d5
movq 0x18(%r14), %rdi
callq 0x36ac3
vmovsd 0x48(%rsp), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x33a1d1
movq %r15, %rdi
movl %ebx, %esi
callq 0x3626e
incl %ebx
jmp 0x33a1ae
leaq 0x1e8(%rsp), %rdi
callq 0x357fe
vmovsd 0x18(%r12), %xmm0
movl 0x1d8(%rsp), %ecx
movl 0x1dc(%rsp), %r8d
movq 0xb0(%r12), %r9
vmovsd %xmm0, 0x48(%rsp)
leaq 0x12036a(%rip), %rdx # 0x45a577
leaq 0x1e0(%rsp), %rdi
pushq $0x3
popq %rsi
callq 0x4346e
callq 0xb5a0
movq %rax, (%r14)
callq 0xb5a0
movq %rax, 0x8(%r14)
leaq 0x118(%rsp), %rdi
leaq 0x150(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x335094
vmovsd 0x48(%rsp), %xmm0
movl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x70(%rsp), %r13
xorl %r15d, %r15d
vmovsd %xmm0, 0xf0(%rsp)
fldl 0xf0(%rsp)
fldt 0x54(%rsp)
cmpq 0xb0(%r12), %r15
je 0x33a37e
movq 0x18(%r14), %rcx
fstpt 0x20(%rsp)
leaq 0x118(%rsp), %rdi
leaq 0x150(%rsp), %rsi
movq %r13, %rdx
fldt 0x9c(%rsp)
fstpt 0x10(%rsp)
fld %st(0)
fstpt 0x48(%rsp)
fstpt (%rsp)
callq 0x3350d6
movq 0x1a0(%rsp), %rdx
movq 0x1c8(%rsp), %rcx
movl %eax, %ebx
leaq 0x1e0(%rsp), %rdi
leaq 0x160(%rsp), %rsi
callq 0x95692
testl %ebx, %ebx
je 0x33a432
cmpl %ebp, %ebx
jge 0x33a2f6
movq %r14, %rdi
movq %r13, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x33aeec
movl %ebx, %ebp
cmpq 0x90(%rsp), %r15
jle 0x33a347
movl %ebx, 0xb0(%rsp)
fildl 0xb0(%rsp)
movl 0x1d8(%rsp), %eax
movl %eax, 0xb4(%rsp)
fidivl 0xb4(%rsp)
fldt 0xcc(%rsp)
fstpt 0x10(%rsp)
fstpt (%rsp)
callq 0xb110
fldt 0xd8(%rsp)
fmulp %st, %st(1)
fldt 0x48(%rsp)
faddp %st, %st(1)
jmp 0x33a34b
fldt 0x48(%rsp)
fldt 0xe4(%rsp)
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
fldz
ja 0x33a37e
fstp %st(0)
movq %r14, %rdi
fstpt 0x48(%rsp)
callq 0x33af24
fldt 0x48(%rsp)
fldt 0x54(%rsp)
testb %al, %al
jne 0x33a37e
incq %r15
jmp 0x33a26f
fstp %st(0)
fstp %st(0)
movq 0x60(%rsp), %rax
movl $0x5, 0xa0(%rax)
fldz
fldz
fstp %st(1)
fstp %st(0)
cmpl $0x0, 0x50(%r14)
jne 0x33a3ac
movq 0x60(%rsp), %rax
andl $0x0, 0xa0(%rax)
cmpq $0x0, 0x28(%r14)
je 0x33a3dd
movq 0x60(%rsp), %rax
leaq 0x68(%rax), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x35292
movq (%rbx), %rsi
addq $0x20, %r14
movl 0x98(%rsp), %edx
movq %r14, %rdi
callq 0x35781
leaq 0x1e0(%rsp), %rdi
callq 0x435d0
leaq 0x118(%rsp), %rdi
callq 0x393ac
leaq 0x150(%rsp), %rdi
callq 0x3355aa
leaq 0xc0(%rsp), %rdi
callq 0x8affa
leaq 0x78(%rsp), %rdi
callq 0x357fe
movq 0x60(%rsp), %rax
addq $0x438, %rsp # imm = 0x438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
vmovsd 0x88(%rsp), %xmm0
movq 0x80(%rsp), %rdi
leaq 0x70(%rsp), %rbx
movq %rbx, %rsi
callq 0x8b74a
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x33aea2
movl $0x0, 0x6c(%rsp)
leaq 0x150(%rsp), %r15
leaq 0x70(%rsp), %rbp
xorl %ebx, %ebx
fldt 0x54(%rsp)
fldt 0x48(%rsp)
cmpl 0xbc(%r12), %ebx
jge 0x33a395
movq 0x18(%r14), %rcx
fldt 0x10c(%rsp)
fld %st(1)
fstpt 0x48(%rsp)
fmulp %st, %st(1)
fldt 0x100(%rsp)
fstpt 0x30(%rsp)
fxch %st(1)
fstpt 0x20(%rsp)
leaq 0x118(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
fldt 0x9c(%rsp)
fstpt 0x10(%rsp)
fstpt (%rsp)
callq 0x335306
testl %eax, %eax
jne 0x33a508
vmovsd 0x88(%rsp), %xmm0
movq 0x80(%rsp), %rdi
movq %rbp, %rsi
callq 0x8b74a
movl 0xc0(%r12), %eax
imull %ebx, %eax
notl %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x33aea2
movq %r14, %rdi
callq 0x33af24
fldt 0x54(%rsp)
fldt 0x48(%rsp)
testb %al, %al
jne 0x33a395
movl %ebx, 0x90(%rsp)
pushq $0x1
popq %rax
movl %eax, %ebx
leal -0x1(%rbx), %r13d
cmpl 0xc0(%r12), %r13d
jge 0x33a651
movq 0x18(%r14), %rcx
fxch %st(1)
fstpt 0x20(%rsp)
leaq 0x118(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
fldt 0x9c(%rsp)
fstpt 0x10(%rsp)
fld %st(0)
fstpt 0x48(%rsp)
fstpt (%rsp)
callq 0x3350d6
testl %eax, %eax
je 0x33a601
vcvtsi2sd %r13d, %xmm1, %xmm0
vucomisd 0xa0(%r12), %xmm0
jbe 0x33a5cf
movl %eax, 0xa8(%rsp)
fildl 0xa8(%rsp)
movl 0x1d8(%rsp), %eax
movl %eax, 0xac(%rsp)
fidivl 0xac(%rsp)
fldt 0xcc(%rsp)
fstpt 0x10(%rsp)
fstpt (%rsp)
callq 0xb110
fldt 0xd8(%rsp)
fmulp %st, %st(1)
fldt 0x48(%rsp)
faddp %st, %st(1)
jmp 0x33a5d3
fldt 0x48(%rsp)
fldt 0xe4(%rsp)
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
ja 0x33a641
movq %r14, %rdi
fstpt 0x48(%rsp)
callq 0x33af24
testb %al, %al
jne 0x33a649
fldt 0x54(%rsp)
fldt 0x48(%rsp)
incl %ebx
jmp 0x33a52c
vmovsd 0x88(%rsp), %xmm0
movq 0x80(%rsp), %rdi
movq %rbp, %rsi
callq 0x8b74a
movl 0xc0(%r12), %eax
imull 0x6c(%rsp), %eax
subl %ebx, %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x33aea2
fldt 0x54(%rsp)
fldt 0x48(%rsp)
jmp 0x33a651
fldt 0x54(%rsp)
fxch %st(1)
jmp 0x33a651
fldt 0x54(%rsp)
fldt 0x48(%rsp)
movl 0x90(%rsp), %ebx
decl 0x6c(%rsp)
incl %ebx
jmp 0x33a47d
jmp 0x33a69e
jmp 0x33a677
fstp %st(1)
fstp %st(0)
jmp 0x33a69e
movq %rax, %rbx
jmp 0x33a6ae
movq %rax, %rbx
jmp 0x33a6bb
movq %rax, %rbx
jmp 0x33a6c8
movq %rax, %rbx
jmp 0x33a6d5
movq %rax, %rbx
jmp 0x33a6df
jmp 0x33a69e
jmp 0x33a69e
jmp 0x33a69e
leaq 0x1e8(%rsp), %rdi
movq %rax, %rbx
callq 0x357fe
jmp 0x33a6ae
leaq 0x1e0(%rsp), %rdi
movq %rax, %rbx
callq 0x435d0
leaq 0x118(%rsp), %rdi
callq 0x393ac
leaq 0x150(%rsp), %rdi
callq 0x3355aa
leaq 0xc0(%rsp), %rdi
callq 0x8affa
leaq 0x78(%rsp), %rdi
callq 0x357fe
movq 0x60(%rsp), %rdi
callq 0xea60
movq %rbx, %rdi
callq 0xb3d0
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_101coeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, false>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, baryonyx::pnm_observer>::store_if_better(baryonyx::bit_array const&, double, long) | inline bool
is_better_solution(Float lhs, Float rhs) noexcept
{
if constexpr (std::is_same_v<Mode, minimize_tag>)
return lhs < rhs;
else
return lhs > rhs;
} | vucomisd 0x30(%rdi), %xmm0
jbe 0x33ae08
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x20, %rdi
movq %rdx, %rbx
vmovsd %xmm0, (%rsp)
callq 0x36a44
movq %r14, %rdi
callq 0x33ae82
vmovsd (%rsp), %xmm1
vmovsd %xmm0, 0x38(%r14)
movq %rbx, 0x48(%r14)
andl $0x0, 0x50(%r14)
vmovsd %xmm1, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::pnm_observer>::operator()(std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&, int, baryonyx::itm::quadratic_cost_type<double> const&, double) | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx.parameters;
auto norm_costs = normalize_costs<Float, Cost>(
m_ctx, original_costs, m_rng, variables);
const auto kappa_step = static_cast<Float>(p.kappa_step);
const auto kappa_max = static_cast<Float>(p.kappa_max);
const auto alpha = static_cast<Float>(p.alpha);
const auto theta = static_cast<Float>(p.theta);
const auto delta =
p.delta < 0
? compute_delta<Float, Cost>(m_ctx, norm_costs, theta, variables)
: static_cast<Float>(p.delta);
const auto pushing_k_factor = static_cast<Float>(p.pushing_k_factor);
const auto pushing_objective_amplifier =
static_cast<Float>(p.pushing_objective_amplifier);
const long int w_limit = static_cast<long int>(p.w);
Solver slv(
m_rng, length(constraints), variables, norm_costs, constraints);
compute_order compute(p.order, variables);
{
std::bernoulli_distribution choose_mutation(
m_ctx.parameters.init_policy_random);
bit_array empty_x;
switch (p.init_policy) {
case solver_parameters::init_policy_type::pessimistic_solve:
init_with_pre_solve<Cost, Mode>(
x, empty_x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::optimistic_solve:
init_with_pre_solve<Cost, Mode>(
empty_x, x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::bastert:
init_with_bastert<Cost, Mode>(x, original_costs, variables, 0);
break;
}
for (int i = 0, e = x.size(); i != e; ++i)
if (choose_mutation(m_rng))
x.invert(i);
}
bool start_push = false;
auto kappa = static_cast<Float>(p.kappa_min);
Observer obs("img", slv.m, slv.n, p.limit);
m_begin = std::chrono::steady_clock::now();
m_end = std::chrono::steady_clock::now();
compute.init(slv, x);
for (long int i = 0; i != p.limit; ++i) {
auto remaining = compute.run(slv, x, m_rng, kappa, delta, theta);
obs.make_observation(slv.ap, slv.P.get(), slv.pi.get());
if (remaining == 0) {
store_if_better(
x, original_costs.results(x, cost_constant), i);
best_remaining = remaining;
start_push = true;
break;
}
if (remaining < best_remaining) {
store_if_better(x, remaining, i);
best_remaining = remaining;
}
if (i > w_limit)
kappa += kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max) {
r.status = result_status::kappa_max_reached;
break;
}
if (is_timelimit_reached()) {
r.status = result_status::time_limit_reached;
break;
}
}
if (!start_push) {
r.status = result_status::limit_reached;
} else {
for (int push = 0; push < p.pushes_limit; ++push) {
auto remaining =
compute.push_and_run(slv,
x,
m_rng,
pushing_k_factor * kappa,
delta,
theta,
pushing_objective_amplifier);
if (remaining == 0)
store_if_better(x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - 1);
if (is_timelimit_reached())
break;
for (int iter = 0; iter < p.pushing_iteration_limit; ++iter) {
remaining =
compute.run(slv, x, m_rng, kappa, delta, theta);
if (remaining == 0) {
store_if_better(
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - iter - 1);
break;
}
if (iter > p.w)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
if (is_timelimit_reached())
break;
}
}
}
if (m_best.remaining_constraints == 0)
r.status = result_status::success;
if (!m_best.x.empty()) {
r.solutions.resize(1);
convert(m_best, r.solutions[0], variables);
}
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4a8, %rsp # imm = 0x4A8
vmovsd %xmm0, 0x40(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
leaq 0x18(%rsp), %rdi
movl %ecx, %esi
vzeroupper
callq 0x368ae
movq 0x10(%r14), %r12
movq 0x18(%r14), %rcx
leaq 0x80(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebx, %r8d
callq 0x6fb57
vmovsd 0x20(%r12), %xmm0
vmovsd 0x10(%r12), %xmm1
vmovsd %xmm0, 0x60(%rsp)
vmovsd 0x28(%r12), %xmm0
vmovsd %xmm1, 0x28(%rsp)
vmovsd %xmm0, 0x68(%rsp)
vmovsd 0x30(%r12), %xmm0
vmovsd %xmm0, 0x58(%rsp)
vmovsd 0x8(%r12), %xmm0
vmovsd %xmm0, 0x30(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm1, %xmm0
jbe 0x3d9f48
movq 0x10(%r14), %rdi
vmovsd 0x30(%rsp), %xmm0
leaq 0x80(%rsp), %rsi
movl %ebx, %edx
callq 0x6fc31
vmovsd %xmm0, 0x28(%rsp)
vcvttsd2si 0xa0(%r12), %rax
vmovsd 0x38(%r12), %xmm0
vmovsd 0x40(%r12), %xmm1
movq 0x18(%r14), %rsi
movq %rax, 0x48(%rsp)
movq 0x8(%r15), %rax
vmovsd %xmm0, 0x78(%rsp)
vmovsd %xmm1, 0x70(%rsp)
subq (%r15), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq 0xd8(%rsp), %rdi
leaq 0x80(%rsp), %r8
movl %eax, %edx
movl %ebx, %ecx
movq %r15, %r9
callq 0x3d37d2
movl 0xcc(%r12), %esi
leaq 0xa0(%rsp), %rdi
movl %ebx, %edx
callq 0x38cd8
movq 0x10(%r14), %rax
movl %ebx, 0x54(%rsp)
vmovsd 0x48(%rax), %xmm0
vmovsd %xmm0, (%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0x250(%rsp)
movl 0xd4(%r12), %eax
testl %eax, %eax
je 0x3da025
cmpl $0x1, %eax
je 0x3d9fff
cmpl $0x2, %eax
jne 0x3da036
movq 0x18(%r14), %rdx
leaq 0x250(%rsp), %rdi
leaq 0x18(%rsp), %rsi
jmp 0x3da010
movq 0x18(%r14), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x250(%rsp), %rsi
vmovsd 0x7a020(%rip), %xmm0 # 0x454038
movq %r13, %rcx
movq %r15, %r8
callq 0x6ddd4
jmp 0x3da036
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x6dd5f
leaq 0x18(%rsp), %r15
movq %r13, 0x38(%rsp)
xorl %ebx, %ebx
movl (%r15), %ebp
cmpl %ebx, %ebp
je 0x3da06b
movq 0x18(%r14), %rdi
callq 0x36ac3
vmovsd (%rsp), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x3da067
movq %r15, %rdi
movl %ebx, %esi
callq 0x3626e
incl %ebx
jmp 0x3da045
leaq 0x258(%rsp), %rdi
callq 0x357fe
vmovsd 0x18(%r12), %xmm0
movl 0x248(%rsp), %ecx
movl 0x24c(%rsp), %r8d
movq 0xb0(%r12), %r9
vmovsd %xmm0, (%rsp)
leaq 0x804d5(%rip), %rdx # 0x45a577
leaq 0x250(%rsp), %rdi
pushq $0x3
popq %rsi
callq 0x42b5a
callq 0xb5a0
movq %rax, (%r14)
callq 0xb5a0
movq %rax, 0x8(%r14)
leaq 0xa0(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x3d3bdc
vmovsd (%rsp), %xmm0
movl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x18(%rsp), %r13
xorl %r15d, %r15d
cmpq 0xb0(%r12), %r15
je 0x3da1cf
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xa0(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
movq %r13, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3d3c1e
movq 0x128(%rsp), %rdx
movq 0x150(%rsp), %rcx
movl %eax, %ebx
leaq 0x250(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x6c2be
testl %ebx, %ebx
je 0x3da274
cmpl %ebp, %ebx
jge 0x3da16f
movq %r14, %rdi
movq %r13, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x3db172
movl %ebx, %ebp
cmpq 0x48(%rsp), %r15
jle 0x3da1a4
vcvtsi2sd %ebx, %xmm3, %xmm0
vcvtsi2sdl 0x248(%rsp), %xmm3, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3da1a9
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3da1cf
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x3db1aa
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3da1cf
incq %r15
jmp 0x3da0ef
movq 0x8(%rsp), %rax
movl $0x5, 0xa0(%rax)
cmpl $0x0, 0x50(%r14)
jne 0x3da1f1
movq 0x8(%rsp), %rax
andl $0x0, 0xa0(%rax)
cmpq $0x0, 0x28(%r14)
je 0x3da21f
movq 0x8(%rsp), %rax
leaq 0x68(%rax), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x35292
movq (%rbx), %rsi
addq $0x20, %r14
movl 0x54(%rsp), %edx
movq %r14, %rdi
callq 0x35781
leaq 0x250(%rsp), %rdi
callq 0x42cbc
leaq 0xa0(%rsp), %rdi
callq 0x393ac
leaq 0xd8(%rsp), %rdi
callq 0x3d407e
leaq 0x80(%rsp), %rdi
callq 0x6d8d6
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rax
addq $0x4a8, %rsp # imm = 0x4A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq 0x6e096
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3db128
vmovsd (%rsp), %xmm0
leaq 0xd8(%rsp), %r15
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
movl $0x0, 0x14(%rsp)
cmpl 0xbc(%r12), %ebx
jge 0x3da1de
vmovsd %xmm0, (%rsp)
vmulsd 0x78(%rsp), %xmm0, %xmm0
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
vmovsd 0x70(%rsp), %xmm3
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x3d3e2a
testl %eax, %eax
jne 0x3da32a
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6e096
movl 0xc0(%r12), %eax
imull %ebx, %eax
notl %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3db128
movq %r14, %rdi
callq 0x3db1aa
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3da1de
movl %ebx, 0x48(%rsp)
pushq $0x1
popq %rax
movl %eax, %ebx
leal -0x1(%rbx), %r13d
cmpl 0xc0(%r12), %r13d
jge 0x3da42b
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3d3c1e
testl %eax, %eax
je 0x3da3ef
vcvtsi2sd %r13d, %xmm4, %xmm0
vucomisd 0xa0(%r12), %xmm0
jbe 0x3da3c5
vcvtsi2sd %eax, %xmm4, %xmm0
vcvtsi2sdl 0x248(%rsp), %xmm4, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3da3ca
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3da42b
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x3db1aa
testb %al, %al
jne 0x3da426
vmovsd (%rsp), %xmm0
incl %ebx
jmp 0x3da348
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6e096
movl 0xc0(%r12), %eax
imull 0x14(%rsp), %eax
subl %ebx, %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3db128
vmovsd (%rsp), %xmm0
jmp 0x3da42b
vmovsd (%rsp), %xmm0
movl 0x48(%rsp), %ebx
decl 0x14(%rsp)
incl %ebx
jmp 0x3da2b6
jmp 0x3da471
jmp 0x3da44a
jmp 0x3da471
movq %rax, %r14
jmp 0x3da481
movq %rax, %r14
jmp 0x3da48e
movq %rax, %r14
jmp 0x3da49b
movq %rax, %r14
jmp 0x3da4a8
movq %rax, %r14
jmp 0x3da4b2
jmp 0x3da471
jmp 0x3da471
jmp 0x3da471
leaq 0x258(%rsp), %rdi
movq %rax, %r14
callq 0x357fe
jmp 0x3da481
leaq 0x250(%rsp), %rdi
movq %rax, %r14
callq 0x42cbc
leaq 0xa0(%rsp), %rdi
callq 0x393ac
leaq 0xd8(%rsp), %rdi
callq 0x3d407e
leaq 0x80(%rsp), %rdi
callq 0x6d8d6
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rdi
callq 0xea60
movq %r14, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, true>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, double, double, double) | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
Float pi_change;
int selected = -2;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x38(%rsp)
leaq 0x50(%rsp), %rcx
leaq 0x48(%rsp), %r8
leaq 0x40(%rsp), %r9
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x7d708(%rip), %rdx # 0x45c344
vmovsd %xmm0, (%rcx)
vmovsd %xmm1, (%r8)
vmovsd %xmm2, (%r9)
pushq $0x14
popq %rsi
callq 0xefd10
leaq 0x10(%r12), %rax
movq %rax, 0x30(%rsp)
leaq 0x60(%r12), %rax
movq %rax, (%rsp)
leaq 0xf0(%r12), %rax
movq %rax, 0x18(%rsp)
leaq 0x80(%r12), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x38(%rsp), %r14
je 0x3dee3e
movl (%r14), %ebx
movq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl %eax, 0xc(%rsp)
movl %ebx, %edx
callq 0x3de66
vmovsd 0x40(%rsp), %xmm0
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0x3dee92
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
movq %r15, %rbp
callq 0x3deeb0
movq 0x68(%r12), %rcx
movslq %ebx, %r15
movl %eax, %r13d
movzbl (%rcx,%r15), %eax
pushq $-0x2
popq %r8
cmpq $0x4, %rax
ja 0x3dee09
leaq 0x8749f(%rip), %rcx # 0x466198
movslq %r13d, %rsi
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3dedaa
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3df502
jmp 0x3dee06
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %r15
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
callq 0x3df4ba
cmpl $-0x2, %eax
jne 0x3dee06
movq 0x70(%r12), %rax
movl (%rax,%r15), %ecx
movl 0x4(%rax,%r15), %r8d
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movl %r13d, %edx
callq 0x3defcc
jmp 0x3dee06
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3df4ba
cmpl $-0x2, %eax
jne 0x3dee06
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
movl %ebx, %esi
movl %r13d, %ecx
callq 0x3df2c2
movl %eax, %r8d
vmovsd 0x50(%rsp), %xmm0
vmovsd 0x48(%rsp), %xmm1
movq 0x28(%rsp), %rdx
movq %r12, %rdi
movq %rbp, %r15
movq %rbp, %rsi
movl %ebx, %ecx
movl %r13d, %r9d
callq 0x3df54a
movl 0xc(%rsp), %ecx
addq $0x4, %r14
orb %al, %cl
movl %ecx, %eax
jmp 0x3dec81
andb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
double baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, true>::local_compute_reduced_cost<baryonyx::bit_array>(int, baryonyx::bit_array const&) | Float local_compute_reduced_cost(int variable, const Xtype& x) noexcept
{
Float sum_a_pi_p = 0;
for (auto [ht, hte] = ap.column(variable); ht != hte; ++ht) {
auto a = std::abs(static_cast<Float>(A[ht->value]));
sum_a_pi_p += a * (pi[ht->row] + P[ht->value]);
}
return c(variable, x) - sum_a_pi_p;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0x10(%rdi), %rsi
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movl %ebx, %edx
callq 0x3dede
vmovddup 0x75763(%rip), %xmm1 # xmm1 = mem[0,0]
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq 0x50(%r14), %rdx
movq 0x58(%r14), %rsi
movq 0x78(%r14), %rdi
vxorpd %xmm0, %xmm0, %xmm0
cmpq %rax, %rcx
je 0x3e23a6
movslq (%rcx), %r8
movslq 0x4(%rcx), %r9
addq $0x8, %rcx
vcvtsi2sdl (%rsi,%r8,4), %xmm4, %xmm2
vmovsd (%rdi,%r9,8), %xmm3
vaddsd (%rdx,%r8,8), %xmm3, %xmm3
movq %rcx, 0x8(%rsp)
vandpd %xmm1, %xmm2, %xmm2
vfmadd231sd %xmm3, %xmm2, %xmm0 # xmm0 = (xmm2 * xmm3) + xmm0
jmp 0x3e2374
movq 0x168(%r14), %rax
movslq %ebx, %rcx
movq 0x8(%rax), %rax
vmovsd (%rax,%rcx,8), %xmm1
vsubsd %xmm0, %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, true>::push_and_compute_update_row<baryonyx::bit_array, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>>(baryonyx::bit_array&, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>, double, double, double, double) | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
Float obj_amp)
{
auto at_least_one_pi_changed{ false };
logger::log("push-update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
// Before sort and select variables, we apply the push method: for
// each reduces cost, we had the cost multiply with an objective
// amplifier.
for (int i = 0; i != r_size; ++i)
R[i].value +=
obj_amp * c((std::get<0>(it) + R[i].id)->column, x);
Float pi_change;
int selected;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
default:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, 0x48(%rsp)
leaq 0x60(%rsp), %rcx
leaq 0x58(%rsp), %r8
leaq 0x50(%rsp), %r9
movq %rdx, %r14
movq %rdi, %r12
vmovsd %xmm3, 0x40(%rsp)
movq %rsi, 0x30(%rsp)
leaq 0x78c7f(%rip), %rdx # 0x45c33f
vmovsd %xmm0, (%rcx)
vmovsd %xmm1, (%r8)
vmovsd %xmm2, (%r9)
pushq $0x19
popq %rsi
callq 0xefd10
leaq 0x10(%r12), %rax
leaq 0x60(%r12), %rcx
leaq 0xf0(%r12), %rdx
xorl %ebp, %ebp
movq %rax, 0x38(%rsp)
movq (%r14), %rax
movq %rcx, 0x8(%rsp)
leaq 0x80(%r12), %rcx
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x48(%rsp), %rcx
cmpq (%rcx), %rax
je 0x3e38fb
movl -0x4(%rax), %ebx
movq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movslq %ebx, %r15
movl %r15d, %edx
callq 0x3de66
vmovsd 0x50(%rsp), %xmm0
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
movq %r12, %rdi
callq 0x3dee92
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rcx
movq %r12, %rdi
callq 0x3deeb0
vmovsd 0x40(%rsp), %xmm1
movl %eax, %r13d
movq 0x60(%r12), %rdi
movq 0x168(%r12), %rax
movq 0x18(%rsp), %rcx
movl %r13d, %edx
shlq $0x4, %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x3e37ac
movslq 0x8(%rdi,%rsi), %r8
movq 0x8(%rax), %r9
movslq 0x4(%rcx,%r8,8), %r8
vmovsd (%r9,%r8,8), %xmm0
vfmadd213sd (%rdi,%rsi), %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + mem
vmovsd %xmm0, (%rdi,%rsi)
addq $0x10, %rsi
jmp 0x3e3782
movq 0x68(%r12), %rax
movslq %r13d, %rsi
movzbl (%rax,%r15), %eax
cmpq $0x3, %rax
ja 0x3e3897
leaq 0x829e2(%rip), %rcx # 0x4661ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3e383c
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %r15
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
callq 0x3df4ba
cmpl $-0x2, %eax
jne 0x3e38c3
movq 0x70(%r12), %rax
movl (%rax,%r15), %ecx
movl 0x4(%rax,%r15), %r8d
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl %r13d, %edx
callq 0x3defcc
jmp 0x3e38c3
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3df4ba
cmpl $-0x2, %eax
jne 0x3e38c3
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl %ebx, %esi
movl %r13d, %ecx
callq 0x3df2c2
jmp 0x3e38c3
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3df502
vmovsd 0x60(%rsp), %xmm0
vmovsd 0x58(%rsp), %xmm1
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
movl %ebx, %ecx
movl %eax, %r8d
movl %r13d, %r9d
callq 0x3df54a
orb %al, %bpl
movq (%r14), %rax
addq $-0x4, %rax
movq %rax, (%r14)
jmp 0x3e3709
andb $0x1, %bpl
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, true>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, double, double, double, double) | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
Float obj_amp)
{
auto at_least_one_pi_changed{ false };
logger::log("push-update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
// Before sort and select variables, we apply the push method: for
// each reduces cost, we had the cost multiply with an objective
// amplifier.
for (int i = 0; i != r_size; ++i)
R[i].value +=
obj_amp * c((std::get<0>(it) + R[i].id)->column, x);
Float pi_change;
int selected;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
default:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, 0x48(%rsp)
leaq 0x60(%rsp), %rcx
leaq 0x58(%rsp), %r8
leaq 0x50(%rsp), %r9
movq %rdx, %r14
movq %rdi, %r12
vmovsd %xmm3, 0x40(%rsp)
movq %rsi, 0x30(%rsp)
leaq 0x789f5(%rip), %rdx # 0x45c33f
vmovsd %xmm0, (%rcx)
vmovsd %xmm1, (%r8)
vmovsd %xmm2, (%r9)
pushq $0x19
popq %rsi
callq 0xefd10
leaq 0x60(%r12), %rcx
leaq 0x10(%r12), %rax
leaq 0xf0(%r12), %rdx
xorl %ebp, %ebp
movq %rcx, 0x8(%rsp)
leaq 0x80(%r12), %rcx
movq %rax, 0x38(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
cmpq 0x48(%rsp), %r14
je 0x3e3b79
movl (%r14), %ebx
movq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movslq %ebx, %r15
movl %r15d, %edx
callq 0x3de66
vmovsd 0x50(%rsp), %xmm0
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
movq %r12, %rdi
callq 0x3dee92
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rcx
movq %r12, %rdi
callq 0x3deeb0
vmovsd 0x40(%rsp), %xmm1
movl %eax, %r13d
movq 0x60(%r12), %rdi
movq 0x168(%r12), %rax
movq 0x18(%rsp), %rcx
movl %r13d, %edx
shlq $0x4, %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x3e3a30
movslq 0x8(%rdi,%rsi), %r8
movq 0x8(%rax), %r9
movslq 0x4(%rcx,%r8,8), %r8
vmovsd (%r9,%r8,8), %xmm0
vfmadd213sd (%rdi,%rsi), %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + mem
vmovsd %xmm0, (%rdi,%rsi)
addq $0x10, %rsi
jmp 0x3e3a06
movq 0x68(%r12), %rax
movslq %r13d, %rsi
movzbl (%rax,%r15), %eax
cmpq $0x3, %rax
ja 0x3e3b1b
leaq 0x8276e(%rip), %rcx # 0x4661bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3e3ac0
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %r15
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
callq 0x3df4ba
cmpl $-0x2, %eax
jne 0x3e3b47
movq 0x70(%r12), %rax
movl (%rax,%r15), %ecx
movl 0x4(%rax,%r15), %r8d
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl %r13d, %edx
callq 0x3defcc
jmp 0x3e3b47
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3df4ba
cmpl $-0x2, %eax
jne 0x3e3b47
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl %ebx, %esi
movl %r13d, %ecx
callq 0x3df2c2
jmp 0x3e3b47
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3df502
vmovsd 0x60(%rsp), %xmm0
vmovsd 0x58(%rsp), %xmm1
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
movl %ebx, %ecx
movl %eax, %r8d
movl %r13d, %r9d
callq 0x3df54a
orb %al, %bpl
addq $0x4, %r14
jmp 0x3e3990
andb $0x1, %bpl
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, true>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>, double, double, double, double) | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
Float obj_amp)
{
auto at_least_one_pi_changed{ false };
logger::log("push-update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
// Before sort and select variables, we apply the push method: for
// each reduces cost, we had the cost multiply with an objective
// amplifier.
for (int i = 0; i != r_size; ++i)
R[i].value +=
obj_amp * c((std::get<0>(it) + R[i].id)->column, x);
Float pi_change;
int selected;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
default:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, 0x48(%rsp)
leaq 0x60(%rsp), %rcx
leaq 0x58(%rsp), %r8
leaq 0x50(%rsp), %r9
movq %rdx, %r14
movq %rdi, %r12
vmovsd %xmm3, 0x40(%rsp)
movq %rsi, 0x30(%rsp)
leaq 0x78777(%rip), %rdx # 0x45c33f
vmovsd %xmm0, (%rcx)
vmovsd %xmm1, (%r8)
vmovsd %xmm2, (%r9)
pushq $0x19
popq %rsi
callq 0xefd10
leaq 0x60(%r12), %rcx
leaq 0x10(%r12), %rax
leaq 0xf0(%r12), %rdx
xorl %ebp, %ebp
movq %rcx, 0x8(%rsp)
leaq 0x80(%r12), %rcx
movq %rax, 0x38(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
cmpq 0x48(%rsp), %r14
je 0x3e3df7
movl (%r14), %ebx
movq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movslq %ebx, %r15
movl %r15d, %edx
callq 0x3de66
vmovsd 0x50(%rsp), %xmm0
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
movq %r12, %rdi
callq 0x3dee92
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rcx
movq %r12, %rdi
callq 0x3deeb0
vmovsd 0x40(%rsp), %xmm1
movl %eax, %r13d
movq 0x60(%r12), %rdi
movq 0x168(%r12), %rax
movq 0x18(%rsp), %rcx
movl %r13d, %edx
shlq $0x4, %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x3e3cae
movslq 0x8(%rdi,%rsi), %r8
movq 0x8(%rax), %r9
movslq 0x4(%rcx,%r8,8), %r8
vmovsd (%r9,%r8,8), %xmm0
vfmadd213sd (%rdi,%rsi), %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + mem
vmovsd %xmm0, (%rdi,%rsi)
addq $0x10, %rsi
jmp 0x3e3c84
movq 0x68(%r12), %rax
movslq %r13d, %rsi
movzbl (%rax,%r15), %eax
cmpq $0x3, %rax
ja 0x3e3d99
leaq 0x82500(%rip), %rcx # 0x4661cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3e3d3e
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %r15
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
callq 0x3df4ba
cmpl $-0x2, %eax
jne 0x3e3dc5
movq 0x70(%r12), %rax
movl (%rax,%r15), %ecx
movl 0x4(%rax,%r15), %r8d
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl %r13d, %edx
callq 0x3defcc
jmp 0x3e3dc5
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3df4ba
cmpl $-0x2, %eax
jne 0x3e3dc5
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl %ebx, %esi
movl %r13d, %ecx
callq 0x3df2c2
jmp 0x3e3dc5
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3def99
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3df502
vmovsd 0x60(%rsp), %xmm0
vmovsd 0x58(%rsp), %xmm1
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
movl %ebx, %ecx
movl %eax, %r8d
movl %r13d, %r9d
callq 0x3df54a
orb %al, %bpl
addq $0x8, %r14
jmp 0x3e3c0e
andb $0x1, %bpl
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, true>, double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, baryonyx::pnm_observer>::operator()(std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&, int, baryonyx::itm::default_cost_type<double> const&, double) | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx.parameters;
auto norm_costs = normalize_costs<Float, Cost>(
m_ctx, original_costs, m_rng, variables);
const auto kappa_step = static_cast<Float>(p.kappa_step);
const auto kappa_max = static_cast<Float>(p.kappa_max);
const auto alpha = static_cast<Float>(p.alpha);
const auto theta = static_cast<Float>(p.theta);
const auto delta =
p.delta < 0
? compute_delta<Float, Cost>(m_ctx, norm_costs, theta, variables)
: static_cast<Float>(p.delta);
const auto pushing_k_factor = static_cast<Float>(p.pushing_k_factor);
const auto pushing_objective_amplifier =
static_cast<Float>(p.pushing_objective_amplifier);
const long int w_limit = static_cast<long int>(p.w);
Solver slv(
m_rng, length(constraints), variables, norm_costs, constraints);
compute_order compute(p.order, variables);
{
std::bernoulli_distribution choose_mutation(
m_ctx.parameters.init_policy_random);
bit_array empty_x;
switch (p.init_policy) {
case solver_parameters::init_policy_type::pessimistic_solve:
init_with_pre_solve<Cost, Mode>(
x, empty_x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::optimistic_solve:
init_with_pre_solve<Cost, Mode>(
empty_x, x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::bastert:
init_with_bastert<Cost, Mode>(x, original_costs, variables, 0);
break;
}
for (int i = 0, e = x.size(); i != e; ++i)
if (choose_mutation(m_rng))
x.invert(i);
}
bool start_push = false;
auto kappa = static_cast<Float>(p.kappa_min);
Observer obs("img", slv.m, slv.n, p.limit);
m_begin = std::chrono::steady_clock::now();
m_end = std::chrono::steady_clock::now();
compute.init(slv, x);
for (long int i = 0; i != p.limit; ++i) {
auto remaining = compute.run(slv, x, m_rng, kappa, delta, theta);
obs.make_observation(slv.ap, slv.P.get(), slv.pi.get());
if (remaining == 0) {
store_if_better(
x, original_costs.results(x, cost_constant), i);
best_remaining = remaining;
start_push = true;
break;
}
if (remaining < best_remaining) {
store_if_better(x, remaining, i);
best_remaining = remaining;
}
if (i > w_limit)
kappa += kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max) {
r.status = result_status::kappa_max_reached;
break;
}
if (is_timelimit_reached()) {
r.status = result_status::time_limit_reached;
break;
}
}
if (!start_push) {
r.status = result_status::limit_reached;
} else {
for (int push = 0; push < p.pushes_limit; ++push) {
auto remaining =
compute.push_and_run(slv,
x,
m_rng,
pushing_k_factor * kappa,
delta,
theta,
pushing_objective_amplifier);
if (remaining == 0)
store_if_better(x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - 1);
if (is_timelimit_reached())
break;
for (int iter = 0; iter < p.pushing_iteration_limit; ++iter) {
remaining =
compute.run(slv, x, m_rng, kappa, delta, theta);
if (remaining == 0) {
store_if_better(
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - iter - 1);
break;
}
if (iter > p.w)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
if (is_timelimit_reached())
break;
}
}
}
if (m_best.remaining_constraints == 0)
r.status = result_status::success;
if (!m_best.x.empty()) {
r.solutions.resize(1);
convert(m_best, r.solutions[0], variables);
}
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp # imm = 0x498
vmovsd %xmm0, 0x40(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
leaq 0x18(%rsp), %rdi
movl %ecx, %esi
vzeroupper
callq 0x368ae
movq 0x10(%r14), %r12
movq 0x18(%r14), %rcx
leaq 0x70(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebx, %r8d
callq 0x64935
vmovsd 0x20(%r12), %xmm0
vmovsd 0x10(%r12), %xmm1
vmovsd %xmm0, 0x60(%rsp)
vmovsd 0x28(%r12), %xmm0
vmovsd %xmm1, 0x28(%rsp)
vmovsd %xmm0, 0x68(%rsp)
vmovsd 0x30(%r12), %xmm0
vmovsd %xmm0, 0x58(%rsp)
vmovsd 0x8(%r12), %xmm0
vmovsd %xmm0, 0x30(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm1, %xmm0
jbe 0x3e5458
movq 0x10(%r14), %rdi
vmovsd 0x30(%rsp), %xmm0
leaq 0x70(%rsp), %rsi
movl %ebx, %edx
callq 0x64a13
vmovsd %xmm0, 0x28(%rsp)
vcvttsd2si 0xa0(%r12), %rax
vmovsd 0x38(%r12), %xmm0
vmovsd 0x40(%r12), %xmm1
movq 0x18(%r14), %rsi
movq %rax, 0x48(%rsp)
movq 0x8(%r15), %rax
vmovsd %xmm0, 0x88(%rsp)
vmovsd %xmm1, 0x80(%rsp)
subq (%r15), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq 0xc8(%rsp), %rdi
leaq 0x70(%rsp), %r8
movl %eax, %edx
movl %ebx, %ecx
movq %r15, %r9
callq 0x3dcfc0
movl 0xcc(%r12), %esi
leaq 0x90(%rsp), %rdi
movl %ebx, %edx
callq 0x38cd8
movq 0x10(%r14), %rax
movl %ebx, 0x54(%rsp)
vmovsd 0x48(%rax), %xmm0
vmovsd %xmm0, (%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0x240(%rsp)
movl 0xd4(%r12), %eax
testl %eax, %eax
je 0x3e5538
cmpl $0x1, %eax
je 0x3e5512
cmpl $0x2, %eax
jne 0x3e5549
movq 0x18(%r14), %rdx
leaq 0x240(%rsp), %rdi
leaq 0x18(%rsp), %rsi
jmp 0x3e5523
movq 0x18(%r14), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x240(%rsp), %rsi
vmovsd 0x6eb0d(%rip), %xmm0 # 0x454038
movq %r13, %rcx
movq %r15, %r8
callq 0x78789
jmp 0x3e5549
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x7871d
leaq 0x18(%rsp), %r15
movq %r13, 0x38(%rsp)
xorl %ebx, %ebx
movl (%r15), %ebp
cmpl %ebx, %ebp
je 0x3e557e
movq 0x18(%r14), %rdi
callq 0x36ac3
vmovsd (%rsp), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x3e557a
movq %r15, %rdi
movl %ebx, %esi
callq 0x3626e
incl %ebx
jmp 0x3e5558
leaq 0x248(%rsp), %rdi
callq 0x357fe
vmovsd 0x18(%r12), %xmm0
movl 0x238(%rsp), %ecx
movl 0x23c(%rsp), %r8d
movq 0xb0(%r12), %r9
vmovsd %xmm0, (%rsp)
leaq 0x74fc2(%rip), %rdx # 0x45a577
leaq 0x240(%rsp), %rdi
pushq $0x3
popq %rsi
callq 0x42b5a
callq 0xb5a0
movq %rax, (%r14)
callq 0xb5a0
movq %rax, 0x8(%r14)
leaq 0x90(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x3dd454
vmovsd (%rsp), %xmm0
movl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x18(%rsp), %r13
xorl %r15d, %r15d
cmpq 0xb0(%r12), %r15
je 0x3e56e2
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0x90(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
movq %r13, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3dd496
movq 0x118(%rsp), %rdx
movq 0x140(%rsp), %rcx
movl %eax, %ebx
leaq 0x240(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x6c2be
testl %ebx, %ebx
je 0x3e5784
cmpl %ebp, %ebx
jge 0x3e5682
movq %r14, %rdi
movq %r13, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x3e6688
movl %ebx, %ebp
cmpq 0x48(%rsp), %r15
jle 0x3e56b7
vcvtsi2sd %ebx, %xmm3, %xmm0
vcvtsi2sdl 0x238(%rsp), %xmm3, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3e56bc
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3e56e2
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x3e66c0
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3e56e2
incq %r15
jmp 0x3e5602
movq 0x8(%rsp), %rax
movl $0x5, 0xa0(%rax)
cmpl $0x0, 0x50(%r14)
jne 0x3e5704
movq 0x8(%rsp), %rax
andl $0x0, 0xa0(%rax)
cmpq $0x0, 0x28(%r14)
je 0x3e5732
movq 0x8(%rsp), %rax
leaq 0x68(%rax), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x35292
movq (%rbx), %rsi
addq $0x20, %r14
movl 0x54(%rsp), %edx
movq %r14, %rdi
callq 0x4f485
leaq 0x240(%rsp), %rdi
callq 0x42cbc
leaq 0x90(%rsp), %rdi
callq 0x393ac
leaq 0xc8(%rsp), %rdi
callq 0x3dd8f6
leaq 0x78(%rsp), %rdi
callq 0x29066
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rax
addq $0x498, %rsp # imm = 0x498
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq 0x62f18
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3e663a
vmovsd (%rsp), %xmm0
leaq 0xc8(%rsp), %r15
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
movl $0x0, 0x14(%rsp)
cmpl 0xbc(%r12), %ebx
jge 0x3e56f1
vmovsd %xmm0, (%rsp)
vmulsd 0x88(%rsp), %xmm0, %xmm0
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
vmovsd 0x80(%rsp), %xmm3
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x3dd6a2
testl %eax, %eax
jne 0x3e5840
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x62f18
movl 0xc0(%r12), %eax
imull %ebx, %eax
notl %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3e663a
movq %r14, %rdi
callq 0x3e66c0
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3e56f1
movl %ebx, 0x48(%rsp)
pushq $0x1
popq %rax
movl %eax, %ebx
leal -0x1(%rbx), %r13d
cmpl 0xc0(%r12), %r13d
jge 0x3e5941
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3dd496
testl %eax, %eax
je 0x3e5905
vcvtsi2sd %r13d, %xmm4, %xmm0
vucomisd 0xa0(%r12), %xmm0
jbe 0x3e58db
vcvtsi2sd %eax, %xmm4, %xmm0
vcvtsi2sdl 0x238(%rsp), %xmm4, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3e58e0
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3e5941
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x3e66c0
testb %al, %al
jne 0x3e593c
vmovsd (%rsp), %xmm0
incl %ebx
jmp 0x3e585e
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x62f18
movl 0xc0(%r12), %eax
imull 0x14(%rsp), %eax
subl %ebx, %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3e663a
vmovsd (%rsp), %xmm0
jmp 0x3e5941
vmovsd (%rsp), %xmm0
movl 0x48(%rsp), %ebx
decl 0x14(%rsp)
incl %ebx
jmp 0x3e57c6
jmp 0x3e5987
jmp 0x3e5960
jmp 0x3e5987
movq %rax, %r14
jmp 0x3e5997
movq %rax, %r14
jmp 0x3e59a4
movq %rax, %r14
jmp 0x3e59b1
movq %rax, %r14
jmp 0x3e59bb
movq %rax, %r14
jmp 0x3e59c5
jmp 0x3e5987
jmp 0x3e5987
jmp 0x3e5987
leaq 0x248(%rsp), %rdi
movq %rax, %r14
callq 0x357fe
jmp 0x3e5997
leaq 0x240(%rsp), %rdi
movq %rax, %r14
callq 0x42cbc
leaq 0x90(%rsp), %rdi
callq 0x393ac
leaq 0xc8(%rsp), %rdi
callq 0x3dd8f6
leaq 0x78(%rsp), %rdi
callq 0x29066
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rdi
callq 0xea60
movq %r14, %rdi
callq 0xb3d0
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, true>, double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, baryonyx::file_observer>::operator()(std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&, int, baryonyx::itm::default_cost_type<double> const&, double) | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx.parameters;
auto norm_costs = normalize_costs<Float, Cost>(
m_ctx, original_costs, m_rng, variables);
const auto kappa_step = static_cast<Float>(p.kappa_step);
const auto kappa_max = static_cast<Float>(p.kappa_max);
const auto alpha = static_cast<Float>(p.alpha);
const auto theta = static_cast<Float>(p.theta);
const auto delta =
p.delta < 0
? compute_delta<Float, Cost>(m_ctx, norm_costs, theta, variables)
: static_cast<Float>(p.delta);
const auto pushing_k_factor = static_cast<Float>(p.pushing_k_factor);
const auto pushing_objective_amplifier =
static_cast<Float>(p.pushing_objective_amplifier);
const long int w_limit = static_cast<long int>(p.w);
Solver slv(
m_rng, length(constraints), variables, norm_costs, constraints);
compute_order compute(p.order, variables);
{
std::bernoulli_distribution choose_mutation(
m_ctx.parameters.init_policy_random);
bit_array empty_x;
switch (p.init_policy) {
case solver_parameters::init_policy_type::pessimistic_solve:
init_with_pre_solve<Cost, Mode>(
x, empty_x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::optimistic_solve:
init_with_pre_solve<Cost, Mode>(
empty_x, x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::bastert:
init_with_bastert<Cost, Mode>(x, original_costs, variables, 0);
break;
}
for (int i = 0, e = x.size(); i != e; ++i)
if (choose_mutation(m_rng))
x.invert(i);
}
bool start_push = false;
auto kappa = static_cast<Float>(p.kappa_min);
Observer obs("img", slv.m, slv.n, p.limit);
m_begin = std::chrono::steady_clock::now();
m_end = std::chrono::steady_clock::now();
compute.init(slv, x);
for (long int i = 0; i != p.limit; ++i) {
auto remaining = compute.run(slv, x, m_rng, kappa, delta, theta);
obs.make_observation(slv.ap, slv.P.get(), slv.pi.get());
if (remaining == 0) {
store_if_better(
x, original_costs.results(x, cost_constant), i);
best_remaining = remaining;
start_push = true;
break;
}
if (remaining < best_remaining) {
store_if_better(x, remaining, i);
best_remaining = remaining;
}
if (i > w_limit)
kappa += kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max) {
r.status = result_status::kappa_max_reached;
break;
}
if (is_timelimit_reached()) {
r.status = result_status::time_limit_reached;
break;
}
}
if (!start_push) {
r.status = result_status::limit_reached;
} else {
for (int push = 0; push < p.pushes_limit; ++push) {
auto remaining =
compute.push_and_run(slv,
x,
m_rng,
pushing_k_factor * kappa,
delta,
theta,
pushing_objective_amplifier);
if (remaining == 0)
store_if_better(x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - 1);
if (is_timelimit_reached())
break;
for (int iter = 0; iter < p.pushing_iteration_limit; ++iter) {
remaining =
compute.run(slv, x, m_rng, kappa, delta, theta);
if (remaining == 0) {
store_if_better(
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - iter - 1);
break;
}
if (iter > p.w)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
if (is_timelimit_reached())
break;
}
}
}
if (m_best.remaining_constraints == 0)
r.status = result_status::success;
if (!m_best.x.empty()) {
r.solutions.resize(1);
convert(m_best, r.solutions[0], variables);
}
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp # imm = 0x498
vmovsd %xmm0, 0x40(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
leaq 0x18(%rsp), %rdi
movl %ecx, %esi
vzeroupper
callq 0x368ae
movq 0x10(%r14), %r12
movq 0x18(%r14), %rcx
leaq 0x70(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebx, %r8d
callq 0x64935
vmovsd 0x20(%r12), %xmm0
vmovsd 0x10(%r12), %xmm1
vmovsd %xmm0, 0x60(%rsp)
vmovsd 0x28(%r12), %xmm0
vmovsd %xmm1, 0x28(%rsp)
vmovsd %xmm0, 0x68(%rsp)
vmovsd 0x30(%r12), %xmm0
vmovsd %xmm0, 0x58(%rsp)
vmovsd 0x8(%r12), %xmm0
vmovsd %xmm0, 0x30(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm1, %xmm0
jbe 0x3e5ac0
movq 0x10(%r14), %rdi
vmovsd 0x30(%rsp), %xmm0
leaq 0x70(%rsp), %rsi
movl %ebx, %edx
callq 0x64a13
vmovsd %xmm0, 0x28(%rsp)
vcvttsd2si 0xa0(%r12), %rax
vmovsd 0x38(%r12), %xmm0
vmovsd 0x40(%r12), %xmm1
movq 0x18(%r14), %rsi
movq %rax, 0x48(%rsp)
movq 0x8(%r15), %rax
vmovsd %xmm0, 0x88(%rsp)
vmovsd %xmm1, 0x80(%rsp)
subq (%r15), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq 0xc8(%rsp), %rdi
leaq 0x70(%rsp), %r8
movl %eax, %edx
movl %ebx, %ecx
movq %r15, %r9
callq 0x3dcfc0
movl 0xcc(%r12), %esi
leaq 0x90(%rsp), %rdi
movl %ebx, %edx
callq 0x38cd8
movq 0x10(%r14), %rax
movl %ebx, 0x54(%rsp)
vmovsd 0x48(%rax), %xmm0
vmovsd %xmm0, (%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0x240(%rsp)
movl 0xd4(%r12), %eax
testl %eax, %eax
je 0x3e5ba0
cmpl $0x1, %eax
je 0x3e5b7a
cmpl $0x2, %eax
jne 0x3e5bb1
movq 0x18(%r14), %rdx
leaq 0x240(%rsp), %rdi
leaq 0x18(%rsp), %rsi
jmp 0x3e5b8b
movq 0x18(%r14), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x240(%rsp), %rsi
vmovsd 0x6e4a5(%rip), %xmm0 # 0x454038
movq %r13, %rcx
movq %r15, %r8
callq 0x78789
jmp 0x3e5bb1
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x7871d
leaq 0x18(%rsp), %r15
movq %r13, 0x38(%rsp)
xorl %ebx, %ebx
movl (%r15), %ebp
cmpl %ebx, %ebp
je 0x3e5be6
movq 0x18(%r14), %rdi
callq 0x36ac3
vmovsd (%rsp), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x3e5be2
movq %r15, %rdi
movl %ebx, %esi
callq 0x3626e
incl %ebx
jmp 0x3e5bc0
leaq 0x248(%rsp), %rdi
callq 0x357fe
vmovsd 0x18(%r12), %xmm0
movl 0x238(%rsp), %ecx
movl 0x23c(%rsp), %r8d
movq 0xb0(%r12), %r9
vmovsd %xmm0, (%rsp)
leaq 0x7495a(%rip), %rdx # 0x45a577
leaq 0x240(%rsp), %rdi
pushq $0x3
popq %rsi
callq 0x4346e
callq 0xb5a0
movq %rax, (%r14)
callq 0xb5a0
movq %rax, 0x8(%r14)
leaq 0x90(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x3dd454
vmovsd (%rsp), %xmm0
movl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x18(%rsp), %r13
xorl %r15d, %r15d
cmpq 0xb0(%r12), %r15
je 0x3e5d4a
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0x90(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
movq %r13, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3dd496
movq 0x118(%rsp), %rdx
movq 0x140(%rsp), %rcx
movl %eax, %ebx
leaq 0x240(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x6c6c0
testl %ebx, %ebx
je 0x3e5dec
cmpl %ebp, %ebx
jge 0x3e5cea
movq %r14, %rdi
movq %r13, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x3e676e
movl %ebx, %ebp
cmpq 0x48(%rsp), %r15
jle 0x3e5d1f
vcvtsi2sd %ebx, %xmm3, %xmm0
vcvtsi2sdl 0x238(%rsp), %xmm3, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3e5d24
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3e5d4a
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x3e67a6
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3e5d4a
incq %r15
jmp 0x3e5c6a
movq 0x8(%rsp), %rax
movl $0x5, 0xa0(%rax)
cmpl $0x0, 0x50(%r14)
jne 0x3e5d6c
movq 0x8(%rsp), %rax
andl $0x0, 0xa0(%rax)
cmpq $0x0, 0x28(%r14)
je 0x3e5d9a
movq 0x8(%rsp), %rax
leaq 0x68(%rax), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x35292
movq (%rbx), %rsi
addq $0x20, %r14
movl 0x54(%rsp), %edx
movq %r14, %rdi
callq 0x4f485
leaq 0x240(%rsp), %rdi
callq 0x435d0
leaq 0x90(%rsp), %rdi
callq 0x393ac
leaq 0xc8(%rsp), %rdi
callq 0x3dd8f6
leaq 0x78(%rsp), %rdi
callq 0x29066
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rax
addq $0x498, %rsp # imm = 0x498
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq 0x62f18
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3e6720
vmovsd (%rsp), %xmm0
leaq 0xc8(%rsp), %r15
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
movl $0x0, 0x14(%rsp)
cmpl 0xbc(%r12), %ebx
jge 0x3e5d59
vmovsd %xmm0, (%rsp)
vmulsd 0x88(%rsp), %xmm0, %xmm0
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
vmovsd 0x80(%rsp), %xmm3
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x3dd6a2
testl %eax, %eax
jne 0x3e5ea8
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x62f18
movl 0xc0(%r12), %eax
imull %ebx, %eax
notl %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3e6720
movq %r14, %rdi
callq 0x3e67a6
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3e5d59
movl %ebx, 0x48(%rsp)
pushq $0x1
popq %rax
movl %eax, %ebx
leal -0x1(%rbx), %r13d
cmpl 0xc0(%r12), %r13d
jge 0x3e5fa9
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3dd496
testl %eax, %eax
je 0x3e5f6d
vcvtsi2sd %r13d, %xmm4, %xmm0
vucomisd 0xa0(%r12), %xmm0
jbe 0x3e5f43
vcvtsi2sd %eax, %xmm4, %xmm0
vcvtsi2sdl 0x238(%rsp), %xmm4, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3e5f48
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3e5fa9
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x3e67a6
testb %al, %al
jne 0x3e5fa4
vmovsd (%rsp), %xmm0
incl %ebx
jmp 0x3e5ec6
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x62f18
movl 0xc0(%r12), %eax
imull 0x14(%rsp), %eax
subl %ebx, %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3e6720
vmovsd (%rsp), %xmm0
jmp 0x3e5fa9
vmovsd (%rsp), %xmm0
movl 0x48(%rsp), %ebx
decl 0x14(%rsp)
incl %ebx
jmp 0x3e5e2e
jmp 0x3e5fef
jmp 0x3e5fc8
jmp 0x3e5fef
movq %rax, %r14
jmp 0x3e5fff
movq %rax, %r14
jmp 0x3e600c
movq %rax, %r14
jmp 0x3e6019
movq %rax, %r14
jmp 0x3e6023
movq %rax, %r14
jmp 0x3e602d
jmp 0x3e5fef
jmp 0x3e5fef
jmp 0x3e5fef
leaq 0x248(%rsp), %rdi
movq %rax, %r14
callq 0x357fe
jmp 0x3e5fff
leaq 0x240(%rsp), %rdi
movq %rax, %r14
callq 0x435d0
leaq 0x90(%rsp), %rdi
callq 0x393ac
leaq 0xc8(%rsp), %rdi
callq 0x3dd8f6
leaq 0x78(%rsp), %rdi
callq 0x29066
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rdi
callq 0xea60
movq %r14, %rdi
callq 0xb3d0
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, true>, double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, baryonyx::none_observer>::operator()(std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&, int, baryonyx::itm::default_cost_type<double> const&, double) | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx.parameters;
auto norm_costs = normalize_costs<Float, Cost>(
m_ctx, original_costs, m_rng, variables);
const auto kappa_step = static_cast<Float>(p.kappa_step);
const auto kappa_max = static_cast<Float>(p.kappa_max);
const auto alpha = static_cast<Float>(p.alpha);
const auto theta = static_cast<Float>(p.theta);
const auto delta =
p.delta < 0
? compute_delta<Float, Cost>(m_ctx, norm_costs, theta, variables)
: static_cast<Float>(p.delta);
const auto pushing_k_factor = static_cast<Float>(p.pushing_k_factor);
const auto pushing_objective_amplifier =
static_cast<Float>(p.pushing_objective_amplifier);
const long int w_limit = static_cast<long int>(p.w);
Solver slv(
m_rng, length(constraints), variables, norm_costs, constraints);
compute_order compute(p.order, variables);
{
std::bernoulli_distribution choose_mutation(
m_ctx.parameters.init_policy_random);
bit_array empty_x;
switch (p.init_policy) {
case solver_parameters::init_policy_type::pessimistic_solve:
init_with_pre_solve<Cost, Mode>(
x, empty_x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::optimistic_solve:
init_with_pre_solve<Cost, Mode>(
empty_x, x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::bastert:
init_with_bastert<Cost, Mode>(x, original_costs, variables, 0);
break;
}
for (int i = 0, e = x.size(); i != e; ++i)
if (choose_mutation(m_rng))
x.invert(i);
}
bool start_push = false;
auto kappa = static_cast<Float>(p.kappa_min);
Observer obs("img", slv.m, slv.n, p.limit);
m_begin = std::chrono::steady_clock::now();
m_end = std::chrono::steady_clock::now();
compute.init(slv, x);
for (long int i = 0; i != p.limit; ++i) {
auto remaining = compute.run(slv, x, m_rng, kappa, delta, theta);
obs.make_observation(slv.ap, slv.P.get(), slv.pi.get());
if (remaining == 0) {
store_if_better(
x, original_costs.results(x, cost_constant), i);
best_remaining = remaining;
start_push = true;
break;
}
if (remaining < best_remaining) {
store_if_better(x, remaining, i);
best_remaining = remaining;
}
if (i > w_limit)
kappa += kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max) {
r.status = result_status::kappa_max_reached;
break;
}
if (is_timelimit_reached()) {
r.status = result_status::time_limit_reached;
break;
}
}
if (!start_push) {
r.status = result_status::limit_reached;
} else {
for (int push = 0; push < p.pushes_limit; ++push) {
auto remaining =
compute.push_and_run(slv,
x,
m_rng,
pushing_k_factor * kappa,
delta,
theta,
pushing_objective_amplifier);
if (remaining == 0)
store_if_better(x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - 1);
if (is_timelimit_reached())
break;
for (int iter = 0; iter < p.pushing_iteration_limit; ++iter) {
remaining =
compute.run(slv, x, m_rng, kappa, delta, theta);
if (remaining == 0) {
store_if_better(
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - iter - 1);
break;
}
if (iter > p.w)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
if (is_timelimit_reached())
break;
}
}
}
if (m_best.remaining_constraints == 0)
r.status = result_status::success;
if (!m_best.x.empty()) {
r.solutions.resize(1);
convert(m_best, r.solutions[0], variables);
}
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
vmovsd %xmm0, 0x40(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
leaq 0x18(%rsp), %rdi
movl %ecx, %esi
vzeroupper
callq 0x368ae
movq 0x10(%r14), %r12
movq 0x18(%r14), %rcx
leaq 0x88(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebx, %r8d
callq 0x64935
vmovsd 0x20(%r12), %xmm0
vmovsd 0x10(%r12), %xmm1
vmovsd %xmm0, 0x60(%rsp)
vmovsd 0x28(%r12), %xmm0
vmovsd %xmm1, 0x28(%rsp)
vmovsd %xmm0, 0x68(%rsp)
vmovsd 0x30(%r12), %xmm0
vmovsd %xmm0, 0x58(%rsp)
vmovsd 0x8(%r12), %xmm0
vmovsd %xmm0, 0x30(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm1, %xmm0
jbe 0x3e612e
movq 0x10(%r14), %rdi
vmovsd 0x30(%rsp), %xmm0
leaq 0x88(%rsp), %rsi
movl %ebx, %edx
callq 0x64a13
vmovsd %xmm0, 0x28(%rsp)
vcvttsd2si 0xa0(%r12), %rax
vmovsd 0x38(%r12), %xmm0
vmovsd 0x40(%r12), %xmm1
movq 0x18(%r14), %rsi
movq %rax, 0x48(%rsp)
movq 0x8(%r15), %rax
vmovsd %xmm0, 0xa0(%rsp)
vmovsd %xmm1, 0x98(%rsp)
subq (%r15), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq 0xe0(%rsp), %rdi
leaq 0x88(%rsp), %r8
movl %eax, %edx
movl %ebx, %ecx
movq %r15, %r9
callq 0x3dcfc0
movl 0xcc(%r12), %esi
leaq 0xa8(%rsp), %rdi
movl %ebx, %edx
callq 0x38cd8
movq 0x10(%r14), %rax
movl %ebx, 0x54(%rsp)
vmovsd 0x48(%rax), %xmm0
vmovsd %xmm0, (%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0x70(%rsp)
movl 0xd4(%r12), %eax
testl %eax, %eax
je 0x3e6208
cmpl $0x1, %eax
je 0x3e61e5
cmpl $0x2, %eax
jne 0x3e6219
movq 0x18(%r14), %rdx
leaq 0x70(%rsp), %rdi
leaq 0x18(%rsp), %rsi
jmp 0x3e61f3
movq 0x18(%r14), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
vmovsd 0x6de3d(%rip), %xmm0 # 0x454038
movq %r13, %rcx
movq %r15, %r8
callq 0x78789
jmp 0x3e6219
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x7871d
leaq 0x18(%rsp), %r15
movq %r13, 0x38(%rsp)
xorl %ebx, %ebx
movl (%r15), %ebp
cmpl %ebx, %ebp
je 0x3e624e
movq 0x18(%r14), %rdi
callq 0x36ac3
vmovsd (%rsp), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x3e624a
movq %r15, %rdi
movl %ebx, %esi
callq 0x3626e
incl %ebx
jmp 0x3e6228
leaq 0x78(%rsp), %rdi
callq 0x357fe
vmovsd 0x18(%r12), %xmm0
vmovsd %xmm0, (%rsp)
callq 0xb5a0
movq %rax, (%r14)
callq 0xb5a0
movq %rax, 0x8(%r14)
leaq 0xa8(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x3dd454
vmovsd (%rsp), %xmm0
movl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x18(%rsp), %rbx
xorl %r15d, %r15d
cmpq 0xb0(%r12), %r15
je 0x3e6361
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xa8(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
movq %rbx, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3dd496
movl %eax, %r13d
testl %eax, %eax
je 0x3e63f9
cmpl %ebp, %r13d
jge 0x3e6300
movq %r14, %rdi
movq %rbx, %rsi
movl %r13d, %edx
movq %r15, %rcx
callq 0x3e6854
movl %r13d, %ebp
cmpq 0x48(%rsp), %r15
jle 0x3e6336
vcvtsi2sd %r13d, %xmm3, %xmm0
vcvtsi2sdl 0x250(%rsp), %xmm3, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3e633b
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3e6361
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x3e688c
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3e6361
incq %r15
jmp 0x3e62a1
movq 0x8(%rsp), %rax
movl $0x5, 0xa0(%rax)
cmpl $0x0, 0x50(%r14)
jne 0x3e6383
movq 0x8(%rsp), %rax
andl $0x0, 0xa0(%rax)
cmpq $0x0, 0x28(%r14)
je 0x3e63b1
movq 0x8(%rsp), %rax
leaq 0x68(%rax), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x35292
movq (%rbx), %rsi
addq $0x20, %r14
movl 0x54(%rsp), %edx
movq %r14, %rdi
callq 0x4f485
leaq 0xa8(%rsp), %rdi
callq 0x393ac
leaq 0xe0(%rsp), %rdi
callq 0x3dd8f6
leaq 0x90(%rsp), %rdi
callq 0x29066
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rax
addq $0x258, %rsp # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq 0x62f18
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3e6806
vmovsd (%rsp), %xmm0
leaq 0xe0(%rsp), %r15
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
movl $0x0, 0x14(%rsp)
cmpl 0xbc(%r12), %ebx
jge 0x3e6370
vmovsd %xmm0, (%rsp)
vmulsd 0xa0(%rsp), %xmm0, %xmm0
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
vmovsd 0x98(%rsp), %xmm3
leaq 0xa8(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x3dd6a2
testl %eax, %eax
jne 0x3e64b5
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x62f18
movl 0xc0(%r12), %eax
imull %ebx, %eax
notl %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3e6806
movq %r14, %rdi
callq 0x3e688c
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3e6370
movl %ebx, 0x48(%rsp)
pushq $0x1
popq %rax
movl %eax, %ebx
leal -0x1(%rbx), %r13d
cmpl 0xc0(%r12), %r13d
jge 0x3e65b6
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xa8(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3dd496
testl %eax, %eax
je 0x3e657a
vcvtsi2sd %r13d, %xmm4, %xmm0
vucomisd 0xa0(%r12), %xmm0
jbe 0x3e6550
vcvtsi2sd %eax, %xmm4, %xmm0
vcvtsi2sdl 0x250(%rsp), %xmm4, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3e6555
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3e65b6
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x3e688c
testb %al, %al
jne 0x3e65b1
vmovsd (%rsp), %xmm0
incl %ebx
jmp 0x3e64d3
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x62f18
movl 0xc0(%r12), %eax
imull 0x14(%rsp), %eax
subl %ebx, %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3e6806
vmovsd (%rsp), %xmm0
jmp 0x3e65b6
vmovsd (%rsp), %xmm0
movl 0x48(%rsp), %ebx
decl 0x14(%rsp)
incl %ebx
jmp 0x3e643b
jmp 0x3e65f4
jmp 0x3e65d0
jmp 0x3e65f4
movq %rax, %r14
jmp 0x3e6604
movq %rax, %r14
jmp 0x3e6611
movq %rax, %r14
jmp 0x3e661e
movq %rax, %r14
jmp 0x3e6628
jmp 0x3e65f4
jmp 0x3e65f4
jmp 0x3e65f4
leaq 0x78(%rsp), %rdi
movq %rax, %r14
callq 0x357fe
jmp 0x3e65f7
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0x393ac
leaq 0xe0(%rsp), %rdi
callq 0x3dd8f6
leaq 0x90(%rsp), %rdi
callq 0x29066
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rdi
callq 0xea60
movq %r14, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, true>, double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, baryonyx::pnm_observer>::is_timelimit_reached() | bool is_timelimit_reached()
{
m_end = std::chrono::steady_clock::now();
return is_time_limit(m_ctx.parameters.time_limit, m_begin, m_end);
} | pushq %rbx
movq %rdi, %rbx
callq 0xb5a0
movq %rax, 0x8(%rbx)
vxorpd %xmm2, %xmm2, %xmm2
movq 0x10(%rbx), %rcx
subq (%rbx), %rax
vmovsd (%rcx), %xmm0
vcvtsi2sd %rax, %xmm1, %xmm1
vdivsd 0x73397(%rip), %xmm1, %xmm1 # 0x459a80
vcmpnlepd %xmm2, %xmm0, %k1
vcmpltpd %xmm1, %xmm0, %k0 {%k1}
kmovd %k0, %eax
andb $0x1, %al
popq %rbx
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
int baryonyx::itm::compute_order::infeasibility_local_compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, false> const, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<double>, false> const&, baryonyx::bit_array const&) | int infeasibility_local_compute_violated_constraints(Solver& solver,
const Xtype& x)
{
m_order.clear();
for (int k = 0, e = solver.m; k != e; ++k) {
sparse_matrix<int>::const_row_iterator it, et;
std::tie(it, et) = solver.ap.row(k);
int v = 0;
for (; it != et; ++it)
v += solver.factor(it->value) * x[it->column];
if (solver.bound_min(k) > v)
m_order.push_back(std::make_pair(k, solver.bound_min(k) - v));
else if (solver.bound_max(k) < v)
m_order.push_back(std::make_pair(k, v - solver.bound_max(k)));
}
return length(m_order);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x18(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
cmpq %rax, 0x20(%rdi)
je 0x3e7c46
movq %rax, 0x20(%rdi)
leaq 0x18(%rdi), %rax
leaq 0x10(%r15), %rcx
xorl %r12d, %r12d
movq %rdi, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movl 0x170(%r15), %eax
movq %rcx, 0x18(%rsp)
movq %rax, 0x28(%rsp)
cmpq 0x28(%rsp), %r12
je 0x3e7d0b
movq 0x18(%rsp), %rsi
movq %rsp, %rdi
movl %r12d, %edx
movq %r12, 0x30(%rsp)
callq 0x3c868
movq (%rsp), %r13
movq 0x8(%rsp), %r12
xorl %ebx, %ebx
cmpq %r13, %r12
je 0x3e7cbf
movslq (%r12), %rax
movq 0x58(%r15), %rcx
movl 0x4(%r12), %esi
movq %r14, %rdi
movl (%rcx,%rax,4), %ebp
callq 0x3664a
imull %ebp, %eax
addq $0x8, %r12
addl %eax, %ebx
jmp 0x3e7c97
movq 0x30(%rsp), %r12
movq 0x70(%r15), %rcx
imulq $0xc, %r12, %rdx
movl (%rcx,%rdx), %eax
subl %ebx, %eax
jle 0x3e7ce0
shlq $0x20, %rax
orq %r12, %rax
movq %rax, (%rsp)
jmp 0x3e7cf1
subl 0x4(%rcx,%rdx), %ebx
jle 0x3e7cfe
shlq $0x20, %rbx
orq %r12, %rbx
movq %rbx, (%rsp)
movq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x3c8c2
movq 0x20(%rsp), %rdi
incq %r12
jmp 0x3e7c6c
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
shrq $0x3, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
baryonyx::result baryonyx::itm::solve_problem<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>>(baryonyx::context const&, baryonyx::problem const&) | inline result
solve_problem(const context& ctx, const problem& pb)
{
if (ctx.start)
ctx.start(ctx.parameters);
result ret;
auto variables = length(pb.vars.values);
auto constraints{ make_merged_constraints(ctx, pb) };
if (!constraints.empty() && !pb.vars.values.empty()) {
random_engine rng(init_random_generator_seed(ctx));
auto cost = Cost(pb.objective, variables);
auto cost_constant = pb.objective.value;
switch (ctx.parameters.observer) {
case solver_parameters::observer_type::pnm: {
using obs = pnm_observer;
solver_functor<Solver, Float, Mode, Cost, obs> slv(ctx, rng);
ret = slv(constraints, variables, cost, cost_constant);
} break;
case solver_parameters::observer_type::file: {
using obs = file_observer;
solver_functor<Solver, Float, Mode, Cost, obs> slv(ctx, rng);
ret = slv(constraints, variables, cost, cost_constant);
} break;
default: {
using obs = none_observer;
solver_functor<Solver, Float, Mode, Cost, obs> slv(ctx, rng);
ret = slv(constraints, variables, cost, cost_constant);
break;
}
}
} else {
ret.status = result_status::success;
ret.solutions.resize(1);
ret.solutions.back().value = pb.objective.value;
}
ret.strings = pb.strings;
ret.variable_name = std::move(pb.vars.names);
ret.affected_vars = std::move(pb.affected_vars);
ret.variables = variables;
ret.constraints = length(constraints);
if (ctx.finish)
ctx.finish(ret);
return ret;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x140, %rsp # imm = 0x140
cmpq $0x0, 0x128(%rsi)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
je 0x3ef39c
leaq 0x118(%r14), %rdi
movq %r14, %rsi
callq 0x3527e
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, 0x58(%rbx)
vmovups %zmm0, 0x40(%rbx)
vmovups %zmm0, (%rbx)
movq $0x7fffffff, 0x98(%rbx) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rbx)
movq 0xb0(%r15), %rax
subq 0xa8(%r15), %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
movq %rax, %r12
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
vzeroupper
callq 0x450078
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x3ef4c5
movq 0xa8(%r15), %rax
cmpq 0xb0(%r15), %rax
je 0x3ef4c5
movq %r14, %rdi
callq 0x353ba
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
xorl %edx, %edx
leaq 0x10(%r15), %rsi
divq %rcx
cmpq $0x1, %rdx
adcq $0x0, %rdx
movq %rdx, (%rsp)
leaq 0x20(%rsp), %rdi
movl %r12d, %edx
callq 0x6d526
vmovsd 0x40(%r15), %xmm0
movl 0xe4(%r14), %eax
vxorps %xmm1, %xmm1, %xmm1
leaq 0x40(%rsp), %rsi
cmpl $0x1, %eax
je 0x3ef4ec
cmpl $0x2, %eax
jne 0x3ef53b
movabsq $0x7ff0000000000000, %r9 # imm = 0x7FF0000000000000
vmovaps %xmm1, (%rsi)
movq %r14, 0x10(%rsi)
movq %rsp, %rax
movq %rax, 0x18(%rsi)
vmovaps %xmm1, 0x20(%rsi)
movq %r9, 0x30(%rsi)
andq $0x0, 0x48(%rsi)
vmovups %xmm1, 0x38(%rsi)
movl $0x7fffffff, 0x50(%rsi) # imm = 0x7FFFFFFF
leaq 0x98(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %r8
movl %r12d, %ecx
callq 0x3f7820
jmp 0x3ef588
andl $0x0, 0xa0(%rbx)
leaq 0x68(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x35292
vmovsd 0x40(%r15), %xmm0
movq 0x70(%rbx), %rax
vmovsd %xmm0, -0x8(%rax)
jmp 0x3ef5b7
movabsq $0x7ff0000000000000, %r9 # imm = 0x7FF0000000000000
vmovaps %xmm1, (%rsi)
movq %r14, 0x10(%rsi)
movq %rsp, %rax
movq %rax, 0x18(%rsi)
vmovaps %xmm1, 0x20(%rsi)
movq %r9, 0x30(%rsi)
andq $0x0, 0x48(%rsi)
vmovups %xmm1, 0x38(%rsi)
movl $0x7fffffff, 0x50(%rsi) # imm = 0x7FFFFFFF
leaq 0x98(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %r8
movl %r12d, %ecx
callq 0x3f71b6
jmp 0x3ef588
movabsq $0x7ff0000000000000, %r9 # imm = 0x7FF0000000000000
vmovaps %xmm1, (%rsi)
movq %r14, 0x10(%rsi)
movq %rsp, %rax
movq %rax, 0x18(%rsi)
vmovaps %xmm1, 0x20(%rsi)
movq %r9, 0x30(%rsi)
andq $0x0, 0x48(%rsi)
vmovups %xmm1, 0x38(%rsi)
movl $0x7fffffff, 0x50(%rsi) # imm = 0x7FFFFFFF
leaq 0x98(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %r8
movl %r12d, %ecx
callq 0x3f7e8a
leaq 0x98(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x41d9e
movq %r13, %rdi
callq 0xea60
leaq 0x68(%rsp), %rdi
callq 0x357fe
leaq 0x20(%rsp), %rdi
callq 0x6d8d6
leaq 0x90(%r15), %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31d28
leaq 0x50(%rbx), %rdi
movq %r13, %rsi
callq 0x352ec
addq $0xc0, %r15
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x352c2
movq 0x10(%rsp), %rax
movl %r12d, 0x90(%rbx)
subq 0x8(%rsp), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
movl %eax, 0x94(%rbx)
cmpq $0x0, 0x168(%r14)
je 0x3ef623
addq $0x158, %r14 # imm = 0x158
movq %r14, %rdi
movq %rbx, %rsi
callq 0x357ea
leaq 0x8(%rsp), %rdi
callq 0x35858
movq %rbx, %rax
addq $0x140, %rsp # imm = 0x140
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3ef645
jmp 0x3ef645
leaq 0x68(%rsp), %rdi
movq %rax, %r14
callq 0x357fe
leaq 0x20(%rsp), %rdi
callq 0x6d8d6
jmp 0x3ef668
jmp 0x3ef665
movq %rax, %r14
jmp 0x3ef672
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x35858
movq %rbx, %rdi
callq 0xea60
movq %r14, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::result baryonyx::itm::optimize_problem<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>>(baryonyx::context const&, baryonyx::problem const&) | inline result
optimize_problem(const context& ctx, const problem& pb)
{
result r;
if (ctx.start)
ctx.start(ctx.parameters);
auto constraints{ make_merged_constraints(ctx, pb) };
if (constraints.empty() || pb.vars.values.empty()) {
r.status = result_status::success;
r.solutions.resize(1);
r.solutions.back().value = pb.objective.value;
r.strings = pb.strings;
r.affected_vars = pb.affected_vars;
r.variable_name = pb.vars.names;
return r;
}
random_engine rng(init_random_generator_seed(ctx));
auto variables = length(pb.vars.values);
auto cost = Cost(pb.objective, variables);
auto cost_constant = pb.objective.value;
const auto thread = get_thread_number(ctx);
std::vector<optimize_functor<Solver, Float, Mode, Cost>> functors;
std::vector<std::thread> pool(thread);
best_solution_recorder<Cost, Float, Mode> best_recorder(
rng,
thread,
cost,
cost_constant,
variables,
constraints,
ctx.parameters.init_population_size);
auto seeds = generate_seed(rng, thread);
std::atomic_bool stop_task;
stop_task.store(false);
for (unsigned i = 0u; i != thread; ++i)
functors.emplace_back(ctx, i, seeds[i]);
for (unsigned i = 0u; i != thread; ++i)
pool[i] = std::thread(std::ref(functors[i]),
std::ref(stop_task),
std::ref(best_recorder),
std::cref(constraints),
variables,
std::cref(cost),
cost_constant);
const auto start = std::chrono::steady_clock::now();
auto end = start;
do {
std::this_thread::sleep_for(std::chrono::seconds{ 1L });
if (ctx.update) {
auto call_number = 0L;
for (auto i = 0u; i != thread; ++i)
call_number += functors[i].m_call_number;
int constraints_remaining;
long int loop;
double value;
double duration;
best_recorder.get_best(
constraints_remaining, value, duration, loop);
ctx.update(
constraints_remaining, value, loop, duration, call_number);
}
end = std::chrono::steady_clock::now();
} while (!is_time_limit(ctx.parameters.time_limit, start, end));
stop_task.store(true);
for (auto& t : pool)
t.join();
r.strings = pb.strings;
r.affected_vars = pb.affected_vars;
r.variable_name = pb.vars.names;
r.variables = variables;
r.constraints = length(constraints);
const auto& first = best_recorder.get_best(0);
if (!first.is_solution())
r.status = result_status::time_limit_reached;
else
r.status = result_status::success;
r.duration = first.duration;
r.loop = first.loop;
r.remaining_constraints = first.remaining_constraints;
switch (ctx.parameters.storage) {
case solver_parameters::storage_type::one: {
r.solutions.resize(1);
convert(first, r.solutions[0], variables);
} break;
case solver_parameters::storage_type::bound: {
r.solutions.resize(2);
convert(first, r.solutions[0], variables);
convert(best_recorder.get_worst(), r.solutions[1], variables);
} break;
case solver_parameters::storage_type::five: {
r.solutions.resize(5);
for (int i = 0; i != 5; ++i)
convert(best_recorder.get_best(i), r.solutions[i], variables);
} break;
}
best_recorder.show_population(ctx);
if (ctx.finish)
ctx.finish(r);
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
vxorpd %xmm0, %xmm0, %xmm0
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
cmpq $0x0, 0x128(%rsi)
je 0x3ef6e8
leaq 0x118(%r15), %rdi
movq %r15, %rsi
vzeroupper
callq 0x3527e
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
vzeroupper
callq 0x450078
movq 0x48(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x3ef847
movq 0xa8(%r13), %rax
cmpq 0xb0(%r13), %rax
je 0x3ef847
movq %r15, %rdi
callq 0x353ba
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rcx
cmpq $0x1, %rdx
adcq $0x0, %rdx
movq %rdx, 0x40(%rsp)
movq 0xb0(%r13), %rax
subq 0xa8(%r13), %rax
pushq $0xc
popq %rcx
cqto
leaq 0x10(%r13), %rsi
idivq %rcx
movl %eax, 0x4(%rsp)
leaq 0xb8(%rsp), %rdi
movl %eax, %edx
movq %r12, 0x10(%rsp)
callq 0x6d526
vmovsd 0x40(%r13), %xmm0
vmovsd %xmm0, 0x38(%rsp)
movq %r15, %rdi
callq 0x35447
andq $0x0, 0x70(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movl %eax, %ebp
vmovapd %xmm0, 0x60(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0xd8(%rsp), %rdx
movq %rbp, %rsi
callq 0x35462
vmovsd 0x38(%rsp), %xmm0
movl 0xc4(%r15), %eax
movl 0x4(%rsp), %r8d
subq $0x8, %rsp
movl %ebp, %edx
leaq 0xe0(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0xc0(%rsp), %rcx
leaq 0x50(%rsp), %r9
pushq %rax
callq 0x8177c
popq %rax
popq %rcx
leaq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl %ebp, %edx
callq 0x3551c
xorl %eax, %eax
movb %al, 0x3(%rsp)
xorl %ecx, %ecx
leaq 0x60(%rsp), %rbx
leaq 0x8(%rsp), %r14
xchgb %cl, 0x3(%rsp)
leaq 0x90(%r13), %rcx
movq %rcx, 0x88(%rsp)
movl %eax, 0x8(%rsp)
cmpl %ebp, %eax
je 0x3ef8a2
movl %eax, %ecx
shlq $0x3, %rcx
addq 0x30(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3f8736
movl 0x8(%rsp), %eax
incl %eax
jmp 0x3ef81e
andl $0x0, 0xa0(%r12)
leaq 0x68(%r12), %rdi
pushq $0x1
popq %rsi
callq 0x35292
vmovsd 0x40(%r13), %xmm0
movq 0x70(%r12), %rax
vmovsd %xmm0, -0x8(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x31d28
leaq 0xc0(%r13), %rsi
leaq 0x20(%r12), %rdi
callq 0x352c2
addq $0x90, %r13
leaq 0x50(%r12), %rdi
movq %r13, %rsi
callq 0x352ec
jmp 0x3efc3d
movq %r13, 0x80(%rsp)
movq %r15, %r13
leaq 0x8(%rsp), %r15
leaq 0x98(%rsp), %r14
leaq 0x4(%rsp), %rbx
xorl %r12d, %r12d
cmpq %rbp, %r12
je 0x3ef966
imulq $0xc0, %r12, %rax
addq 0x60(%rsp), %rax
leaq 0x3(%rsp), %r10
leaq 0xd8(%rsp), %r11
movq %r10, 0x20(%rsp)
leaq 0x48(%rsp), %r10
movq %r11, 0x18(%rsp)
movq %r10, 0x98(%rsp)
movq %rax, 0x28(%rsp)
leaq 0xb8(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0x20(%rsp), %rdx
leaq 0x38(%rsp), %rax
movq %r15, %rdi
leaq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rcx
movq %r14, %r8
movq %rbx, %r9
pushq %rax
leaq 0x98(%rsp), %rax
pushq %rax
callq 0x3f8782
popq %rax
popq %rcx
leaq (,%r12,8), %rdi
addq 0xa0(%rsp), %rdi
movq %r15, %rsi
callq 0x356d6
movq %r15, %rdi
callq 0x356f0
incq %r12
jmp 0x3ef8c2
callq 0xb5a0
imulq $0xc0, %rbp, %r15
leaq 0x138(%r13), %r12
leaq 0x8(%rsp), %rbp
movq %rax, %rbx
movq $0x1, 0x8(%rsp)
movq %rbp, %rdi
callq 0x356fd
cmpq $0x0, 0x148(%r13)
je 0x3ef9fb
movq 0x60(%rsp), %rax
xorl %ecx, %ecx
xorl %r14d, %r14d
cmpq %rcx, %r15
je 0x3ef9bc
addq 0xb0(%rax,%rcx), %r14
addq $0xc0, %rcx
jmp 0x3ef9a6
leaq 0xe0(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rbp, %r8
callq 0x88d36
vmovsd 0x28(%rsp), %xmm0
vmovsd 0x20(%rsp), %xmm1
movq 0x8(%rsp), %rdx
movl 0x18(%rsp), %esi
movq %r12, %rdi
movq %r14, %rcx
callq 0x35736
callq 0xb5a0
vmovsd (%r13), %xmm0
subq %rbx, %rax
vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm0, %xmm1
vcvtsi2sd %rax, %xmm2, %xmm1
vdivsd 0x6a062(%rip), %xmm1, %xmm1 # 0x459a80
jae 0x3ef981
vucomisd %xmm0, %xmm1
jbe 0x3ef981
movb $0x1, %al
xchgb %al, 0x3(%rsp)
movq 0xa0(%rsp), %rbx
movq 0xa8(%rsp), %r14
movq 0x10(%rsp), %r12
cmpq %r14, %rbx
je 0x3efa5c
movq %rbx, %rdi
callq 0xb1a0
addq $0x8, %rbx
jmp 0x3efa49
movq 0x80(%rsp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x31d28
addq $0xc0, %rbx
leaq 0x20(%r12), %rdi
movq %rbx, %rsi
callq 0x352c2
leaq 0x50(%r12), %rdi
movq 0x88(%rsp), %rsi
callq 0x352ec
movl 0x4(%rsp), %eax
movl %eax, 0x90(%r12)
movq 0x50(%rsp), %rax
subq 0x48(%rsp), %rax
pushq $0x28
popq %rcx
cqto
xorl %esi, %esi
idivq %rcx
movq 0x118(%rsp), %rdi
movq 0x130(%rsp), %rcx
movl %eax, 0x94(%r12)
movslq (%rdi), %rax
imulq $0x38, %rax, %rax
movl 0x30(%rcx,%rax), %edx
leaq (%rcx,%rax), %rbx
testl %edx, %edx
setne %sil
leal (%rsi,%rsi,2), %esi
movl %esi, 0xa0(%r12)
vmovsd 0x18(%rcx,%rax), %xmm0
vmovsd %xmm0, 0x80(%r12)
movq 0x28(%rcx,%rax), %rax
movq %rax, 0x88(%r12)
movl %edx, 0x98(%r12)
movl 0xe8(%r13), %eax
testl %eax, %eax
je 0x3efbb7
cmpl $0x1, %eax
je 0x3efb7f
cmpl $0x2, %eax
jne 0x3efbd6
leaq 0x68(%r12), %rbx
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x35292
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq $0x5, %r15
je 0x3efbd6
movq 0x118(%rsp), %rax
movq (%rbx), %rsi
movl 0x4(%rsp), %edx
movslq (%rax,%r15,4), %rax
addq %r14, %rsi
imulq $0x38, %rax, %rdi
addq 0x130(%rsp), %rdi
callq 0x4f485
incq %r15
addq $0x20, %r14
jmp 0x3efb45
leaq 0x68(%r12), %r14
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x35292
movl 0x4(%rsp), %edx
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x4f485
leaq 0xe0(%rsp), %rdi
callq 0x88db4
movq (%r14), %rsi
movq %rax, %rbx
addq $0x20, %rsi
jmp 0x3efbca
leaq 0x68(%r12), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x35292
movq (%r14), %rsi
movl 0x4(%rsp), %edx
movq %rbx, %rdi
callq 0x4f485
leaq 0xd8(%rsp), %rdi
movq %r13, %rsi
callq 0x818e0
cmpq $0x0, 0x168(%r13)
je 0x3efc02
addq $0x158, %r13 # imm = 0x158
movq %r13, %rdi
movq %r12, %rsi
callq 0x357ea
leaq 0x30(%rsp), %rdi
callq 0x357fe
leaq 0xd8(%rsp), %rdi
callq 0x818f4
leaq 0xa0(%rsp), %rdi
callq 0x35836
leaq 0x60(%rsp), %rdi
callq 0x3ff6a6
leaq 0xb8(%rsp), %rdi
callq 0x6d8d6
leaq 0x48(%rsp), %rdi
callq 0x35858
movq %r12, %rax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3efc9e
movq %rax, %rbx
jmp 0x3efcab
movq %rax, %rbx
jmp 0x3efcb8
jmp 0x3efc82
jmp 0x3efc73
jmp 0x3efc91
jmp 0x3efc91
movq %r12, 0x10(%rsp)
movq %rax, %rbx
jmp 0x3efcd9
movq %r12, 0x10(%rsp)
movq %rax, %rbx
jmp 0x3efccf
jmp 0x3efc91
jmp 0x3efc91
jmp 0x3efc91
jmp 0x3efc91
jmp 0x3efc91
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x357fe
leaq 0xd8(%rsp), %rdi
callq 0x818f4
leaq 0xa0(%rsp), %rdi
callq 0x35836
leaq 0x60(%rsp), %rdi
callq 0x3ff6a6
leaq 0xb8(%rsp), %rdi
callq 0x6d8d6
leaq 0x48(%rsp), %rdi
callq 0x35858
movq 0x10(%rsp), %rdi
callq 0xea60
movq %rbx, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-optimizer-common.hpp |
baryonyx::result baryonyx::itm::solve_problem<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>>(baryonyx::context const&, baryonyx::problem const&) | inline result
solve_problem(const context& ctx, const problem& pb)
{
if (ctx.start)
ctx.start(ctx.parameters);
result ret;
auto variables = length(pb.vars.values);
auto constraints{ make_merged_constraints(ctx, pb) };
if (!constraints.empty() && !pb.vars.values.empty()) {
random_engine rng(init_random_generator_seed(ctx));
auto cost = Cost(pb.objective, variables);
auto cost_constant = pb.objective.value;
switch (ctx.parameters.observer) {
case solver_parameters::observer_type::pnm: {
using obs = pnm_observer;
solver_functor<Solver, Float, Mode, Cost, obs> slv(ctx, rng);
ret = slv(constraints, variables, cost, cost_constant);
} break;
case solver_parameters::observer_type::file: {
using obs = file_observer;
solver_functor<Solver, Float, Mode, Cost, obs> slv(ctx, rng);
ret = slv(constraints, variables, cost, cost_constant);
} break;
default: {
using obs = none_observer;
solver_functor<Solver, Float, Mode, Cost, obs> slv(ctx, rng);
ret = slv(constraints, variables, cost, cost_constant);
break;
}
}
} else {
ret.status = result_status::success;
ret.solutions.resize(1);
ret.solutions.back().value = pb.objective.value;
}
ret.strings = pb.strings;
ret.variable_name = std::move(pb.vars.names);
ret.affected_vars = std::move(pb.affected_vars);
ret.variables = variables;
ret.constraints = length(constraints);
if (ctx.finish)
ctx.finish(ret);
return ret;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x140, %rsp # imm = 0x140
cmpq $0x0, 0x128(%rsi)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
je 0x3efd1d
leaq 0x118(%r14), %rdi
movq %r14, %rsi
callq 0x3527e
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, 0x58(%rbx)
vmovups %zmm0, 0x40(%rbx)
vmovups %zmm0, (%rbx)
movq $0x7fffffff, 0x98(%rbx) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rbx)
movq 0xb0(%r15), %rax
subq 0xa8(%r15), %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
movq %rax, %r12
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
vzeroupper
callq 0x450078
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x3efe46
movq 0xa8(%r15), %rax
cmpq 0xb0(%r15), %rax
je 0x3efe46
movq %r14, %rdi
callq 0x353ba
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
xorl %edx, %edx
leaq 0x10(%r15), %rsi
divq %rcx
cmpq $0x1, %rdx
adcq $0x0, %rdx
movq %rdx, (%rsp)
leaq 0x20(%rsp), %rdi
movl %r12d, %edx
callq 0x6d526
vmovsd 0x40(%r15), %xmm0
movl 0xe4(%r14), %eax
vxorps %xmm1, %xmm1, %xmm1
leaq 0x40(%rsp), %rsi
cmpl $0x1, %eax
je 0x3efe6d
cmpl $0x2, %eax
jne 0x3efebc
movabsq $0x7ff0000000000000, %r9 # imm = 0x7FF0000000000000
vmovaps %xmm1, (%rsi)
movq %r14, 0x10(%rsi)
movq %rsp, %rax
movq %rax, 0x18(%rsi)
vmovaps %xmm1, 0x20(%rsi)
movq %r9, 0x30(%rsi)
andq $0x0, 0x48(%rsi)
vmovups %xmm1, 0x38(%rsi)
movl $0x7fffffff, 0x50(%rsi) # imm = 0x7FFFFFFF
leaq 0x98(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %r8
movl %r12d, %ecx
callq 0x3ffd38
jmp 0x3eff09
andl $0x0, 0xa0(%rbx)
leaq 0x68(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x35292
vmovsd 0x40(%r15), %xmm0
movq 0x70(%rbx), %rax
vmovsd %xmm0, -0x8(%rax)
jmp 0x3eff38
movabsq $0x7ff0000000000000, %r9 # imm = 0x7FF0000000000000
vmovaps %xmm1, (%rsi)
movq %r14, 0x10(%rsi)
movq %rsp, %rax
movq %rax, 0x18(%rsi)
vmovaps %xmm1, 0x20(%rsi)
movq %r9, 0x30(%rsi)
andq $0x0, 0x48(%rsi)
vmovups %xmm1, 0x38(%rsi)
movl $0x7fffffff, 0x50(%rsi) # imm = 0x7FFFFFFF
leaq 0x98(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %r8
movl %r12d, %ecx
callq 0x3ff6ce
jmp 0x3eff09
movabsq $0x7ff0000000000000, %r9 # imm = 0x7FF0000000000000
vmovaps %xmm1, (%rsi)
movq %r14, 0x10(%rsi)
movq %rsp, %rax
movq %rax, 0x18(%rsi)
vmovaps %xmm1, 0x20(%rsi)
movq %r9, 0x30(%rsi)
andq $0x0, 0x48(%rsi)
vmovups %xmm1, 0x38(%rsi)
movl $0x7fffffff, 0x50(%rsi) # imm = 0x7FFFFFFF
leaq 0x98(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %r8
movl %r12d, %ecx
callq 0x4003a2
leaq 0x98(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x41d9e
movq %r13, %rdi
callq 0xea60
leaq 0x68(%rsp), %rdi
callq 0x357fe
leaq 0x20(%rsp), %rdi
callq 0x6d8d6
leaq 0x90(%r15), %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31d28
leaq 0x50(%rbx), %rdi
movq %r13, %rsi
callq 0x352ec
addq $0xc0, %r15
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x352c2
movq 0x10(%rsp), %rax
movl %r12d, 0x90(%rbx)
subq 0x8(%rsp), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
movl %eax, 0x94(%rbx)
cmpq $0x0, 0x168(%r14)
je 0x3effa4
addq $0x158, %r14 # imm = 0x158
movq %r14, %rdi
movq %rbx, %rsi
callq 0x357ea
leaq 0x8(%rsp), %rdi
callq 0x35858
movq %rbx, %rax
addq $0x140, %rsp # imm = 0x140
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3effc6
jmp 0x3effc6
leaq 0x68(%rsp), %rdi
movq %rax, %r14
callq 0x357fe
leaq 0x20(%rsp), %rdi
callq 0x6d8d6
jmp 0x3effe9
jmp 0x3effe6
movq %rax, %r14
jmp 0x3efff3
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x35858
movq %rbx, %rdi
callq 0xea60
movq %r14, %rdi
callq 0xb3d0
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::solver_inequalities_Zcoeff(std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, int, int, baryonyx::itm::quadratic_cost_type<double> const&, std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&) | solver_inequalities_Zcoeff(random_engine& rng_,
int m_,
int n_,
const cost_type& c_,
const std::vector<merged_constraint>& csts)
: logger("solver_inequalities_Zcoeff")
, rng(rng_)
, ap(csts, m_, n_)
, P(std::make_unique<Float[]>(ap.size()))
, A(std::make_unique<int[]>(ap.size()))
, R(std::make_unique<rc_data[]>(compute_reduced_costs_vector_size(csts)))
, Z(std::make_unique<subsolver_type[]>(m_))
, b(std::make_unique<bound_factor[]>(m_))
, pi(std::make_unique<Float[]>(m_))
, c(c_)
, m(m_)
, n(n_)
{
// Count the maximum function elements in the constraint where a least
// one coefficient is in Z. To be use with the branch-and-bound and
// exhaustive solvers.
std::size_t z_variables_max = 0;
// Count the maximum constraint number where at leat one coefficient is
// in Z. To be used with the exhaustive solver.
std::size_t z_constraint_exhaustive = 0;
int id = 0;
for (int i = 0, e = length(csts); i != e; ++i) {
int lower = 0, upper = 0;
std::size_t local_z_variables_max = 0;
Z[i] =
subsolver_type::linear; // Default, Z solver use the classical
// Bastert selection for 101 problem.
for (const auto& cst : csts[i].elements) {
bx_ensures(cst.factor);
A[id++] = cst.factor;
++local_z_variables_max;
if (cst.factor > 0)
upper += cst.factor;
else
lower += cst.factor;
if (cst.factor < -1 || cst.factor > 1) {
Z[i] = subsolver_type::branch_and_bound;
}
}
if (Z[i] == subsolver_type::branch_and_bound &&
local_z_variables_max < maximum_factor_exhaustive_solver)
Z[i] = subsolver_type::exhaustive;
if (csts[i].min == csts[i].max) {
b[i].min = csts[i].min;
b[i].max = csts[i].max;
} else {
if (lower >= csts[i].min || upper <= csts[i].max) {
if (Z[i] == subsolver_type::branch_and_bound)
Z[i] = subsolver_type::unconstrained_branch_and_bound;
else if (Z[i] == subsolver_type::exhaustive)
Z[i] = subsolver_type::unconstrained_exhaustive;
}
b[i].min = std::max(lower, csts[i].min);
b[i].max = std::min(upper, csts[i].max);
}
z_variables_max = std::max(z_variables_max, local_z_variables_max);
if (Z[i] == subsolver_type::exhaustive ||
Z[i] == subsolver_type::unconstrained_exhaustive) {
z_constraint_exhaustive++;
ex.build_constraints(i, csts[i].elements, b[i].min, b[i].max);
}
logger::log("Is Z: {} ({}) with {} <= {}\n",
static_cast<int>(Z[i]),
local_z_variables_max,
b[i].min,
b[i].max);
bx_ensures(b[i].min <= b[i].max);
}
if (z_constraint_exhaustive > 0)
ex.reserve(z_variables_max, z_constraint_exhaustive);
bb.reserve(z_variables_max);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %r13d
leaq 0x76194(%rip), %rdx # 0x466abb
movq %r9, %r12
movq %r8, %rbp
movl %ecx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x1a
popq %rsi
callq 0xb8418
movq %r15, 0x8(%rbx)
leaq 0x10(%rbx), %r15
movq %r15, %rdi
movq %r12, 0x18(%rsp)
movq %r12, %rsi
movl %r13d, %edx
movl %r14d, %ecx
movq %rbx, 0x50(%rsp)
callq 0x3a4ca
movl 0x38(%rbx), %esi
leaq 0x50(%rbx), %r12
movq %r12, %rdi
movq %r15, 0x78(%rsp)
callq 0x2900a
movl 0x38(%rbx), %esi
leaq 0x58(%rbx), %rdi
movq %rdi, 0x58(%rsp)
movq %r12, 0x70(%rsp)
callq 0x28eb6
movq 0x18(%rsp), %rdi
leaq 0x60(%rbx), %r15
callq 0x3a89d
movq %r15, %rdi
movq %rax, %rsi
callq 0x3f12a6
movslq %r13d, %r12
leaq 0x68(%rbx), %rdi
movq %r12, %rsi
movq %rdi, 0x20(%rsp)
movq %r15, 0x68(%rsp)
callq 0x3f12e6
leaq 0x70(%rbx), %rdi
movq %r12, %rsi
movq %rdi, 0x8(%rsp)
callq 0x3f1315
leaq 0x78(%rbx), %rdi
movq %r12, %rsi
movq %rdi, 0x60(%rsp)
callq 0x2900a
movq 0x18(%rsp), %rcx
vxorps %xmm0, %xmm0, %xmm0
leaq 0x80(%rbx), %rax
vmovups %xmm0, 0x8c(%rbx)
vmovups %xmm0, 0x80(%rbx)
vxorps %xmm0, %xmm0, %xmm0
movq %rax, 0x40(%rsp)
orl $-0x1, 0x9c(%rbx)
leaq 0x140(%rbx), %rax
vmovups %ymm0, 0xa0(%rbx)
vmovups %ymm0, 0xb0(%rbx)
vxorps %xmm0, %xmm0, %xmm0
andl $0x0, 0x140(%rbx)
andq $0x0, 0x148(%rbx)
andq $0x0, 0x130(%rbx)
vmovups %zmm0, 0xf0(%rbx)
movq %rax, 0x150(%rbx)
movq %rax, 0x158(%rbx)
andq $0x0, 0x160(%rbx)
movq %rbp, 0x168(%rbx)
movl %r13d, 0x170(%rbx)
movl %r14d, 0x174(%rbx)
movq 0x8(%rcx), %rax
subq (%rcx), %rax
pushq $0x28
popq %rcx
cqto
xorl %r12d, %r12d
xorl %ebp, %ebp
idivq %rcx
leaq 0xf0(%rbx), %rcx
movq $0x0, 0x28(%rsp)
movq $0x0, 0x48(%rsp)
movq %rcx, 0x10(%rsp)
movl %eax, %eax
movq %rax, 0x80(%rsp)
cmpq 0x80(%rsp), %r12
je 0x3f0c85
movq 0x20(%rsp), %rax
andq $0x0, 0x30(%rsp)
imulq $0x28, %r12, %rsi
movslq %ebp, %rbp
xorl %r11d, %r11d
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movb $0x4, (%rcx,%r12)
movq (%rax), %rax
leaq (%rax,%rsi), %rdx
movq (%rax,%rsi), %r8
movq 0x8(%rax,%rsi), %r9
movq 0x58(%rsp), %rax
movq (%rax), %r10
movb $0x4, %al
pushq $0x1
popq %r15
xorl %esi, %esi
xorl %edi, %edi
leaq (%r8,%r11), %rbx
cmpq %r9, %rbx
je 0x3f0b62
movl -0x8(%r8,%r15,8), %ebx
testl %ebx, %ebx
je 0x3f0cc6
movl %ebx, (%r10,%rbp,4)
movq %r15, 0x30(%rsp)
movl $0x0, %r14d
movl -0x8(%r8,%r15,8), %ebx
testl %ebx, %ebx
leal -0x2(%rbx), %r13d
cmovsl %ebx, %r14d
cmpl $-0x4, %r13d
ja 0x3f0b45
xorl %eax, %eax
movb $0x0, (%rcx,%r12)
movl %ebx, %r13d
sarl $0x1f, %r13d
addl %r14d, %edi
incq %r15
addq $0x8, %r11
incq %rbp
andnl %ebx, %r13d, %ebx
addl %ebx, %esi
jmp 0x3f0b04
movq 0x30(%rsp), %r10
testb %al, %al
sete %r8b
cmpq $0xa, %r10
setb %r9b
testb %r9b, %r8b
je 0x3f0b81
movb $0x1, %al
movb $0x1, (%rcx,%r12)
movl 0x18(%rdx), %r8d
movl 0x1c(%rdx), %r9d
movq 0x50(%rsp), %rbx
cmpl %r9d, %r8d
jne 0x3f0ba8
movq 0x8(%rsp), %rcx
movq (%rcx), %r9
imulq $0xc, %r12, %rcx
movl %r8d, (%r9,%rcx)
movl %r8d, %ecx
jmp 0x3f0bee
cmpl %r8d, %edi
jge 0x3f0bb2
cmpl %r9d, %esi
jg 0x3f0bca
testb %al, %al
je 0x3f0bc4
movzbl %al, %r9d
cmpl $0x1, %r9d
jne 0x3f0bca
movb $0x3, %al
jmp 0x3f0bc6
movb $0x2, %al
movb %al, (%rcx,%r12)
movq 0x8(%rsp), %r9
cmpl %r8d, %edi
movl %r8d, %ecx
cmovgl %edi, %ecx
imulq $0xc, %r12, %rdi
movq (%r9), %r9
movl %ecx, (%r9,%rdi)
movl 0x1c(%rdx), %edi
cmpl %esi, %edi
cmovll %edi, %esi
movl %esi, %r8d
movq 0x28(%rsp), %rsi
imulq $0xc, %r12, %r15
movzbl %al, %edi
movl %r8d, 0x4(%r9,%r15)
cmpq %r10, %rsi
cmovbeq %r10, %rsi
orl $0x2, %edi
movq %rsi, 0x28(%rsp)
cmpl $0x3, %edi
jne 0x3f0c3c
movq 0x10(%rsp), %rdi
movl %r12d, %esi
vzeroupper
callq 0x3dda06
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
incq 0x48(%rsp)
movq (%rax), %rax
movq (%rcx), %r9
movb (%rax,%r12), %al
leaq 0x4(%r9,%r15), %rsi
movsbl %al, %eax
addq %r15, %r9
movq %rbx, %rdi
movl %eax, 0x3c(%rsp)
movq %rsi, (%rsp)
pushq $0x1c
popq %rsi
leaq 0x75ef4(%rip), %rdx # 0x466b50
leaq 0x3c(%rsp), %rcx
leaq 0x30(%rsp), %r8
vzeroupper
callq 0x36b838
movq 0x70(%rbx), %rax
movl (%rax,%r15), %ecx
cmpl 0x4(%rax,%r15), %ecx
jg 0x3f0cea
incq %r12
jmp 0x3f0ab2
movq 0x48(%rsp), %rdx
movq 0x28(%rsp), %rbx
testq %rdx, %rdx
je 0x3f0ca4
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
vzeroupper
callq 0x3ddc1a
movq 0x40(%rsp), %rdi
movq %rbx, %rsi
vzeroupper
callq 0x3ddc9e
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6775d(%rip), %rdi # 0x45842a
leaq 0x75e02(%rip), %rsi # 0x466ad6
leaq 0x75e06(%rip), %rdx # 0x466ae1
leaq 0x75e6a(%rip), %rcx # 0x466b4c
vzeroupper
callq 0x2813f
leaq 0x67739(%rip), %rdi # 0x45842a
leaq 0x695b1(%rip), %rsi # 0x45a2a9
leaq 0x75de2(%rip), %rdx # 0x466ae1
leaq 0x75e67(%rip), %rcx # 0x466b6d
callq 0x2813f
movq %rax, %r14
jmp 0x3f0d51
movq %rax, %r14
jmp 0x3f0d5b
movq %rax, %r14
jmp 0x3f0d65
movq %rax, %r14
jmp 0x3f0d6f
movq %rax, %r14
jmp 0x3f0d79
movq %rax, %r14
jmp 0x3f0d83
movq %rax, %r14
jmp 0x3f0d8d
jmp 0x3f0d30
movq 0x10(%rsp), %rdi
movq %rax, %r14
callq 0x3ddcc8
movq 0x40(%rsp), %rdi
callq 0x3ddcf0
movq 0x60(%rsp), %rdi
callq 0x29066
movq 0x8(%rsp), %rdi
callq 0x3f1352
movq 0x20(%rsp), %rdi
callq 0x3f136c
movq 0x68(%rsp), %rdi
callq 0x3f1386
movq 0x58(%rsp), %rdi
callq 0x28fb6
movq 0x70(%rsp), %rdi
callq 0x29066
movq 0x78(%rsp), %rdi
callq 0x3a954
movq 0x50(%rsp), %rdi
callq 0xb853a
movq %r14, %rdi
callq 0xb3d0
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
void baryonyx::itm::compute_order::init<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true> const&, baryonyx::bit_array const&) | void init(const Solver& s, const Xtype& x)
{
switch (order) {
case solver_parameters::constraint_order::infeasibility_decr:
case solver_parameters::constraint_order::infeasibility_incr:
infeasibility_local_compute_violated_constraints(s, x);
break;
case solver_parameters::constraint_order::pi_sign_change:
std::iota(R.begin(), R.end(), 0);
break;
case solver_parameters::constraint_order::none:
case solver_parameters::constraint_order::reversing:
case solver_parameters::constraint_order::random_sorting:
case solver_parameters::constraint_order::lagrangian_decr:
case solver_parameters::constraint_order::lagrangian_incr:
default:
compute_violated_constraints(s, x, R);
break;
}
} | movl 0x30(%rdi), %ecx
movq %rdi, %rax
leal -0x3(%rcx), %edi
cmpl $0x2, %edi
jae 0x3f0db6
movq %rax, %rdi
jmp 0x3f13ca
cmpl $0x7, %ecx
jne 0x3f0dd3
movq (%rax), %rcx
movq 0x8(%rax), %rax
xorl %edx, %edx
cmpq %rax, %rcx
je 0x3f0de1
movl %edx, (%rcx)
incl %edx
addq $0x4, %rcx
jmp 0x3f0dc4
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
jmp 0x3f14cc
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::compute_order::run<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, baryonyx::bit_array, double>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>&, baryonyx::bit_array&, std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, double, double, double) | int run(Solver& solver,
Xtype& x,
random_engine& rng,
Float kappa,
Float delta,
Float theta)
{
bool pi_changed = false;
int remaining = 0;
switch (order) {
case solver_parameters::constraint_order::reversing:
solver.compute_update_row(
x, R.crbegin(), R.crend(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::random_sorting:
std::shuffle(R.begin(), R.end(), rng);
solver.compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::infeasibility_decr:
std::sort(m_order.begin(),
m_order.end(),
[](const auto& lhs, const auto& rhs) {
return rhs.second < lhs.second;
});
solver.compute_update_row(
x, m_order.cbegin(), m_order.cend(), kappa, delta, theta);
return infeasibility_local_compute_violated_constraints(solver, x);
case solver_parameters::constraint_order::infeasibility_incr:
std::sort(m_order.begin(),
m_order.end(),
[](const auto& lhs, const auto& rhs) {
return lhs.second < rhs.second;
});
solver.compute_update_row(
x, m_order.cbegin(), m_order.cend(), kappa, delta, theta);
return infeasibility_local_compute_violated_constraints(solver, x);
case solver_parameters::constraint_order::lagrangian_decr:
std::sort(
R.begin(), R.end(), [&solver](const auto lhs, const auto rhs) {
return solver.pi[rhs] < solver.pi[lhs];
});
solver.compute_update_row(
x, R.cbegin(), R.cend(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::lagrangian_incr:
std::sort(
R.begin(), R.end(), [&solver](const auto lhs, const auto rhs) {
return solver.pi[lhs] < solver.pi[rhs];
});
solver.compute_update_row(
x, R.cbegin(), R.cend(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::pi_sign_change:
std::shuffle(R.begin(), R.end(), rng);
pi_changed = solver.compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta);
remaining = local_compute_violated_constraints(solver, x);
if (!pi_changed && remaining == 0)
return 0;
return remaining;
case solver_parameters::constraint_order::none:
default:
solver.compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl 0x30(%rdi), %eax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
decl %eax
cmpl $0x6, %eax
ja 0x3f0f21
leaq 0x754ab(%rip), %rdx # 0x4662b4
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, (%rdx)
movq (%r14), %rax
movq %rax, (%rcx)
callq 0x3f15c2
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3f14cc
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %r15, %rdx
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
callq 0x3f4a04
jmp 0x3f0f56
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
callq 0x3f412e
jmp 0x3f0eb2
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
callq 0x3f4599
vmovsd 0x8(%rsp), %xmm0
vmovsd 0x10(%rsp), %xmm1
vmovsd 0x18(%rsp), %xmm2
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3f1a5e
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3f1ca4
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rcx, %rdx
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
callq 0x3ceed
vmovsd 0x8(%rsp), %xmm0
vmovsd 0x10(%rsp), %xmm1
vmovsd 0x18(%rsp), %xmm2
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3f1818
jmp 0x3f0f7a
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %r15, %rdx
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
callq 0x3f4ef6
vmovsd 0x8(%rsp), %xmm0
vmovsd 0x10(%rsp), %xmm1
vmovsd 0x18(%rsp), %xmm2
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3f1da6
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3f14cc
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rcx, %rdx
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
callq 0x3ceed
vmovsd 0x8(%rsp), %xmm0
vmovsd 0x10(%rsp), %xmm1
vmovsd 0x18(%rsp), %xmm2
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3f1818
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3f1fec
nop
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::compute_order::push_and_run<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, baryonyx::bit_array, double>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>&, baryonyx::bit_array&, std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, double, double, double, double) | int push_and_run(Solver& solver,
Xtype& x,
random_engine& rng,
Float kappa,
Float delta,
Float theta,
Float objective_amplifier)
{
bool pi_changed = 0;
int remaining = 0;
if (use_cycle)
order = next_state(order);
switch (order) {
case solver_parameters::constraint_order::reversing:
solver.push_and_compute_update_row(x,
R.crbegin(),
R.crend(),
kappa,
delta,
theta,
objective_amplifier);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::random_sorting:
std::shuffle(R.begin(), R.end(), rng);
solver.push_and_compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta, objective_amplifier);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::infeasibility_decr:
std::sort(m_order.begin(),
m_order.end(),
[](const auto& lhs, const auto& rhs) {
return rhs.second < lhs.second;
});
solver.push_and_compute_update_row(x,
m_order.cbegin(),
m_order.cend(),
kappa,
delta,
theta,
objective_amplifier);
return infeasibility_local_compute_violated_constraints(solver, x);
case solver_parameters::constraint_order::infeasibility_incr:
std::sort(m_order.begin(),
m_order.end(),
[](const auto& lhs, const auto& rhs) {
return lhs.second < rhs.second;
});
solver.push_and_compute_update_row(x,
m_order.cbegin(),
m_order.cend(),
kappa,
delta,
theta,
objective_amplifier);
return infeasibility_local_compute_violated_constraints(solver, x);
case solver_parameters::constraint_order::lagrangian_decr:
std::sort(
R.begin(), R.end(), [&solver](const auto lhs, const auto rhs) {
return solver.pi[rhs] < solver.pi[lhs];
});
solver.push_and_compute_update_row(x,
R.cbegin(),
R.cend(),
kappa,
delta,
theta,
objective_amplifier);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::lagrangian_incr:
std::sort(
R.begin(), R.end(), [&solver](const auto lhs, const auto rhs) {
return solver.pi[lhs] < solver.pi[rhs];
});
solver.push_and_compute_update_row(x,
R.cbegin(),
R.cend(),
kappa,
delta,
theta,
objective_amplifier);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::pi_sign_change:
std::shuffle(R.begin(), R.end(), rng);
pi_changed = solver.push_and_compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta, objective_amplifier);
remaining = local_compute_violated_constraints(solver, x);
if (!pi_changed && remaining == 0)
return 0;
return remaining;
case solver_parameters::constraint_order::none:
default:
solver.push_and_compute_update_row(x,
R.cbegin(),
R.cend(),
kappa,
delta,
theta,
objective_amplifier);
return compute_violated_constraints(solver, x, R);
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl 0x30(%rdi), %eax
cmpb $0x1, 0x34(%rdi)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
jne 0x3f101a
xorl %esi, %esi
leal 0x1(%rax), %edx
cmpl $0x7, %eax
cmovll %edx, %esi
movl %esi, %eax
movl %esi, 0x30(%r14)
decl %eax
cmpl $0x6, %eax
ja 0x3f11b3
leaq 0x752a4(%rip), %rdx # 0x4662d0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, (%rdx)
movq (%r14), %rax
movq %rax, (%rcx)
callq 0x3f53ec
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3f14cc
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %r15, %rdx
vmovsd %xmm3, 0x18(%rsp)
vmovsd %xmm2, 0x10(%rsp)
vmovsd %xmm1, 0x8(%rsp)
vmovsd %xmm0, (%rsp)
callq 0x3f67a6
jmp 0x3f119c
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
vmovsd %xmm3, 0x18(%rsp)
vmovsd %xmm2, 0x10(%rsp)
vmovsd %xmm1, 0x8(%rsp)
vmovsd %xmm0, (%rsp)
callq 0x3f5ed0
jmp 0x3f10e4
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
vmovsd %xmm3, 0x18(%rsp)
vmovsd %xmm2, 0x10(%rsp)
vmovsd %xmm1, 0x8(%rsp)
vmovsd %xmm0, (%rsp)
callq 0x3f633b
vmovsd (%rsp), %xmm0
vmovsd 0x8(%rsp), %xmm1
vmovsd 0x10(%rsp), %xmm2
vmovsd 0x18(%rsp), %xmm3
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3f5960
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3f1ca4
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rcx, %rdx
vmovsd %xmm3, 0x18(%rsp)
vmovsd %xmm2, 0x10(%rsp)
vmovsd %xmm1, 0x8(%rsp)
vmovsd %xmm0, (%rsp)
callq 0x3ceed
vmovsd (%rsp), %xmm0
vmovsd 0x8(%rsp), %xmm1
vmovsd 0x10(%rsp), %xmm2
vmovsd 0x18(%rsp), %xmm3
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3f56a8
jmp 0x3f11c5
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %r15, %rdx
vmovsd %xmm3, 0x18(%rsp)
vmovsd %xmm2, 0x10(%rsp)
vmovsd %xmm1, 0x8(%rsp)
vmovsd %xmm0, (%rsp)
callq 0x3f6c98
vmovsd (%rsp), %xmm0
vmovsd 0x8(%rsp), %xmm1
vmovsd 0x10(%rsp), %xmm2
vmovsd 0x18(%rsp), %xmm3
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3f5c18
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3f14cc
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rcx, %rdx
vmovsd %xmm3, 0x18(%rsp)
vmovsd %xmm2, 0x10(%rsp)
vmovsd %xmm1, 0x8(%rsp)
vmovsd %xmm0, (%rsp)
callq 0x3ceed
vmovsd (%rsp), %xmm0
vmovsd 0x8(%rsp), %xmm1
vmovsd 0x10(%rsp), %xmm2
vmovsd 0x18(%rsp), %xmm3
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3f56a8
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3f1fec
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true> const&, baryonyx::bit_array const&, std::vector<int, std::allocator<int>>&) | int
compute_violated_constraints(const Solver& slv,
const Xtype& x,
std::vector<int>& out)
{
out.clear();
for (int k = 0; k != slv.m; ++k)
if (!is_valid_constraint(slv, k, x))
out.emplace_back(k);
return length(out);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq %rax, 0x8(%rdx)
je 0x3f14ea
movq %rax, 0x8(%rbx)
leaq 0x4(%rsp), %r12
xorl %esi, %esi
movl %esi, 0x4(%rsp)
cmpl 0x170(%r15), %esi
je 0x3f1520
movq %r15, %rdi
movq %r14, %rdx
callq 0x3f1537
testb %al, %al
jne 0x3f1518
movq %rbx, %rdi
movq %r12, %rsi
callq 0x31460
movl 0x4(%rsp), %esi
incl %esi
jmp 0x3f14f1
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x2, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
bool baryonyx::itm::is_valid_constraint<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true> const&, int, baryonyx::bit_array const&) | bool
is_valid_constraint(const Solver& slv, int k, const Xtype& x)
{
typename sparse_matrix<int>::const_row_iterator it, et;
std::tie(it, et) = slv.ap.row(k);
int v = 0;
for (; it != et; ++it)
v += slv.factor(it->value) * x[it->column];
return slv.bound_min(k) <= v && v <= slv.bound_max(k);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %edx
leaq 0x10(%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
movq %r15, %rdi
callq 0x3c868
movq (%r15), %r12
movq 0x8(%r15), %r13
xorl %r15d, %r15d
cmpq %r12, %r13
je 0x3f1594
movslq (%r13), %rax
movq 0x58(%rbx), %rcx
movl 0x4(%r13), %esi
movq %r14, %rdi
movl (%rcx,%rax,4), %ebp
callq 0x3664a
imull %ebp, %eax
addq $0x8, %r13
addl %eax, %r15d
jmp 0x3f156c
movslq 0x4(%rsp), %rcx
movq 0x70(%rbx), %rax
imulq $0xc, %rcx, %rcx
cmpl %r15d, (%rax,%rcx)
jle 0x3f15ab
xorl %eax, %eax
jmp 0x3f15b3
cmpl 0x4(%rax,%rcx), %r15d
setle %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::compute_update_row<baryonyx::bit_array, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>>(baryonyx::bit_array&, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>, double, double, double) | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
Float pi_change;
int selected = -2;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x38(%rsp)
leaq 0x50(%rsp), %rcx
leaq 0x48(%rsp), %r8
leaq 0x40(%rsp), %r9
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x6ad50(%rip), %rdx # 0x45c344
vmovsd %xmm0, (%rcx)
vmovsd %xmm1, (%r8)
vmovsd %xmm2, (%r9)
pushq $0x14
popq %rsi
callq 0xefd10
leaq 0x10(%r12), %rax
leaq 0x60(%r12), %rcx
leaq 0xf0(%r12), %rdx
movq %rbx, 0x30(%rsp)
xorl %ebp, %ebp
movq %rax, 0x28(%rsp)
movq (%rbx), %rax
movq %rcx, (%rsp)
leaq 0x80(%r12), %rcx
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x38(%rsp), %rcx
cmpq (%rcx), %rax
je 0x3f1803
movl -0x4(%rax), %ebx
movq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movl %ebx, %edx
callq 0x3de66
vmovsd 0x40(%rsp), %xmm0
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq %r12, %rdi
callq 0x3f202e
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
movq %r15, %r14
callq 0x3f204c
movq 0x68(%r12), %rcx
movslq %ebx, %r15
movl %eax, %r13d
movzbl (%rcx,%r15), %eax
pushq $-0x2
popq %r8
cmpq $0x4, %rax
ja 0x3f17c8
leaq 0x74c34(%rip), %rcx # 0x4662ec
movslq %r13d, %rsi
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3f1769
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3f26a8
jmp 0x3f17c5
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %r15
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
callq 0x3f2660
cmpl $-0x2, %eax
jne 0x3f17c5
movq 0x70(%r12), %rax
movl (%rax,%r15), %ecx
movl 0x4(%rax,%r15), %r8d
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movl %r13d, %edx
callq 0x3f2172
jmp 0x3f17c5
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3f2660
cmpl $-0x2, %eax
jne 0x3f17c5
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
movl %ebx, %esi
movl %r13d, %ecx
callq 0x3f2468
movl %eax, %r8d
vmovsd 0x50(%rsp), %xmm0
vmovsd 0x48(%rsp), %xmm1
movq 0x20(%rsp), %rdx
movq %r12, %rdi
movq %r14, %r15
movq %r14, %rsi
movl %ebx, %ecx
movl %r13d, %r9d
callq 0x3f26f0
movq 0x30(%rsp), %rcx
orb %al, %bpl
movq (%rcx), %rax
addq $-0x4, %rax
movq %rax, (%rcx)
jmp 0x3f1641
andb $0x1, %bpl
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, double, double, double) | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
Float pi_change;
int selected = -2;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x38(%rsp)
leaq 0x50(%rsp), %rcx
leaq 0x48(%rsp), %r8
leaq 0x40(%rsp), %r9
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x6aafa(%rip), %rdx # 0x45c344
vmovsd %xmm0, (%rcx)
vmovsd %xmm1, (%r8)
vmovsd %xmm2, (%r9)
pushq $0x14
popq %rsi
callq 0xefd10
leaq 0x10(%r12), %rax
movq %rax, 0x30(%rsp)
leaq 0x60(%r12), %rax
movq %rax, (%rsp)
leaq 0xf0(%r12), %rax
movq %rax, 0x18(%rsp)
leaq 0x80(%r12), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x38(%rsp), %r14
je 0x3f1a4c
movl (%r14), %ebx
movq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl %eax, 0xc(%rsp)
movl %ebx, %edx
callq 0x3de66
vmovsd 0x40(%rsp), %xmm0
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0x3f202e
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
movq %r15, %rbp
callq 0x3f204c
movq 0x68(%r12), %rcx
movslq %ebx, %r15
movl %eax, %r13d
movzbl (%rcx,%r15), %eax
pushq $-0x2
popq %r8
cmpq $0x4, %rax
ja 0x3f1a17
leaq 0x749f9(%rip), %rcx # 0x466300
movslq %r13d, %rsi
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3f19b8
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3f26a8
jmp 0x3f1a14
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %r15
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
callq 0x3f2660
cmpl $-0x2, %eax
jne 0x3f1a14
movq 0x70(%r12), %rax
movl (%rax,%r15), %ecx
movl 0x4(%rax,%r15), %r8d
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movl %r13d, %edx
callq 0x3f2172
jmp 0x3f1a14
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3f2660
cmpl $-0x2, %eax
jne 0x3f1a14
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
movl %ebx, %esi
movl %r13d, %ecx
callq 0x3f2468
movl %eax, %r8d
vmovsd 0x50(%rsp), %xmm0
vmovsd 0x48(%rsp), %xmm1
movq 0x28(%rsp), %rdx
movq %r12, %rdi
movq %rbp, %r15
movq %rbp, %rsi
movl %ebx, %ecx
movl %r13d, %r9d
callq 0x3f26f0
movl 0xc(%rsp), %ecx
addq $0x4, %r14
orb %al, %cl
movl %ecx, %eax
jmp 0x3f188f
andb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>, double, double, double) | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
Float pi_change;
int selected = -2;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x38(%rsp)
leaq 0x50(%rsp), %rcx
leaq 0x48(%rsp), %r8
leaq 0x40(%rsp), %r9
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x6a8b4(%rip), %rdx # 0x45c344
vmovsd %xmm0, (%rcx)
vmovsd %xmm1, (%r8)
vmovsd %xmm2, (%r9)
pushq $0x14
popq %rsi
callq 0xefd10
leaq 0x10(%r12), %rax
movq %rax, 0x30(%rsp)
leaq 0x60(%r12), %rax
movq %rax, (%rsp)
leaq 0xf0(%r12), %rax
movq %rax, 0x18(%rsp)
leaq 0x80(%r12), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x38(%rsp), %r14
je 0x3f1c92
movl (%r14), %ebx
movq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl %eax, 0xc(%rsp)
movl %ebx, %edx
callq 0x3de66
vmovsd 0x40(%rsp), %xmm0
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0x3f202e
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
movq %r15, %rbp
callq 0x3f204c
movq 0x68(%r12), %rcx
movslq %ebx, %r15
movl %eax, %r13d
movzbl (%rcx,%r15), %eax
pushq $-0x2
popq %r8
cmpq $0x4, %rax
ja 0x3f1c5d
leaq 0x747c7(%rip), %rcx # 0x466314
movslq %r13d, %rsi
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3f1bfe
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3f26a8
jmp 0x3f1c5a
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %r15
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
callq 0x3f2660
cmpl $-0x2, %eax
jne 0x3f1c5a
movq 0x70(%r12), %rax
movl (%rax,%r15), %ecx
movl 0x4(%rax,%r15), %r8d
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movl %r13d, %edx
callq 0x3f2172
jmp 0x3f1c5a
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3f2660
cmpl $-0x2, %eax
jne 0x3f1c5a
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
movl %ebx, %esi
movl %r13d, %ecx
callq 0x3f2468
movl %eax, %r8d
vmovsd 0x50(%rsp), %xmm0
vmovsd 0x48(%rsp), %xmm1
movq 0x28(%rsp), %rdx
movq %r12, %rdi
movq %rbp, %r15
movq %rbp, %rsi
movl %ebx, %ecx
movl %r13d, %r9d
callq 0x3f26f0
movl 0xc(%rsp), %ecx
addq $0x8, %r14
orb %al, %cl
movl %ecx, %eax
jmp 0x3f1ad5
andb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::compute_order::infeasibility_local_compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>&, baryonyx::bit_array const&) | int infeasibility_local_compute_violated_constraints(Solver& solver,
const Xtype& x)
{
m_order.clear();
for (int k = 0, e = solver.m; k != e; ++k) {
sparse_matrix<int>::const_row_iterator it, et;
std::tie(it, et) = solver.ap.row(k);
int v = 0;
for (; it != et; ++it)
v += solver.factor(it->value) * x[it->column];
if (solver.bound_min(k) > v)
m_order.push_back(std::make_pair(k, solver.bound_min(k) - v));
else if (solver.bound_max(k) < v)
m_order.push_back(std::make_pair(k, v - solver.bound_max(k)));
}
return length(m_order);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x18(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
cmpq %rax, 0x20(%rdi)
je 0x3f1cc6
movq %rax, 0x20(%rdi)
leaq 0x18(%rdi), %rax
leaq 0x10(%r15), %rcx
xorl %r12d, %r12d
movq %rdi, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movl 0x170(%r15), %eax
movq %rcx, 0x18(%rsp)
movq %rax, 0x28(%rsp)
cmpq 0x28(%rsp), %r12
je 0x3f1d8b
movq 0x18(%rsp), %rsi
movq %rsp, %rdi
movl %r12d, %edx
movq %r12, 0x30(%rsp)
callq 0x3de66
movq (%rsp), %r13
movq 0x8(%rsp), %r12
xorl %ebx, %ebx
cmpq %r13, %r12
je 0x3f1d3f
movslq (%r12), %rax
movq 0x58(%r15), %rcx
movl 0x4(%r12), %esi
movq %r14, %rdi
movl (%rcx,%rax,4), %ebp
callq 0x3664a
imull %ebp, %eax
addq $0x8, %r12
addl %eax, %ebx
jmp 0x3f1d17
movq 0x30(%rsp), %r12
movq 0x70(%r15), %rcx
imulq $0xc, %r12, %rdx
movl (%rcx,%rdx), %eax
subl %ebx, %eax
jle 0x3f1d60
shlq $0x20, %rax
orq %r12, %rax
movq %rax, (%rsp)
jmp 0x3f1d71
subl 0x4(%rcx,%rdx), %ebx
jle 0x3f1d7e
shlq $0x20, %rbx
orq %r12, %rbx
movq %rbx, (%rsp)
movq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x3c8c2
movq 0x20(%rsp), %rdi
incq %r12
jmp 0x3f1cec
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
shrq $0x3, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, double, double, double) | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
Float pi_change;
int selected = -2;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x38(%rsp)
leaq 0x50(%rsp), %rcx
leaq 0x48(%rsp), %r8
leaq 0x40(%rsp), %r9
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x6a56c(%rip), %rdx # 0x45c344
vmovsd %xmm0, (%rcx)
vmovsd %xmm1, (%r8)
vmovsd %xmm2, (%r9)
pushq $0x14
popq %rsi
callq 0xefd10
leaq 0x10(%r12), %rax
movq %rax, 0x30(%rsp)
leaq 0x60(%r12), %rax
movq %rax, (%rsp)
leaq 0xf0(%r12), %rax
movq %rax, 0x18(%rsp)
leaq 0x80(%r12), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x38(%rsp), %r14
je 0x3f1fda
movl (%r14), %ebx
movq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl %eax, 0xc(%rsp)
movl %ebx, %edx
callq 0x3de66
vmovsd 0x40(%rsp), %xmm0
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0x3f202e
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
movq %r15, %rbp
callq 0x3f204c
movq 0x68(%r12), %rcx
movslq %ebx, %r15
movl %eax, %r13d
movzbl (%rcx,%r15), %eax
pushq $-0x2
popq %r8
cmpq $0x4, %rax
ja 0x3f1fa5
leaq 0x74493(%rip), %rcx # 0x466328
movslq %r13d, %rsi
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3f1f46
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3f26a8
jmp 0x3f1fa2
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %r15
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
callq 0x3f2660
cmpl $-0x2, %eax
jne 0x3f1fa2
movq 0x70(%r12), %rax
movl (%rax,%r15), %ecx
movl 0x4(%rax,%r15), %r8d
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movl %r13d, %edx
callq 0x3f2172
jmp 0x3f1fa2
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3f2660
cmpl $-0x2, %eax
jne 0x3f1fa2
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
movl %ebx, %esi
movl %r13d, %ecx
callq 0x3f2468
movl %eax, %r8d
vmovsd 0x50(%rsp), %xmm0
vmovsd 0x48(%rsp), %xmm1
movq 0x28(%rsp), %rdx
movq %r12, %rdi
movq %rbp, %r15
movq %rbp, %rsi
movl %ebx, %ecx
movl %r13d, %r9d
callq 0x3f26f0
movl 0xc(%rsp), %ecx
addq $0x4, %r14
orb %al, %cl
movl %ecx, %eax
jmp 0x3f1e1d
andb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::compute_order::local_compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true> const&, baryonyx::bit_array const&) | int local_compute_violated_constraints(const Solver& slv, const Xtype& x)
{
int remaining = 0;
for (int k = 0; k != slv.m; ++k)
if (!is_valid_constraint(slv, k, x))
++remaining;
return remaining;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpl 0x170(%r14), %r15d
je 0x3f2021
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x3f1537
xorb $0x1, %al
incl %r15d
movzbl %al, %eax
addl %eax, %ebp
jmp 0x3f1ffe
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::compute_reduced_costs<baryonyx::bit_array>(baryonyx::sparse_matrix<int>::row_value*, baryonyx::sparse_matrix<int>::row_value*, baryonyx::bit_array const&) | int compute_reduced_costs(sparse_matrix<int>::row_iterator begin,
sparse_matrix<int>::row_iterator end,
const Xtype& x) noexcept
{
// to_log(
// debug_os, " compute-reduced-cost {}\n", std::distance(begin,
// end));
int r_size = 0;
for (; begin != end; ++begin) {
Float sum_a_pi_p = 0;
for (auto [first, last] = ap.column(begin->column); first != last;
++first) {
auto a = std::abs(static_cast<Float>(A[first->value]));
sum_a_pi_p += a * (pi[first->row] + P[first->value]);
}
R[r_size].id = r_size;
R[r_size].f = A[begin->value];
R[r_size].value = c(begin->column, x) - sum_a_pi_p;
// to_log(debug_os,
// 4u,
// "Compute: {} = {} - {} - {}\n",
// r_size,
// c(begin->column, x),
// sum_pi,
// sum_p);
// to_log(debug_os, 4u, "{}x{}\n", R[r_size].f, R[r_size].value);
++r_size;
}
// to_log(debug_os, "\n");
return r_size;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rdi), %rbp
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
xorl %ebx, %ebx
cmpq %r14, %r15
je 0x3f212e
movl 0x4(%r15), %edx
leaq 0x18(%rsp), %rdi
movq %rbp, %rsi
callq 0x3dede
vmovddup 0x65a30(%rip), %xmm2 # xmm2 = mem[0,0]
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rdx
movq 0x50(%r13), %rsi
movq 0x58(%r13), %rax
movq 0x78(%r13), %rdi
vxorpd %xmm3, %xmm3, %xmm3
cmpq %rcx, %rdx
je 0x3f20dc
movslq (%rdx), %r8
movslq 0x4(%rdx), %r9
addq $0x8, %rdx
vcvtsi2sdl (%rax,%r8,4), %xmm4, %xmm0
vmovsd (%rdi,%r9,8), %xmm1
vaddsd (%rsi,%r8,8), %xmm1, %xmm1
movq %rdx, 0x20(%rsp)
vandpd %xmm2, %xmm0, %xmm0
vfmadd231sd %xmm1, %xmm0, %xmm3 # xmm3 = (xmm0 * xmm1) + xmm3
jmp 0x3f20aa
movq 0x60(%r13), %rcx
movq %rbx, %r12
shlq $0x4, %r12
vmovsd %xmm3, 0x10(%rsp)
movl %ebx, 0x8(%rcx,%r12)
movslq (%r15), %rdx
movl (%rax,%rdx,4), %eax
movq 0x8(%rsp), %rdx
movl %eax, 0xc(%rcx,%r12)
movq 0x168(%r13), %rdi
movl 0x4(%r15), %esi
callq 0x73084
vsubsd 0x10(%rsp), %xmm0, %xmm0
movq 0x60(%r13), %rax
incq %rbx
addq $0x8, %r15
vmovsd %xmm0, (%rax,%r12)
jmp 0x3f206e
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::select_variables(int, int, int) | int select_variables(const int r_size, int bkmin, int bkmax)
{
int sum = 0;
int best = -2;
for (int i = -1; i < r_size; ++i) {
if (bkmin <= sum && sum <= bkmax)
best = i;
if (best != -2 && i - 1 < r_size &&
stop_iterating<Mode>(R[i + 1].value))
break;
sum += R[i + 1].f;
}
return best;
} | movq 0x60(%rdi), %rdi
movslq %esi, %rsi
pushq $-0x2
popq %rax
xorl %r8d, %r8d
pushq $-0x1
popq %r9
vxorpd %xmm0, %xmm0, %xmm0
cmpq %rsi, %r9
jge 0x3f26a7
cmpl %ecx, %r8d
movl %r9d, %r10d
cmovgl %eax, %r10d
cmpl %edx, %r8d
cmovgel %r10d, %eax
cmpl $-0x2, %eax
je 0x3f269a
vmovsd (%rdi), %xmm1
vucomisd %xmm0, %xmm1
ja 0x3f26a7
addl 0xc(%rdi), %r8d
incq %r9
addq $0x10, %rdi
jmp 0x3f2675
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::select_variables_101(int, int, int) | int select_variables_101(const int r_size, int bkmin, int bkmax)
{
int sum = 0;
int best = -2;
for (int i = -1; i < r_size; ++i) {
if (bkmin <= sum && sum <= bkmax)
best = i;
if (best != -2 && i - 1 < r_size &&
stop_iterating<Mode>(R[i + 1].value))
break;
sum += R[i + 1].f;
}
return best;
} | movq 0x60(%rdi), %rdi
movslq %esi, %rsi
pushq $-0x2
popq %rax
xorl %r8d, %r8d
pushq $-0x1
popq %r9
vxorpd %xmm0, %xmm0, %xmm0
cmpq %rsi, %r9
jge 0x3f26ef
cmpl %ecx, %r8d
movl %r9d, %r10d
cmovgl %eax, %r10d
cmpl %edx, %r8d
cmovgel %r10d, %eax
cmpl $-0x2, %eax
je 0x3f26e2
vmovsd (%rdi), %xmm1
vucomisd %xmm0, %xmm1
ja 0x3f26ef
addl 0xc(%rdi), %r8d
incq %r9
addq $0x10, %rdi
jmp 0x3f26bd
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::local_affect<baryonyx::bit_array, baryonyx::sparse_matrix<int>::row_value*>(baryonyx::bit_array&, baryonyx::sparse_matrix<int>::row_value*, int, int, int, double, double) | bool local_affect(Xtype& x,
Iterator it,
int k,
int selected,
int r_size,
const Float kappa,
const Float delta)
{
constexpr Float one{ 1 };
constexpr Float two{ 2 };
constexpr Float middle{ (two + one) / two };
const auto old_pi = pi[k];
auto d = (kappa / (one - kappa)) + delta;
if (selected < 0) {
pi[k] += R[0].value / two;
logger::log(" selected: {}/{} ({})/2 = pi {}\n",
selected,
r_size,
R[0].value,
pi[k]);
for (int i = 0; i != r_size; ++i) {
auto var = it + R[i].id;
x.unset(var->column);
P[var->value] -= d;
auto repair = local_compute_reduced_cost(var->column, x);
if (repair <= 0)
P[var->value] = P[var->value] + repair - d;
}
} else if (selected + 1 >= r_size) {
pi[k] += R[selected].value * middle;
logger::log(" selected: {}/{} ({})/2 = pi {}\n",
selected,
r_size,
R[selected].value,
pi[k]);
for (int i = 0; i != r_size; ++i) {
auto var = it + R[i].id;
x.set(var->column);
P[var->value] += d;
auto repair = local_compute_reduced_cost(var->column, x);
if (repair >= 0)
P[var->value] = P[var->value] - repair + d;
}
} else {
pi[k] += ((R[selected].value + R[selected + 1].value) / two);
logger::log(" selected: {}/{} ({}x{})/2 = pi {}\n",
selected,
r_size,
R[selected].value,
R[selected + 1].value,
pi[k]);
int i = 0;
for (; i <= selected; ++i) {
auto var = it + R[i].id;
x.set(var->column);
P[var->value] += d;
auto repair = local_compute_reduced_cost(var->column, x);
if (repair >= 0)
P[var->value] = P[var->value] - repair + d;
}
for (; i != r_size; ++i) {
auto var = it + R[i].id;
x.unset(var->column);
P[var->value] -= d;
auto repair = local_compute_reduced_cost(var->column, x);
if (repair <= 0)
P[var->value] = P[var->value] + repair - d;
}
}
// TODO job: develops is_valid_constraint for all the solvers
bx_expects(is_valid_constraint(*this, k, x));
return is_signbit_change(old_pi, pi[k]);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
vmovsd 0x61932(%rip), %xmm2 # 0x454038
movl %r8d, 0x14(%rsp)
movl %r9d, 0x10(%rsp)
movq %rdx, %r15
movslq %ecx, %rdx
movl %ecx, 0x24(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rdi), %rcx
movq %rdx, 0x28(%rsp)
leaq (%rcx,%rdx,8), %rcx
vsubsd %xmm0, %xmm2, %xmm2
vmovsd (%rcx), %xmm3
vdivsd %xmm2, %xmm0, %xmm0
vmovapd %xmm3, 0x30(%rsp)
vaddsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x18(%rsp)
testl %r8d, %r8d
js 0x3f28ef
movq 0x60(%rbx), %rdx
movl %r8d, %esi
shlq $0x4, %rsi
movl %r9d, %eax
incl %r8d
vmovsd (%rdx,%rsi), %xmm0
leaq (%rdx,%rsi), %r9
cmpl %eax, %r8d
jge 0x3f29a4
movl %r8d, %eax
shlq $0x4, %rax
vaddsd (%rdx,%rax), %xmm0, %xmm0
leaq (%rdx,%rax), %rsi
leaq 0x74641(%rip), %rdx # 0x466dcd
vmulsd 0x661e4(%rip), %xmm0, %xmm0 # 0x458978
vaddsd %xmm0, %xmm3, %xmm0
vmovsd %xmm0, (%rcx)
movq %rcx, 0x8(%rsp)
movq %rsi, (%rsp)
pushq $0x26
popq %rsi
leaq 0x14(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
callq 0x3bcad4
pushq $0x8
popq %r13
xorl %r12d, %r12d
movslq 0x14(%rsp), %rax
cmpq %rax, %r12
jg 0x3f28a1
movq 0x60(%rbx), %rax
movq %r14, %rdi
movslq (%rax,%r13), %rbp
movl 0x4(%r15,%rbp,8), %esi
callq 0x369c8
movslq (%r15,%rbp,8), %rax
movq 0x50(%rbx), %rcx
vmovsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rdx
vaddsd (%rcx,%rax,8), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
movl 0x4(%r15,%rbp,8), %esi
callq 0x3f4092
vucomisd 0x6180c(%rip), %xmm0 # 0x454020
jb 0x3f2832
movslq (%r15,%rbp,8), %rax
movq 0x50(%rbx), %rcx
vmovsd (%rcx,%rax,8), %xmm1
vsubsd %xmm0, %xmm1, %xmm0
vaddsd 0x18(%rsp), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
incq %r12
addq $0x10, %r13
jmp 0x3f27c1
movq 0x60(%rbx), %rax
movq %r14, %rdi
movslq (%rax,%r13), %rbp
movl 0x4(%r15,%rbp,8), %esi
callq 0x36a06
movslq (%r15,%rbp,8), %rax
movq 0x50(%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rdx
vmovsd (%rcx,%rax,8), %xmm0
vsubsd 0x18(%rsp), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
movl 0x4(%r15,%rbp,8), %esi
callq 0x3f4092
vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm0, %xmm1
jb 0x3f289a
movslq (%r15,%rbp,8), %rax
movq 0x50(%rbx), %rcx
vaddsd (%rcx,%rax,8), %xmm0, %xmm0
vsubsd 0x18(%rsp), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
incq %r12
addq $0x10, %r13
movl 0x10(%rsp), %eax
cmpq %rax, %r12
jne 0x3f283b
movl 0x24(%rsp), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3f1537
testb %al, %al
je 0x3f2a51
vmovapd 0x30(%rsp), %xmm0
movq 0x78(%rbx), %rcx
movq 0x28(%rsp), %rdx
vmovmskpd %xmm0, %eax
shlq $0x3f, %rax
xorq (%rcx,%rdx,8), %rax
shrq $0x3f, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x60(%rbx), %r9
leaq 0x744af(%rip), %rdx # 0x466da9
vmovsd (%r9), %xmm0
vmulsd 0x66071(%rip), %xmm0, %xmm0 # 0x458978
vaddsd %xmm0, %xmm3, %xmm0
vmovsd %xmm0, (%rcx)
movq %rcx, (%rsp)
pushq $0x23
popq %rsi
leaq 0x14(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
callq 0x3bca08
pushq $0x8
popq %r12
xorl %r13d, %r13d
movl 0x10(%rsp), %eax
cmpq %rax, %r13
je 0x3f28aa
movq 0x60(%rbx), %rax
movq %r14, %rdi
movslq (%rax,%r12), %rbp
movl 0x4(%r15,%rbp,8), %esi
callq 0x36a06
movslq (%r15,%rbp,8), %rax
movq 0x50(%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rdx
vmovsd (%rcx,%rax,8), %xmm0
vsubsd 0x18(%rsp), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
movl 0x4(%r15,%rbp,8), %esi
callq 0x3f4092
vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm0, %xmm1
jb 0x3f299b
movslq (%r15,%rbp,8), %rax
movq 0x50(%rbx), %rcx
vaddsd (%rcx,%rax,8), %xmm0, %xmm0
vsubsd 0x18(%rsp), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
incq %r13
addq $0x10, %r12
jmp 0x3f292f
vfmadd132sd 0x69313(%rip), %xmm3, %xmm0 # xmm0 = (xmm0 * mem) + xmm3
leaq 0x743f5(%rip), %rdx # 0x466da9
vmovsd %xmm0, (%rcx)
movq %rcx, (%rsp)
pushq $0x23
popq %rsi
leaq 0x14(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
callq 0x3bca08
pushq $0x8
popq %r12
xorl %r13d, %r13d
movl 0x10(%rsp), %eax
cmpq %rax, %r13
je 0x3f28aa
movq 0x60(%rbx), %rax
movq %r14, %rdi
movslq (%rax,%r12), %rbp
movl 0x4(%r15,%rbp,8), %esi
callq 0x369c8
movslq (%r15,%rbp,8), %rax
movq 0x50(%rbx), %rcx
vmovsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rdx
vaddsd (%rcx,%rax,8), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
movl 0x4(%r15,%rbp,8), %esi
callq 0x3f4092
vucomisd 0x615f6(%rip), %xmm0 # 0x454020
jb 0x3f2a48
movslq (%r15,%rbp,8), %rax
movq 0x50(%rbx), %rcx
vmovsd (%rcx,%rax,8), %xmm1
vsubsd %xmm0, %xmm1, %xmm0
vaddsd 0x18(%rsp), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
incq %r13
addq $0x10, %r12
jmp 0x3f29d8
leaq 0x65786(%rip), %rdi # 0x4581de
leaq 0x67a25(%rip), %rsi # 0x45a484
leaq 0x7407b(%rip), %rdx # 0x466ae1
leaq 0x74387(%rip), %rcx # 0x466df4
callq 0x2813f
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
void baryonyx::itm::random_shuffle_unique<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::rc_data*>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::rc_data*, baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::rc_data*, std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&) | inline void
random_shuffle_unique(iteratorT begin,
iteratorT end,
random_engine& rng) noexcept
{
auto ret = begin++;
for (; begin != end; ++begin) {
if (ret->value != begin->value) {
std::shuffle(ret, begin, rng);
ret = begin;
}
}
std::shuffle(ret, begin, rng);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x10(%rdi), %rsi
cmpq %r14, %rsi
je 0x3f2aad
vmovsd (%rdi), %xmm0
leaq 0x10(%rsi), %r15
vucomisd (%rsi), %xmm0
movq %r15, %rsi
jne 0x3f2a99
jnp 0x3f2a81
addq $-0x10, %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3f2fce
movq %r15, %rdi
jmp 0x3f2a7d
movq %rbx, %rdx
callq 0x3f2fce
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3f2abd
movq %rax, %rdi
callq 0xeb9f
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
double baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::local_compute_reduced_cost<baryonyx::bit_array>(int, baryonyx::bit_array const&) | Float local_compute_reduced_cost(int variable, const Xtype& x) noexcept
{
Float sum_a_pi_p = 0;
for (auto [ht, hte] = ap.column(variable); ht != hte; ++ht) {
auto a = std::abs(static_cast<Float>(A[ht->value]));
sum_a_pi_p += a * (pi[ht->row] + P[ht->value]);
}
return c(variable, x) - sum_a_pi_p;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
leaq 0x10(%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %rdx, %rbx
movq %rdi, %r14
movl %ebp, %edx
movq %r15, %rdi
callq 0x3dede
vmovddup 0x63a01(%rip), %xmm0 # xmm0 = mem[0,0]
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq 0x50(%r14), %rdx
movq 0x58(%r14), %rsi
movq 0x78(%r14), %rdi
vxorpd %xmm3, %xmm3, %xmm3
cmpq %rax, %rcx
je 0x3f4108
movslq (%rcx), %r8
movslq 0x4(%rcx), %r9
addq $0x8, %rcx
vcvtsi2sdl (%rsi,%r8,4), %xmm4, %xmm1
vmovsd (%rdi,%r9,8), %xmm2
vaddsd (%rdx,%r8,8), %xmm2, %xmm2
movq %rcx, 0x10(%rsp)
vandpd %xmm0, %xmm1, %xmm1
vfmadd231sd %xmm2, %xmm1, %xmm3 # xmm3 = (xmm1 * xmm2) + xmm3
jmp 0x3f40d6
movq 0x168(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
vmovsd %xmm3, (%rsp)
callq 0x73084
vsubsd (%rsp), %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, double, double, double, double) | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
Float obj_amp)
{
auto at_least_one_pi_changed{ false };
logger::log("push-update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
// Before sort and select variables, we apply the push method: for
// each reduces cost, we had the cost multiply with an objective
// amplifier.
for (int i = 0; i != r_size; ++i)
R[i].value +=
obj_amp * c((std::get<0>(it) + R[i].id)->column, x);
Float pi_change;
int selected;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
default:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x50(%rsp)
leaq 0x70(%rsp), %rcx
leaq 0x68(%rsp), %r8
leaq 0x60(%rsp), %r9
movq %rdx, %rbx
vmovsd %xmm3, 0x58(%rsp)
movq %rsi, %r15
movq %rdi, %r12
leaq 0x66c5f(%rip), %rdx # 0x45c33f
vmovsd %xmm0, (%rcx)
vmovsd %xmm1, (%r8)
vmovsd %xmm2, (%r9)
pushq $0x19
popq %rsi
callq 0xefd10
leaq 0x60(%r12), %rcx
leaq 0x10(%r12), %rax
leaq 0xf0(%r12), %rdx
xorl %r14d, %r14d
movq %rcx, 0x20(%rsp)
leaq 0x80(%r12), %rcx
movq %rax, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
cmpq 0x50(%rsp), %rbx
je 0x3f594a
movl (%rbx), %eax
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movslq %eax, %rbp
movl %eax, 0xc(%rsp)
movl %ebp, %edx
callq 0x3de66
vmovsd 0x60(%rsp), %xmm0
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
callq 0x3f202e
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
callq 0x3f204c
movl %eax, %ebx
shlq $0x4, %rbx
movl %eax, %r13d
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x3f57d4
movq 0x60(%r12), %rax
movq 0x30(%rsp), %rcx
movq 0x168(%r12), %rdi
movq %r15, %rdx
movslq 0x8(%rax,%r14), %rax
movl 0x4(%rcx,%rax,8), %esi
callq 0x73084
movq 0x60(%r12), %rax
vmovsd 0x58(%rsp), %xmm1
vfmadd213sd (%rax,%r14), %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + mem
vmovsd %xmm0, (%rax,%r14)
addq $0x10, %r14
jmp 0x3f578f
movq 0x68(%r12), %rax
movslq %r13d, %rsi
movzbl (%rax,%rbp), %eax
cmpq $0x3, %rax
ja 0x3f58db
leaq 0x70b5b(%rip), %rcx # 0x46634c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3f586a
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rbx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rbx), %edx
movl 0x4(%rax,%rbx), %ecx
callq 0x3f2660
cmpl $-0x2, %eax
jne 0x3f590c
movq 0x70(%r12), %rax
movl (%rax,%rbx), %ecx
movl 0x4(%rax,%rbx), %r8d
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %r13d, %edx
callq 0x3f2172
jmp 0x3f590c
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3f2660
cmpl $-0x2, %eax
jne 0x3f590c
movl 0xc(%rsp), %ebp
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl %r13d, %ecx
movl %ebp, %esi
callq 0x3f2468
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %r14
jmp 0x3f591a
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3f26a8
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %r14
movl 0xc(%rsp), %ebp
vmovsd 0x70(%rsp), %xmm0
vmovsd 0x68(%rsp), %xmm1
movq 0x30(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %ecx
movl %eax, %r8d
movl %r13d, %r9d
callq 0x3f26f0
orb %al, %r14b
addq $0x4, %rbx
jmp 0x3f5727
andb $0x1, %r14b
movl %r14d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>, double, double, double, double) | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
Float obj_amp)
{
auto at_least_one_pi_changed{ false };
logger::log("push-update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
// Before sort and select variables, we apply the push method: for
// each reduces cost, we had the cost multiply with an objective
// amplifier.
for (int i = 0; i != r_size; ++i)
R[i].value +=
obj_amp * c((std::get<0>(it) + R[i].id)->column, x);
Float pi_change;
int selected;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
default:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x50(%rsp)
leaq 0x70(%rsp), %rcx
leaq 0x68(%rsp), %r8
leaq 0x60(%rsp), %r9
movq %rdx, %rbx
vmovsd %xmm3, 0x58(%rsp)
movq %rsi, %r15
movq %rdi, %r12
leaq 0x669a7(%rip), %rdx # 0x45c33f
vmovsd %xmm0, (%rcx)
vmovsd %xmm1, (%r8)
vmovsd %xmm2, (%r9)
pushq $0x19
popq %rsi
callq 0xefd10
leaq 0x60(%r12), %rcx
leaq 0x10(%r12), %rax
leaq 0xf0(%r12), %rdx
xorl %r14d, %r14d
movq %rcx, 0x20(%rsp)
leaq 0x80(%r12), %rcx
movq %rax, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
cmpq 0x50(%rsp), %rbx
je 0x3f5c02
movl (%rbx), %eax
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movslq %eax, %rbp
movl %eax, 0xc(%rsp)
movl %ebp, %edx
callq 0x3de66
vmovsd 0x60(%rsp), %xmm0
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
callq 0x3f202e
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
callq 0x3f204c
movl %eax, %ebx
shlq $0x4, %rbx
movl %eax, %r13d
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x3f5a8c
movq 0x60(%r12), %rax
movq 0x30(%rsp), %rcx
movq 0x168(%r12), %rdi
movq %r15, %rdx
movslq 0x8(%rax,%r14), %rax
movl 0x4(%rcx,%rax,8), %esi
callq 0x73084
movq 0x60(%r12), %rax
vmovsd 0x58(%rsp), %xmm1
vfmadd213sd (%rax,%r14), %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + mem
vmovsd %xmm0, (%rax,%r14)
addq $0x10, %r14
jmp 0x3f5a47
movq 0x68(%r12), %rax
movslq %r13d, %rsi
movzbl (%rax,%rbp), %eax
cmpq $0x3, %rax
ja 0x3f5b93
leaq 0x708b3(%rip), %rcx # 0x46635c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3f5b22
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rbx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rbx), %edx
movl 0x4(%rax,%rbx), %ecx
callq 0x3f2660
cmpl $-0x2, %eax
jne 0x3f5bc4
movq 0x70(%r12), %rax
movl (%rax,%rbx), %ecx
movl 0x4(%rax,%rbx), %r8d
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %r13d, %edx
callq 0x3f2172
jmp 0x3f5bc4
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3f2660
cmpl $-0x2, %eax
jne 0x3f5bc4
movl 0xc(%rsp), %ebp
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl %r13d, %ecx
movl %ebp, %esi
callq 0x3f2468
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %r14
jmp 0x3f5bd2
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3f26a8
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %r14
movl 0xc(%rsp), %ebp
vmovsd 0x70(%rsp), %xmm0
vmovsd 0x68(%rsp), %xmm1
movq 0x30(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %ecx
movl %eax, %r8d
movl %r13d, %r9d
callq 0x3f26f0
orb %al, %r14b
addq $0x8, %rbx
jmp 0x3f59df
andb $0x1, %r14b
movl %r14d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, double, double, double, double) | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
Float obj_amp)
{
auto at_least_one_pi_changed{ false };
logger::log("push-update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
// Before sort and select variables, we apply the push method: for
// each reduces cost, we had the cost multiply with an objective
// amplifier.
for (int i = 0; i != r_size; ++i)
R[i].value +=
obj_amp * c((std::get<0>(it) + R[i].id)->column, x);
Float pi_change;
int selected;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
default:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x50(%rsp)
leaq 0x70(%rsp), %rcx
leaq 0x68(%rsp), %r8
leaq 0x60(%rsp), %r9
movq %rdx, %rbx
vmovsd %xmm3, 0x58(%rsp)
movq %rsi, %r15
movq %rdi, %r12
leaq 0x666ef(%rip), %rdx # 0x45c33f
vmovsd %xmm0, (%rcx)
vmovsd %xmm1, (%r8)
vmovsd %xmm2, (%r9)
pushq $0x19
popq %rsi
callq 0xefd10
leaq 0x60(%r12), %rcx
leaq 0x10(%r12), %rax
leaq 0xf0(%r12), %rdx
xorl %r14d, %r14d
movq %rcx, 0x20(%rsp)
leaq 0x80(%r12), %rcx
movq %rax, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
cmpq 0x50(%rsp), %rbx
je 0x3f5eba
movl (%rbx), %eax
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movslq %eax, %rbp
movl %eax, 0xc(%rsp)
movl %ebp, %edx
callq 0x3de66
vmovsd 0x60(%rsp), %xmm0
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
callq 0x3f202e
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
callq 0x3f204c
movl %eax, %ebx
shlq $0x4, %rbx
movl %eax, %r13d
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x3f5d44
movq 0x60(%r12), %rax
movq 0x30(%rsp), %rcx
movq 0x168(%r12), %rdi
movq %r15, %rdx
movslq 0x8(%rax,%r14), %rax
movl 0x4(%rcx,%rax,8), %esi
callq 0x73084
movq 0x60(%r12), %rax
vmovsd 0x58(%rsp), %xmm1
vfmadd213sd (%rax,%r14), %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + mem
vmovsd %xmm0, (%rax,%r14)
addq $0x10, %r14
jmp 0x3f5cff
movq 0x68(%r12), %rax
movslq %r13d, %rsi
movzbl (%rax,%rbp), %eax
cmpq $0x3, %rax
ja 0x3f5e4b
leaq 0x7060b(%rip), %rcx # 0x46636c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3f5dda
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rbx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rbx), %edx
movl 0x4(%rax,%rbx), %ecx
callq 0x3f2660
cmpl $-0x2, %eax
jne 0x3f5e7c
movq 0x70(%r12), %rax
movl (%rax,%rbx), %ecx
movl 0x4(%rax,%rbx), %r8d
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %r13d, %edx
callq 0x3f2172
jmp 0x3f5e7c
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3f2660
cmpl $-0x2, %eax
jne 0x3f5e7c
movl 0xc(%rsp), %ebp
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl %r13d, %ecx
movl %ebp, %esi
callq 0x3f2468
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %r14
jmp 0x3f5e8a
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3f213f
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3f26a8
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %r14
movl 0xc(%rsp), %ebp
vmovsd 0x70(%rsp), %xmm0
vmovsd 0x68(%rsp), %xmm1
movq 0x30(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %ecx
movl %eax, %r8d
movl %r13d, %r9d
callq 0x3f26f0
orb %al, %r14b
addq $0x4, %rbx
jmp 0x3f5c97
andb $0x1, %r14b
movl %r14d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::pnm_observer>::operator()(std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&, int, baryonyx::itm::quadratic_cost_type<double> const&, double) | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx.parameters;
auto norm_costs = normalize_costs<Float, Cost>(
m_ctx, original_costs, m_rng, variables);
const auto kappa_step = static_cast<Float>(p.kappa_step);
const auto kappa_max = static_cast<Float>(p.kappa_max);
const auto alpha = static_cast<Float>(p.alpha);
const auto theta = static_cast<Float>(p.theta);
const auto delta =
p.delta < 0
? compute_delta<Float, Cost>(m_ctx, norm_costs, theta, variables)
: static_cast<Float>(p.delta);
const auto pushing_k_factor = static_cast<Float>(p.pushing_k_factor);
const auto pushing_objective_amplifier =
static_cast<Float>(p.pushing_objective_amplifier);
const long int w_limit = static_cast<long int>(p.w);
Solver slv(
m_rng, length(constraints), variables, norm_costs, constraints);
compute_order compute(p.order, variables);
{
std::bernoulli_distribution choose_mutation(
m_ctx.parameters.init_policy_random);
bit_array empty_x;
switch (p.init_policy) {
case solver_parameters::init_policy_type::pessimistic_solve:
init_with_pre_solve<Cost, Mode>(
x, empty_x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::optimistic_solve:
init_with_pre_solve<Cost, Mode>(
empty_x, x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::bastert:
init_with_bastert<Cost, Mode>(x, original_costs, variables, 0);
break;
}
for (int i = 0, e = x.size(); i != e; ++i)
if (choose_mutation(m_rng))
x.invert(i);
}
bool start_push = false;
auto kappa = static_cast<Float>(p.kappa_min);
Observer obs("img", slv.m, slv.n, p.limit);
m_begin = std::chrono::steady_clock::now();
m_end = std::chrono::steady_clock::now();
compute.init(slv, x);
for (long int i = 0; i != p.limit; ++i) {
auto remaining = compute.run(slv, x, m_rng, kappa, delta, theta);
obs.make_observation(slv.ap, slv.P.get(), slv.pi.get());
if (remaining == 0) {
store_if_better(
x, original_costs.results(x, cost_constant), i);
best_remaining = remaining;
start_push = true;
break;
}
if (remaining < best_remaining) {
store_if_better(x, remaining, i);
best_remaining = remaining;
}
if (i > w_limit)
kappa += kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max) {
r.status = result_status::kappa_max_reached;
break;
}
if (is_timelimit_reached()) {
r.status = result_status::time_limit_reached;
break;
}
}
if (!start_push) {
r.status = result_status::limit_reached;
} else {
for (int push = 0; push < p.pushes_limit; ++push) {
auto remaining =
compute.push_and_run(slv,
x,
m_rng,
pushing_k_factor * kappa,
delta,
theta,
pushing_objective_amplifier);
if (remaining == 0)
store_if_better(x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - 1);
if (is_timelimit_reached())
break;
for (int iter = 0; iter < p.pushing_iteration_limit; ++iter) {
remaining =
compute.run(slv, x, m_rng, kappa, delta, theta);
if (remaining == 0) {
store_if_better(
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - iter - 1);
break;
}
if (iter > p.w)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
if (is_timelimit_reached())
break;
}
}
}
if (m_best.remaining_constraints == 0)
r.status = result_status::success;
if (!m_best.x.empty()) {
r.solutions.resize(1);
convert(m_best, r.solutions[0], variables);
}
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4a8, %rsp # imm = 0x4A8
vmovsd %xmm0, 0x40(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
leaq 0x18(%rsp), %rdi
movl %ecx, %esi
vzeroupper
callq 0x368ae
movq 0x10(%r14), %r12
movq 0x18(%r14), %rcx
leaq 0x80(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebx, %r8d
callq 0x6fb57
vmovsd 0x20(%r12), %xmm0
vmovsd 0x10(%r12), %xmm1
vmovsd %xmm0, 0x60(%rsp)
vmovsd 0x28(%r12), %xmm0
vmovsd %xmm1, 0x28(%rsp)
vmovsd %xmm0, 0x68(%rsp)
vmovsd 0x30(%r12), %xmm0
vmovsd %xmm0, 0x58(%rsp)
vmovsd 0x8(%r12), %xmm0
vmovsd %xmm0, 0x30(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm1, %xmm0
jbe 0x3f72a4
movq 0x10(%r14), %rdi
vmovsd 0x30(%rsp), %xmm0
leaq 0x80(%rsp), %rsi
movl %ebx, %edx
callq 0x6fc31
vmovsd %xmm0, 0x28(%rsp)
vcvttsd2si 0xa0(%r12), %rax
vmovsd 0x38(%r12), %xmm0
vmovsd 0x40(%r12), %xmm1
movq 0x18(%r14), %rsi
movq %rax, 0x48(%rsp)
movq 0x8(%r15), %rax
vmovsd %xmm0, 0x78(%rsp)
vmovsd %xmm1, 0x70(%rsp)
subq (%r15), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq 0xd8(%rsp), %rdi
leaq 0x80(%rsp), %r8
movl %eax, %edx
movl %ebx, %ecx
movq %r15, %r9
callq 0x3f090c
movl 0xcc(%r12), %esi
leaq 0xa0(%rsp), %rdi
movl %ebx, %edx
callq 0x38cd8
movq 0x10(%r14), %rax
movl %ebx, 0x54(%rsp)
vmovsd 0x48(%rax), %xmm0
vmovsd %xmm0, (%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0x250(%rsp)
movl 0xd4(%r12), %eax
testl %eax, %eax
je 0x3f7381
cmpl $0x1, %eax
je 0x3f735b
cmpl $0x2, %eax
jne 0x3f7392
movq 0x18(%r14), %rdx
leaq 0x250(%rsp), %rdi
leaq 0x18(%rsp), %rsi
jmp 0x3f736c
movq 0x18(%r14), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x250(%rsp), %rsi
vmovsd 0x5ccc4(%rip), %xmm0 # 0x454038
movq %r13, %rcx
movq %r15, %r8
callq 0x81d84
jmp 0x3f7392
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x81d0f
leaq 0x18(%rsp), %r15
movq %r13, 0x38(%rsp)
xorl %ebx, %ebx
movl (%r15), %ebp
cmpl %ebx, %ebp
je 0x3f73c7
movq 0x18(%r14), %rdi
callq 0x36ac3
vmovsd (%rsp), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x3f73c3
movq %r15, %rdi
movl %ebx, %esi
callq 0x3626e
incl %ebx
jmp 0x3f73a1
leaq 0x258(%rsp), %rdi
callq 0x357fe
vmovsd 0x18(%r12), %xmm0
movl 0x248(%rsp), %ecx
movl 0x24c(%rsp), %r8d
movq 0xb0(%r12), %r9
vmovsd %xmm0, (%rsp)
leaq 0x63179(%rip), %rdx # 0x45a577
leaq 0x250(%rsp), %rdi
pushq $0x3
popq %rsi
callq 0x42b5a
callq 0xb5a0
movq %rax, (%r14)
callq 0xb5a0
movq %rax, 0x8(%r14)
leaq 0xa0(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x3f0da0
vmovsd (%rsp), %xmm0
movl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x18(%rsp), %r13
xorl %r15d, %r15d
cmpq 0xb0(%r12), %r15
je 0x3f752b
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xa0(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
movq %r13, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3f0de2
movq 0x128(%rsp), %rdx
movq 0x150(%rsp), %rcx
movl %eax, %ebx
leaq 0x250(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x6c2be
testl %ebx, %ebx
je 0x3f75d0
cmpl %ebp, %ebx
jge 0x3f74cb
movq %r14, %rdi
movq %r13, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x3f84d2
movl %ebx, %ebp
cmpq 0x48(%rsp), %r15
jle 0x3f7500
vcvtsi2sd %ebx, %xmm3, %xmm0
vcvtsi2sdl 0x248(%rsp), %xmm3, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3f7505
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3f752b
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x3f850a
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3f752b
incq %r15
jmp 0x3f744b
movq 0x8(%rsp), %rax
movl $0x5, 0xa0(%rax)
cmpl $0x0, 0x50(%r14)
jne 0x3f754d
movq 0x8(%rsp), %rax
andl $0x0, 0xa0(%rax)
cmpq $0x0, 0x28(%r14)
je 0x3f757b
movq 0x8(%rsp), %rax
leaq 0x68(%rax), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x35292
movq (%rbx), %rsi
addq $0x20, %r14
movl 0x54(%rsp), %edx
movq %r14, %rdi
callq 0x4f485
leaq 0x250(%rsp), %rdi
callq 0x42cbc
leaq 0xa0(%rsp), %rdi
callq 0x393ac
leaq 0xd8(%rsp), %rdi
callq 0x3f1242
leaq 0x80(%rsp), %rdi
callq 0x6d8d6
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rax
addq $0x4a8, %rsp # imm = 0x4A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq 0x6e096
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3f8484
vmovsd (%rsp), %xmm0
leaq 0xd8(%rsp), %r15
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
movl $0x0, 0x14(%rsp)
cmpl 0xbc(%r12), %ebx
jge 0x3f753a
vmovsd %xmm0, (%rsp)
vmulsd 0x78(%rsp), %xmm0, %xmm0
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
vmovsd 0x70(%rsp), %xmm3
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x3f0fee
testl %eax, %eax
jne 0x3f7686
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6e096
movl 0xc0(%r12), %eax
imull %ebx, %eax
notl %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3f8484
movq %r14, %rdi
callq 0x3f850a
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3f753a
movl %ebx, 0x48(%rsp)
pushq $0x1
popq %rax
movl %eax, %ebx
leal -0x1(%rbx), %r13d
cmpl 0xc0(%r12), %r13d
jge 0x3f7787
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3f0de2
testl %eax, %eax
je 0x3f774b
vcvtsi2sd %r13d, %xmm4, %xmm0
vucomisd 0xa0(%r12), %xmm0
jbe 0x3f7721
vcvtsi2sd %eax, %xmm4, %xmm0
vcvtsi2sdl 0x248(%rsp), %xmm4, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3f7726
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3f7787
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x3f850a
testb %al, %al
jne 0x3f7782
vmovsd (%rsp), %xmm0
incl %ebx
jmp 0x3f76a4
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6e096
movl 0xc0(%r12), %eax
imull 0x14(%rsp), %eax
subl %ebx, %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3f8484
vmovsd (%rsp), %xmm0
jmp 0x3f7787
vmovsd (%rsp), %xmm0
movl 0x48(%rsp), %ebx
decl 0x14(%rsp)
incl %ebx
jmp 0x3f7612
jmp 0x3f77cd
jmp 0x3f77a6
jmp 0x3f77cd
movq %rax, %r14
jmp 0x3f77dd
movq %rax, %r14
jmp 0x3f77ea
movq %rax, %r14
jmp 0x3f77f7
movq %rax, %r14
jmp 0x3f7804
movq %rax, %r14
jmp 0x3f780e
jmp 0x3f77cd
jmp 0x3f77cd
jmp 0x3f77cd
leaq 0x258(%rsp), %rdi
movq %rax, %r14
callq 0x357fe
jmp 0x3f77dd
leaq 0x250(%rsp), %rdi
movq %rax, %r14
callq 0x42cbc
leaq 0xa0(%rsp), %rdi
callq 0x393ac
leaq 0xd8(%rsp), %rdi
callq 0x3f1242
leaq 0x80(%rsp), %rdi
callq 0x6d8d6
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rdi
callq 0xea60
movq %r14, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::file_observer>::operator()(std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&, int, baryonyx::itm::quadratic_cost_type<double> const&, double) | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx.parameters;
auto norm_costs = normalize_costs<Float, Cost>(
m_ctx, original_costs, m_rng, variables);
const auto kappa_step = static_cast<Float>(p.kappa_step);
const auto kappa_max = static_cast<Float>(p.kappa_max);
const auto alpha = static_cast<Float>(p.alpha);
const auto theta = static_cast<Float>(p.theta);
const auto delta =
p.delta < 0
? compute_delta<Float, Cost>(m_ctx, norm_costs, theta, variables)
: static_cast<Float>(p.delta);
const auto pushing_k_factor = static_cast<Float>(p.pushing_k_factor);
const auto pushing_objective_amplifier =
static_cast<Float>(p.pushing_objective_amplifier);
const long int w_limit = static_cast<long int>(p.w);
Solver slv(
m_rng, length(constraints), variables, norm_costs, constraints);
compute_order compute(p.order, variables);
{
std::bernoulli_distribution choose_mutation(
m_ctx.parameters.init_policy_random);
bit_array empty_x;
switch (p.init_policy) {
case solver_parameters::init_policy_type::pessimistic_solve:
init_with_pre_solve<Cost, Mode>(
x, empty_x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::optimistic_solve:
init_with_pre_solve<Cost, Mode>(
empty_x, x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::bastert:
init_with_bastert<Cost, Mode>(x, original_costs, variables, 0);
break;
}
for (int i = 0, e = x.size(); i != e; ++i)
if (choose_mutation(m_rng))
x.invert(i);
}
bool start_push = false;
auto kappa = static_cast<Float>(p.kappa_min);
Observer obs("img", slv.m, slv.n, p.limit);
m_begin = std::chrono::steady_clock::now();
m_end = std::chrono::steady_clock::now();
compute.init(slv, x);
for (long int i = 0; i != p.limit; ++i) {
auto remaining = compute.run(slv, x, m_rng, kappa, delta, theta);
obs.make_observation(slv.ap, slv.P.get(), slv.pi.get());
if (remaining == 0) {
store_if_better(
x, original_costs.results(x, cost_constant), i);
best_remaining = remaining;
start_push = true;
break;
}
if (remaining < best_remaining) {
store_if_better(x, remaining, i);
best_remaining = remaining;
}
if (i > w_limit)
kappa += kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max) {
r.status = result_status::kappa_max_reached;
break;
}
if (is_timelimit_reached()) {
r.status = result_status::time_limit_reached;
break;
}
}
if (!start_push) {
r.status = result_status::limit_reached;
} else {
for (int push = 0; push < p.pushes_limit; ++push) {
auto remaining =
compute.push_and_run(slv,
x,
m_rng,
pushing_k_factor * kappa,
delta,
theta,
pushing_objective_amplifier);
if (remaining == 0)
store_if_better(x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - 1);
if (is_timelimit_reached())
break;
for (int iter = 0; iter < p.pushing_iteration_limit; ++iter) {
remaining =
compute.run(slv, x, m_rng, kappa, delta, theta);
if (remaining == 0) {
store_if_better(
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - iter - 1);
break;
}
if (iter > p.w)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
if (is_timelimit_reached())
break;
}
}
}
if (m_best.remaining_constraints == 0)
r.status = result_status::success;
if (!m_best.x.empty()) {
r.solutions.resize(1);
convert(m_best, r.solutions[0], variables);
}
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4a8, %rsp # imm = 0x4A8
vmovsd %xmm0, 0x40(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
leaq 0x18(%rsp), %rdi
movl %ecx, %esi
vzeroupper
callq 0x368ae
movq 0x10(%r14), %r12
movq 0x18(%r14), %rcx
leaq 0x80(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebx, %r8d
callq 0x6fb57
vmovsd 0x20(%r12), %xmm0
vmovsd 0x10(%r12), %xmm1
vmovsd %xmm0, 0x60(%rsp)
vmovsd 0x28(%r12), %xmm0
vmovsd %xmm1, 0x28(%rsp)
vmovsd %xmm0, 0x68(%rsp)
vmovsd 0x30(%r12), %xmm0
vmovsd %xmm0, 0x58(%rsp)
vmovsd 0x8(%r12), %xmm0
vmovsd %xmm0, 0x30(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm1, %xmm0
jbe 0x3f790e
movq 0x10(%r14), %rdi
vmovsd 0x30(%rsp), %xmm0
leaq 0x80(%rsp), %rsi
movl %ebx, %edx
callq 0x6fc31
vmovsd %xmm0, 0x28(%rsp)
vcvttsd2si 0xa0(%r12), %rax
vmovsd 0x38(%r12), %xmm0
vmovsd 0x40(%r12), %xmm1
movq 0x18(%r14), %rsi
movq %rax, 0x48(%rsp)
movq 0x8(%r15), %rax
vmovsd %xmm0, 0x78(%rsp)
vmovsd %xmm1, 0x70(%rsp)
subq (%r15), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq 0xd8(%rsp), %rdi
leaq 0x80(%rsp), %r8
movl %eax, %edx
movl %ebx, %ecx
movq %r15, %r9
callq 0x3f090c
movl 0xcc(%r12), %esi
leaq 0xa0(%rsp), %rdi
movl %ebx, %edx
callq 0x38cd8
movq 0x10(%r14), %rax
movl %ebx, 0x54(%rsp)
vmovsd 0x48(%rax), %xmm0
vmovsd %xmm0, (%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0x250(%rsp)
movl 0xd4(%r12), %eax
testl %eax, %eax
je 0x3f79eb
cmpl $0x1, %eax
je 0x3f79c5
cmpl $0x2, %eax
jne 0x3f79fc
movq 0x18(%r14), %rdx
leaq 0x250(%rsp), %rdi
leaq 0x18(%rsp), %rsi
jmp 0x3f79d6
movq 0x18(%r14), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x250(%rsp), %rsi
vmovsd 0x5c65a(%rip), %xmm0 # 0x454038
movq %r13, %rcx
movq %r15, %r8
callq 0x81d84
jmp 0x3f79fc
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x81d0f
leaq 0x18(%rsp), %r15
movq %r13, 0x38(%rsp)
xorl %ebx, %ebx
movl (%r15), %ebp
cmpl %ebx, %ebp
je 0x3f7a31
movq 0x18(%r14), %rdi
callq 0x36ac3
vmovsd (%rsp), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x3f7a2d
movq %r15, %rdi
movl %ebx, %esi
callq 0x3626e
incl %ebx
jmp 0x3f7a0b
leaq 0x258(%rsp), %rdi
callq 0x357fe
vmovsd 0x18(%r12), %xmm0
movl 0x248(%rsp), %ecx
movl 0x24c(%rsp), %r8d
movq 0xb0(%r12), %r9
vmovsd %xmm0, (%rsp)
leaq 0x62b0f(%rip), %rdx # 0x45a577
leaq 0x250(%rsp), %rdi
pushq $0x3
popq %rsi
callq 0x4346e
callq 0xb5a0
movq %rax, (%r14)
callq 0xb5a0
movq %rax, 0x8(%r14)
leaq 0xa0(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x3f0da0
vmovsd (%rsp), %xmm0
movl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x18(%rsp), %r13
xorl %r15d, %r15d
cmpq 0xb0(%r12), %r15
je 0x3f7b95
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xa0(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
movq %r13, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3f0de2
movq 0x128(%rsp), %rdx
movq 0x150(%rsp), %rcx
movl %eax, %ebx
leaq 0x250(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x6c6c0
testl %ebx, %ebx
je 0x3f7c3a
cmpl %ebp, %ebx
jge 0x3f7b35
movq %r14, %rdi
movq %r13, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x3f85b8
movl %ebx, %ebp
cmpq 0x48(%rsp), %r15
jle 0x3f7b6a
vcvtsi2sd %ebx, %xmm3, %xmm0
vcvtsi2sdl 0x248(%rsp), %xmm3, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3f7b6f
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3f7b95
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x3f85f0
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3f7b95
incq %r15
jmp 0x3f7ab5
movq 0x8(%rsp), %rax
movl $0x5, 0xa0(%rax)
cmpl $0x0, 0x50(%r14)
jne 0x3f7bb7
movq 0x8(%rsp), %rax
andl $0x0, 0xa0(%rax)
cmpq $0x0, 0x28(%r14)
je 0x3f7be5
movq 0x8(%rsp), %rax
leaq 0x68(%rax), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x35292
movq (%rbx), %rsi
addq $0x20, %r14
movl 0x54(%rsp), %edx
movq %r14, %rdi
callq 0x4f485
leaq 0x250(%rsp), %rdi
callq 0x435d0
leaq 0xa0(%rsp), %rdi
callq 0x393ac
leaq 0xd8(%rsp), %rdi
callq 0x3f1242
leaq 0x80(%rsp), %rdi
callq 0x6d8d6
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rax
addq $0x4a8, %rsp # imm = 0x4A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq 0x6e096
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3f856a
vmovsd (%rsp), %xmm0
leaq 0xd8(%rsp), %r15
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
movl $0x0, 0x14(%rsp)
cmpl 0xbc(%r12), %ebx
jge 0x3f7ba4
vmovsd %xmm0, (%rsp)
vmulsd 0x78(%rsp), %xmm0, %xmm0
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
vmovsd 0x70(%rsp), %xmm3
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x3f0fee
testl %eax, %eax
jne 0x3f7cf0
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6e096
movl 0xc0(%r12), %eax
imull %ebx, %eax
notl %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3f856a
movq %r14, %rdi
callq 0x3f85f0
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3f7ba4
movl %ebx, 0x48(%rsp)
pushq $0x1
popq %rax
movl %eax, %ebx
leal -0x1(%rbx), %r13d
cmpl 0xc0(%r12), %r13d
jge 0x3f7df1
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3f0de2
testl %eax, %eax
je 0x3f7db5
vcvtsi2sd %r13d, %xmm4, %xmm0
vucomisd 0xa0(%r12), %xmm0
jbe 0x3f7d8b
vcvtsi2sd %eax, %xmm4, %xmm0
vcvtsi2sdl 0x248(%rsp), %xmm4, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3f7d90
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3f7df1
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x3f85f0
testb %al, %al
jne 0x3f7dec
vmovsd (%rsp), %xmm0
incl %ebx
jmp 0x3f7d0e
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6e096
movl 0xc0(%r12), %eax
imull 0x14(%rsp), %eax
subl %ebx, %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3f856a
vmovsd (%rsp), %xmm0
jmp 0x3f7df1
vmovsd (%rsp), %xmm0
movl 0x48(%rsp), %ebx
decl 0x14(%rsp)
incl %ebx
jmp 0x3f7c7c
jmp 0x3f7e37
jmp 0x3f7e10
jmp 0x3f7e37
movq %rax, %r14
jmp 0x3f7e47
movq %rax, %r14
jmp 0x3f7e54
movq %rax, %r14
jmp 0x3f7e61
movq %rax, %r14
jmp 0x3f7e6e
movq %rax, %r14
jmp 0x3f7e78
jmp 0x3f7e37
jmp 0x3f7e37
jmp 0x3f7e37
leaq 0x258(%rsp), %rdi
movq %rax, %r14
callq 0x357fe
jmp 0x3f7e47
leaq 0x250(%rsp), %rdi
movq %rax, %r14
callq 0x435d0
leaq 0xa0(%rsp), %rdi
callq 0x393ac
leaq 0xd8(%rsp), %rdi
callq 0x3f1242
leaq 0x80(%rsp), %rdi
callq 0x6d8d6
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rdi
callq 0xea60
movq %r14, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::none_observer>::operator()(std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&, int, baryonyx::itm::quadratic_cost_type<double> const&, double) | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx.parameters;
auto norm_costs = normalize_costs<Float, Cost>(
m_ctx, original_costs, m_rng, variables);
const auto kappa_step = static_cast<Float>(p.kappa_step);
const auto kappa_max = static_cast<Float>(p.kappa_max);
const auto alpha = static_cast<Float>(p.alpha);
const auto theta = static_cast<Float>(p.theta);
const auto delta =
p.delta < 0
? compute_delta<Float, Cost>(m_ctx, norm_costs, theta, variables)
: static_cast<Float>(p.delta);
const auto pushing_k_factor = static_cast<Float>(p.pushing_k_factor);
const auto pushing_objective_amplifier =
static_cast<Float>(p.pushing_objective_amplifier);
const long int w_limit = static_cast<long int>(p.w);
Solver slv(
m_rng, length(constraints), variables, norm_costs, constraints);
compute_order compute(p.order, variables);
{
std::bernoulli_distribution choose_mutation(
m_ctx.parameters.init_policy_random);
bit_array empty_x;
switch (p.init_policy) {
case solver_parameters::init_policy_type::pessimistic_solve:
init_with_pre_solve<Cost, Mode>(
x, empty_x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::optimistic_solve:
init_with_pre_solve<Cost, Mode>(
empty_x, x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::bastert:
init_with_bastert<Cost, Mode>(x, original_costs, variables, 0);
break;
}
for (int i = 0, e = x.size(); i != e; ++i)
if (choose_mutation(m_rng))
x.invert(i);
}
bool start_push = false;
auto kappa = static_cast<Float>(p.kappa_min);
Observer obs("img", slv.m, slv.n, p.limit);
m_begin = std::chrono::steady_clock::now();
m_end = std::chrono::steady_clock::now();
compute.init(slv, x);
for (long int i = 0; i != p.limit; ++i) {
auto remaining = compute.run(slv, x, m_rng, kappa, delta, theta);
obs.make_observation(slv.ap, slv.P.get(), slv.pi.get());
if (remaining == 0) {
store_if_better(
x, original_costs.results(x, cost_constant), i);
best_remaining = remaining;
start_push = true;
break;
}
if (remaining < best_remaining) {
store_if_better(x, remaining, i);
best_remaining = remaining;
}
if (i > w_limit)
kappa += kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max) {
r.status = result_status::kappa_max_reached;
break;
}
if (is_timelimit_reached()) {
r.status = result_status::time_limit_reached;
break;
}
}
if (!start_push) {
r.status = result_status::limit_reached;
} else {
for (int push = 0; push < p.pushes_limit; ++push) {
auto remaining =
compute.push_and_run(slv,
x,
m_rng,
pushing_k_factor * kappa,
delta,
theta,
pushing_objective_amplifier);
if (remaining == 0)
store_if_better(x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - 1);
if (is_timelimit_reached())
break;
for (int iter = 0; iter < p.pushing_iteration_limit; ++iter) {
remaining =
compute.run(slv, x, m_rng, kappa, delta, theta);
if (remaining == 0) {
store_if_better(
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - iter - 1);
break;
}
if (iter > p.w)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
if (is_timelimit_reached())
break;
}
}
}
if (m_best.remaining_constraints == 0)
r.status = result_status::success;
if (!m_best.x.empty()) {
r.solutions.resize(1);
convert(m_best, r.solutions[0], variables);
}
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
vmovsd %xmm0, 0x40(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
leaq 0x18(%rsp), %rdi
movl %ecx, %esi
vzeroupper
callq 0x368ae
movq 0x10(%r14), %r12
movq 0x18(%r14), %rcx
leaq 0x98(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebx, %r8d
callq 0x6fb57
vmovsd 0x20(%r12), %xmm0
vmovsd 0x10(%r12), %xmm1
vmovsd %xmm0, 0x60(%rsp)
vmovsd 0x28(%r12), %xmm0
vmovsd %xmm1, 0x28(%rsp)
vmovsd %xmm0, 0x68(%rsp)
vmovsd 0x30(%r12), %xmm0
vmovsd %xmm0, 0x58(%rsp)
vmovsd 0x8(%r12), %xmm0
vmovsd %xmm0, 0x30(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm1, %xmm0
jbe 0x3f7f78
movq 0x10(%r14), %rdi
vmovsd 0x30(%rsp), %xmm0
leaq 0x98(%rsp), %rsi
movl %ebx, %edx
callq 0x6fc31
vmovsd %xmm0, 0x28(%rsp)
vcvttsd2si 0xa0(%r12), %rax
vmovsd 0x38(%r12), %xmm0
vmovsd 0x40(%r12), %xmm1
movq 0x18(%r14), %rsi
movq %rax, 0x48(%rsp)
movq 0x8(%r15), %rax
vmovsd %xmm0, 0x90(%rsp)
vmovsd %xmm1, 0x88(%rsp)
subq (%r15), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq 0xf0(%rsp), %rdi
leaq 0x98(%rsp), %r8
movl %eax, %edx
movl %ebx, %ecx
movq %r15, %r9
callq 0x3f090c
movl 0xcc(%r12), %esi
leaq 0xb8(%rsp), %rdi
movl %ebx, %edx
callq 0x38cd8
movq 0x10(%r14), %rax
movl %ebx, 0x54(%rsp)
vmovsd 0x48(%rax), %xmm0
vmovsd %xmm0, (%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0x70(%rsp)
movl 0xd4(%r12), %eax
testl %eax, %eax
je 0x3f8052
cmpl $0x1, %eax
je 0x3f802f
cmpl $0x2, %eax
jne 0x3f8063
movq 0x18(%r14), %rdx
leaq 0x70(%rsp), %rdi
leaq 0x18(%rsp), %rsi
jmp 0x3f803d
movq 0x18(%r14), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
vmovsd 0x5bff3(%rip), %xmm0 # 0x454038
movq %r13, %rcx
movq %r15, %r8
callq 0x81d84
jmp 0x3f8063
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x81d0f
leaq 0x18(%rsp), %r15
movq %r13, 0x38(%rsp)
xorl %ebx, %ebx
movl (%r15), %ebp
cmpl %ebx, %ebp
je 0x3f8098
movq 0x18(%r14), %rdi
callq 0x36ac3
vmovsd (%rsp), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x3f8094
movq %r15, %rdi
movl %ebx, %esi
callq 0x3626e
incl %ebx
jmp 0x3f8072
leaq 0x78(%rsp), %rdi
callq 0x357fe
vmovsd 0x18(%r12), %xmm0
vmovsd %xmm0, (%rsp)
callq 0xb5a0
movq %rax, (%r14)
callq 0xb5a0
movq %rax, 0x8(%r14)
leaq 0xb8(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x3f0da0
vmovsd (%rsp), %xmm0
movl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x18(%rsp), %rbx
xorl %r15d, %r15d
cmpq 0xb0(%r12), %r15
je 0x3f81ab
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xb8(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
movq %rbx, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3f0de2
movl %eax, %r13d
testl %eax, %eax
je 0x3f8243
cmpl %ebp, %r13d
jge 0x3f814a
movq %r14, %rdi
movq %rbx, %rsi
movl %r13d, %edx
movq %r15, %rcx
callq 0x3f869e
movl %r13d, %ebp
cmpq 0x48(%rsp), %r15
jle 0x3f8180
vcvtsi2sd %r13d, %xmm3, %xmm0
vcvtsi2sdl 0x260(%rsp), %xmm3, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3f8185
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3f81ab
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x3f86d6
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3f81ab
incq %r15
jmp 0x3f80eb
movq 0x8(%rsp), %rax
movl $0x5, 0xa0(%rax)
cmpl $0x0, 0x50(%r14)
jne 0x3f81cd
movq 0x8(%rsp), %rax
andl $0x0, 0xa0(%rax)
cmpq $0x0, 0x28(%r14)
je 0x3f81fb
movq 0x8(%rsp), %rax
leaq 0x68(%rax), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x35292
movq (%rbx), %rsi
addq $0x20, %r14
movl 0x54(%rsp), %edx
movq %r14, %rdi
callq 0x4f485
leaq 0xb8(%rsp), %rdi
callq 0x393ac
leaq 0xf0(%rsp), %rdi
callq 0x3f1242
leaq 0x98(%rsp), %rdi
callq 0x6d8d6
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rax
addq $0x268, %rsp # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq 0x6e096
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3f8650
vmovsd (%rsp), %xmm0
leaq 0xf0(%rsp), %r15
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
movl $0x0, 0x14(%rsp)
cmpl 0xbc(%r12), %ebx
jge 0x3f81ba
vmovsd %xmm0, (%rsp)
vmulsd 0x90(%rsp), %xmm0, %xmm0
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
vmovsd 0x88(%rsp), %xmm3
leaq 0xb8(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x3f0fee
testl %eax, %eax
jne 0x3f82ff
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6e096
movl 0xc0(%r12), %eax
imull %ebx, %eax
notl %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3f8650
movq %r14, %rdi
callq 0x3f86d6
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3f81ba
movl %ebx, 0x48(%rsp)
pushq $0x1
popq %rax
movl %eax, %ebx
leal -0x1(%rbx), %r13d
cmpl 0xc0(%r12), %r13d
jge 0x3f8400
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xb8(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3f0de2
testl %eax, %eax
je 0x3f83c4
vcvtsi2sd %r13d, %xmm4, %xmm0
vucomisd 0xa0(%r12), %xmm0
jbe 0x3f839a
vcvtsi2sd %eax, %xmm4, %xmm0
vcvtsi2sdl 0x260(%rsp), %xmm4, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3f839f
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3f8400
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x3f86d6
testb %al, %al
jne 0x3f83fb
vmovsd (%rsp), %xmm0
incl %ebx
jmp 0x3f831d
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6e096
movl 0xc0(%r12), %eax
imull 0x14(%rsp), %eax
subl %ebx, %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3f8650
vmovsd (%rsp), %xmm0
jmp 0x3f8400
vmovsd (%rsp), %xmm0
movl 0x48(%rsp), %ebx
decl 0x14(%rsp)
incl %ebx
jmp 0x3f8285
jmp 0x3f843e
jmp 0x3f841a
jmp 0x3f843e
movq %rax, %r14
jmp 0x3f844e
movq %rax, %r14
jmp 0x3f845b
movq %rax, %r14
jmp 0x3f8468
movq %rax, %r14
jmp 0x3f8472
jmp 0x3f843e
jmp 0x3f843e
jmp 0x3f843e
leaq 0x78(%rsp), %rdi
movq %rax, %r14
callq 0x357fe
jmp 0x3f8441
movq %rax, %r14
leaq 0xb8(%rsp), %rdi
callq 0x393ac
leaq 0xf0(%rsp), %rdi
callq 0x3f1242
leaq 0x98(%rsp), %rdi
callq 0x6d8d6
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rdi
callq 0xea60
movq %r14, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::pnm_observer>::store_if_better(baryonyx::bit_array const&, double, long) | void store_if_better(const bit_array& x, double current, long int i)
{
if (is_better_solution<Mode>(current, m_best.value)) {
m_best.x = x;
m_best.duration = duration();
m_best.loop = i;
m_best.remaining_constraints = 0;
m_best.value = current;
}
} | vmovsd 0x30(%rdi), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x3f84d0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x20, %rdi
movq %rdx, %rbx
vmovsd %xmm0, (%rsp)
callq 0x36a44
movq %r14, %rdi
callq 0x3f854a
vmovsd (%rsp), %xmm1
vmovsd %xmm0, 0x38(%r14)
movq %rbx, 0x48(%r14)
andl $0x0, 0x50(%r14)
vmovsd %xmm1, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::pnm_observer>::is_timelimit_reached() | bool is_timelimit_reached()
{
m_end = std::chrono::steady_clock::now();
return is_time_limit(m_ctx.parameters.time_limit, m_begin, m_end);
} | pushq %rbx
movq %rdi, %rbx
callq 0xb5a0
movq %rax, 0x8(%rbx)
vxorpd %xmm2, %xmm2, %xmm2
movq 0x10(%rbx), %rcx
subq (%rbx), %rax
vmovsd (%rcx), %xmm0
vcvtsi2sd %rax, %xmm1, %xmm1
vdivsd 0x6154d(%rip), %xmm1, %xmm1 # 0x459a80
vcmpnlepd %xmm2, %xmm0, %k1
vcmpltpd %xmm1, %xmm0, %k0 {%k1}
kmovd %k0, %eax
andb $0x1, %al
popq %rbx
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::file_observer>::store_if_better(baryonyx::bit_array const&, double, long) | void store_if_better(const bit_array& x, double current, long int i)
{
if (is_better_solution<Mode>(current, m_best.value)) {
m_best.x = x;
m_best.duration = duration();
m_best.loop = i;
m_best.remaining_constraints = 0;
m_best.value = current;
}
} | vmovsd 0x30(%rdi), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x3f85b6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x20, %rdi
movq %rdx, %rbx
vmovsd %xmm0, (%rsp)
callq 0x36a44
movq %r14, %rdi
callq 0x3f8630
vmovsd (%rsp), %xmm1
vmovsd %xmm0, 0x38(%r14)
movq %rbx, 0x48(%r14)
andl $0x0, 0x50(%r14)
vmovsd %xmm1, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::file_observer>::is_timelimit_reached() | bool is_timelimit_reached()
{
m_end = std::chrono::steady_clock::now();
return is_time_limit(m_ctx.parameters.time_limit, m_begin, m_end);
} | pushq %rbx
movq %rdi, %rbx
callq 0xb5a0
movq %rax, 0x8(%rbx)
vxorpd %xmm2, %xmm2, %xmm2
movq 0x10(%rbx), %rcx
subq (%rbx), %rax
vmovsd (%rcx), %xmm0
vcvtsi2sd %rax, %xmm1, %xmm1
vdivsd 0x61467(%rip), %xmm1, %xmm1 # 0x459a80
vcmpnlepd %xmm2, %xmm0, %k1
vcmpltpd %xmm1, %xmm0, %k0 {%k1}
kmovd %k0, %eax
andb $0x1, %al
popq %rbx
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::none_observer>::store_if_better(baryonyx::bit_array const&, double, long) | void store_if_better(const bit_array& x, double current, long int i)
{
if (is_better_solution<Mode>(current, m_best.value)) {
m_best.x = x;
m_best.duration = duration();
m_best.loop = i;
m_best.remaining_constraints = 0;
m_best.value = current;
}
} | vmovsd 0x30(%rdi), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x3f869c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x20, %rdi
movq %rdx, %rbx
vmovsd %xmm0, (%rsp)
callq 0x36a44
movq %r14, %rdi
callq 0x3f8716
vmovsd (%rsp), %xmm1
vmovsd %xmm0, 0x38(%r14)
movq %rbx, 0x48(%r14)
andl $0x0, 0x50(%r14)
vmovsd %xmm1, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, true>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::none_observer>::is_timelimit_reached() | bool is_timelimit_reached()
{
m_end = std::chrono::steady_clock::now();
return is_time_limit(m_ctx.parameters.time_limit, m_begin, m_end);
} | pushq %rbx
movq %rdi, %rbx
callq 0xb5a0
movq %rax, 0x8(%rbx)
vxorpd %xmm2, %xmm2, %xmm2
movq 0x10(%rbx), %rcx
subq (%rbx), %rax
vmovsd (%rcx), %xmm0
vcvtsi2sd %rax, %xmm1, %xmm1
vdivsd 0x61381(%rip), %xmm1, %xmm1 # 0x459a80
vcmpnlepd %xmm2, %xmm0, %k1
vcmpltpd %xmm1, %xmm0, %k0 {%k1}
kmovd %k0, %eax
andb $0x1, %al
popq %rbx
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::optimize_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>>::operator()(std::atomic<bool> const&, baryonyx::itm::best_solution_recorder<baryonyx::itm::quadratic_cost_type<double>, double, baryonyx::itm::minimize_tag>&, std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&, int, baryonyx::itm::quadratic_cost_type<double> const&, double) | void operator()(const std::atomic_bool& stop_task,
best_solution_recorder<Cost, Float, Mode>& best_recorder,
const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
bit_array x(variables);
auto& p = m_ctx.parameters;
auto norm_costs = normalize_costs<Float, Cost>(
m_ctx, original_costs, m_local_ctx.rng, variables);
const auto kappa_step = static_cast<Float>(p.kappa_step);
const auto kappa_max = static_cast<Float>(p.kappa_max);
const auto alpha = static_cast<Float>(p.alpha);
const auto theta = static_cast<Float>(p.theta);
const auto delta =
p.delta < 0
? compute_delta<Float, Cost>(m_ctx, norm_costs, theta, variables)
: static_cast<Float>(p.delta);
const auto pushing_k_factor = static_cast<Float>(p.pushing_k_factor);
const auto pushing_objective_amplifier =
static_cast<Float>(p.pushing_objective_amplifier);
const auto w_limit = static_cast<long int>(p.w);
Solver slv(m_local_ctx.rng,
length(constraints),
variables,
norm_costs,
constraints);
compute_order compute(p.order, variables);
bool is_a_solution = false;
while (!stop_task.load()) {
++m_call_number;
const auto kappa_start = static_cast<Float>(best_recorder.reinit(
m_local_ctx, is_a_solution, p.kappa_min, p.kappa_max, x));
auto kappa = kappa_start;
compute.init(slv, x);
auto best_remaining = INT_MAX;
is_a_solution = false;
for (long int i = 0; !stop_task.load() && i != p.limit; ++i) {
auto remaining =
compute.run(slv, x, m_local_ctx.rng, kappa, delta, theta);
if (remaining == 0) {
best_recorder.try_update(
m_local_ctx,
x,
original_costs.results(x, cost_constant),
i);
best_remaining = 0;
is_a_solution = true;
break;
} else {
best_remaining = std::min(remaining, best_remaining);
}
if (i > w_limit)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
}
if (best_remaining > 0) {
best_recorder.try_advance(
m_local_ctx, x, best_remaining, p.limit);
continue;
}
for (int push = 0; !stop_task.load() && push < p.pushes_limit;
++push) {
auto remaining =
compute.push_and_run(slv,
x,
m_local_ctx.rng,
pushing_k_factor,
delta,
theta,
pushing_objective_amplifier);
if (remaining == 0) {
best_recorder.try_update(
m_local_ctx,
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - 1);
is_a_solution = true;
}
kappa = kappa_start;
for (int iter = 0;
!stop_task.load() && iter < p.pushing_iteration_limit;
++iter) {
remaining = compute.run(
slv, x, m_local_ctx.rng, kappa, delta, theta);
if (remaining == 0) {
best_recorder.try_update(
m_local_ctx,
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - iter - 1);
is_a_solution = true;
break;
}
if (iter > p.w)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
}
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rdi, %rbp
leaq 0x10(%rsp), %rdi
movq %rsi, %r15
movl %r8d, %esi
vmovsd %xmm0, 0x50(%rsp)
movq %r9, %r12
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, 0x20(%rsp)
callq 0x368ae
movq (%rbp), %r13
movq %rbp, 0x58(%rsp)
addq $0x8, %rbp
leaq 0x98(%rsp), %rdi
movq %r13, %rsi
movq %r12, 0x48(%rsp)
movq %r12, %rdx
movq %rbp, %rcx
movl %ebx, %r8d
callq 0x6fb57
vmovsd 0x20(%r13), %xmm0
vmovsd 0x10(%r13), %xmm1
vmovsd %xmm0, 0x70(%rsp)
vmovsd 0x28(%r13), %xmm0
vmovsd %xmm1, 0x38(%rsp)
vmovsd %xmm0, 0x78(%rsp)
vmovsd 0x30(%r13), %xmm0
vmovsd %xmm0, 0x68(%rsp)
vmovsd 0x8(%r13), %xmm0
vmovsd %xmm0, 0x40(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm1, %xmm0
jbe 0x3f8c16
movq 0x58(%rsp), %rax
movq (%rax), %rdi
vmovsd 0x40(%rsp), %xmm0
leaq 0x98(%rsp), %rsi
movl %ebx, %edx
callq 0x6fc31
vmovsd %xmm0, 0x38(%rsp)
vcvttsd2si 0xa0(%r13), %rax
vmovsd 0x38(%r13), %xmm0
vmovsd 0x40(%r13), %xmm1
movq %rax, 0x80(%rsp)
movq 0x8(%r14), %rax
vmovsd %xmm0, 0x90(%rsp)
vmovsd %xmm1, 0x88(%rsp)
subq (%r14), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq 0xf0(%rsp), %rdi
leaq 0x98(%rsp), %r8
movq %rbp, %rsi
movl %eax, %edx
movl %ebx, %ecx
movq %r14, %r9
callq 0x3f903e
movl 0xcc(%r13), %esi
leaq 0xb8(%rsp), %rdi
movl %ebx, %edx
callq 0x38cd8
movq $0x0, 0x8(%rsp)
movb (%r15), %al
testb $0x1, %al
jne 0x3f8fa5
movq 0x58(%rsp), %rax
incq 0xb0(%rax)
vmovsd 0x18(%r13), %xmm0
vmovsd 0x28(%r13), %xmm1
movzbl 0x8(%rsp), %edx
movq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rbx
movq %rbp, %rsi
movq %rbx, %rcx
andl $0x1, %edx
callq 0x83c1a
vmovsd %xmm0, 0x60(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
movq %rbx, %rdx
callq 0x3f9448
vmovsd 0x60(%rsp), %xmm0
movl $0x7fffffff, %ebx # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movb (%r15), %al
testb $0x1, %al
jne 0x3f8d9d
cmpq 0xb0(%r13), %r14
je 0x3f8d9d
vmovsd 0x38(%rsp), %xmm1
vmovsd 0x40(%rsp), %xmm2
leaq 0xb8(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbp, %rcx
vmovsd %xmm0, 0x28(%rsp)
callq 0x3f948a
testl %eax, %eax
je 0x3f8db5
cmpl %eax, %ebx
cmovgel %eax, %ebx
cmpq 0x80(%rsp), %r14
jle 0x3f8d87
vcvtsi2sd %eax, %xmm3, %xmm0
vcvtsi2sdl 0x260(%rsp), %xmm3, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x68(%rsp), %xmm1
callq 0xb1f0
vmovsd 0x28(%rsp), %xmm1
vfmadd231sd 0x70(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3f8d8d
vmovsd 0x28(%rsp), %xmm0
vucomisd 0x78(%rsp), %xmm0
ja 0x3f8d9d
incq %r14
jmp 0x3f8cfe
testl %ebx, %ebx
jg 0x3f8f85
leaq 0x10(%rsp), %rbx
movq $0x0, 0x8(%rsp)
jmp 0x3f8de7
vmovsd 0x50(%rsp), %xmm0
movq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x6e096
movq 0x20(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x83f68
movb $0x1, %al
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
movl $0x0, 0x34(%rsp)
movb (%r15), %al
testb $0x1, %al
jne 0x3f8c92
cmpl 0xbc(%r13), %r14d
jge 0x3f8c92
vmovsd 0x90(%rsp), %xmm0
vmovsd 0x38(%rsp), %xmm1
vmovsd 0x40(%rsp), %xmm2
vmovsd 0x88(%rsp), %xmm3
leaq 0xb8(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
movq %rbx, %rdx
movq %rbp, %rcx
callq 0x3f9696
testl %eax, %eax
jne 0x3f8e81
vmovsd 0x50(%rsp), %xmm0
movq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x6e096
movl 0xc0(%r13), %eax
movq 0x20(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
imull %r14d, %eax
notl %eax
movslq %eax, %rcx
callq 0x83f68
movb $0x1, %al
movq %rax, 0x8(%rsp)
pushq $0x1
popq %rax
vmovsd 0x60(%rsp), %xmm0
movl %eax, %ebx
movb (%r15), %al
testb $0x1, %al
jne 0x3f8f2f
leal -0x1(%rbx), %r12d
cmpl 0xc0(%r13), %r12d
jge 0x3f8f2f
vmovsd 0x38(%rsp), %xmm1
vmovsd 0x40(%rsp), %xmm2
leaq 0xb8(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbp, %rcx
vmovsd %xmm0, 0x28(%rsp)
callq 0x3f948a
testl %eax, %eax
je 0x3f8f36
vcvtsi2sd %r12d, %xmm4, %xmm0
vucomisd 0xa0(%r13), %xmm0
jbe 0x3f8f1a
vcvtsi2sd %eax, %xmm4, %xmm0
vcvtsi2sdl 0x260(%rsp), %xmm4, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x68(%rsp), %xmm1
callq 0xb1f0
vmovsd 0x28(%rsp), %xmm1
vfmadd231sd 0x70(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3f8f20
vmovsd 0x28(%rsp), %xmm0
vucomisd 0x78(%rsp), %xmm0
ja 0x3f8f2f
incl %ebx
jmp 0x3f8e8c
leaq 0x10(%rsp), %rbx
jmp 0x3f8f79
vmovsd 0x50(%rsp), %xmm0
movq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %r12
movq %r12, %rsi
callq 0x6e096
movl 0xc0(%r13), %eax
movq 0x20(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
imull 0x34(%rsp), %eax
subl %ebx, %eax
movq %r12, %rbx
movslq %eax, %rcx
callq 0x83f68
movb $0x1, %al
movq %rax, 0x8(%rsp)
decl 0x34(%rsp)
incl %r14d
jmp 0x3f8df2
movq 0xb0(%r13), %r8
movq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %rbp, %rsi
movl %ebx, %ecx
callq 0x83ff0
jmp 0x3f8c89
leaq 0xb8(%rsp), %rdi
callq 0x393ac
leaq 0xf0(%rsp), %rdi
callq 0x3f98ea
leaq 0x98(%rsp), %rdi
callq 0x6d8d6
leaq 0x18(%rsp), %rdi
callq 0x357fe
addq $0x268, %rsp # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f8fef
movq %rax, %rbx
jmp 0x3f9011
movq %rax, %rbx
jmp 0x3f901e
movq %rax, %rbx
jmp 0x3f902b
jmp 0x3f9001
jmp 0x3f9001
jmp 0x3f9001
jmp 0x3f9001
leaq 0xb8(%rsp), %rdi
movq %rax, %rbx
callq 0x393ac
leaq 0xf0(%rsp), %rdi
callq 0x3f98ea
leaq 0x98(%rsp), %rdi
callq 0x6d8d6
leaq 0x18(%rsp), %rdi
callq 0x357fe
movq %rbx, %rdi
callq 0xb3d0
nop
| /quesnel[P]baryonyx/lib/src/itm-optimizer-common.hpp |
baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::solver_inequalities_Zcoeff(std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, int, int, baryonyx::itm::quadratic_cost_type<double> const&, std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&) | solver_inequalities_Zcoeff(random_engine& rng_,
int m_,
int n_,
const cost_type& c_,
const std::vector<merged_constraint>& csts)
: logger("solver_inequalities_Zcoeff")
, rng(rng_)
, ap(csts, m_, n_)
, P(std::make_unique<Float[]>(ap.size()))
, A(std::make_unique<int[]>(ap.size()))
, R(std::make_unique<rc_data[]>(compute_reduced_costs_vector_size(csts)))
, Z(std::make_unique<subsolver_type[]>(m_))
, b(std::make_unique<bound_factor[]>(m_))
, pi(std::make_unique<Float[]>(m_))
, c(c_)
, m(m_)
, n(n_)
{
// Count the maximum function elements in the constraint where a least
// one coefficient is in Z. To be use with the branch-and-bound and
// exhaustive solvers.
std::size_t z_variables_max = 0;
// Count the maximum constraint number where at leat one coefficient is
// in Z. To be used with the exhaustive solver.
std::size_t z_constraint_exhaustive = 0;
int id = 0;
for (int i = 0, e = length(csts); i != e; ++i) {
int lower = 0, upper = 0;
std::size_t local_z_variables_max = 0;
Z[i] =
subsolver_type::linear; // Default, Z solver use the classical
// Bastert selection for 101 problem.
for (const auto& cst : csts[i].elements) {
bx_ensures(cst.factor);
A[id++] = cst.factor;
++local_z_variables_max;
if (cst.factor > 0)
upper += cst.factor;
else
lower += cst.factor;
if (cst.factor < -1 || cst.factor > 1) {
Z[i] = subsolver_type::branch_and_bound;
}
}
if (Z[i] == subsolver_type::branch_and_bound &&
local_z_variables_max < maximum_factor_exhaustive_solver)
Z[i] = subsolver_type::exhaustive;
if (csts[i].min == csts[i].max) {
b[i].min = csts[i].min;
b[i].max = csts[i].max;
} else {
if (lower >= csts[i].min || upper <= csts[i].max) {
if (Z[i] == subsolver_type::branch_and_bound)
Z[i] = subsolver_type::unconstrained_branch_and_bound;
else if (Z[i] == subsolver_type::exhaustive)
Z[i] = subsolver_type::unconstrained_exhaustive;
}
b[i].min = std::max(lower, csts[i].min);
b[i].max = std::min(upper, csts[i].max);
}
z_variables_max = std::max(z_variables_max, local_z_variables_max);
if (Z[i] == subsolver_type::exhaustive ||
Z[i] == subsolver_type::unconstrained_exhaustive) {
z_constraint_exhaustive++;
ex.build_constraints(i, csts[i].elements, b[i].min, b[i].max);
}
logger::log("Is Z: {} ({}) with {} <= {}\n",
static_cast<int>(Z[i]),
local_z_variables_max,
b[i].min,
b[i].max);
bx_ensures(b[i].min <= b[i].max);
}
if (z_constraint_exhaustive > 0)
ex.reserve(z_variables_max, z_constraint_exhaustive);
bb.reserve(z_variables_max);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
andq $0x0, (%rdi)
leaq 0x10(%rdi), %rbx
movq %rsi, 0x8(%rdi)
movq %rdi, %r15
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r12d
movq %r9, 0x28(%rsp)
movq %r9, %rsi
movq %rbx, %rdi
callq 0x3a4ca
movl 0x38(%r15), %esi
leaq 0x50(%r15), %r13
movq %r13, %rdi
movq %rbx, 0x60(%rsp)
callq 0x2900a
movl 0x38(%r15), %esi
leaq 0x58(%r15), %rdi
movq %rdi, 0x40(%rsp)
movq %r13, 0x58(%rsp)
callq 0x28eb6
movq 0x28(%rsp), %rdi
movl %ebp, 0x20(%rsp)
movq %r14, 0x8(%rsp)
leaq 0x60(%r15), %rbp
callq 0x3a89d
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3f9949
movslq %r12d, %r14
leaq 0x68(%r15), %rdi
movq %r14, %rsi
movq %rdi, 0x38(%rsp)
movq %rbp, 0x50(%rsp)
callq 0x3f9989
leaq 0x70(%r15), %rdi
movq %r14, %rsi
movq %rdi, 0x10(%rsp)
callq 0x3f99b8
leaq 0x78(%r15), %rdi
movq %r14, %rsi
movq %rdi, 0x48(%rsp)
callq 0x2900a
leaq 0x80(%r15), %rax
vxorps %xmm0, %xmm0, %xmm0
movq 0x28(%rsp), %rcx
movq %rax, 0x30(%rsp)
vmovups %xmm0, 0x8c(%r15)
vmovups %xmm0, 0x80(%r15)
leaq 0xf0(%r15), %rax
vxorps %xmm0, %xmm0, %xmm0
orl $-0x1, 0x9c(%r15)
vmovups %ymm0, 0xa0(%r15)
vmovups %ymm0, 0xb0(%r15)
movq %rax, 0x18(%rsp)
leaq 0x140(%r15), %rax
vxorps %xmm0, %xmm0, %xmm0
andl $0x0, 0x140(%r15)
andq $0x0, 0x148(%r15)
andq $0x0, 0x130(%r15)
vmovups %zmm0, 0xf0(%r15)
movq %rax, 0x150(%r15)
movq %rax, 0x158(%r15)
movq 0x8(%rsp), %rax
andq $0x0, 0x160(%r15)
movq %rax, 0x168(%r15)
movl 0x20(%rsp), %eax
movl %r12d, 0x170(%r15)
movl %eax, 0x174(%r15)
movq 0x8(%rcx), %rax
subq (%rcx), %rax
pushq $0x28
popq %rcx
cqto
xorl %r15d, %r15d
xorl %r14d, %r14d
xorl %ebp, %ebp
idivq %rcx
movq $0x0, 0x8(%rsp)
movl %eax, %eax
movq %rax, 0x20(%rsp)
cmpq 0x20(%rsp), %r15
je 0x3f9365
movq 0x38(%rsp), %rax
imulq $0x28, %r15, %rsi
movslq %ebp, %rbp
xorl %r13d, %r13d
xorl %edi, %edi
leaq (,%rbp,4), %r9
movq (%rax), %rcx
movq 0x28(%rsp), %rax
movb $0x4, (%rcx,%r15)
movq (%rax), %rax
leaq (%rax,%rsi), %rdx
movq (%rax,%rsi), %r8
movq 0x8(%rax,%rsi), %r10
movq 0x40(%rsp), %rax
xorl %esi, %esi
addq (%rax), %r9
movb $0x4, %al
cmpq %r10, %r8
je 0x3f9274
movl (%r8), %r11d
testl %r11d, %r11d
je 0x3f939e
movl %r11d, (%r9)
movl $0x0, %r11d
movl (%r8), %ebx
testl %ebx, %ebx
leal -0x2(%rbx), %r12d
cmovsl %ebx, %r11d
cmpl $-0x4, %r12d
ja 0x3f9256
xorl %eax, %eax
movb $0x0, (%rcx,%r15)
movl %ebx, %r12d
sarl $0x1f, %r12d
addl %r11d, %edi
addq $0x8, %r8
decq %r13
addq $0x4, %r9
andnl %ebx, %r12d, %ebx
addl %ebx, %esi
jmp 0x3f9222
movq %r13, %r9
negq %r9
testb %al, %al
jne 0x3f928b
cmpq $0xa, %r9
jae 0x3f928b
movb $0x1, %al
movb $0x1, (%rcx,%r15)
movl 0x18(%rdx), %r8d
movl 0x1c(%rdx), %r10d
cmpl %r10d, %r8d
jne 0x3f92ad
movq 0x10(%rsp), %rcx
movq (%rcx), %rdi
imulq $0xc, %r15, %rcx
movl %r8d, (%rdi,%rcx)
movl %r8d, %ecx
jmp 0x3f92f6
cmpl %r8d, %edi
jge 0x3f92b7
cmpl %r10d, %esi
jg 0x3f92cf
testb %al, %al
je 0x3f92c9
movzbl %al, %r10d
cmpl $0x1, %r10d
jne 0x3f92cf
movb $0x3, %al
jmp 0x3f92cb
movb $0x2, %al
movb %al, (%rcx,%r15)
cmpl %r8d, %edi
movl %r8d, %ecx
movq 0x10(%rsp), %r8
cmovgl %edi, %ecx
movq (%r8), %rdi
imulq $0xc, %r15, %r8
movl %ecx, (%rdi,%r8)
movl 0x1c(%rdx), %r8d
cmpl %esi, %r8d
cmovll %r8d, %esi
movl %esi, %r8d
imulq $0xc, %r15, %rbx
cmpq %r9, %r14
movzbl %al, %eax
cmovbeq %r9, %r14
orl $0x2, %eax
movl %r8d, 0x4(%rdi,%rbx)
cmpl $0x3, %eax
jne 0x3f932e
movq 0x18(%rsp), %rdi
movl %r15d, %esi
vzeroupper
callq 0x3dda06
movq 0x10(%rsp), %rax
incq 0x8(%rsp)
movq (%rax), %rdi
subq %r13, %rbp
movl (%rdi,%rbx), %eax
incq %r15
cmpl 0x4(%rdi,%rbx), %eax
jle 0x3f91d5
leaq 0x5f0e2(%rip), %rdi # 0x45842a
leaq 0x60f5a(%rip), %rsi # 0x45a2a9
leaq 0x6d78b(%rip), %rdx # 0x466ae1
leaq 0x6d810(%rip), %rcx # 0x466b6d
vzeroupper
callq 0x2813f
movq 0x8(%rsp), %rdx
testq %rdx, %rdx
je 0x3f937f
movq 0x18(%rsp), %rdi
movq %r14, %rsi
vzeroupper
callq 0x3ddc1a
movq 0x30(%rsp), %rdi
movq %r14, %rsi
vzeroupper
callq 0x3ddc9e
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5f085(%rip), %rdi # 0x45842a
leaq 0x6d72a(%rip), %rsi # 0x466ad6
leaq 0x6d72e(%rip), %rdx # 0x466ae1
leaq 0x6d792(%rip), %rcx # 0x466b4c
vzeroupper
callq 0x2813f
movq %rax, %r14
jmp 0x3f9403
movq %rax, %r14
jmp 0x3f940d
movq %rax, %r14
jmp 0x3f9417
movq %rax, %r14
jmp 0x3f9421
movq %rax, %r14
jmp 0x3f942b
movq %rax, %r14
jmp 0x3f9435
jmp 0x3f93e2
movq 0x18(%rsp), %rdi
movq %rax, %r14
callq 0x3ddcc8
movq 0x30(%rsp), %rdi
callq 0x3ddcf0
movq 0x48(%rsp), %rdi
callq 0x29066
movq 0x10(%rsp), %rdi
callq 0x3f99f6
movq 0x38(%rsp), %rdi
callq 0x3f9a10
movq 0x50(%rsp), %rdi
callq 0x3f9a2a
movq 0x40(%rsp), %rdi
callq 0x28fb6
movq 0x58(%rsp), %rdi
callq 0x29066
movq 0x60(%rsp), %rdi
callq 0x3a954
movq %r14, %rdi
callq 0xb3d0
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
void baryonyx::itm::compute_order::init<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false> const&, baryonyx::bit_array const&) | void init(const Solver& s, const Xtype& x)
{
switch (order) {
case solver_parameters::constraint_order::infeasibility_decr:
case solver_parameters::constraint_order::infeasibility_incr:
infeasibility_local_compute_violated_constraints(s, x);
break;
case solver_parameters::constraint_order::pi_sign_change:
std::iota(R.begin(), R.end(), 0);
break;
case solver_parameters::constraint_order::none:
case solver_parameters::constraint_order::reversing:
case solver_parameters::constraint_order::random_sorting:
case solver_parameters::constraint_order::lagrangian_decr:
case solver_parameters::constraint_order::lagrangian_incr:
default:
compute_violated_constraints(s, x, R);
break;
}
} | movl 0x30(%rdi), %ecx
movq %rdi, %rax
leal -0x3(%rcx), %edi
cmpl $0x2, %edi
jae 0x3f945e
movq %rax, %rdi
jmp 0x3f9a6e
cmpl $0x7, %ecx
jne 0x3f947b
movq (%rax), %rcx
movq 0x8(%rax), %rax
xorl %edx, %edx
cmpq %rax, %rcx
je 0x3f9489
movl %edx, (%rcx)
incl %edx
addq $0x4, %rcx
jmp 0x3f946c
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
jmp 0x3f9b70
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::compute_order::run<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, baryonyx::bit_array, double>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>&, baryonyx::bit_array&, std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, double, double, double) | int run(Solver& solver,
Xtype& x,
random_engine& rng,
Float kappa,
Float delta,
Float theta)
{
bool pi_changed = false;
int remaining = 0;
switch (order) {
case solver_parameters::constraint_order::reversing:
solver.compute_update_row(
x, R.crbegin(), R.crend(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::random_sorting:
std::shuffle(R.begin(), R.end(), rng);
solver.compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::infeasibility_decr:
std::sort(m_order.begin(),
m_order.end(),
[](const auto& lhs, const auto& rhs) {
return rhs.second < lhs.second;
});
solver.compute_update_row(
x, m_order.cbegin(), m_order.cend(), kappa, delta, theta);
return infeasibility_local_compute_violated_constraints(solver, x);
case solver_parameters::constraint_order::infeasibility_incr:
std::sort(m_order.begin(),
m_order.end(),
[](const auto& lhs, const auto& rhs) {
return lhs.second < rhs.second;
});
solver.compute_update_row(
x, m_order.cbegin(), m_order.cend(), kappa, delta, theta);
return infeasibility_local_compute_violated_constraints(solver, x);
case solver_parameters::constraint_order::lagrangian_decr:
std::sort(
R.begin(), R.end(), [&solver](const auto lhs, const auto rhs) {
return solver.pi[rhs] < solver.pi[lhs];
});
solver.compute_update_row(
x, R.cbegin(), R.cend(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::lagrangian_incr:
std::sort(
R.begin(), R.end(), [&solver](const auto lhs, const auto rhs) {
return solver.pi[lhs] < solver.pi[rhs];
});
solver.compute_update_row(
x, R.cbegin(), R.cend(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::pi_sign_change:
std::shuffle(R.begin(), R.end(), rng);
pi_changed = solver.compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta);
remaining = local_compute_violated_constraints(solver, x);
if (!pi_changed && remaining == 0)
return 0;
return remaining;
case solver_parameters::constraint_order::none:
default:
solver.compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl 0x30(%rdi), %eax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
decl %eax
cmpl $0x6, %eax
ja 0x3f95c9
leaq 0x6cecb(%rip), %rdx # 0x46637c
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, (%rdx)
movq (%r14), %rax
movq %rax, (%rcx)
callq 0x3f9c66
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3f9b70
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %r15, %rdx
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
callq 0x3fcf9a
jmp 0x3f95fe
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
callq 0x3fc6c4
jmp 0x3f955a
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
callq 0x3fcb2f
vmovsd 0x8(%rsp), %xmm0
vmovsd 0x10(%rsp), %xmm1
vmovsd 0x18(%rsp), %xmm2
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3fa0be
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3fa2e2
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rcx, %rdx
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
callq 0x3ceed
vmovsd 0x8(%rsp), %xmm0
vmovsd 0x10(%rsp), %xmm1
vmovsd 0x18(%rsp), %xmm2
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3f9e9a
jmp 0x3f9622
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %r15, %rdx
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
callq 0x3fd48c
vmovsd 0x8(%rsp), %xmm0
vmovsd 0x10(%rsp), %xmm1
vmovsd 0x18(%rsp), %xmm2
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3fa3e4
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3f9b70
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rcx, %rdx
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
callq 0x3ceed
vmovsd 0x8(%rsp), %xmm0
vmovsd 0x10(%rsp), %xmm1
vmovsd 0x18(%rsp), %xmm2
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3f9e9a
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3fa608
nop
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::compute_order::push_and_run<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, baryonyx::bit_array, double>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>&, baryonyx::bit_array&, std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, double, double, double, double) | int push_and_run(Solver& solver,
Xtype& x,
random_engine& rng,
Float kappa,
Float delta,
Float theta,
Float objective_amplifier)
{
bool pi_changed = 0;
int remaining = 0;
if (use_cycle)
order = next_state(order);
switch (order) {
case solver_parameters::constraint_order::reversing:
solver.push_and_compute_update_row(x,
R.crbegin(),
R.crend(),
kappa,
delta,
theta,
objective_amplifier);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::random_sorting:
std::shuffle(R.begin(), R.end(), rng);
solver.push_and_compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta, objective_amplifier);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::infeasibility_decr:
std::sort(m_order.begin(),
m_order.end(),
[](const auto& lhs, const auto& rhs) {
return rhs.second < lhs.second;
});
solver.push_and_compute_update_row(x,
m_order.cbegin(),
m_order.cend(),
kappa,
delta,
theta,
objective_amplifier);
return infeasibility_local_compute_violated_constraints(solver, x);
case solver_parameters::constraint_order::infeasibility_incr:
std::sort(m_order.begin(),
m_order.end(),
[](const auto& lhs, const auto& rhs) {
return lhs.second < rhs.second;
});
solver.push_and_compute_update_row(x,
m_order.cbegin(),
m_order.cend(),
kappa,
delta,
theta,
objective_amplifier);
return infeasibility_local_compute_violated_constraints(solver, x);
case solver_parameters::constraint_order::lagrangian_decr:
std::sort(
R.begin(), R.end(), [&solver](const auto lhs, const auto rhs) {
return solver.pi[rhs] < solver.pi[lhs];
});
solver.push_and_compute_update_row(x,
R.cbegin(),
R.cend(),
kappa,
delta,
theta,
objective_amplifier);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::lagrangian_incr:
std::sort(
R.begin(), R.end(), [&solver](const auto lhs, const auto rhs) {
return solver.pi[lhs] < solver.pi[rhs];
});
solver.push_and_compute_update_row(x,
R.cbegin(),
R.cend(),
kappa,
delta,
theta,
objective_amplifier);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::pi_sign_change:
std::shuffle(R.begin(), R.end(), rng);
pi_changed = solver.push_and_compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta, objective_amplifier);
remaining = local_compute_violated_constraints(solver, x);
if (!pi_changed && remaining == 0)
return 0;
return remaining;
case solver_parameters::constraint_order::none:
default:
solver.push_and_compute_update_row(x,
R.cbegin(),
R.cend(),
kappa,
delta,
theta,
objective_amplifier);
return compute_violated_constraints(solver, x, R);
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl 0x30(%rdi), %eax
cmpb $0x1, 0x34(%rdi)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
jne 0x3f96c2
xorl %esi, %esi
leal 0x1(%rax), %edx
cmpl $0x7, %eax
cmovll %edx, %esi
movl %esi, %eax
movl %esi, 0x30(%r14)
decl %eax
cmpl $0x6, %eax
ja 0x3f985b
leaq 0x6ccc4(%rip), %rdx # 0x466398
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, (%rdx)
movq (%r14), %rax
movq %rax, (%rcx)
callq 0x3fd982
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3f9b70
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %r15, %rdx
vmovsd %xmm3, 0x18(%rsp)
vmovsd %xmm2, 0x10(%rsp)
vmovsd %xmm1, 0x8(%rsp)
vmovsd %xmm0, (%rsp)
callq 0x3fecbd
jmp 0x3f9844
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
vmovsd %xmm3, 0x18(%rsp)
vmovsd %xmm2, 0x10(%rsp)
vmovsd %xmm1, 0x8(%rsp)
vmovsd %xmm0, (%rsp)
callq 0x3fe3e7
jmp 0x3f978c
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
vmovsd %xmm3, 0x18(%rsp)
vmovsd %xmm2, 0x10(%rsp)
vmovsd %xmm1, 0x8(%rsp)
vmovsd %xmm0, (%rsp)
callq 0x3fe852
vmovsd (%rsp), %xmm0
vmovsd 0x8(%rsp), %xmm1
vmovsd 0x10(%rsp), %xmm2
vmovsd 0x18(%rsp), %xmm3
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3fdeb4
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3fa2e2
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rcx, %rdx
vmovsd %xmm3, 0x18(%rsp)
vmovsd %xmm2, 0x10(%rsp)
vmovsd %xmm1, 0x8(%rsp)
vmovsd %xmm0, (%rsp)
callq 0x3ceed
vmovsd (%rsp), %xmm0
vmovsd 0x8(%rsp), %xmm1
vmovsd 0x10(%rsp), %xmm2
vmovsd 0x18(%rsp), %xmm3
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3fdc1a
jmp 0x3f986d
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %r15, %rdx
vmovsd %xmm3, 0x18(%rsp)
vmovsd %xmm2, 0x10(%rsp)
vmovsd %xmm1, 0x8(%rsp)
vmovsd %xmm0, (%rsp)
callq 0x3ff1af
vmovsd (%rsp), %xmm0
vmovsd 0x8(%rsp), %xmm1
vmovsd 0x10(%rsp), %xmm2
vmovsd 0x18(%rsp), %xmm3
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3fe14e
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3f9b70
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rcx, %rdx
vmovsd %xmm3, 0x18(%rsp)
vmovsd %xmm2, 0x10(%rsp)
vmovsd %xmm1, 0x8(%rsp)
vmovsd %xmm0, (%rsp)
callq 0x3ceed
vmovsd (%rsp), %xmm0
vmovsd 0x8(%rsp), %xmm1
vmovsd 0x10(%rsp), %xmm2
vmovsd 0x18(%rsp), %xmm3
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3fdc1a
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3fa608
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::compute_order::infeasibility_local_compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false> const, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false> const&, baryonyx::bit_array const&) | int infeasibility_local_compute_violated_constraints(Solver& solver,
const Xtype& x)
{
m_order.clear();
for (int k = 0, e = solver.m; k != e; ++k) {
sparse_matrix<int>::const_row_iterator it, et;
std::tie(it, et) = solver.ap.row(k);
int v = 0;
for (; it != et; ++it)
v += solver.factor(it->value) * x[it->column];
if (solver.bound_min(k) > v)
m_order.push_back(std::make_pair(k, solver.bound_min(k) - v));
else if (solver.bound_max(k) < v)
m_order.push_back(std::make_pair(k, v - solver.bound_max(k)));
}
return length(m_order);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x18(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
cmpq %rax, 0x20(%rdi)
je 0x3f9a90
movq %rax, 0x20(%rdi)
leaq 0x18(%rdi), %rax
leaq 0x10(%r15), %rcx
xorl %r12d, %r12d
movq %rdi, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movl 0x170(%r15), %eax
movq %rcx, 0x18(%rsp)
movq %rax, 0x28(%rsp)
cmpq 0x28(%rsp), %r12
je 0x3f9b55
movq 0x18(%rsp), %rsi
movq %rsp, %rdi
movl %r12d, %edx
movq %r12, 0x30(%rsp)
callq 0x3c868
movq (%rsp), %r13
movq 0x8(%rsp), %r12
xorl %ebx, %ebx
cmpq %r13, %r12
je 0x3f9b09
movslq (%r12), %rax
movq 0x58(%r15), %rcx
movl 0x4(%r12), %esi
movq %r14, %rdi
movl (%rcx,%rax,4), %ebp
callq 0x3664a
imull %ebp, %eax
addq $0x8, %r12
addl %eax, %ebx
jmp 0x3f9ae1
movq 0x30(%rsp), %r12
movq 0x70(%r15), %rcx
imulq $0xc, %r12, %rdx
movl (%rcx,%rdx), %eax
subl %ebx, %eax
jle 0x3f9b2a
shlq $0x20, %rax
orq %r12, %rax
movq %rax, (%rsp)
jmp 0x3f9b3b
subl 0x4(%rcx,%rdx), %ebx
jle 0x3f9b48
shlq $0x20, %rbx
orq %r12, %rbx
movq %rbx, (%rsp)
movq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x3c8c2
movq 0x20(%rsp), %rdi
incq %r12
jmp 0x3f9ab6
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
shrq $0x3, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false> const&, baryonyx::bit_array const&, std::vector<int, std::allocator<int>>&) | int
compute_violated_constraints(const Solver& slv,
const Xtype& x,
std::vector<int>& out)
{
out.clear();
for (int k = 0; k != slv.m; ++k)
if (!is_valid_constraint(slv, k, x))
out.emplace_back(k);
return length(out);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq %rax, 0x8(%rdx)
je 0x3f9b8e
movq %rax, 0x8(%rbx)
leaq 0x4(%rsp), %r12
xorl %esi, %esi
movl %esi, 0x4(%rsp)
cmpl 0x170(%r15), %esi
je 0x3f9bc4
movq %r15, %rdi
movq %r14, %rdx
callq 0x3f9bdb
testb %al, %al
jne 0x3f9bbc
movq %rbx, %rdi
movq %r12, %rsi
callq 0x31460
movl 0x4(%rsp), %esi
incl %esi
jmp 0x3f9b95
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x2, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
bool baryonyx::itm::is_valid_constraint<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false> const&, int, baryonyx::bit_array const&) | bool
is_valid_constraint(const Solver& slv, int k, const Xtype& x)
{
typename sparse_matrix<int>::const_row_iterator it, et;
std::tie(it, et) = slv.ap.row(k);
int v = 0;
for (; it != et; ++it)
v += slv.factor(it->value) * x[it->column];
return slv.bound_min(k) <= v && v <= slv.bound_max(k);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %edx
leaq 0x10(%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
movq %r15, %rdi
callq 0x3c868
movq (%r15), %r12
movq 0x8(%r15), %r13
xorl %r15d, %r15d
cmpq %r12, %r13
je 0x3f9c38
movslq (%r13), %rax
movq 0x58(%rbx), %rcx
movl 0x4(%r13), %esi
movq %r14, %rdi
movl (%rcx,%rax,4), %ebp
callq 0x3664a
imull %ebp, %eax
addq $0x8, %r13
addl %eax, %r15d
jmp 0x3f9c10
movslq 0x4(%rsp), %rcx
movq 0x70(%rbx), %rax
imulq $0xc, %rcx, %rcx
cmpl %r15d, (%rax,%rcx)
jle 0x3f9c4f
xorl %eax, %eax
jmp 0x3f9c57
cmpl 0x4(%rax,%rcx), %r15d
setle %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::compute_update_row<baryonyx::bit_array, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>>(baryonyx::bit_array&, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>, double, double, double) | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
Float pi_change;
int selected = -2;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x10(%rdi), %rax
movq %rcx, 0x50(%rsp)
leaq 0x60(%rdi), %rcx
movq %rsi, %r15
leaq 0xf0(%rdi), %rsi
vmovsd %xmm2, 0x48(%rsp)
vmovsd %xmm1, 0x40(%rsp)
vmovsd %xmm0, 0x38(%rsp)
movq %rdi, %r12
movq %rdx, 0x30(%rsp)
xorl %ebp, %ebp
movq %rax, 0x28(%rsp)
movq (%rdx), %rax
movq %rcx, (%rsp)
leaq 0x80(%rdi), %rcx
movq %rsi, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x50(%rsp), %rcx
cmpq (%rcx), %rax
je 0x3f9e84
movl -0x4(%rax), %r13d
movq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movl %r13d, %edx
callq 0x3de66
vmovsd 0x48(%rsp), %xmm0
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq %r12, %rdi
callq 0x3fa64a
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
movq %r15, %r14
callq 0x3fa668
movq 0x68(%r12), %rcx
movslq %r13d, %r15
movl %eax, %ebx
movzbl (%rcx,%r15), %eax
pushq $-0x2
popq %r8
cmpq $0x4, %rax
ja 0x3f9e48
leaq 0x6c678(%rip), %rcx # 0x4663b4
movslq %ebx, %rsi
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3f9deb
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3facc4
jmp 0x3f9e45
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r15, %r15
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
callq 0x3fac7c
cmpl $-0x2, %eax
jne 0x3f9e45
movq 0x70(%r12), %rax
movl (%rax,%r15), %ecx
movl 0x4(%rax,%r15), %r8d
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movl %ebx, %edx
callq 0x3fa78e
jmp 0x3f9e45
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3fac7c
cmpl $-0x2, %eax
jne 0x3f9e45
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
movl %r13d, %esi
movl %ebx, %ecx
callq 0x3faa84
movl %eax, %r8d
vmovsd 0x38(%rsp), %xmm0
vmovsd 0x40(%rsp), %xmm1
movq 0x20(%rsp), %rdx
movq %r12, %rdi
movq %r14, %r15
movq %r14, %rsi
movl %r13d, %ecx
movl %ebx, %r9d
callq 0x3fad0c
movq 0x30(%rsp), %rcx
orb %al, %bpl
movq (%rcx), %rax
addq $-0x4, %rax
movq %rax, (%rcx)
jmp 0x3f9cc4
andb $0x1, %bpl
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, double, double, double) | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
Float pi_change;
int selected = -2;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x10(%rdi), %rax
vmovsd %xmm2, 0x48(%rsp)
vmovsd %xmm1, 0x40(%rsp)
vmovsd %xmm0, 0x38(%rsp)
movq %rcx, 0x50(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rax, 0x30(%rsp)
leaq 0x60(%rdi), %rax
movq %rax, (%rsp)
leaq 0xf0(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x80(%rdi), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x50(%rsp), %r14
je 0x3fa0ad
movl (%r14), %r13d
movq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl %eax, 0xc(%rsp)
movl %r13d, %edx
callq 0x3de66
vmovsd 0x48(%rsp), %xmm0
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0x3fa64a
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
movq %r15, %rbp
callq 0x3fa668
movq 0x68(%r12), %rcx
movslq %r13d, %r15
movl %eax, %ebx
movzbl (%rcx,%r15), %eax
pushq $-0x2
popq %r8
cmpq $0x4, %rax
ja 0x3fa077
leaq 0x6c45d(%rip), %rcx # 0x4663c8
movslq %ebx, %rsi
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3fa01a
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3facc4
jmp 0x3fa074
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r15, %r15
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
callq 0x3fac7c
cmpl $-0x2, %eax
jne 0x3fa074
movq 0x70(%r12), %rax
movl (%rax,%r15), %ecx
movl 0x4(%rax,%r15), %r8d
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movl %ebx, %edx
callq 0x3fa78e
jmp 0x3fa074
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3fac7c
cmpl $-0x2, %eax
jne 0x3fa074
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
movl %r13d, %esi
movl %ebx, %ecx
callq 0x3faa84
movl %eax, %r8d
vmovsd 0x38(%rsp), %xmm0
vmovsd 0x40(%rsp), %xmm1
movq 0x28(%rsp), %rdx
movq %r12, %rdi
movq %rbp, %r15
movq %rbp, %rsi
movl %r13d, %ecx
movl %ebx, %r9d
callq 0x3fad0c
movl 0xc(%rsp), %ecx
addq $0x4, %r14
orb %al, %cl
movl %ecx, %eax
jmp 0x3f9ef3
andb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>, double, double, double) | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
Float pi_change;
int selected = -2;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x10(%rdi), %rax
vmovsd %xmm2, 0x48(%rsp)
vmovsd %xmm1, 0x40(%rsp)
vmovsd %xmm0, 0x38(%rsp)
movq %rcx, 0x50(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rax, 0x30(%rsp)
leaq 0x60(%rdi), %rax
movq %rax, (%rsp)
leaq 0xf0(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x80(%rdi), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x50(%rsp), %r14
je 0x3fa2d1
movl (%r14), %r13d
movq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl %eax, 0xc(%rsp)
movl %r13d, %edx
callq 0x3de66
vmovsd 0x48(%rsp), %xmm0
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0x3fa64a
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
movq %r15, %rbp
callq 0x3fa668
movq 0x68(%r12), %rcx
movslq %r13d, %r15
movl %eax, %ebx
movzbl (%rcx,%r15), %eax
pushq $-0x2
popq %r8
cmpq $0x4, %rax
ja 0x3fa29b
leaq 0x6c24d(%rip), %rcx # 0x4663dc
movslq %ebx, %rsi
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3fa23e
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3facc4
jmp 0x3fa298
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r15, %r15
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
callq 0x3fac7c
cmpl $-0x2, %eax
jne 0x3fa298
movq 0x70(%r12), %rax
movl (%rax,%r15), %ecx
movl 0x4(%rax,%r15), %r8d
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movl %ebx, %edx
callq 0x3fa78e
jmp 0x3fa298
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3fac7c
cmpl $-0x2, %eax
jne 0x3fa298
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
movl %r13d, %esi
movl %ebx, %ecx
callq 0x3faa84
movl %eax, %r8d
vmovsd 0x38(%rsp), %xmm0
vmovsd 0x40(%rsp), %xmm1
movq 0x28(%rsp), %rdx
movq %r12, %rdi
movq %rbp, %r15
movq %rbp, %rsi
movl %r13d, %ecx
movl %ebx, %r9d
callq 0x3fad0c
movl 0xc(%rsp), %ecx
addq $0x8, %r14
orb %al, %cl
movl %ecx, %eax
jmp 0x3fa117
andb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::compute_order::local_compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false> const&, baryonyx::bit_array const&) | int local_compute_violated_constraints(const Solver& slv, const Xtype& x)
{
int remaining = 0;
for (int k = 0; k != slv.m; ++k)
if (!is_valid_constraint(slv, k, x))
++remaining;
return remaining;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpl 0x170(%r14), %r15d
je 0x3fa63d
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x3f9bdb
xorb $0x1, %al
incl %r15d
movzbl %al, %eax
addl %eax, %ebp
jmp 0x3fa61a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::compute_reduced_costs<baryonyx::bit_array>(baryonyx::sparse_matrix<int>::row_value*, baryonyx::sparse_matrix<int>::row_value*, baryonyx::bit_array const&) | int compute_reduced_costs(sparse_matrix<int>::row_iterator begin,
sparse_matrix<int>::row_iterator end,
const Xtype& x) noexcept
{
// to_log(
// debug_os, " compute-reduced-cost {}\n", std::distance(begin,
// end));
int r_size = 0;
for (; begin != end; ++begin) {
Float sum_a_pi_p = 0;
for (auto [first, last] = ap.column(begin->column); first != last;
++first) {
auto a = std::abs(static_cast<Float>(A[first->value]));
sum_a_pi_p += a * (pi[first->row] + P[first->value]);
}
R[r_size].id = r_size;
R[r_size].f = A[begin->value];
R[r_size].value = c(begin->column, x) - sum_a_pi_p;
// to_log(debug_os,
// 4u,
// "Compute: {} = {} - {} - {}\n",
// r_size,
// c(begin->column, x),
// sum_pi,
// sum_p);
// to_log(debug_os, 4u, "{}x{}\n", R[r_size].f, R[r_size].value);
++r_size;
}
// to_log(debug_os, "\n");
return r_size;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rdi), %rbp
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
xorl %ebx, %ebx
cmpq %r14, %r15
je 0x3fa74a
movl 0x4(%r15), %edx
leaq 0x18(%rsp), %rdi
movq %rbp, %rsi
callq 0x3dede
vmovddup 0x5d414(%rip), %xmm2 # xmm2 = mem[0,0]
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rdx
movq 0x50(%r13), %rsi
movq 0x58(%r13), %rax
movq 0x78(%r13), %rdi
vxorpd %xmm3, %xmm3, %xmm3
cmpq %rcx, %rdx
je 0x3fa6f8
movslq (%rdx), %r8
movslq 0x4(%rdx), %r9
addq $0x8, %rdx
vcvtsi2sdl (%rax,%r8,4), %xmm4, %xmm0
vmovsd (%rdi,%r9,8), %xmm1
vaddsd (%rsi,%r8,8), %xmm1, %xmm1
movq %rdx, 0x20(%rsp)
vandpd %xmm2, %xmm0, %xmm0
vfmadd231sd %xmm1, %xmm0, %xmm3 # xmm3 = (xmm0 * xmm1) + xmm3
jmp 0x3fa6c6
movq 0x60(%r13), %rcx
movq %rbx, %r12
shlq $0x4, %r12
vmovsd %xmm3, 0x10(%rsp)
movl %ebx, 0x8(%rcx,%r12)
movslq (%r15), %rdx
movl (%rax,%rdx,4), %eax
movq 0x8(%rsp), %rdx
movl %eax, 0xc(%rcx,%r12)
movq 0x168(%r13), %rdi
movl 0x4(%r15), %esi
callq 0x73084
vsubsd 0x10(%rsp), %xmm0, %xmm0
movq 0x60(%r13), %rax
incq %rbx
addq $0x8, %r15
vmovsd %xmm0, (%rax,%r12)
jmp 0x3fa68a
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::branch_and_bound_solver<baryonyx::itm::minimize_tag, double>::solve<std::unique_ptr<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::rc_data [], std::default_delete<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::rc_data []>>>(std::unique_ptr<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::rc_data [], std::default_delete<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::rc_data []>>&, int, int, int) | int solve(R& reduced_cost, int r_size, int bk_min, int bk_max)
{
bx_assert(r_size >= 4);
bx_assert(bk_min <= bk_max);
b_min = bk_min;
b_max = bk_max;
items.resize(r_size);
if (!subvector.init(r_size))
throw solver_failure(solver_error_tag::no_solver_available);
solution = subvector.emplace();
bx_assert(solution == 0u);
nodes.clear();
for (int i = 0; i != r_size; ++i) {
items[i].r = reduced_cost[i].value;
items[i].variable = reduced_cost[i].id;
items[i].original_factor = reduced_cost[i].f;
items[i].factor = std::abs(reduced_cost[i].f);
items[i].result = 0;
}
std::fill_n(
subvector.element_data(solution), subvector.element_size(), 0);
std::sort(std::begin(items), std::end(items));
for (std::size_t i = 0, e = items.size(); i != e; ++i) {
if (items[i].original_factor < 0) {
b_min += items[i].factor;
b_max += items[i].factor;
}
}
// Compute the inversion of the sum z
items.back().sum_z = items.back().r;
for (int i = length(items) - 2; i >= 0; --i)
items[i].sum_z = items[i + 1].sum_z + items[i].r;
if (b_max == b_min)
solve_equality();
else
solve_inequality();
for (int i = 0, e = length(items); i != e; ++i) {
if (items[i].original_factor > 0)
items[i].result = subvector[solution + i] == 0 ? 0 : 1;
else
items[i].result = subvector[solution + i] == 0 ? 1 : 0;
}
std::sort(std::begin(items),
std::end(items),
[](const auto& lhs, const auto& rhs) {
if (lhs.result == rhs.result) {
if constexpr (std::is_same_v<Mode, minimize_tag>)
return lhs.r < rhs.r;
else
return lhs.r > rhs.r;
} else
return lhs.result > rhs.result;
});
auto middle =
std::find_if(std::begin(items),
std::end(items),
[](const auto& item) { return item.result == 0; });
for (std::size_t i = 0, e = items.size(); i != e; ++i) {
reduced_cost[i].value = items[i].r;
reduced_cost[i].id = items[i].variable;
reduced_cost[i].f = items[i].original_factor;
}
if (middle == std::end(items))
return items[0].result == 0 ? -1 : r_size;
return static_cast<int>(std::distance(std::begin(items), middle) - 1);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x3, %edx
jle 0x3fa9e2
cmpl %r8d, %ecx
jg 0x3faa03
leaq 0x20(%rdi), %r13
movl %ecx, 0x64(%rdi)
movl %edx, %ebx
movq %rsi, %r14
movl %edx, %r12d
movq %rdi, %r15
movl %r8d, 0x68(%rdi)
movq %r12, %rsi
movq %r13, %rdi
callq 0x3dffae
movq %r15, %rdi
movl %ebx, %esi
callq 0x36e080
testb %al, %al
je 0x3faa45
movq %r15, %rdi
callq 0x36e100
movl %eax, 0x60(%r15)
testl %eax, %eax
jne 0x3faa24
movq 0x38(%r15), %rax
cmpq %rax, 0x40(%r15)
je 0x3fa800
movq %rax, 0x40(%r15)
movq (%r14), %rax
movq (%r13), %rcx
shlq $0x4, %r12
xorl %edx, %edx
cmpq %rdx, %r12
je 0x3fa842
vmovsd (%rax,%rdx), %xmm0
vmovsd %xmm0, (%rcx,%rdx,2)
movl 0x8(%rax,%rdx), %esi
movl %esi, 0x18(%rcx,%rdx,2)
movl 0xc(%rax,%rdx), %esi
movl %esi, %edi
negl %edi
movl %esi, 0x14(%rcx,%rdx,2)
cmovsl %esi, %edi
movl %edi, 0x10(%rcx,%rdx,2)
andl $0x0, 0x1c(%rcx,%rdx,2)
addq $0x10, %rdx
jmp 0x3fa80d
movq %r15, %rdi
xorl %esi, %esi
callq 0x36e156
leaq 0x4(%rsp), %rdx
movl 0x18(%r15), %esi
movq %rax, %rdi
andl $0x0, (%rdx)
callq 0x36e561
movq 0x20(%r15), %rdi
movq 0x28(%r15), %rsi
callq 0x3e030b
movq 0x20(%r15), %rax
movq 0x28(%r15), %rdi
movl 0x64(%r15), %edx
movl 0x68(%r15), %esi
movq %rdi, %rcx
subq %rax, %rcx
leaq 0x14(%rax), %r9
movq %rcx, %r8
sarq $0x5, %r8
subq $0x1, %r8
jb 0x3fa8b2
cmpl $0x0, (%r9)
jns 0x3fa8ac
movl -0x4(%r9), %r10d
addl %r10d, %edx
addl %r10d, %esi
movl %edx, 0x64(%r15)
movl %esi, 0x68(%r15)
addq $0x20, %r9
jmp 0x3fa88e
vmovsd -0x20(%rdi), %xmm0
shrq $0x5, %rcx
addl $-0x2, %ecx
vmovsd %xmm0, -0x18(%rdi)
leaq 0x28(%rax), %rdi
testl %ecx, %ecx
js 0x3fa8e9
movl %ecx, %r8d
shlq $0x5, %r8
decl %ecx
vmovsd (%rdi,%r8), %xmm0
vaddsd (%rax,%r8), %xmm0, %xmm0
vmovsd %xmm0, 0x8(%rax,%r8)
jmp 0x3fa8c7
movl %ebx, (%rsp)
movq %r14, %rbx
movq %r15, %rdi
cmpl %edx, %esi
jne 0x3fa8fd
callq 0x3dffe2
jmp 0x3fa902
callq 0x3e00b4
movq 0x20(%r15), %rcx
movq 0x28(%r15), %rax
movabsq $0x1fffffffe0, %r12 # imm = 0x1FFFFFFFE0
xorl %r13d, %r13d
xorl %ebp, %ebp
subq %rcx, %rax
andq %rax, %r12
cmpq %rbp, %r12
je 0x3fa959
cmpl $0x0, 0x14(%rcx,%rbp)
movl 0x60(%r15), %esi
movq %r15, %rdi
setg %r14b
addl %r13d, %esi
callq 0x36e328
cmpb $0x0, (%rax)
movq 0x20(%r15), %rcx
sete %al
incl %r13d
xorb %r14b, %al
movzbl %al, %eax
movl %eax, 0x1c(%rcx,%rbp)
addq $0x20, %rbp
jmp 0x3fa91f
movq 0x20(%r15), %rdi
movq 0x28(%r15), %rsi
callq 0x3fb6e8
movq 0x20(%r15), %rdi
movq 0x28(%r15), %rsi
callq 0x3fbdad
movq 0x28(%r15), %rdx
movq 0x20(%r15), %rcx
movq (%rbx), %rdi
movl (%rsp), %r9d
xorl %r8d, %r8d
movq %rdx, %rsi
subq %rcx, %rsi
sarq $0x5, %rsi
subq $0x1, %rsi
jb 0x3fa9ba
vmovsd (%rcx,%r8,2), %xmm0
vmovsd %xmm0, (%rdi,%r8)
vmovsd 0x14(%rcx,%r8,2), %xmm0
vshufps $0xe1, %xmm0, %xmm0, %xmm0 # xmm0 = xmm0[1,0,2,3]
vmovlpd %xmm0, 0x8(%rdi,%r8)
addq $0x10, %r8
jmp 0x3fa98f
cmpq %rdx, %rax
je 0x3fa9ca
subq %rcx, %rax
shrq $0x5, %rax
decl %eax
jmp 0x3fa9d3
cmpl $0x1, 0x1c(%rcx)
sbbl %eax, %eax
orl %r9d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5e783(%rip), %rdi # 0x45916c
leaq 0x6c275(%rip), %rsi # 0x466c65
leaq 0x6c27a(%rip), %rdx # 0x466c71
leaq 0x6c2dc(%rip), %rcx # 0x466cda
callq 0x2813f
leaq 0x5e762(%rip), %rdi # 0x45916c
leaq 0x6c2cd(%rip), %rsi # 0x466cde
leaq 0x6c259(%rip), %rdx # 0x466c71
leaq 0x6c2d0(%rip), %rcx # 0x466cef
callq 0x2813f
leaq 0x5e741(%rip), %rdi # 0x45916c
leaq 0x6c2c1(%rip), %rsi # 0x466cf3
leaq 0x6c238(%rip), %rdx # 0x466c71
leaq 0x6c2c2(%rip), %rcx # 0x466d02
callq 0x2813f
pushq $0x18
popq %rdi
callq 0xb210
movq %rax, %rbx
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x36e0d4
movq 0x24255e(%rip), %rdx # 0x63cfc0
leaq 0x23f9a7(%rip), %rsi # 0x63a410
movq %rbx, %rdi
callq 0xb3c0
movq %rbx, %rdi
movq %rax, %r14
callq 0xb570
movq %r14, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/branch-and-bound-solver.hpp |
int baryonyx::itm::exhaustive_solver<baryonyx::itm::minimize_tag, double>::solve<std::unique_ptr<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::rc_data [], std::default_delete<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::rc_data []>>>(int, std::unique_ptr<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::rc_data [], std::default_delete<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::rc_data []>>&, int) | int solve(int k, R& reduced_cost, int r_size)
{
const auto it_constraint = constraints.find(k);
bx_expects(it_constraint != constraints.end());
items.resize(r_size);
for (int i = 0; i != r_size; ++i) {
items[i].r = reduced_cost[i].value;
items[i].variable = reduced_cost[i].id;
items[i].factor = reduced_cost[i].f;
items[i].result = 0;
}
Float z_best = 0;
auto best = 0;
auto start_solution = it_constraint->start;
for (int j = 0; j != r_size; ++j)
if (flat_constraints[start_solution + j])
z_best += reduced_cost[j].value;
for (auto i = 1; i != it_constraint->solutions; ++i) {
start_solution = it_constraint->start + (i * r_size);
Float z = 0;
for (int j = 0; j != r_size; ++j)
if (flat_constraints[start_solution + j])
z += reduced_cost[j].value;
if (is_best_solution(z, z_best)) {
z_best = z;
best = i;
}
}
start_solution = it_constraint->start + (best * r_size);
for (int i = 0; i != r_size; ++i)
items[i].result = flat_constraints[start_solution + i] ? 1 : 0;
std::sort(std::begin(items),
std::end(items),
[](const auto& lhs, const auto& rhs) {
if (lhs.result == rhs.result) {
if constexpr (std::is_same_v<Mode, minimize_tag>)
return lhs.r < rhs.r;
else
return lhs.r > rhs.r;
} else
return lhs.result > rhs.result;
});
auto middle =
std::find_if(std::begin(items),
std::end(items),
[](const auto& item) { return item.result == 0; });
for (std::size_t i = 0, e = items.size(); i != e; ++i) {
reduced_cost[i].value = items[i].r;
reduced_cost[i].id = items[i].variable;
reduced_cost[i].f = items[i].factor;
}
if (middle == std::end(items))
return items[0].result == 0 ? -1 : r_size;
return static_cast<int>(std::distance(std::begin(items), middle) - 1);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0xc(%rsp), %rax
movq %rdi, %r15
addq $0x48, %rdi
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, (%rax)
andq $0x0, 0xc(%rax)
movq %rax, %rsi
callq 0x3e1972
leaq 0x50(%r15), %rcx
movq %rax, %r13
cmpq %rcx, %r13
je 0x3fac5a
movslq %ebx, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3e193a
movq (%r14), %rcx
movq (%r15), %rdx
movl %r12d, %eax
imulq $0x18, %rax, %rsi
xorl %edi, %edi
addq $0x8, %rcx
cmpq %rdi, %rsi
je 0x3fab0f
vmovsd -0x8(%rcx), %xmm0
vmovsd %xmm0, (%rdx,%rdi)
vmovsd (%rcx), %xmm0
addq $0x10, %rcx
vshufps $0xe1, %xmm0, %xmm0, %xmm0 # xmm0 = xmm0[1,0,2,3]
vmovlpd %xmm0, 0x8(%rdx,%rdi)
andl $0x0, 0x10(%rdx,%rdi)
addq $0x18, %rdi
jmp 0x3faae2
movslq 0x24(%r13), %rdx
movq 0x18(%r15), %rcx
movq (%r14), %rsi
leaq (,%rax,4), %rdi
vxorpd %xmm0, %xmm0, %xmm0
xorl %r9d, %r9d
leaq (%rcx,%rdx,4), %r8
cmpq %r9, %rdi
je 0x3fab45
cmpl $0x0, (%r8,%r9)
je 0x3fab3f
vaddsd (%rsi,%r9,4), %xmm0, %xmm0
addq $0x4, %r9
jmp 0x3fab2d
leaq (,%rdx,4), %r9
movl 0x28(%r13), %r8d
leaq (%r9,%r12,4), %r10
shlq $0x2, %r12
xorl %r9d, %r9d
addq %rcx, %r10
pushq $0x1
popq %r11
cmpq %r8, %r11
je 0x3fab9b
vxorpd %xmm1, %xmm1, %xmm1
xorl %r13d, %r13d
cmpq %r13, %rdi
je 0x3fab87
cmpl $0x0, (%r10,%r13)
je 0x3fab81
vaddsd (%rsi,%r13,4), %xmm1, %xmm1
addq $0x4, %r13
jmp 0x3fab6f
vucomisd %xmm1, %xmm0
vminsd %xmm0, %xmm1, %xmm0
cmoval %r11d, %r9d
incq %r11
addq %r12, %r10
jmp 0x3fab63
imull %ebx, %r9d
addl %edx, %r9d
movq (%r15), %rdx
movslq %r9d, %rsi
leaq (%rcx,%rsi,4), %rcx
xorl %esi, %esi
addq $0x10, %rdx
cmpq %rsi, %rax
je 0x3fabcc
xorl %edi, %edi
cmpl $0x0, (%rcx,%rsi,4)
setne %dil
incq %rsi
movl %edi, (%rdx)
addq $0x18, %rdx
jmp 0x3fabb2
movq (%r15), %rdi
movq 0x8(%r15), %rsi
callq 0x3fbe3a
movq (%r15), %rdi
movq 0x8(%r15), %rsi
callq 0x3fc58a
movq (%r15), %rsi
movq 0x8(%r15), %r8
movq %rax, %rcx
movq %r8, %rax
subq %rsi, %rax
pushq $0x18
popq %rdi
cqto
leaq 0x8(%rsi), %r9
idivq %rdi
movq (%r14), %rdx
addq $0x8, %rdx
subq $0x1, %rax
jb 0x3fac30
vmovsd -0x8(%r9), %xmm0
vmovsd %xmm0, -0x8(%rdx)
vmovsd (%r9), %xmm0
addq $0x18, %r9
vshufps $0xe1, %xmm0, %xmm0, %xmm0 # xmm0 = xmm0[1,0,2,3]
vmovlpd %xmm0, (%rdx)
addq $0x10, %rdx
jmp 0x3fac07
cmpq %r8, %rcx
je 0x3fac44
subq %rsi, %rcx
movq %rcx, %rax
cqto
idivq %rdi
decl %eax
jmp 0x3fac4c
cmpl $0x1, 0x10(%rsi)
sbbl %eax, %eax
orl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x5d57d(%rip), %rdi # 0x4581de
leaq 0x6c11e(%rip), %rsi # 0x466d86
leaq 0x6bf09(%rip), %rdx # 0x466b78
leaq 0x5d7b0(%rip), %rcx # 0x458426
callq 0x2813f
nop
| /quesnel[P]baryonyx/lib/src/exhaustive-solver.hpp |
baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::select_variables(int, int, int) | int select_variables(const int r_size, int bkmin, int bkmax)
{
int sum = 0;
int best = -2;
for (int i = -1; i < r_size; ++i) {
if (bkmin <= sum && sum <= bkmax)
best = i;
if (best != -2 && i - 1 < r_size &&
stop_iterating<Mode>(R[i + 1].value))
break;
sum += R[i + 1].f;
}
return best;
} | movq 0x60(%rdi), %rdi
movslq %esi, %rsi
pushq $-0x2
popq %rax
xorl %r8d, %r8d
pushq $-0x1
popq %r9
vxorpd %xmm0, %xmm0, %xmm0
cmpq %rsi, %r9
jge 0x3facc3
cmpl %ecx, %r8d
movl %r9d, %r10d
cmovgl %eax, %r10d
cmpl %edx, %r8d
cmovgel %r10d, %eax
cmpl $-0x2, %eax
je 0x3facb6
vmovsd (%rdi), %xmm1
vucomisd %xmm0, %xmm1
ja 0x3facc3
addl 0xc(%rdi), %r8d
incq %r9
addq $0x10, %rdi
jmp 0x3fac91
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::select_variables_101(int, int, int) | int select_variables_101(const int r_size, int bkmin, int bkmax)
{
int sum = 0;
int best = -2;
for (int i = -1; i < r_size; ++i) {
if (bkmin <= sum && sum <= bkmax)
best = i;
if (best != -2 && i - 1 < r_size &&
stop_iterating<Mode>(R[i + 1].value))
break;
sum += R[i + 1].f;
}
return best;
} | movq 0x60(%rdi), %rdi
movslq %esi, %rsi
pushq $-0x2
popq %rax
xorl %r8d, %r8d
pushq $-0x1
popq %r9
vxorpd %xmm0, %xmm0, %xmm0
cmpq %rsi, %r9
jge 0x3fad0b
cmpl %ecx, %r8d
movl %r9d, %r10d
cmovgl %eax, %r10d
cmpl %edx, %r8d
cmovgel %r10d, %eax
cmpl $-0x2, %eax
je 0x3facfe
vmovsd (%rdi), %xmm1
vucomisd %xmm0, %xmm1
ja 0x3fad0b
addl 0xc(%rdi), %r8d
incq %r9
addq $0x10, %rdi
jmp 0x3facd9
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::local_affect<baryonyx::bit_array, baryonyx::sparse_matrix<int>::row_value*>(baryonyx::bit_array&, baryonyx::sparse_matrix<int>::row_value*, int, int, int, double, double) | bool local_affect(Xtype& x,
Iterator it,
int k,
int selected,
int r_size,
const Float kappa,
const Float delta)
{
constexpr Float one{ 1 };
constexpr Float two{ 2 };
constexpr Float middle{ (two + one) / two };
const auto old_pi = pi[k];
auto d = (kappa / (one - kappa)) + delta;
if (selected < 0) {
pi[k] += R[0].value / two;
logger::log(" selected: {}/{} ({})/2 = pi {}\n",
selected,
r_size,
R[0].value,
pi[k]);
for (int i = 0; i != r_size; ++i) {
auto var = it + R[i].id;
x.unset(var->column);
P[var->value] -= d;
auto repair = local_compute_reduced_cost(var->column, x);
if (repair <= 0)
P[var->value] = P[var->value] + repair - d;
}
} else if (selected + 1 >= r_size) {
pi[k] += R[selected].value * middle;
logger::log(" selected: {}/{} ({})/2 = pi {}\n",
selected,
r_size,
R[selected].value,
pi[k]);
for (int i = 0; i != r_size; ++i) {
auto var = it + R[i].id;
x.set(var->column);
P[var->value] += d;
auto repair = local_compute_reduced_cost(var->column, x);
if (repair >= 0)
P[var->value] = P[var->value] - repair + d;
}
} else {
pi[k] += ((R[selected].value + R[selected + 1].value) / two);
logger::log(" selected: {}/{} ({}x{})/2 = pi {}\n",
selected,
r_size,
R[selected].value,
R[selected + 1].value,
pi[k]);
int i = 0;
for (; i <= selected; ++i) {
auto var = it + R[i].id;
x.set(var->column);
P[var->value] += d;
auto repair = local_compute_reduced_cost(var->column, x);
if (repair >= 0)
P[var->value] = P[var->value] - repair + d;
}
for (; i != r_size; ++i) {
auto var = it + R[i].id;
x.unset(var->column);
P[var->value] -= d;
auto repair = local_compute_reduced_cost(var->column, x);
if (repair <= 0)
P[var->value] = P[var->value] + repair - d;
}
}
// TODO job: develops is_valid_constraint for all the solvers
bx_expects(is_valid_constraint(*this, k, x));
return is_signbit_change(old_pi, pi[k]);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
vmovsd 0x59316(%rip), %xmm2 # 0x454038
movq 0x78(%rdi), %rax
movq %rsi, %r14
movslq %ecx, %rsi
movq %rdx, %r15
movq %rdi, %rbx
movl %ecx, 0xc(%rsp)
movq %rsi, 0x18(%rsp)
vmovsd (%rax,%rsi,8), %xmm3
vsubsd %xmm0, %xmm2, %xmm2
vdivsd %xmm2, %xmm0, %xmm0
vmovapd %xmm3, 0x20(%rsp)
vaddsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, (%rsp)
testl %r8d, %r8d
js 0x3fae17
movq 0x60(%rbx), %rcx
movl %r8d, %edx
shlq $0x4, %rdx
incl %r8d
vmovsd (%rcx,%rdx), %xmm0
cmpl %r9d, %r8d
jge 0x3faea6
movl %r8d, %ebp
movq %rbp, 0x10(%rsp)
shlq $0x4, %rbp
xorl %r13d, %r13d
movl %r9d, 0x8(%rsp)
vaddsd (%rcx,%rbp), %xmm0, %xmm0
vmulsd 0x5dbdb(%rip), %xmm0, %xmm0 # 0x458978
vaddsd %xmm0, %xmm3, %xmm0
vmovsd %xmm0, (%rax,%rsi,8)
cmpq %r13, %rbp
je 0x3faf2e
movq 0x60(%rbx), %rax
movq %r14, %rdi
movslq 0x8(%rax,%r13), %r12
movl 0x4(%r15,%r12,8), %esi
callq 0x369c8
movslq (%r15,%r12,8), %rax
movq 0x50(%rbx), %rcx
vmovsd (%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rdx
vaddsd (%rcx,%rax,8), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
movl 0x4(%r15,%r12,8), %esi
callq 0x3fc628
vucomisd 0x5922c(%rip), %xmm0 # 0x454020
jb 0x3fae11
movslq (%r15,%r12,8), %rax
movq 0x50(%rbx), %rcx
vmovsd (%rcx,%rax,8), %xmm1
vsubsd %xmm0, %xmm1, %xmm0
vaddsd (%rsp), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
addq $0x10, %r13
jmp 0x3fada6
movq 0x60(%rbx), %rcx
movl %r9d, %r12d
shlq $0x4, %r12
xorl %ebp, %ebp
vmovsd (%rcx), %xmm0
vmulsd 0x5db48(%rip), %xmm0, %xmm0 # 0x458978
vaddsd %xmm0, %xmm3, %xmm0
vmovsd %xmm0, (%rax,%rsi,8)
cmpq %rbp, %r12
je 0x3fafa5
movq 0x60(%rbx), %rax
movq %r14, %rdi
movslq 0x8(%rax,%rbp), %r13
movl 0x4(%r15,%r13,8), %esi
callq 0x36a06
movslq (%r15,%r13,8), %rax
movq 0x50(%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rdx
vmovsd (%rcx,%rax,8), %xmm0
vsubsd (%rsp), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
movl 0x4(%r15,%r13,8), %esi
callq 0x3fc628
vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm0, %xmm1
jb 0x3faea0
movslq (%r15,%r13,8), %rax
movq 0x50(%rbx), %rcx
vaddsd (%rcx,%rax,8), %xmm0, %xmm0
vsubsd (%rsp), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
addq $0x10, %rbp
jmp 0x3fae39
vfmadd132sd 0x60e11(%rip), %xmm3, %xmm0 # xmm0 = (xmm0 * mem) + xmm3
movl %r9d, %r12d
shlq $0x4, %r12
xorl %ebp, %ebp
vmovsd %xmm0, (%rax,%rsi,8)
cmpq %rbp, %r12
je 0x3fafa5
movq 0x60(%rbx), %rax
movq %r14, %rdi
movslq 0x8(%rax,%rbp), %r13
movl 0x4(%r15,%r13,8), %esi
callq 0x369c8
movslq (%r15,%r13,8), %rax
movq 0x50(%rbx), %rcx
vmovsd (%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rdx
vaddsd (%rcx,%rax,8), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
movl 0x4(%r15,%r13,8), %esi
callq 0x3fc628
vucomisd 0x59115(%rip), %xmm0 # 0x454020
jb 0x3faf28
movslq (%r15,%r13,8), %rax
movq 0x50(%rbx), %rcx
vmovsd (%rcx,%rax,8), %xmm1
vsubsd %xmm0, %xmm1, %xmm0
vaddsd (%rsp), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
addq $0x10, %rbp
jmp 0x3faebd
movl 0x8(%rsp), %r12d
orq $0x8, %rbp
subq 0x10(%rsp), %r12
subq $0x1, %r12
jb 0x3fafa5
movq 0x60(%rbx), %rax
movq %r14, %rdi
movslq (%rax,%rbp), %r13
movl 0x4(%r15,%r13,8), %esi
callq 0x36a06
movslq (%r15,%r13,8), %rax
movq 0x50(%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rdx
vmovsd (%rcx,%rax,8), %xmm0
vsubsd (%rsp), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
movl 0x4(%r15,%r13,8), %esi
callq 0x3fc628
vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm0, %xmm1
jb 0x3faf9f
movslq (%r15,%r13,8), %rax
movq 0x50(%rbx), %rcx
vaddsd (%rcx,%rax,8), %xmm0, %xmm0
vsubsd (%rsp), %xmm0, %xmm0
vmovsd %xmm0, (%rcx,%rax,8)
addq $0x10, %rbp
jmp 0x3faf3c
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3f9bdb
testb %al, %al
je 0x3fafe6
vmovapd 0x20(%rsp), %xmm0
movq 0x78(%rbx), %rcx
movq 0x18(%rsp), %rdx
vmovmskpd %xmm0, %eax
shlq $0x3f, %rax
xorq (%rcx,%rdx,8), %rax
shrq $0x3f, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5d1f1(%rip), %rdi # 0x4581de
leaq 0x5f490(%rip), %rsi # 0x45a484
leaq 0x6bae6(%rip), %rdx # 0x466ae1
leaq 0x6bdf2(%rip), %rcx # 0x466df4
callq 0x2813f
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
void baryonyx::itm::random_shuffle_unique<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::rc_data*>(baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::rc_data*, baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::rc_data*, std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&) | inline void
random_shuffle_unique(iteratorT begin,
iteratorT end,
random_engine& rng) noexcept
{
auto ret = begin++;
for (; begin != end; ++begin) {
if (ret->value != begin->value) {
std::shuffle(ret, begin, rng);
ret = begin;
}
}
std::shuffle(ret, begin, rng);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x10(%rdi), %rsi
cmpq %r14, %rsi
je 0x3fb042
vmovsd (%rdi), %xmm0
leaq 0x10(%rsi), %r15
vucomisd (%rsi), %xmm0
movq %r15, %rsi
jne 0x3fb02e
jnp 0x3fb016
addq $-0x10, %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3fb563
movq %r15, %rdi
jmp 0x3fb012
movq %rbx, %rdx
callq 0x3fb563
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3fb052
movq %rax, %rdi
callq 0xeb9f
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
double baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::local_compute_reduced_cost<baryonyx::bit_array>(int, baryonyx::bit_array const&) | Float local_compute_reduced_cost(int variable, const Xtype& x) noexcept
{
Float sum_a_pi_p = 0;
for (auto [ht, hte] = ap.column(variable); ht != hte; ++ht) {
auto a = std::abs(static_cast<Float>(A[ht->value]));
sum_a_pi_p += a * (pi[ht->row] + P[ht->value]);
}
return c(variable, x) - sum_a_pi_p;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
leaq 0x10(%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %rdx, %rbx
movq %rdi, %r14
movl %ebp, %edx
movq %r15, %rdi
callq 0x3dede
vmovddup 0x5b46b(%rip), %xmm0 # xmm0 = mem[0,0]
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq 0x50(%r14), %rdx
movq 0x58(%r14), %rsi
movq 0x78(%r14), %rdi
vxorpd %xmm3, %xmm3, %xmm3
cmpq %rax, %rcx
je 0x3fc69e
movslq (%rcx), %r8
movslq 0x4(%rcx), %r9
addq $0x8, %rcx
vcvtsi2sdl (%rsi,%r8,4), %xmm4, %xmm1
vmovsd (%rdi,%r9,8), %xmm2
vaddsd (%rdx,%r8,8), %xmm2, %xmm2
movq %rcx, 0x10(%rsp)
vandpd %xmm0, %xmm1, %xmm1
vfmadd231sd %xmm2, %xmm1, %xmm3 # xmm3 = (xmm1 * xmm2) + xmm3
jmp 0x3fc66c
movq 0x168(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
vmovsd %xmm3, (%rsp)
callq 0x73084
vsubsd (%rsp), %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::push_and_compute_update_row<baryonyx::bit_array, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>>(baryonyx::bit_array&, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>, double, double, double, double) | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
Float obj_amp)
{
auto at_least_one_pi_changed{ false };
logger::log("push-update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
// Before sort and select variables, we apply the push method: for
// each reduces cost, we had the cost multiply with an objective
// amplifier.
for (int i = 0; i != r_size; ++i)
R[i].value +=
obj_amp * c((std::get<0>(it) + R[i].id)->column, x);
Float pi_change;
int selected;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
default:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq 0x10(%rdi), %rax
movq %rcx, 0x68(%rsp)
leaq 0x60(%rdi), %rcx
movq %rsi, %r15
leaq 0xf0(%rdi), %rsi
vmovsd %xmm3, 0x70(%rsp)
vmovsd %xmm2, 0x60(%rsp)
vmovsd %xmm1, 0x58(%rsp)
vmovsd %xmm0, 0x50(%rsp)
movq %rdi, %r12
movq %rdx, 0x48(%rsp)
xorl %r14d, %r14d
movq %rax, 0x40(%rsp)
movq (%rdx), %rax
movq %rcx, 0x18(%rsp)
leaq 0x80(%rdi), %rcx
movq %rsi, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x68(%rsp), %rcx
cmpq (%rcx), %rax
je 0x3fdc03
movl -0x4(%rax), %eax
movq 0x40(%rsp), %rsi
movq %r14, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
movslq %eax, %r14
movl %eax, 0x14(%rsp)
movl %r14d, %edx
callq 0x3de66
vmovsd 0x60(%rsp), %xmm0
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0x3fa64a
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
callq 0x3fa668
movl %eax, %ebp
shlq $0x4, %rbp
movl %eax, %ebx
xorl %r13d, %r13d
cmpq %r13, %rbp
je 0x3fda94
movq 0x60(%r12), %rax
movq 0x28(%rsp), %rcx
movq 0x168(%r12), %rdi
movq %r15, %rdx
movslq 0x8(%rax,%r13), %rax
movl 0x4(%rcx,%rax,8), %esi
callq 0x73084
movq 0x60(%r12), %rax
vmovsd 0x70(%rsp), %xmm1
vfmadd213sd (%rax,%r13), %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + mem
vmovsd %xmm0, (%rax,%r13)
addq $0x10, %r13
jmp 0x3fda4f
movq 0x68(%r12), %rax
movslq %ebx, %rsi
movzbl (%rax,%r14), %eax
cmpq $0x3, %rax
ja 0x3fdbc8
leaq 0x68952(%rip), %rcx # 0x466404
movl 0x14(%rsp), %ebp
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r14, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3fdb2d
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r14, %r14
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%r14), %edx
movl 0x4(%rax,%r14), %ecx
callq 0x3fac7c
cmpl $-0x2, %eax
jne 0x3fdb88
movq 0x70(%r12), %rax
movl (%rax,%r14), %ecx
movl 0x4(%rax,%r14), %r8d
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl %ebx, %edx
callq 0x3fa78e
jmp 0x3fdb88
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r14, %rcx
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3fac7c
cmpl $-0x2, %eax
jne 0x3fdb88
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl %ebp, %esi
movl %ebx, %ecx
callq 0x3faa84
movq 0x8(%rsp), %r14
vmovsd 0x50(%rsp), %xmm0
vmovsd 0x58(%rsp), %xmm1
movq 0x28(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %ecx
movl %eax, %r8d
movl %ebx, %r9d
callq 0x3fad0c
movq 0x48(%rsp), %rcx
orb %al, %r14b
movq (%rcx), %rax
addq $-0x4, %rax
movq %rax, (%rcx)
jmp 0x3fd9e8
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %r14, %rcx
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3facc4
movq 0x8(%rsp), %r14
movl 0x14(%rsp), %ebp
jmp 0x3fdb8d
andb $0x1, %r14b
movl %r14d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, double, double, double, double) | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
Float obj_amp)
{
auto at_least_one_pi_changed{ false };
logger::log("push-update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
// Before sort and select variables, we apply the push method: for
// each reduces cost, we had the cost multiply with an objective
// amplifier.
for (int i = 0; i != r_size; ++i)
R[i].value +=
obj_amp * c((std::get<0>(it) + R[i].id)->column, x);
Float pi_change;
int selected;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
default:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x68(%rsp)
leaq 0x60(%rdi), %rcx
movq %rdx, %r14
leaq 0x10(%rdi), %rax
leaq 0xf0(%rdi), %rdx
vmovsd %xmm3, 0x70(%rsp)
vmovsd %xmm2, 0x60(%rsp)
vmovsd %xmm1, 0x58(%rsp)
vmovsd %xmm0, 0x50(%rsp)
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq %rcx, 0x20(%rsp)
leaq 0x80(%rdi), %rcx
movq %rax, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
cmpq 0x68(%rsp), %r14
je 0x3fde9d
movl (%r14), %eax
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %r13, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movslq %eax, %rbp
movl %eax, 0xc(%rsp)
movl %ebp, %edx
callq 0x3de66
vmovsd 0x60(%rsp), %xmm0
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
callq 0x3fa64a
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
callq 0x3fa668
movl %eax, %r13d
shlq $0x4, %r13
movl %eax, %ebx
xorl %r14d, %r14d
cmpq %r14, %r13
je 0x3fdd29
movq 0x60(%r12), %rax
movq 0x30(%rsp), %rcx
movq 0x168(%r12), %rdi
movq %r15, %rdx
movslq 0x8(%rax,%r14), %rax
movl 0x4(%rcx,%rax,8), %esi
callq 0x73084
movq 0x60(%r12), %rax
vmovsd 0x70(%rsp), %xmm1
vfmadd213sd (%rax,%r14), %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + mem
vmovsd %xmm0, (%rax,%r14)
addq $0x10, %r14
jmp 0x3fdce4
movq 0x68(%r12), %rax
movslq %ebx, %rsi
movzbl (%rax,%rbp), %eax
cmpq $0x3, %rax
ja 0x3fde2f
leaq 0x686ce(%rip), %rcx # 0x466414
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3fddc1
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %r14
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%r14), %edx
movl 0x4(%rax,%r14), %ecx
callq 0x3fac7c
cmpl $-0x2, %eax
jne 0x3fde5f
movq 0x70(%r12), %rax
movl (%rax,%r14), %ecx
movl 0x4(%rax,%r14), %r8d
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %ebx, %edx
callq 0x3fa78e
jmp 0x3fde5f
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rcx
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3fac7c
cmpl $-0x2, %eax
jne 0x3fde5f
movl 0xc(%rsp), %ebp
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl %ebx, %ecx
movl %ebp, %esi
callq 0x3faa84
movq 0x18(%rsp), %r14
movq 0x10(%rsp), %r13
jmp 0x3fde6d
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rcx
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3facc4
movq 0x18(%rsp), %r14
movq 0x10(%rsp), %r13
movl 0xc(%rsp), %ebp
vmovsd 0x50(%rsp), %xmm0
vmovsd 0x58(%rsp), %xmm1
movq 0x30(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %ecx
movl %eax, %r8d
movl %ebx, %r9d
callq 0x3fad0c
orb %al, %r13b
addq $0x4, %r14
jmp 0x3fdc7b
andb $0x1, %r13b
movl %r13d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>, double, double, double, double) | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
Float obj_amp)
{
auto at_least_one_pi_changed{ false };
logger::log("push-update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
// Before sort and select variables, we apply the push method: for
// each reduces cost, we had the cost multiply with an objective
// amplifier.
for (int i = 0; i != r_size; ++i)
R[i].value +=
obj_amp * c((std::get<0>(it) + R[i].id)->column, x);
Float pi_change;
int selected;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
default:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x68(%rsp)
leaq 0x60(%rdi), %rcx
movq %rdx, %r14
leaq 0x10(%rdi), %rax
leaq 0xf0(%rdi), %rdx
vmovsd %xmm3, 0x70(%rsp)
vmovsd %xmm2, 0x60(%rsp)
vmovsd %xmm1, 0x58(%rsp)
vmovsd %xmm0, 0x50(%rsp)
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq %rcx, 0x20(%rsp)
leaq 0x80(%rdi), %rcx
movq %rax, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
cmpq 0x68(%rsp), %r14
je 0x3fe137
movl (%r14), %eax
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %r13, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movslq %eax, %rbp
movl %eax, 0xc(%rsp)
movl %ebp, %edx
callq 0x3de66
vmovsd 0x60(%rsp), %xmm0
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
callq 0x3fa64a
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
callq 0x3fa668
movl %eax, %r13d
shlq $0x4, %r13
movl %eax, %ebx
xorl %r14d, %r14d
cmpq %r14, %r13
je 0x3fdfc3
movq 0x60(%r12), %rax
movq 0x30(%rsp), %rcx
movq 0x168(%r12), %rdi
movq %r15, %rdx
movslq 0x8(%rax,%r14), %rax
movl 0x4(%rcx,%rax,8), %esi
callq 0x73084
movq 0x60(%r12), %rax
vmovsd 0x70(%rsp), %xmm1
vfmadd213sd (%rax,%r14), %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + mem
vmovsd %xmm0, (%rax,%r14)
addq $0x10, %r14
jmp 0x3fdf7e
movq 0x68(%r12), %rax
movslq %ebx, %rsi
movzbl (%rax,%rbp), %eax
cmpq $0x3, %rax
ja 0x3fe0c9
leaq 0x68444(%rip), %rcx # 0x466424
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3fe05b
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %r14
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%r14), %edx
movl 0x4(%rax,%r14), %ecx
callq 0x3fac7c
cmpl $-0x2, %eax
jne 0x3fe0f9
movq 0x70(%r12), %rax
movl (%rax,%r14), %ecx
movl 0x4(%rax,%r14), %r8d
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %ebx, %edx
callq 0x3fa78e
jmp 0x3fe0f9
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rcx
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3fac7c
cmpl $-0x2, %eax
jne 0x3fe0f9
movl 0xc(%rsp), %ebp
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl %ebx, %ecx
movl %ebp, %esi
callq 0x3faa84
movq 0x18(%rsp), %r14
movq 0x10(%rsp), %r13
jmp 0x3fe107
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rcx
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3facc4
movq 0x18(%rsp), %r14
movq 0x10(%rsp), %r13
movl 0xc(%rsp), %ebp
vmovsd 0x50(%rsp), %xmm0
vmovsd 0x58(%rsp), %xmm1
movq 0x30(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %ecx
movl %eax, %r8d
movl %ebx, %r9d
callq 0x3fad0c
orb %al, %r13b
addq $0x8, %r14
jmp 0x3fdf15
andb $0x1, %r13b
movl %r13d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, double, double, double, double) | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
Float obj_amp)
{
auto at_least_one_pi_changed{ false };
logger::log("push-update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
// Before sort and select variables, we apply the push method: for
// each reduces cost, we had the cost multiply with an objective
// amplifier.
for (int i = 0; i != r_size; ++i)
R[i].value +=
obj_amp * c((std::get<0>(it) + R[i].id)->column, x);
Float pi_change;
int selected;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
default:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x68(%rsp)
leaq 0x60(%rdi), %rcx
movq %rdx, %r14
leaq 0x10(%rdi), %rax
leaq 0xf0(%rdi), %rdx
vmovsd %xmm3, 0x70(%rsp)
vmovsd %xmm2, 0x60(%rsp)
vmovsd %xmm1, 0x58(%rsp)
vmovsd %xmm0, 0x50(%rsp)
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq %rcx, 0x20(%rsp)
leaq 0x80(%rdi), %rcx
movq %rax, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
cmpq 0x68(%rsp), %r14
je 0x3fe3d1
movl (%r14), %eax
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %r13, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movslq %eax, %rbp
movl %eax, 0xc(%rsp)
movl %ebp, %edx
callq 0x3de66
vmovsd 0x60(%rsp), %xmm0
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
callq 0x3fa64a
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
callq 0x3fa668
movl %eax, %r13d
shlq $0x4, %r13
movl %eax, %ebx
xorl %r14d, %r14d
cmpq %r14, %r13
je 0x3fe25d
movq 0x60(%r12), %rax
movq 0x30(%rsp), %rcx
movq 0x168(%r12), %rdi
movq %r15, %rdx
movslq 0x8(%rax,%r14), %rax
movl 0x4(%rcx,%rax,8), %esi
callq 0x73084
movq 0x60(%r12), %rax
vmovsd 0x70(%rsp), %xmm1
vfmadd213sd (%rax,%r14), %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + mem
vmovsd %xmm0, (%rax,%r14)
addq $0x10, %r14
jmp 0x3fe218
movq 0x68(%r12), %rax
movslq %ebx, %rsi
movzbl (%rax,%rbp), %eax
cmpq $0x3, %rax
ja 0x3fe363
leaq 0x681ba(%rip), %rcx # 0x466434
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x3fe2f5
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %r14
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%r14), %edx
movl 0x4(%rax,%r14), %ecx
callq 0x3fac7c
cmpl $-0x2, %eax
jne 0x3fe393
movq 0x70(%r12), %rax
movl (%rax,%r14), %ecx
movl 0x4(%rax,%r14), %r8d
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %ebx, %edx
callq 0x3fa78e
jmp 0x3fe393
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rcx
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3fac7c
cmpl $-0x2, %eax
jne 0x3fe393
movl 0xc(%rsp), %ebp
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl %ebx, %ecx
movl %ebp, %esi
callq 0x3faa84
movq 0x18(%rsp), %r14
movq 0x10(%rsp), %r13
jmp 0x3fe3a1
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x4, %rsi
addq %rdi, %rsi
callq 0x3fa75b
movq 0x70(%r12), %rax
imulq $0xc, %rbp, %rcx
movq %r12, %rdi
movl %ebx, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x3facc4
movq 0x18(%rsp), %r14
movq 0x10(%rsp), %r13
movl 0xc(%rsp), %ebp
vmovsd 0x50(%rsp), %xmm0
vmovsd 0x58(%rsp), %xmm1
movq 0x30(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %ecx
movl %eax, %r8d
movl %ebx, %r9d
callq 0x3fad0c
orb %al, %r13b
addq $0x4, %r14
jmp 0x3fe1af
andb $0x1, %r13b
movl %r13d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::pnm_observer>::operator()(std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&, int, baryonyx::itm::quadratic_cost_type<double> const&, double) | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx.parameters;
auto norm_costs = normalize_costs<Float, Cost>(
m_ctx, original_costs, m_rng, variables);
const auto kappa_step = static_cast<Float>(p.kappa_step);
const auto kappa_max = static_cast<Float>(p.kappa_max);
const auto alpha = static_cast<Float>(p.alpha);
const auto theta = static_cast<Float>(p.theta);
const auto delta =
p.delta < 0
? compute_delta<Float, Cost>(m_ctx, norm_costs, theta, variables)
: static_cast<Float>(p.delta);
const auto pushing_k_factor = static_cast<Float>(p.pushing_k_factor);
const auto pushing_objective_amplifier =
static_cast<Float>(p.pushing_objective_amplifier);
const long int w_limit = static_cast<long int>(p.w);
Solver slv(
m_rng, length(constraints), variables, norm_costs, constraints);
compute_order compute(p.order, variables);
{
std::bernoulli_distribution choose_mutation(
m_ctx.parameters.init_policy_random);
bit_array empty_x;
switch (p.init_policy) {
case solver_parameters::init_policy_type::pessimistic_solve:
init_with_pre_solve<Cost, Mode>(
x, empty_x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::optimistic_solve:
init_with_pre_solve<Cost, Mode>(
empty_x, x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::bastert:
init_with_bastert<Cost, Mode>(x, original_costs, variables, 0);
break;
}
for (int i = 0, e = x.size(); i != e; ++i)
if (choose_mutation(m_rng))
x.invert(i);
}
bool start_push = false;
auto kappa = static_cast<Float>(p.kappa_min);
Observer obs("img", slv.m, slv.n, p.limit);
m_begin = std::chrono::steady_clock::now();
m_end = std::chrono::steady_clock::now();
compute.init(slv, x);
for (long int i = 0; i != p.limit; ++i) {
auto remaining = compute.run(slv, x, m_rng, kappa, delta, theta);
obs.make_observation(slv.ap, slv.P.get(), slv.pi.get());
if (remaining == 0) {
store_if_better(
x, original_costs.results(x, cost_constant), i);
best_remaining = remaining;
start_push = true;
break;
}
if (remaining < best_remaining) {
store_if_better(x, remaining, i);
best_remaining = remaining;
}
if (i > w_limit)
kappa += kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max) {
r.status = result_status::kappa_max_reached;
break;
}
if (is_timelimit_reached()) {
r.status = result_status::time_limit_reached;
break;
}
}
if (!start_push) {
r.status = result_status::limit_reached;
} else {
for (int push = 0; push < p.pushes_limit; ++push) {
auto remaining =
compute.push_and_run(slv,
x,
m_rng,
pushing_k_factor * kappa,
delta,
theta,
pushing_objective_amplifier);
if (remaining == 0)
store_if_better(x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - 1);
if (is_timelimit_reached())
break;
for (int iter = 0; iter < p.pushing_iteration_limit; ++iter) {
remaining =
compute.run(slv, x, m_rng, kappa, delta, theta);
if (remaining == 0) {
store_if_better(
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - iter - 1);
break;
}
if (iter > p.w)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
if (is_timelimit_reached())
break;
}
}
}
if (m_best.remaining_constraints == 0)
r.status = result_status::success;
if (!m_best.x.empty()) {
r.solutions.resize(1);
convert(m_best, r.solutions[0], variables);
}
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4a8, %rsp # imm = 0x4A8
vmovsd %xmm0, 0x40(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
leaq 0x18(%rsp), %rdi
movl %ecx, %esi
vzeroupper
callq 0x368ae
movq 0x10(%r14), %r12
movq 0x18(%r14), %rcx
leaq 0x80(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebx, %r8d
callq 0x6fb57
vmovsd 0x20(%r12), %xmm0
vmovsd 0x10(%r12), %xmm1
vmovsd %xmm0, 0x60(%rsp)
vmovsd 0x28(%r12), %xmm0
vmovsd %xmm1, 0x28(%rsp)
vmovsd %xmm0, 0x68(%rsp)
vmovsd 0x30(%r12), %xmm0
vmovsd %xmm0, 0x58(%rsp)
vmovsd 0x8(%r12), %xmm0
vmovsd %xmm0, 0x30(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm1, %xmm0
jbe 0x3ff7bc
movq 0x10(%r14), %rdi
vmovsd 0x30(%rsp), %xmm0
leaq 0x80(%rsp), %rsi
movl %ebx, %edx
callq 0x6fc31
vmovsd %xmm0, 0x28(%rsp)
vcvttsd2si 0xa0(%r12), %rax
vmovsd 0x38(%r12), %xmm0
vmovsd 0x40(%r12), %xmm1
movq 0x18(%r14), %rsi
movq %rax, 0x48(%rsp)
movq 0x8(%r15), %rax
vmovsd %xmm0, 0x78(%rsp)
vmovsd %xmm1, 0x70(%rsp)
subq (%r15), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq 0xd8(%rsp), %rdi
leaq 0x80(%rsp), %r8
movl %eax, %edx
movl %ebx, %ecx
movq %r15, %r9
callq 0x3f903e
movl 0xcc(%r12), %esi
leaq 0xa0(%rsp), %rdi
movl %ebx, %edx
callq 0x38cd8
movq 0x10(%r14), %rax
movl %ebx, 0x54(%rsp)
vmovsd 0x48(%rax), %xmm0
vmovsd %xmm0, (%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0x250(%rsp)
movl 0xd4(%r12), %eax
testl %eax, %eax
je 0x3ff899
cmpl $0x1, %eax
je 0x3ff873
cmpl $0x2, %eax
jne 0x3ff8aa
movq 0x18(%r14), %rdx
leaq 0x250(%rsp), %rdi
leaq 0x18(%rsp), %rsi
jmp 0x3ff884
movq 0x18(%r14), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x250(%rsp), %rsi
vmovsd 0x547ac(%rip), %xmm0 # 0x454038
movq %r13, %rcx
movq %r15, %r8
callq 0x81d84
jmp 0x3ff8aa
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x81d0f
leaq 0x18(%rsp), %r15
movq %r13, 0x38(%rsp)
xorl %ebx, %ebx
movl (%r15), %ebp
cmpl %ebx, %ebp
je 0x3ff8df
movq 0x18(%r14), %rdi
callq 0x36ac3
vmovsd (%rsp), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x3ff8db
movq %r15, %rdi
movl %ebx, %esi
callq 0x3626e
incl %ebx
jmp 0x3ff8b9
leaq 0x258(%rsp), %rdi
callq 0x357fe
vmovsd 0x18(%r12), %xmm0
movl 0x248(%rsp), %ecx
movl 0x24c(%rsp), %r8d
movq 0xb0(%r12), %r9
vmovsd %xmm0, (%rsp)
leaq 0x5ac61(%rip), %rdx # 0x45a577
leaq 0x250(%rsp), %rdi
pushq $0x3
popq %rsi
callq 0x42b5a
callq 0xb5a0
movq %rax, (%r14)
callq 0xb5a0
movq %rax, 0x8(%r14)
leaq 0xa0(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x3f9448
vmovsd (%rsp), %xmm0
movl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x18(%rsp), %r13
xorl %r15d, %r15d
cmpq 0xb0(%r12), %r15
je 0x3ffa43
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xa0(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
movq %r13, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3f948a
movq 0x128(%rsp), %rdx
movq 0x150(%rsp), %rcx
movl %eax, %ebx
leaq 0x250(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x6c2be
testl %ebx, %ebx
je 0x3ffae8
cmpl %ebp, %ebx
jge 0x3ff9e3
movq %r14, %rdi
movq %r13, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x4009ea
movl %ebx, %ebp
cmpq 0x48(%rsp), %r15
jle 0x3ffa18
vcvtsi2sd %ebx, %xmm3, %xmm0
vcvtsi2sdl 0x248(%rsp), %xmm3, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3ffa1d
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3ffa43
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x400a22
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3ffa43
incq %r15
jmp 0x3ff963
movq 0x8(%rsp), %rax
movl $0x5, 0xa0(%rax)
cmpl $0x0, 0x50(%r14)
jne 0x3ffa65
movq 0x8(%rsp), %rax
andl $0x0, 0xa0(%rax)
cmpq $0x0, 0x28(%r14)
je 0x3ffa93
movq 0x8(%rsp), %rax
leaq 0x68(%rax), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x35292
movq (%rbx), %rsi
addq $0x20, %r14
movl 0x54(%rsp), %edx
movq %r14, %rdi
callq 0x4f485
leaq 0x250(%rsp), %rdi
callq 0x42cbc
leaq 0xa0(%rsp), %rdi
callq 0x393ac
leaq 0xd8(%rsp), %rdi
callq 0x3f98ea
leaq 0x80(%rsp), %rdi
callq 0x6d8d6
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rax
addq $0x4a8, %rsp # imm = 0x4A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq 0x6e096
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x40099c
vmovsd (%rsp), %xmm0
leaq 0xd8(%rsp), %r15
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
movl $0x0, 0x14(%rsp)
cmpl 0xbc(%r12), %ebx
jge 0x3ffa52
vmovsd %xmm0, (%rsp)
vmulsd 0x78(%rsp), %xmm0, %xmm0
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
vmovsd 0x70(%rsp), %xmm3
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x3f9696
testl %eax, %eax
jne 0x3ffb9e
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6e096
movl 0xc0(%r12), %eax
imull %ebx, %eax
notl %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x40099c
movq %r14, %rdi
callq 0x400a22
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x3ffa52
movl %ebx, 0x48(%rsp)
pushq $0x1
popq %rax
movl %eax, %ebx
leal -0x1(%rbx), %r13d
cmpl 0xc0(%r12), %r13d
jge 0x3ffc9f
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3f948a
testl %eax, %eax
je 0x3ffc63
vcvtsi2sd %r13d, %xmm4, %xmm0
vucomisd 0xa0(%r12), %xmm0
jbe 0x3ffc39
vcvtsi2sd %eax, %xmm4, %xmm0
vcvtsi2sdl 0x248(%rsp), %xmm4, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x3ffc3e
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x3ffc9f
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x400a22
testb %al, %al
jne 0x3ffc9a
vmovsd (%rsp), %xmm0
incl %ebx
jmp 0x3ffbbc
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6e096
movl 0xc0(%r12), %eax
imull 0x14(%rsp), %eax
subl %ebx, %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x40099c
vmovsd (%rsp), %xmm0
jmp 0x3ffc9f
vmovsd (%rsp), %xmm0
movl 0x48(%rsp), %ebx
decl 0x14(%rsp)
incl %ebx
jmp 0x3ffb2a
jmp 0x3ffce5
jmp 0x3ffcbe
jmp 0x3ffce5
movq %rax, %r14
jmp 0x3ffcf5
movq %rax, %r14
jmp 0x3ffd02
movq %rax, %r14
jmp 0x3ffd0f
movq %rax, %r14
jmp 0x3ffd1c
movq %rax, %r14
jmp 0x3ffd26
jmp 0x3ffce5
jmp 0x3ffce5
jmp 0x3ffce5
leaq 0x258(%rsp), %rdi
movq %rax, %r14
callq 0x357fe
jmp 0x3ffcf5
leaq 0x250(%rsp), %rdi
movq %rax, %r14
callq 0x42cbc
leaq 0xa0(%rsp), %rdi
callq 0x393ac
leaq 0xd8(%rsp), %rdi
callq 0x3f98ea
leaq 0x80(%rsp), %rdi
callq 0x6d8d6
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rdi
callq 0xea60
movq %r14, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::file_observer>::operator()(std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&, int, baryonyx::itm::quadratic_cost_type<double> const&, double) | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx.parameters;
auto norm_costs = normalize_costs<Float, Cost>(
m_ctx, original_costs, m_rng, variables);
const auto kappa_step = static_cast<Float>(p.kappa_step);
const auto kappa_max = static_cast<Float>(p.kappa_max);
const auto alpha = static_cast<Float>(p.alpha);
const auto theta = static_cast<Float>(p.theta);
const auto delta =
p.delta < 0
? compute_delta<Float, Cost>(m_ctx, norm_costs, theta, variables)
: static_cast<Float>(p.delta);
const auto pushing_k_factor = static_cast<Float>(p.pushing_k_factor);
const auto pushing_objective_amplifier =
static_cast<Float>(p.pushing_objective_amplifier);
const long int w_limit = static_cast<long int>(p.w);
Solver slv(
m_rng, length(constraints), variables, norm_costs, constraints);
compute_order compute(p.order, variables);
{
std::bernoulli_distribution choose_mutation(
m_ctx.parameters.init_policy_random);
bit_array empty_x;
switch (p.init_policy) {
case solver_parameters::init_policy_type::pessimistic_solve:
init_with_pre_solve<Cost, Mode>(
x, empty_x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::optimistic_solve:
init_with_pre_solve<Cost, Mode>(
empty_x, x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::bastert:
init_with_bastert<Cost, Mode>(x, original_costs, variables, 0);
break;
}
for (int i = 0, e = x.size(); i != e; ++i)
if (choose_mutation(m_rng))
x.invert(i);
}
bool start_push = false;
auto kappa = static_cast<Float>(p.kappa_min);
Observer obs("img", slv.m, slv.n, p.limit);
m_begin = std::chrono::steady_clock::now();
m_end = std::chrono::steady_clock::now();
compute.init(slv, x);
for (long int i = 0; i != p.limit; ++i) {
auto remaining = compute.run(slv, x, m_rng, kappa, delta, theta);
obs.make_observation(slv.ap, slv.P.get(), slv.pi.get());
if (remaining == 0) {
store_if_better(
x, original_costs.results(x, cost_constant), i);
best_remaining = remaining;
start_push = true;
break;
}
if (remaining < best_remaining) {
store_if_better(x, remaining, i);
best_remaining = remaining;
}
if (i > w_limit)
kappa += kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max) {
r.status = result_status::kappa_max_reached;
break;
}
if (is_timelimit_reached()) {
r.status = result_status::time_limit_reached;
break;
}
}
if (!start_push) {
r.status = result_status::limit_reached;
} else {
for (int push = 0; push < p.pushes_limit; ++push) {
auto remaining =
compute.push_and_run(slv,
x,
m_rng,
pushing_k_factor * kappa,
delta,
theta,
pushing_objective_amplifier);
if (remaining == 0)
store_if_better(x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - 1);
if (is_timelimit_reached())
break;
for (int iter = 0; iter < p.pushing_iteration_limit; ++iter) {
remaining =
compute.run(slv, x, m_rng, kappa, delta, theta);
if (remaining == 0) {
store_if_better(
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - iter - 1);
break;
}
if (iter > p.w)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
if (is_timelimit_reached())
break;
}
}
}
if (m_best.remaining_constraints == 0)
r.status = result_status::success;
if (!m_best.x.empty()) {
r.solutions.resize(1);
convert(m_best, r.solutions[0], variables);
}
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4a8, %rsp # imm = 0x4A8
vmovsd %xmm0, 0x40(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
leaq 0x18(%rsp), %rdi
movl %ecx, %esi
vzeroupper
callq 0x368ae
movq 0x10(%r14), %r12
movq 0x18(%r14), %rcx
leaq 0x80(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebx, %r8d
callq 0x6fb57
vmovsd 0x20(%r12), %xmm0
vmovsd 0x10(%r12), %xmm1
vmovsd %xmm0, 0x60(%rsp)
vmovsd 0x28(%r12), %xmm0
vmovsd %xmm1, 0x28(%rsp)
vmovsd %xmm0, 0x68(%rsp)
vmovsd 0x30(%r12), %xmm0
vmovsd %xmm0, 0x58(%rsp)
vmovsd 0x8(%r12), %xmm0
vmovsd %xmm0, 0x30(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm1, %xmm0
jbe 0x3ffe26
movq 0x10(%r14), %rdi
vmovsd 0x30(%rsp), %xmm0
leaq 0x80(%rsp), %rsi
movl %ebx, %edx
callq 0x6fc31
vmovsd %xmm0, 0x28(%rsp)
vcvttsd2si 0xa0(%r12), %rax
vmovsd 0x38(%r12), %xmm0
vmovsd 0x40(%r12), %xmm1
movq 0x18(%r14), %rsi
movq %rax, 0x48(%rsp)
movq 0x8(%r15), %rax
vmovsd %xmm0, 0x78(%rsp)
vmovsd %xmm1, 0x70(%rsp)
subq (%r15), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq 0xd8(%rsp), %rdi
leaq 0x80(%rsp), %r8
movl %eax, %edx
movl %ebx, %ecx
movq %r15, %r9
callq 0x3f903e
movl 0xcc(%r12), %esi
leaq 0xa0(%rsp), %rdi
movl %ebx, %edx
callq 0x38cd8
movq 0x10(%r14), %rax
movl %ebx, 0x54(%rsp)
vmovsd 0x48(%rax), %xmm0
vmovsd %xmm0, (%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0x250(%rsp)
movl 0xd4(%r12), %eax
testl %eax, %eax
je 0x3fff03
cmpl $0x1, %eax
je 0x3ffedd
cmpl $0x2, %eax
jne 0x3fff14
movq 0x18(%r14), %rdx
leaq 0x250(%rsp), %rdi
leaq 0x18(%rsp), %rsi
jmp 0x3ffeee
movq 0x18(%r14), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x250(%rsp), %rsi
vmovsd 0x54142(%rip), %xmm0 # 0x454038
movq %r13, %rcx
movq %r15, %r8
callq 0x81d84
jmp 0x3fff14
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x81d0f
leaq 0x18(%rsp), %r15
movq %r13, 0x38(%rsp)
xorl %ebx, %ebx
movl (%r15), %ebp
cmpl %ebx, %ebp
je 0x3fff49
movq 0x18(%r14), %rdi
callq 0x36ac3
vmovsd (%rsp), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x3fff45
movq %r15, %rdi
movl %ebx, %esi
callq 0x3626e
incl %ebx
jmp 0x3fff23
leaq 0x258(%rsp), %rdi
callq 0x357fe
vmovsd 0x18(%r12), %xmm0
movl 0x248(%rsp), %ecx
movl 0x24c(%rsp), %r8d
movq 0xb0(%r12), %r9
vmovsd %xmm0, (%rsp)
leaq 0x5a5f7(%rip), %rdx # 0x45a577
leaq 0x250(%rsp), %rdi
pushq $0x3
popq %rsi
callq 0x4346e
callq 0xb5a0
movq %rax, (%r14)
callq 0xb5a0
movq %rax, 0x8(%r14)
leaq 0xa0(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x3f9448
vmovsd (%rsp), %xmm0
movl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x18(%rsp), %r13
xorl %r15d, %r15d
cmpq 0xb0(%r12), %r15
je 0x4000ad
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xa0(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
movq %r13, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3f948a
movq 0x128(%rsp), %rdx
movq 0x150(%rsp), %rcx
movl %eax, %ebx
leaq 0x250(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x6c6c0
testl %ebx, %ebx
je 0x400152
cmpl %ebp, %ebx
jge 0x40004d
movq %r14, %rdi
movq %r13, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x400ad0
movl %ebx, %ebp
cmpq 0x48(%rsp), %r15
jle 0x400082
vcvtsi2sd %ebx, %xmm3, %xmm0
vcvtsi2sdl 0x248(%rsp), %xmm3, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x400087
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x4000ad
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x400b08
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x4000ad
incq %r15
jmp 0x3fffcd
movq 0x8(%rsp), %rax
movl $0x5, 0xa0(%rax)
cmpl $0x0, 0x50(%r14)
jne 0x4000cf
movq 0x8(%rsp), %rax
andl $0x0, 0xa0(%rax)
cmpq $0x0, 0x28(%r14)
je 0x4000fd
movq 0x8(%rsp), %rax
leaq 0x68(%rax), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x35292
movq (%rbx), %rsi
addq $0x20, %r14
movl 0x54(%rsp), %edx
movq %r14, %rdi
callq 0x4f485
leaq 0x250(%rsp), %rdi
callq 0x435d0
leaq 0xa0(%rsp), %rdi
callq 0x393ac
leaq 0xd8(%rsp), %rdi
callq 0x3f98ea
leaq 0x80(%rsp), %rdi
callq 0x6d8d6
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rax
addq $0x4a8, %rsp # imm = 0x4A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq 0x6e096
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x400a82
vmovsd (%rsp), %xmm0
leaq 0xd8(%rsp), %r15
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
movl $0x0, 0x14(%rsp)
cmpl 0xbc(%r12), %ebx
jge 0x4000bc
vmovsd %xmm0, (%rsp)
vmulsd 0x78(%rsp), %xmm0, %xmm0
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
vmovsd 0x70(%rsp), %xmm3
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x3f9696
testl %eax, %eax
jne 0x400208
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6e096
movl 0xc0(%r12), %eax
imull %ebx, %eax
notl %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x400a82
movq %r14, %rdi
callq 0x400b08
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x4000bc
movl %ebx, 0x48(%rsp)
pushq $0x1
popq %rax
movl %eax, %ebx
leal -0x1(%rbx), %r13d
cmpl 0xc0(%r12), %r13d
jge 0x400309
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3f948a
testl %eax, %eax
je 0x4002cd
vcvtsi2sd %r13d, %xmm4, %xmm0
vucomisd 0xa0(%r12), %xmm0
jbe 0x4002a3
vcvtsi2sd %eax, %xmm4, %xmm0
vcvtsi2sdl 0x248(%rsp), %xmm4, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x4002a8
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x400309
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x400b08
testb %al, %al
jne 0x400304
vmovsd (%rsp), %xmm0
incl %ebx
jmp 0x400226
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6e096
movl 0xc0(%r12), %eax
imull 0x14(%rsp), %eax
subl %ebx, %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x400a82
vmovsd (%rsp), %xmm0
jmp 0x400309
vmovsd (%rsp), %xmm0
movl 0x48(%rsp), %ebx
decl 0x14(%rsp)
incl %ebx
jmp 0x400194
jmp 0x40034f
jmp 0x400328
jmp 0x40034f
movq %rax, %r14
jmp 0x40035f
movq %rax, %r14
jmp 0x40036c
movq %rax, %r14
jmp 0x400379
movq %rax, %r14
jmp 0x400386
movq %rax, %r14
jmp 0x400390
jmp 0x40034f
jmp 0x40034f
jmp 0x40034f
leaq 0x258(%rsp), %rdi
movq %rax, %r14
callq 0x357fe
jmp 0x40035f
leaq 0x250(%rsp), %rdi
movq %rax, %r14
callq 0x435d0
leaq 0xa0(%rsp), %rdi
callq 0x393ac
leaq 0xd8(%rsp), %rdi
callq 0x3f98ea
leaq 0x80(%rsp), %rdi
callq 0x6d8d6
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rdi
callq 0xea60
movq %r14, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::none_observer>::operator()(std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&, int, baryonyx::itm::quadratic_cost_type<double> const&, double) | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx.parameters;
auto norm_costs = normalize_costs<Float, Cost>(
m_ctx, original_costs, m_rng, variables);
const auto kappa_step = static_cast<Float>(p.kappa_step);
const auto kappa_max = static_cast<Float>(p.kappa_max);
const auto alpha = static_cast<Float>(p.alpha);
const auto theta = static_cast<Float>(p.theta);
const auto delta =
p.delta < 0
? compute_delta<Float, Cost>(m_ctx, norm_costs, theta, variables)
: static_cast<Float>(p.delta);
const auto pushing_k_factor = static_cast<Float>(p.pushing_k_factor);
const auto pushing_objective_amplifier =
static_cast<Float>(p.pushing_objective_amplifier);
const long int w_limit = static_cast<long int>(p.w);
Solver slv(
m_rng, length(constraints), variables, norm_costs, constraints);
compute_order compute(p.order, variables);
{
std::bernoulli_distribution choose_mutation(
m_ctx.parameters.init_policy_random);
bit_array empty_x;
switch (p.init_policy) {
case solver_parameters::init_policy_type::pessimistic_solve:
init_with_pre_solve<Cost, Mode>(
x, empty_x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::optimistic_solve:
init_with_pre_solve<Cost, Mode>(
empty_x, x, m_rng, original_costs, constraints, 1.0);
break;
case solver_parameters::init_policy_type::bastert:
init_with_bastert<Cost, Mode>(x, original_costs, variables, 0);
break;
}
for (int i = 0, e = x.size(); i != e; ++i)
if (choose_mutation(m_rng))
x.invert(i);
}
bool start_push = false;
auto kappa = static_cast<Float>(p.kappa_min);
Observer obs("img", slv.m, slv.n, p.limit);
m_begin = std::chrono::steady_clock::now();
m_end = std::chrono::steady_clock::now();
compute.init(slv, x);
for (long int i = 0; i != p.limit; ++i) {
auto remaining = compute.run(slv, x, m_rng, kappa, delta, theta);
obs.make_observation(slv.ap, slv.P.get(), slv.pi.get());
if (remaining == 0) {
store_if_better(
x, original_costs.results(x, cost_constant), i);
best_remaining = remaining;
start_push = true;
break;
}
if (remaining < best_remaining) {
store_if_better(x, remaining, i);
best_remaining = remaining;
}
if (i > w_limit)
kappa += kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max) {
r.status = result_status::kappa_max_reached;
break;
}
if (is_timelimit_reached()) {
r.status = result_status::time_limit_reached;
break;
}
}
if (!start_push) {
r.status = result_status::limit_reached;
} else {
for (int push = 0; push < p.pushes_limit; ++push) {
auto remaining =
compute.push_and_run(slv,
x,
m_rng,
pushing_k_factor * kappa,
delta,
theta,
pushing_objective_amplifier);
if (remaining == 0)
store_if_better(x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - 1);
if (is_timelimit_reached())
break;
for (int iter = 0; iter < p.pushing_iteration_limit; ++iter) {
remaining =
compute.run(slv, x, m_rng, kappa, delta, theta);
if (remaining == 0) {
store_if_better(
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - iter - 1);
break;
}
if (iter > p.w)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
if (is_timelimit_reached())
break;
}
}
}
if (m_best.remaining_constraints == 0)
r.status = result_status::success;
if (!m_best.x.empty()) {
r.solutions.resize(1);
convert(m_best, r.solutions[0], variables);
}
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
vmovsd %xmm0, 0x40(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
leaq 0x18(%rsp), %rdi
movl %ecx, %esi
vzeroupper
callq 0x368ae
movq 0x10(%r14), %r12
movq 0x18(%r14), %rcx
leaq 0x98(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebx, %r8d
callq 0x6fb57
vmovsd 0x20(%r12), %xmm0
vmovsd 0x10(%r12), %xmm1
vmovsd %xmm0, 0x60(%rsp)
vmovsd 0x28(%r12), %xmm0
vmovsd %xmm1, 0x28(%rsp)
vmovsd %xmm0, 0x68(%rsp)
vmovsd 0x30(%r12), %xmm0
vmovsd %xmm0, 0x58(%rsp)
vmovsd 0x8(%r12), %xmm0
vmovsd %xmm0, 0x30(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm1, %xmm0
jbe 0x400490
movq 0x10(%r14), %rdi
vmovsd 0x30(%rsp), %xmm0
leaq 0x98(%rsp), %rsi
movl %ebx, %edx
callq 0x6fc31
vmovsd %xmm0, 0x28(%rsp)
vcvttsd2si 0xa0(%r12), %rax
vmovsd 0x38(%r12), %xmm0
vmovsd 0x40(%r12), %xmm1
movq 0x18(%r14), %rsi
movq %rax, 0x48(%rsp)
movq 0x8(%r15), %rax
vmovsd %xmm0, 0x90(%rsp)
vmovsd %xmm1, 0x88(%rsp)
subq (%r15), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq 0xf0(%rsp), %rdi
leaq 0x98(%rsp), %r8
movl %eax, %edx
movl %ebx, %ecx
movq %r15, %r9
callq 0x3f903e
movl 0xcc(%r12), %esi
leaq 0xb8(%rsp), %rdi
movl %ebx, %edx
callq 0x38cd8
movq 0x10(%r14), %rax
movl %ebx, 0x54(%rsp)
vmovsd 0x48(%rax), %xmm0
vmovsd %xmm0, (%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovapd %xmm0, 0x70(%rsp)
movl 0xd4(%r12), %eax
testl %eax, %eax
je 0x40056a
cmpl $0x1, %eax
je 0x400547
cmpl $0x2, %eax
jne 0x40057b
movq 0x18(%r14), %rdx
leaq 0x70(%rsp), %rdi
leaq 0x18(%rsp), %rsi
jmp 0x400555
movq 0x18(%r14), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
vmovsd 0x53adb(%rip), %xmm0 # 0x454038
movq %r13, %rcx
movq %r15, %r8
callq 0x81d84
jmp 0x40057b
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x81d0f
leaq 0x18(%rsp), %r15
movq %r13, 0x38(%rsp)
xorl %ebx, %ebx
movl (%r15), %ebp
cmpl %ebx, %ebp
je 0x4005b0
movq 0x18(%r14), %rdi
callq 0x36ac3
vmovsd (%rsp), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x4005ac
movq %r15, %rdi
movl %ebx, %esi
callq 0x3626e
incl %ebx
jmp 0x40058a
leaq 0x78(%rsp), %rdi
callq 0x357fe
vmovsd 0x18(%r12), %xmm0
vmovsd %xmm0, (%rsp)
callq 0xb5a0
movq %rax, (%r14)
callq 0xb5a0
movq %rax, 0x8(%r14)
leaq 0xb8(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x3f9448
vmovsd (%rsp), %xmm0
movl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x18(%rsp), %rbx
xorl %r15d, %r15d
cmpq 0xb0(%r12), %r15
je 0x4006c3
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xb8(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
movq %rbx, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3f948a
movl %eax, %r13d
testl %eax, %eax
je 0x40075b
cmpl %ebp, %r13d
jge 0x400662
movq %r14, %rdi
movq %rbx, %rsi
movl %r13d, %edx
movq %r15, %rcx
callq 0x400bb6
movl %r13d, %ebp
cmpq 0x48(%rsp), %r15
jle 0x400698
vcvtsi2sd %r13d, %xmm3, %xmm0
vcvtsi2sdl 0x260(%rsp), %xmm3, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x40069d
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x4006c3
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x400bee
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x4006c3
incq %r15
jmp 0x400603
movq 0x8(%rsp), %rax
movl $0x5, 0xa0(%rax)
cmpl $0x0, 0x50(%r14)
jne 0x4006e5
movq 0x8(%rsp), %rax
andl $0x0, 0xa0(%rax)
cmpq $0x0, 0x28(%r14)
je 0x400713
movq 0x8(%rsp), %rax
leaq 0x68(%rax), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x35292
movq (%rbx), %rsi
addq $0x20, %r14
movl 0x54(%rsp), %edx
movq %r14, %rdi
callq 0x4f485
leaq 0xb8(%rsp), %rdi
callq 0x393ac
leaq 0xf0(%rsp), %rdi
callq 0x3f98ea
leaq 0x98(%rsp), %rdi
callq 0x6d8d6
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rax
addq $0x268, %rsp # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq 0x6e096
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x400b68
vmovsd (%rsp), %xmm0
leaq 0xf0(%rsp), %r15
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
movl $0x0, 0x14(%rsp)
cmpl 0xbc(%r12), %ebx
jge 0x4006d2
vmovsd %xmm0, (%rsp)
vmulsd 0x90(%rsp), %xmm0, %xmm0
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
vmovsd 0x88(%rsp), %xmm3
leaq 0xb8(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x3f9696
testl %eax, %eax
jne 0x400817
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6e096
movl 0xc0(%r12), %eax
imull %ebx, %eax
notl %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x400b68
movq %r14, %rdi
callq 0x400bee
vmovsd (%rsp), %xmm0
testb %al, %al
jne 0x4006d2
movl %ebx, 0x48(%rsp)
pushq $0x1
popq %rax
movl %eax, %ebx
leal -0x1(%rbx), %r13d
cmpl 0xc0(%r12), %r13d
jge 0x400918
movq 0x18(%r14), %rcx
vmovsd 0x28(%rsp), %xmm1
vmovsd 0x30(%rsp), %xmm2
leaq 0xb8(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
vmovsd %xmm0, (%rsp)
callq 0x3f948a
testl %eax, %eax
je 0x4008dc
vcvtsi2sd %r13d, %xmm4, %xmm0
vucomisd 0xa0(%r12), %xmm0
jbe 0x4008b2
vcvtsi2sd %eax, %xmm4, %xmm0
vcvtsi2sdl 0x260(%rsp), %xmm4, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd 0x58(%rsp), %xmm1
callq 0xb1f0
vmovsd (%rsp), %xmm1
vfmadd231sd 0x60(%rsp), %xmm0, %xmm1 # xmm1 = (xmm0 * mem) + xmm1
vmovapd %xmm1, %xmm0
jmp 0x4008b7
vmovsd (%rsp), %xmm0
vucomisd 0x68(%rsp), %xmm0
ja 0x400918
movq %r14, %rdi
vmovsd %xmm0, (%rsp)
callq 0x400bee
testb %al, %al
jne 0x400913
vmovsd (%rsp), %xmm0
incl %ebx
jmp 0x400835
vmovsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6e096
movl 0xc0(%r12), %eax
imull 0x14(%rsp), %eax
subl %ebx, %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x400b68
vmovsd (%rsp), %xmm0
jmp 0x400918
vmovsd (%rsp), %xmm0
movl 0x48(%rsp), %ebx
decl 0x14(%rsp)
incl %ebx
jmp 0x40079d
jmp 0x400956
jmp 0x400932
jmp 0x400956
movq %rax, %r14
jmp 0x400966
movq %rax, %r14
jmp 0x400973
movq %rax, %r14
jmp 0x400980
movq %rax, %r14
jmp 0x40098a
jmp 0x400956
jmp 0x400956
jmp 0x400956
leaq 0x78(%rsp), %rdi
movq %rax, %r14
callq 0x357fe
jmp 0x400959
movq %rax, %r14
leaq 0xb8(%rsp), %rdi
callq 0x393ac
leaq 0xf0(%rsp), %rdi
callq 0x3f98ea
leaq 0x98(%rsp), %rdi
callq 0x6d8d6
leaq 0x20(%rsp), %rdi
callq 0x357fe
movq 0x8(%rsp), %rdi
callq 0xea60
movq %r14, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::pnm_observer>::store_if_better(baryonyx::bit_array const&, double, long) | void store_if_better(const bit_array& x, double current, long int i)
{
if (is_better_solution<Mode>(current, m_best.value)) {
m_best.x = x;
m_best.duration = duration();
m_best.loop = i;
m_best.remaining_constraints = 0;
m_best.value = current;
}
} | vmovsd 0x30(%rdi), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x4009e8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x20, %rdi
movq %rdx, %rbx
vmovsd %xmm0, (%rsp)
callq 0x36a44
movq %r14, %rdi
callq 0x400a62
vmovsd (%rsp), %xmm1
vmovsd %xmm0, 0x38(%r14)
movq %rbx, 0x48(%r14)
andl $0x0, 0x50(%r14)
vmovsd %xmm1, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::pnm_observer>::is_timelimit_reached() | bool is_timelimit_reached()
{
m_end = std::chrono::steady_clock::now();
return is_time_limit(m_ctx.parameters.time_limit, m_begin, m_end);
} | pushq %rbx
movq %rdi, %rbx
callq 0xb5a0
movq %rax, 0x8(%rbx)
vxorpd %xmm2, %xmm2, %xmm2
movq 0x10(%rbx), %rcx
subq (%rbx), %rax
vmovsd (%rcx), %xmm0
vcvtsi2sd %rax, %xmm1, %xmm1
vdivsd 0x59035(%rip), %xmm1, %xmm1 # 0x459a80
vcmpnlepd %xmm2, %xmm0, %k1
vcmpltpd %xmm1, %xmm0, %k0 {%k1}
kmovd %k0, %eax
andb $0x1, %al
popq %rbx
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::file_observer>::store_if_better(baryonyx::bit_array const&, double, long) | void store_if_better(const bit_array& x, double current, long int i)
{
if (is_better_solution<Mode>(current, m_best.value)) {
m_best.x = x;
m_best.duration = duration();
m_best.loop = i;
m_best.remaining_constraints = 0;
m_best.value = current;
}
} | vmovsd 0x30(%rdi), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x400ace
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x20, %rdi
movq %rdx, %rbx
vmovsd %xmm0, (%rsp)
callq 0x36a44
movq %r14, %rdi
callq 0x400b48
vmovsd (%rsp), %xmm1
vmovsd %xmm0, 0x38(%r14)
movq %rbx, 0x48(%r14)
andl $0x0, 0x50(%r14)
vmovsd %xmm1, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::file_observer>::is_timelimit_reached() | bool is_timelimit_reached()
{
m_end = std::chrono::steady_clock::now();
return is_time_limit(m_ctx.parameters.time_limit, m_begin, m_end);
} | pushq %rbx
movq %rdi, %rbx
callq 0xb5a0
movq %rax, 0x8(%rbx)
vxorpd %xmm2, %xmm2, %xmm2
movq 0x10(%rbx), %rcx
subq (%rbx), %rax
vmovsd (%rcx), %xmm0
vcvtsi2sd %rax, %xmm1, %xmm1
vdivsd 0x58f4f(%rip), %xmm1, %xmm1 # 0x459a80
vcmpnlepd %xmm2, %xmm0, %k1
vcmpltpd %xmm1, %xmm0, %k0 {%k1}
kmovd %k0, %eax
andb $0x1, %al
popq %rbx
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, false>, double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<double>, baryonyx::none_observer>::store_if_better(baryonyx::bit_array const&, double, long) | void store_if_better(const bit_array& x, double current, long int i)
{
if (is_better_solution<Mode>(current, m_best.value)) {
m_best.x = x;
m_best.duration = duration();
m_best.loop = i;
m_best.remaining_constraints = 0;
m_best.value = current;
}
} | vmovsd 0x30(%rdi), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x400bb4
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x20, %rdi
movq %rdx, %rbx
vmovsd %xmm0, (%rsp)
callq 0x36a44
movq %r14, %rdi
callq 0x400c2e
vmovsd (%rsp), %xmm1
vmovsd %xmm0, 0x38(%r14)
movq %rbx, 0x48(%r14)
andl $0x0, 0x50(%r14)
vmovsd %xmm1, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::result baryonyx::itm::optimize_problem<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>>(baryonyx::context const&, baryonyx::problem const&) | inline result
optimize_problem(const context& ctx, const problem& pb)
{
result r;
if (ctx.start)
ctx.start(ctx.parameters);
auto constraints{ make_merged_constraints(ctx, pb) };
if (constraints.empty() || pb.vars.values.empty()) {
r.status = result_status::success;
r.solutions.resize(1);
r.solutions.back().value = pb.objective.value;
r.strings = pb.strings;
r.affected_vars = pb.affected_vars;
r.variable_name = pb.vars.names;
return r;
}
random_engine rng(init_random_generator_seed(ctx));
auto variables = length(pb.vars.values);
auto cost = Cost(pb.objective, variables);
auto cost_constant = pb.objective.value;
const auto thread = get_thread_number(ctx);
std::vector<optimize_functor<Solver, Float, Mode, Cost>> functors;
std::vector<std::thread> pool(thread);
best_solution_recorder<Cost, Float, Mode> best_recorder(
rng,
thread,
cost,
cost_constant,
variables,
constraints,
ctx.parameters.init_population_size);
auto seeds = generate_seed(rng, thread);
std::atomic_bool stop_task;
stop_task.store(false);
for (unsigned i = 0u; i != thread; ++i)
functors.emplace_back(ctx, i, seeds[i]);
for (unsigned i = 0u; i != thread; ++i)
pool[i] = std::thread(std::ref(functors[i]),
std::ref(stop_task),
std::ref(best_recorder),
std::cref(constraints),
variables,
std::cref(cost),
cost_constant);
const auto start = std::chrono::steady_clock::now();
auto end = start;
do {
std::this_thread::sleep_for(std::chrono::seconds{ 1L });
if (ctx.update) {
auto call_number = 0L;
for (auto i = 0u; i != thread; ++i)
call_number += functors[i].m_call_number;
int constraints_remaining;
long int loop;
double value;
double duration;
best_recorder.get_best(
constraints_remaining, value, duration, loop);
ctx.update(
constraints_remaining, value, loop, duration, call_number);
}
end = std::chrono::steady_clock::now();
} while (!is_time_limit(ctx.parameters.time_limit, start, end));
stop_task.store(true);
for (auto& t : pool)
t.join();
r.strings = pb.strings;
r.affected_vars = pb.affected_vars;
r.variable_name = pb.vars.names;
r.variables = variables;
r.constraints = length(constraints);
const auto& first = best_recorder.get_best(0);
if (!first.is_solution())
r.status = result_status::time_limit_reached;
else
r.status = result_status::success;
r.duration = first.duration;
r.loop = first.loop;
r.remaining_constraints = first.remaining_constraints;
switch (ctx.parameters.storage) {
case solver_parameters::storage_type::one: {
r.solutions.resize(1);
convert(first, r.solutions[0], variables);
} break;
case solver_parameters::storage_type::bound: {
r.solutions.resize(2);
convert(first, r.solutions[0], variables);
convert(best_recorder.get_worst(), r.solutions[1], variables);
} break;
case solver_parameters::storage_type::five: {
r.solutions.resize(5);
for (int i = 0; i != 5; ++i)
convert(best_recorder.get_best(i), r.solutions[i], variables);
} break;
}
best_recorder.show_population(ctx);
if (ctx.finish)
ctx.finish(r);
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
vxorpd %xmm0, %xmm0, %xmm0
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
cmpq $0x0, 0x128(%rsi)
je 0x400cb3
leaq 0x118(%r15), %rdi
movq %r15, %rsi
vzeroupper
callq 0x3527e
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
vzeroupper
callq 0x450078
movq 0x48(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x400e0f
movq 0xa8(%r13), %rax
cmpq 0xb0(%r13), %rax
je 0x400e0f
movq %r15, %rdi
callq 0x353ba
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rcx
cmpq $0x1, %rdx
adcq $0x0, %rdx
movq %rdx, 0x40(%rsp)
movq 0xb0(%r13), %rax
subq 0xa8(%r13), %rax
pushq $0xc
popq %rcx
cqto
leaq 0x10(%r13), %rsi
idivq %rcx
movl %eax, 0x4(%rsp)
leaq 0x60(%rsp), %rdi
movl %eax, %edx
movq %r12, 0x10(%rsp)
callq 0x8adb0
vmovsd 0x40(%r13), %xmm0
vmovsd %xmm0, 0x38(%rsp)
movq %r15, %rdi
callq 0x35447
andq $0x0, 0x80(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movl %eax, %ebp
vmovapd %xmm0, 0x70(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xc8(%rsp), %rdx
movq %rbp, %rsi
callq 0x35462
vmovsd 0x38(%rsp), %xmm0
movl 0xc4(%r15), %eax
movl 0x4(%rsp), %r8d
subq $0x8, %rsp
movl %ebp, %edx
leaq 0xd0(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x68(%rsp), %rcx
leaq 0x50(%rsp), %r9
pushq %rax
callq 0x8ae24
popq %rax
popq %rcx
leaq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl %ebp, %edx
callq 0x3551c
xorl %eax, %eax
movb %al, 0x3(%rsp)
xorl %ecx, %ecx
leaq 0x70(%rsp), %rbx
leaq 0x8(%rsp), %r14
xchgb %cl, 0x3(%rsp)
leaq 0x90(%r13), %rcx
movq %rcx, 0x98(%rsp)
movl %eax, 0x8(%rsp)
cmpl %ebp, %eax
je 0x400e6a
movl %eax, %ecx
shlq $0x3, %rcx
addq 0x30(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x401f38
movl 0x8(%rsp), %eax
incl %eax
jmp 0x400de6
andl $0x0, 0xa0(%r12)
leaq 0x68(%r12), %rdi
pushq $0x1
popq %rsi
callq 0x35292
vmovsd 0x40(%r13), %xmm0
movq 0x70(%r12), %rax
vmovsd %xmm0, -0x8(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x31d28
leaq 0xc0(%r13), %rsi
leaq 0x20(%r12), %rdi
callq 0x352c2
addq $0x90, %r13
leaq 0x50(%r12), %rdi
movq %r13, %rsi
callq 0x352ec
jmp 0x4011ff
movq %r13, 0x90(%rsp)
movq %r15, %r13
leaq 0x8(%rsp), %r15
leaq 0xa8(%rsp), %r14
leaq 0x4(%rsp), %rbx
xorl %r12d, %r12d
cmpq %rbp, %r12
je 0x400f2b
imulq $0xc0, %r12, %rax
addq 0x70(%rsp), %rax
leaq 0x3(%rsp), %r10
leaq 0xc8(%rsp), %r11
movq %r10, 0x20(%rsp)
leaq 0x48(%rsp), %r10
movq %r11, 0x18(%rsp)
movq %r10, 0xa8(%rsp)
movq %rax, 0x28(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, 0xa0(%rsp)
leaq 0x20(%rsp), %rdx
leaq 0x38(%rsp), %rax
movq %r15, %rdi
leaq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rcx
movq %r14, %r8
movq %rbx, %r9
pushq %rax
leaq 0xa8(%rsp), %rax
pushq %rax
callq 0x401f84
popq %rax
popq %rcx
leaq (,%r12,8), %rdi
addq 0xb0(%rsp), %rdi
movq %r15, %rsi
callq 0x356d6
movq %r15, %rdi
callq 0x356f0
incq %r12
jmp 0x400e8a
callq 0xb5a0
imulq $0xc0, %rbp, %r15
leaq 0x138(%r13), %r12
leaq 0x8(%rsp), %rbp
movq %rax, %rbx
movq $0x1, 0x8(%rsp)
movq %rbp, %rdi
callq 0x356fd
cmpq $0x0, 0x148(%r13)
je 0x400fc0
movq 0x70(%rsp), %rax
xorl %ecx, %ecx
xorl %r14d, %r14d
cmpq %rcx, %r15
je 0x400f81
addq 0xb0(%rax,%rcx), %r14
addq $0xc0, %rcx
jmp 0x400f6b
leaq 0xd0(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rbp, %r8
callq 0x93ba8
vmovsd 0x28(%rsp), %xmm0
vmovsd 0x20(%rsp), %xmm1
movq 0x8(%rsp), %rdx
movl 0x18(%rsp), %esi
movq %r12, %rdi
movq %r14, %rcx
callq 0x35736
callq 0xb5a0
vmovsd (%r13), %xmm0
subq %rbx, %rax
vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm0, %xmm1
vcvtsi2sd %rax, %xmm2, %xmm1
vdivsd 0x58a9d(%rip), %xmm1, %xmm1 # 0x459a80
jae 0x400f46
vucomisd %xmm0, %xmm1
jbe 0x400f46
movb $0x1, %al
xchgb %al, 0x3(%rsp)
movq 0xb0(%rsp), %rbx
movq 0xb8(%rsp), %r14
movq 0x10(%rsp), %r12
cmpq %r14, %rbx
je 0x401021
movq %rbx, %rdi
callq 0xb1a0
addq $0x8, %rbx
jmp 0x40100e
movq 0x90(%rsp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x31d28
addq $0xc0, %rbx
leaq 0x20(%r12), %rdi
movq %rbx, %rsi
callq 0x352c2
leaq 0x50(%r12), %rdi
movq 0x98(%rsp), %rsi
callq 0x352ec
movl 0x4(%rsp), %eax
movl %eax, 0x90(%r12)
movq 0x50(%rsp), %rax
subq 0x48(%rsp), %rax
pushq $0x28
popq %rcx
cqto
xorl %esi, %esi
idivq %rcx
movq 0x108(%rsp), %rdi
movq 0x120(%rsp), %rcx
movl %eax, 0x94(%r12)
movslq (%rdi), %rax
imulq $0x38, %rax, %rax
movl 0x30(%rcx,%rax), %edx
leaq (%rcx,%rax), %rbx
testl %edx, %edx
setne %sil
leal (%rsi,%rsi,2), %esi
movl %esi, 0xa0(%r12)
vmovsd 0x18(%rcx,%rax), %xmm0
vmovsd %xmm0, 0x80(%r12)
movq 0x28(%rcx,%rax), %rax
movq %rax, 0x88(%r12)
movl %edx, 0x98(%r12)
movl 0xe8(%r13), %eax
testl %eax, %eax
je 0x40117c
cmpl $0x1, %eax
je 0x401144
cmpl $0x2, %eax
jne 0x40119b
leaq 0x68(%r12), %rbx
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x35292
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq $0x5, %r15
je 0x40119b
movq 0x108(%rsp), %rax
movq (%rbx), %rsi
movl 0x4(%rsp), %edx
movslq (%rax,%r15,4), %rax
addq %r14, %rsi
imulq $0x38, %rax, %rdi
addq 0x120(%rsp), %rdi
callq 0x35781
incq %r15
addq $0x20, %r14
jmp 0x40110a
leaq 0x68(%r12), %r14
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x35292
movl 0x4(%rsp), %edx
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x35781
leaq 0xd0(%rsp), %rdi
callq 0x93c26
movq (%r14), %rsi
movq %rax, %rbx
addq $0x20, %rsi
jmp 0x40118f
leaq 0x68(%r12), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x35292
movq (%r14), %rsi
movl 0x4(%rsp), %edx
movq %rbx, %rdi
callq 0x35781
leaq 0xc8(%rsp), %rdi
movq %r13, %rsi
callq 0x8af88
cmpq $0x0, 0x168(%r13)
je 0x4011c7
addq $0x158, %r13 # imm = 0x158
movq %r13, %rdi
movq %r12, %rsi
callq 0x357ea
leaq 0x30(%rsp), %rdi
callq 0x357fe
leaq 0xc8(%rsp), %rdi
callq 0x8af9c
leaq 0xb0(%rsp), %rdi
callq 0x35836
leaq 0x70(%rsp), %rdi
callq 0x40b314
leaq 0x68(%rsp), %rdi
callq 0x8affa
leaq 0x48(%rsp), %rdi
callq 0x35858
movq %r12, %rax
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x401260
movq %rax, %rbx
jmp 0x40126d
movq %rax, %rbx
jmp 0x40127a
jmp 0x401244
jmp 0x401235
jmp 0x401253
jmp 0x401253
movq %r12, 0x10(%rsp)
movq %rax, %rbx
jmp 0x401298
movq %r12, 0x10(%rsp)
movq %rax, %rbx
jmp 0x40128e
jmp 0x401253
jmp 0x401253
jmp 0x401253
jmp 0x401253
jmp 0x401253
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x357fe
leaq 0xc8(%rsp), %rdi
callq 0x8af9c
leaq 0xb0(%rsp), %rdi
callq 0x35836
leaq 0x70(%rsp), %rdi
callq 0x40b314
leaq 0x68(%rsp), %rdi
callq 0x8affa
leaq 0x48(%rsp), %rdi
callq 0x35858
movq 0x10(%rsp), %rdi
callq 0xea60
movq %rbx, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-optimizer-common.hpp |
baryonyx::result baryonyx::itm::solve_problem<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>>(baryonyx::context const&, baryonyx::problem const&) | inline result
solve_problem(const context& ctx, const problem& pb)
{
if (ctx.start)
ctx.start(ctx.parameters);
result ret;
auto variables = length(pb.vars.values);
auto constraints{ make_merged_constraints(ctx, pb) };
if (!constraints.empty() && !pb.vars.values.empty()) {
random_engine rng(init_random_generator_seed(ctx));
auto cost = Cost(pb.objective, variables);
auto cost_constant = pb.objective.value;
switch (ctx.parameters.observer) {
case solver_parameters::observer_type::pnm: {
using obs = pnm_observer;
solver_functor<Solver, Float, Mode, Cost, obs> slv(ctx, rng);
ret = slv(constraints, variables, cost, cost_constant);
} break;
case solver_parameters::observer_type::file: {
using obs = file_observer;
solver_functor<Solver, Float, Mode, Cost, obs> slv(ctx, rng);
ret = slv(constraints, variables, cost, cost_constant);
} break;
default: {
using obs = none_observer;
solver_functor<Solver, Float, Mode, Cost, obs> slv(ctx, rng);
ret = slv(constraints, variables, cost, cost_constant);
break;
}
}
} else {
ret.status = result_status::success;
ret.solutions.resize(1);
ret.solutions.back().value = pb.objective.value;
}
ret.strings = pb.strings;
ret.variable_name = std::move(pb.vars.names);
ret.affected_vars = std::move(pb.affected_vars);
ret.variables = variables;
ret.constraints = length(constraints);
if (ctx.finish)
ctx.finish(ret);
return ret;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x130, %rsp # imm = 0x130
cmpq $0x0, 0x128(%rsi)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
je 0x4012dc
leaq 0x118(%r14), %rdi
movq %r14, %rsi
callq 0x3527e
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, 0x58(%rbx)
vmovups %zmm0, 0x40(%rbx)
vmovups %zmm0, (%rbx)
movq $0x7fffffff, 0x98(%rbx) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rbx)
movq 0xb0(%r15), %rax
subq 0xa8(%r15), %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
movq %rax, %r12
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
vzeroupper
callq 0x450078
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x401405
movq 0xa8(%r15), %rax
cmpq 0xb0(%r15), %rax
je 0x401405
movq %r14, %rdi
callq 0x353ba
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
xorl %edx, %edx
leaq 0x10(%r15), %rsi
divq %rcx
cmpq $0x1, %rdx
adcq $0x0, %rdx
movq %rdx, (%rsp)
leaq 0x20(%rsp), %rdi
movl %r12d, %edx
callq 0x8adb0
vmovsd 0x40(%r15), %xmm0
movl 0xe4(%r14), %eax
vxorps %xmm1, %xmm1, %xmm1
leaq 0x30(%rsp), %rsi
cmpl $0x1, %eax
je 0x40142c
cmpl $0x2, %eax
jne 0x40147b
movabsq $-0x10000000000000, %r9 # imm = 0xFFF0000000000000
vmovaps %xmm1, (%rsi)
movq %r14, 0x10(%rsi)
movq %rsp, %rax
movq %rax, 0x18(%rsi)
vmovaps %xmm1, 0x20(%rsi)
movq %r9, 0x30(%rsi)
andq $0x0, 0x48(%rsi)
vmovups %xmm1, 0x38(%rsi)
movl $0x7fffffff, 0x50(%rsi) # imm = 0x7FFFFFFF
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %r8
movl %r12d, %ecx
callq 0x40ba84
jmp 0x4014c8
andl $0x0, 0xa0(%rbx)
leaq 0x68(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x35292
vmovsd 0x40(%r15), %xmm0
movq 0x70(%rbx), %rax
vmovsd %xmm0, -0x8(%rax)
jmp 0x4014f7
movabsq $-0x10000000000000, %r9 # imm = 0xFFF0000000000000
vmovaps %xmm1, (%rsi)
movq %r14, 0x10(%rsi)
movq %rsp, %rax
movq %rax, 0x18(%rsi)
vmovaps %xmm1, 0x20(%rsi)
movq %r9, 0x30(%rsi)
andq $0x0, 0x48(%rsi)
vmovups %xmm1, 0x38(%rsi)
movl $0x7fffffff, 0x50(%rsi) # imm = 0x7FFFFFFF
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %r8
movl %r12d, %ecx
callq 0x40b33c
jmp 0x4014c8
movabsq $-0x10000000000000, %r9 # imm = 0xFFF0000000000000
vmovaps %xmm1, (%rsi)
movq %r14, 0x10(%rsi)
movq %rsp, %rax
movq %rax, 0x18(%rsi)
vmovaps %xmm1, 0x20(%rsi)
movq %r9, 0x30(%rsi)
andq $0x0, 0x48(%rsi)
vmovups %xmm1, 0x38(%rsi)
movl $0x7fffffff, 0x50(%rsi) # imm = 0x7FFFFFFF
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %r8
movl %r12d, %ecx
callq 0x40c1cc
leaq 0x88(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x41d9e
movq %r13, %rdi
callq 0xea60
leaq 0x58(%rsp), %rdi
callq 0x357fe
leaq 0x28(%rsp), %rdi
callq 0x8affa
leaq 0x90(%r15), %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31d28
leaq 0x50(%rbx), %rdi
movq %r13, %rsi
callq 0x352ec
addq $0xc0, %r15
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x352c2
movq 0x10(%rsp), %rax
movl %r12d, 0x90(%rbx)
subq 0x8(%rsp), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
movl %eax, 0x94(%rbx)
cmpq $0x0, 0x168(%r14)
je 0x401563
addq $0x158, %r14 # imm = 0x158
movq %r14, %rdi
movq %rbx, %rsi
callq 0x357ea
leaq 0x8(%rsp), %rdi
callq 0x35858
movq %rbx, %rax
addq $0x130, %rsp # imm = 0x130
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x401585
jmp 0x401585
leaq 0x58(%rsp), %rdi
movq %rax, %r14
callq 0x357fe
leaq 0x28(%rsp), %rdi
callq 0x8affa
jmp 0x4015a8
jmp 0x4015a5
movq %rax, %r14
jmp 0x4015b2
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x35858
movq %rbx, %rdi
callq 0xea60
movq %r14, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::result baryonyx::itm::optimize_problem<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, false>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>>(baryonyx::context const&, baryonyx::problem const&) | inline result
optimize_problem(const context& ctx, const problem& pb)
{
result r;
if (ctx.start)
ctx.start(ctx.parameters);
auto constraints{ make_merged_constraints(ctx, pb) };
if (constraints.empty() || pb.vars.values.empty()) {
r.status = result_status::success;
r.solutions.resize(1);
r.solutions.back().value = pb.objective.value;
r.strings = pb.strings;
r.affected_vars = pb.affected_vars;
r.variable_name = pb.vars.names;
return r;
}
random_engine rng(init_random_generator_seed(ctx));
auto variables = length(pb.vars.values);
auto cost = Cost(pb.objective, variables);
auto cost_constant = pb.objective.value;
const auto thread = get_thread_number(ctx);
std::vector<optimize_functor<Solver, Float, Mode, Cost>> functors;
std::vector<std::thread> pool(thread);
best_solution_recorder<Cost, Float, Mode> best_recorder(
rng,
thread,
cost,
cost_constant,
variables,
constraints,
ctx.parameters.init_population_size);
auto seeds = generate_seed(rng, thread);
std::atomic_bool stop_task;
stop_task.store(false);
for (unsigned i = 0u; i != thread; ++i)
functors.emplace_back(ctx, i, seeds[i]);
for (unsigned i = 0u; i != thread; ++i)
pool[i] = std::thread(std::ref(functors[i]),
std::ref(stop_task),
std::ref(best_recorder),
std::cref(constraints),
variables,
std::cref(cost),
cost_constant);
const auto start = std::chrono::steady_clock::now();
auto end = start;
do {
std::this_thread::sleep_for(std::chrono::seconds{ 1L });
if (ctx.update) {
auto call_number = 0L;
for (auto i = 0u; i != thread; ++i)
call_number += functors[i].m_call_number;
int constraints_remaining;
long int loop;
double value;
double duration;
best_recorder.get_best(
constraints_remaining, value, duration, loop);
ctx.update(
constraints_remaining, value, loop, duration, call_number);
}
end = std::chrono::steady_clock::now();
} while (!is_time_limit(ctx.parameters.time_limit, start, end));
stop_task.store(true);
for (auto& t : pool)
t.join();
r.strings = pb.strings;
r.affected_vars = pb.affected_vars;
r.variable_name = pb.vars.names;
r.variables = variables;
r.constraints = length(constraints);
const auto& first = best_recorder.get_best(0);
if (!first.is_solution())
r.status = result_status::time_limit_reached;
else
r.status = result_status::success;
r.duration = first.duration;
r.loop = first.loop;
r.remaining_constraints = first.remaining_constraints;
switch (ctx.parameters.storage) {
case solver_parameters::storage_type::one: {
r.solutions.resize(1);
convert(first, r.solutions[0], variables);
} break;
case solver_parameters::storage_type::bound: {
r.solutions.resize(2);
convert(first, r.solutions[0], variables);
convert(best_recorder.get_worst(), r.solutions[1], variables);
} break;
case solver_parameters::storage_type::five: {
r.solutions.resize(5);
for (int i = 0; i != 5; ++i)
convert(best_recorder.get_best(i), r.solutions[i], variables);
} break;
}
best_recorder.show_population(ctx);
if (ctx.finish)
ctx.finish(r);
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
vxorpd %xmm0, %xmm0, %xmm0
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
cmpq $0x0, 0x128(%rsi)
je 0x401628
leaq 0x118(%r15), %rdi
movq %r15, %rsi
vzeroupper
callq 0x3527e
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
vzeroupper
callq 0x450078
movq 0x48(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x401784
movq 0xa8(%r13), %rax
cmpq 0xb0(%r13), %rax
je 0x401784
movq %r15, %rdi
callq 0x353ba
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rcx
cmpq $0x1, %rdx
adcq $0x0, %rdx
movq %rdx, 0x40(%rsp)
movq 0xb0(%r13), %rax
subq 0xa8(%r13), %rax
pushq $0xc
popq %rcx
cqto
leaq 0x10(%r13), %rsi
idivq %rcx
movl %eax, 0x4(%rsp)
leaq 0x60(%rsp), %rdi
movl %eax, %edx
movq %r12, 0x10(%rsp)
callq 0x8adb0
vmovsd 0x40(%r13), %xmm0
vmovsd %xmm0, 0x38(%rsp)
movq %r15, %rdi
callq 0x35447
andq $0x0, 0x80(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movl %eax, %ebp
vmovapd %xmm0, 0x70(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xc8(%rsp), %rdx
movq %rbp, %rsi
callq 0x35462
vmovsd 0x38(%rsp), %xmm0
movl 0xc4(%r15), %eax
movl 0x4(%rsp), %r8d
subq $0x8, %rsp
movl %ebp, %edx
leaq 0xd0(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x68(%rsp), %rcx
leaq 0x50(%rsp), %r9
pushq %rax
callq 0x8ae24
popq %rax
popq %rcx
leaq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl %ebp, %edx
callq 0x3551c
xorl %eax, %eax
movb %al, 0x3(%rsp)
xorl %ecx, %ecx
leaq 0x70(%rsp), %rbx
leaq 0x8(%rsp), %r14
xchgb %cl, 0x3(%rsp)
leaq 0x90(%r13), %rcx
movq %rcx, 0x98(%rsp)
movl %eax, 0x8(%rsp)
cmpl %ebp, %eax
je 0x4017df
movl %eax, %ecx
shlq $0x3, %rcx
addq 0x30(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x40cb40
movl 0x8(%rsp), %eax
incl %eax
jmp 0x40175b
andl $0x0, 0xa0(%r12)
leaq 0x68(%r12), %rdi
pushq $0x1
popq %rsi
callq 0x35292
vmovsd 0x40(%r13), %xmm0
movq 0x70(%r12), %rax
vmovsd %xmm0, -0x8(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x31d28
leaq 0xc0(%r13), %rsi
leaq 0x20(%r12), %rdi
callq 0x352c2
addq $0x90, %r13
leaq 0x50(%r12), %rdi
movq %r13, %rsi
callq 0x352ec
jmp 0x401b74
movq %r13, 0x90(%rsp)
movq %r15, %r13
leaq 0x8(%rsp), %r15
leaq 0xa8(%rsp), %r14
leaq 0x4(%rsp), %rbx
xorl %r12d, %r12d
cmpq %rbp, %r12
je 0x4018a0
imulq $0xc0, %r12, %rax
addq 0x70(%rsp), %rax
leaq 0x3(%rsp), %r10
leaq 0xc8(%rsp), %r11
movq %r10, 0x20(%rsp)
leaq 0x48(%rsp), %r10
movq %r11, 0x18(%rsp)
movq %r10, 0xa8(%rsp)
movq %rax, 0x28(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, 0xa0(%rsp)
leaq 0x20(%rsp), %rdx
leaq 0x38(%rsp), %rax
movq %r15, %rdi
leaq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rcx
movq %r14, %r8
movq %rbx, %r9
pushq %rax
leaq 0xa8(%rsp), %rax
pushq %rax
callq 0x40cb8c
popq %rax
popq %rcx
leaq (,%r12,8), %rdi
addq 0xb0(%rsp), %rdi
movq %r15, %rsi
callq 0x356d6
movq %r15, %rdi
callq 0x356f0
incq %r12
jmp 0x4017ff
callq 0xb5a0
imulq $0xc0, %rbp, %r15
leaq 0x138(%r13), %r12
leaq 0x8(%rsp), %rbp
movq %rax, %rbx
movq $0x1, 0x8(%rsp)
movq %rbp, %rdi
callq 0x356fd
cmpq $0x0, 0x148(%r13)
je 0x401935
movq 0x70(%rsp), %rax
xorl %ecx, %ecx
xorl %r14d, %r14d
cmpq %rcx, %r15
je 0x4018f6
addq 0xb0(%rax,%rcx), %r14
addq $0xc0, %rcx
jmp 0x4018e0
leaq 0xd0(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rbp, %r8
callq 0x93ba8
vmovsd 0x28(%rsp), %xmm0
vmovsd 0x20(%rsp), %xmm1
movq 0x8(%rsp), %rdx
movl 0x18(%rsp), %esi
movq %r12, %rdi
movq %r14, %rcx
callq 0x35736
callq 0xb5a0
vmovsd (%r13), %xmm0
subq %rbx, %rax
vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm0, %xmm1
vcvtsi2sd %rax, %xmm2, %xmm1
vdivsd 0x58128(%rip), %xmm1, %xmm1 # 0x459a80
jae 0x4018bb
vucomisd %xmm0, %xmm1
jbe 0x4018bb
movb $0x1, %al
xchgb %al, 0x3(%rsp)
movq 0xb0(%rsp), %rbx
movq 0xb8(%rsp), %r14
movq 0x10(%rsp), %r12
cmpq %r14, %rbx
je 0x401996
movq %rbx, %rdi
callq 0xb1a0
addq $0x8, %rbx
jmp 0x401983
movq 0x90(%rsp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x31d28
addq $0xc0, %rbx
leaq 0x20(%r12), %rdi
movq %rbx, %rsi
callq 0x352c2
leaq 0x50(%r12), %rdi
movq 0x98(%rsp), %rsi
callq 0x352ec
movl 0x4(%rsp), %eax
movl %eax, 0x90(%r12)
movq 0x50(%rsp), %rax
subq 0x48(%rsp), %rax
pushq $0x28
popq %rcx
cqto
xorl %esi, %esi
idivq %rcx
movq 0x108(%rsp), %rdi
movq 0x120(%rsp), %rcx
movl %eax, 0x94(%r12)
movslq (%rdi), %rax
imulq $0x38, %rax, %rax
movl 0x30(%rcx,%rax), %edx
leaq (%rcx,%rax), %rbx
testl %edx, %edx
setne %sil
leal (%rsi,%rsi,2), %esi
movl %esi, 0xa0(%r12)
vmovsd 0x18(%rcx,%rax), %xmm0
vmovsd %xmm0, 0x80(%r12)
movq 0x28(%rcx,%rax), %rax
movq %rax, 0x88(%r12)
movl %edx, 0x98(%r12)
movl 0xe8(%r13), %eax
testl %eax, %eax
je 0x401af1
cmpl $0x1, %eax
je 0x401ab9
cmpl $0x2, %eax
jne 0x401b10
leaq 0x68(%r12), %rbx
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x35292
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq $0x5, %r15
je 0x401b10
movq 0x108(%rsp), %rax
movq (%rbx), %rsi
movl 0x4(%rsp), %edx
movslq (%rax,%r15,4), %rax
addq %r14, %rsi
imulq $0x38, %rax, %rdi
addq 0x120(%rsp), %rdi
callq 0x35781
incq %r15
addq $0x20, %r14
jmp 0x401a7f
leaq 0x68(%r12), %r14
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x35292
movl 0x4(%rsp), %edx
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x35781
leaq 0xd0(%rsp), %rdi
callq 0x93c26
movq (%r14), %rsi
movq %rax, %rbx
addq $0x20, %rsi
jmp 0x401b04
leaq 0x68(%r12), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x35292
movq (%r14), %rsi
movl 0x4(%rsp), %edx
movq %rbx, %rdi
callq 0x35781
leaq 0xc8(%rsp), %rdi
movq %r13, %rsi
callq 0x8af88
cmpq $0x0, 0x168(%r13)
je 0x401b3c
addq $0x158, %r13 # imm = 0x158
movq %r13, %rdi
movq %r12, %rsi
callq 0x357ea
leaq 0x30(%rsp), %rdi
callq 0x357fe
leaq 0xc8(%rsp), %rdi
callq 0x8af9c
leaq 0xb0(%rsp), %rdi
callq 0x35836
leaq 0x70(%rsp), %rdi
callq 0x413ef4
leaq 0x68(%rsp), %rdi
callq 0x8affa
leaq 0x48(%rsp), %rdi
callq 0x35858
movq %r12, %rax
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x401bd5
movq %rax, %rbx
jmp 0x401be2
movq %rax, %rbx
jmp 0x401bef
jmp 0x401bb9
jmp 0x401baa
jmp 0x401bc8
jmp 0x401bc8
movq %r12, 0x10(%rsp)
movq %rax, %rbx
jmp 0x401c0d
movq %r12, 0x10(%rsp)
movq %rax, %rbx
jmp 0x401c03
jmp 0x401bc8
jmp 0x401bc8
jmp 0x401bc8
jmp 0x401bc8
jmp 0x401bc8
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x357fe
leaq 0xc8(%rsp), %rdi
callq 0x8af9c
leaq 0xb0(%rsp), %rdi
callq 0x35836
leaq 0x70(%rsp), %rdi
callq 0x413ef4
leaq 0x68(%rsp), %rdi
callq 0x8affa
leaq 0x48(%rsp), %rdi
callq 0x35858
movq 0x10(%rsp), %rdi
callq 0xea60
movq %rbx, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-optimizer-common.hpp |
baryonyx::result baryonyx::itm::solve_problem<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, false>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>>(baryonyx::context const&, baryonyx::problem const&) | inline result
solve_problem(const context& ctx, const problem& pb)
{
if (ctx.start)
ctx.start(ctx.parameters);
result ret;
auto variables = length(pb.vars.values);
auto constraints{ make_merged_constraints(ctx, pb) };
if (!constraints.empty() && !pb.vars.values.empty()) {
random_engine rng(init_random_generator_seed(ctx));
auto cost = Cost(pb.objective, variables);
auto cost_constant = pb.objective.value;
switch (ctx.parameters.observer) {
case solver_parameters::observer_type::pnm: {
using obs = pnm_observer;
solver_functor<Solver, Float, Mode, Cost, obs> slv(ctx, rng);
ret = slv(constraints, variables, cost, cost_constant);
} break;
case solver_parameters::observer_type::file: {
using obs = file_observer;
solver_functor<Solver, Float, Mode, Cost, obs> slv(ctx, rng);
ret = slv(constraints, variables, cost, cost_constant);
} break;
default: {
using obs = none_observer;
solver_functor<Solver, Float, Mode, Cost, obs> slv(ctx, rng);
ret = slv(constraints, variables, cost, cost_constant);
break;
}
}
} else {
ret.status = result_status::success;
ret.solutions.resize(1);
ret.solutions.back().value = pb.objective.value;
}
ret.strings = pb.strings;
ret.variable_name = std::move(pb.vars.names);
ret.affected_vars = std::move(pb.affected_vars);
ret.variables = variables;
ret.constraints = length(constraints);
if (ctx.finish)
ctx.finish(ret);
return ret;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x130, %rsp # imm = 0x130
cmpq $0x0, 0x128(%rsi)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
je 0x401c51
leaq 0x118(%r14), %rdi
movq %r14, %rsi
callq 0x3527e
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, 0x58(%rbx)
vmovups %zmm0, 0x40(%rbx)
vmovups %zmm0, (%rbx)
movq $0x7fffffff, 0x98(%rbx) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rbx)
movq 0xb0(%r15), %rax
subq 0xa8(%r15), %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
movq %rax, %r12
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
vzeroupper
callq 0x450078
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x401d7a
movq 0xa8(%r15), %rax
cmpq 0xb0(%r15), %rax
je 0x401d7a
movq %r14, %rdi
callq 0x353ba
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
xorl %edx, %edx
leaq 0x10(%r15), %rsi
divq %rcx
cmpq $0x1, %rdx
adcq $0x0, %rdx
movq %rdx, (%rsp)
leaq 0x20(%rsp), %rdi
movl %r12d, %edx
callq 0x8adb0
vmovsd 0x40(%r15), %xmm0
movl 0xe4(%r14), %eax
vxorps %xmm1, %xmm1, %xmm1
leaq 0x30(%rsp), %rsi
cmpl $0x1, %eax
je 0x401da1
cmpl $0x2, %eax
jne 0x401df0
movabsq $-0x10000000000000, %r9 # imm = 0xFFF0000000000000
vmovaps %xmm1, (%rsi)
movq %r14, 0x10(%rsi)
movq %rsp, %rax
movq %rax, 0x18(%rsi)
vmovaps %xmm1, 0x20(%rsi)
movq %r9, 0x30(%rsi)
andq $0x0, 0x48(%rsi)
vmovups %xmm1, 0x38(%rsi)
movl $0x7fffffff, 0x50(%rsi) # imm = 0x7FFFFFFF
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %r8
movl %r12d, %ecx
callq 0x414664
jmp 0x401e3d
andl $0x0, 0xa0(%rbx)
leaq 0x68(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x35292
vmovsd 0x40(%r15), %xmm0
movq 0x70(%rbx), %rax
vmovsd %xmm0, -0x8(%rax)
jmp 0x401e6c
movabsq $-0x10000000000000, %r9 # imm = 0xFFF0000000000000
vmovaps %xmm1, (%rsi)
movq %r14, 0x10(%rsi)
movq %rsp, %rax
movq %rax, 0x18(%rsi)
vmovaps %xmm1, 0x20(%rsi)
movq %r9, 0x30(%rsi)
andq $0x0, 0x48(%rsi)
vmovups %xmm1, 0x38(%rsi)
movl $0x7fffffff, 0x50(%rsi) # imm = 0x7FFFFFFF
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %r8
movl %r12d, %ecx
callq 0x413f1c
jmp 0x401e3d
movabsq $-0x10000000000000, %r9 # imm = 0xFFF0000000000000
vmovaps %xmm1, (%rsi)
movq %r14, 0x10(%rsi)
movq %rsp, %rax
movq %rax, 0x18(%rsi)
vmovaps %xmm1, 0x20(%rsi)
movq %r9, 0x30(%rsi)
andq $0x0, 0x48(%rsi)
vmovups %xmm1, 0x38(%rsi)
movl $0x7fffffff, 0x50(%rsi) # imm = 0x7FFFFFFF
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %r8
movl %r12d, %ecx
callq 0x414dac
leaq 0x88(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x41d9e
movq %r13, %rdi
callq 0xea60
leaq 0x58(%rsp), %rdi
callq 0x357fe
leaq 0x28(%rsp), %rdi
callq 0x8affa
leaq 0x90(%r15), %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31d28
leaq 0x50(%rbx), %rdi
movq %r13, %rsi
callq 0x352ec
addq $0xc0, %r15
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x352c2
movq 0x10(%rsp), %rax
movl %r12d, 0x90(%rbx)
subq 0x8(%rsp), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
movl %eax, 0x94(%rbx)
cmpq $0x0, 0x168(%r14)
je 0x401ed8
addq $0x158, %r14 # imm = 0x158
movq %r14, %rdi
movq %rbx, %rsi
callq 0x357ea
leaq 0x8(%rsp), %rdi
callq 0x35858
movq %rbx, %rax
addq $0x130, %rsp # imm = 0x130
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x401efa
jmp 0x401efa
leaq 0x58(%rsp), %rdi
movq %rax, %r14
callq 0x357fe
leaq 0x28(%rsp), %rdi
callq 0x8affa
jmp 0x401f1d
jmp 0x401f1a
movq %rax, %r14
jmp 0x401f27
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x35858
movq %rbx, %rdi
callq 0xea60
movq %r14, %rdi
callq 0xb3d0
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::optimize_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>>::operator()(std::atomic<bool> const&, baryonyx::itm::best_solution_recorder<baryonyx::itm::default_cost_type<long double>, long double, baryonyx::itm::maximize_tag>&, std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&, int, baryonyx::itm::default_cost_type<long double> const&, double) | void operator()(const std::atomic_bool& stop_task,
best_solution_recorder<Cost, Float, Mode>& best_recorder,
const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
bit_array x(variables);
auto& p = m_ctx.parameters;
auto norm_costs = normalize_costs<Float, Cost>(
m_ctx, original_costs, m_local_ctx.rng, variables);
const auto kappa_step = static_cast<Float>(p.kappa_step);
const auto kappa_max = static_cast<Float>(p.kappa_max);
const auto alpha = static_cast<Float>(p.alpha);
const auto theta = static_cast<Float>(p.theta);
const auto delta =
p.delta < 0
? compute_delta<Float, Cost>(m_ctx, norm_costs, theta, variables)
: static_cast<Float>(p.delta);
const auto pushing_k_factor = static_cast<Float>(p.pushing_k_factor);
const auto pushing_objective_amplifier =
static_cast<Float>(p.pushing_objective_amplifier);
const auto w_limit = static_cast<long int>(p.w);
Solver slv(m_local_ctx.rng,
length(constraints),
variables,
norm_costs,
constraints);
compute_order compute(p.order, variables);
bool is_a_solution = false;
while (!stop_task.load()) {
++m_call_number;
const auto kappa_start = static_cast<Float>(best_recorder.reinit(
m_local_ctx, is_a_solution, p.kappa_min, p.kappa_max, x));
auto kappa = kappa_start;
compute.init(slv, x);
auto best_remaining = INT_MAX;
is_a_solution = false;
for (long int i = 0; !stop_task.load() && i != p.limit; ++i) {
auto remaining =
compute.run(slv, x, m_local_ctx.rng, kappa, delta, theta);
if (remaining == 0) {
best_recorder.try_update(
m_local_ctx,
x,
original_costs.results(x, cost_constant),
i);
best_remaining = 0;
is_a_solution = true;
break;
} else {
best_remaining = std::min(remaining, best_remaining);
}
if (i > w_limit)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
}
if (best_remaining > 0) {
best_recorder.try_advance(
m_local_ctx, x, best_remaining, p.limit);
continue;
}
for (int push = 0; !stop_task.load() && push < p.pushes_limit;
++push) {
auto remaining =
compute.push_and_run(slv,
x,
m_local_ctx.rng,
pushing_k_factor,
delta,
theta,
pushing_objective_amplifier);
if (remaining == 0) {
best_recorder.try_update(
m_local_ctx,
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - 1);
is_a_solution = true;
}
kappa = kappa_start;
for (int iter = 0;
!stop_task.load() && iter < p.pushing_iteration_limit;
++iter) {
remaining = compute.run(
slv, x, m_local_ctx.rng, kappa, delta, theta);
if (remaining == 0) {
best_recorder.try_update(
m_local_ctx,
x,
original_costs.results(x, cost_constant),
-push * p.pushing_iteration_limit - iter - 1);
is_a_solution = true;
break;
}
if (iter > p.w)
kappa +=
kappa_step * std::pow(static_cast<Float>(remaining) /
static_cast<Float>(slv.m),
alpha);
if (kappa > kappa_max)
break;
}
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
movq %rdi, %rbp
leaq 0x58(%rsp), %rdi
movq %rsi, %r15
movl %r8d, %esi
vmovsd %xmm0, 0x88(%rsp)
movq %r9, %r12
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, 0x68(%rsp)
callq 0x368ae
movq (%rbp), %r13
movq %rbp, 0xb0(%rsp)
addq $0x8, %rbp
leaq 0xb8(%rsp), %rdi
movq %r13, %rsi
movq %r12, 0x80(%rsp)
movq %r12, %rdx
movq %rbp, %rcx
movl %ebx, %r8d
callq 0x8d226
fldl 0x20(%r13)
fstpt 0xe0(%rsp)
vxorpd %xmm1, %xmm1, %xmm1
fldl 0x28(%r13)
fstpt 0xec(%rsp)
fldl 0x30(%r13)
fstpt 0xd4(%rsp)
fldl 0x8(%r13)
vmovsd 0x10(%r13), %xmm0
fld %st(0)
fstpt 0x44(%rsp)
vucomisd %xmm0, %xmm1
jbe 0x402419
movq 0xb0(%rsp), %rax
movq (%rax), %rdi
leaq 0xb8(%rsp), %rsi
movl %ebx, %edx
fstpt (%rsp)
callq 0x8d304
fstpt 0x94(%rsp)
jmp 0x402432
fstp %st(0)
vmovsd %xmm0, 0x108(%rsp)
fldl 0x108(%rsp)
fstpt 0x94(%rsp)
fldl 0x38(%r13)
fstpt 0x11c(%rsp)
fldl 0x40(%r13)
fstpt 0x110(%rsp)
vcvttsd2si 0xa0(%r13), %rax
movq %rax, 0xf8(%rsp)
movq 0x8(%r14), %rax
subq (%r14), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq 0x160(%rsp), %rdi
leaq 0xb8(%rsp), %r8
movq %rbp, %rsi
movl %eax, %edx
movl %ebx, %ecx
movq %r14, %r9
callq 0x4028fe
movl 0xcc(%r13), %esi
leaq 0x128(%rsp), %rdi
movl %ebx, %edx
callq 0x38cd8
movq $0x0, 0x50(%rsp)
movb (%r15), %al
testb $0x1, %al
jne 0x402866
movq 0xb0(%rsp), %rax
incq 0xb0(%rax)
vmovsd 0x18(%r13), %xmm0
vmovsd 0x28(%r13), %xmm1
movzbl 0x50(%rsp), %edx
movq 0x68(%rsp), %rdi
leaq 0x58(%rsp), %rbx
movq %rbp, %rsi
movq %rbx, %rcx
andl $0x1, %edx
callq 0x8d5a0
vmovsd %xmm0, 0x100(%rsp)
fldl 0x100(%rsp)
fstpt 0xc8(%rsp)
leaq 0x128(%rsp), %rdi
leaq 0x160(%rsp), %rsi
movq %rbx, %rdx
callq 0x402d8e
fldt 0xc8(%rsp)
fldt 0x44(%rsp)
movl $0x7fffffff, %ebx # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movb (%r15), %al
testb $0x1, %al
jne 0x4025fb
cmpq 0xb0(%r13), %r14
je 0x4025fb
fstpt 0x20(%rsp)
leaq 0x128(%rsp), %rdi
leaq 0x160(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movq %rbp, %rcx
fldt 0x94(%rsp)
fstpt 0x10(%rsp)
fld %st(0)
fstpt 0x74(%rsp)
fstpt (%rsp)
callq 0x402dd0
testl %eax, %eax
je 0x402615
cmpl %eax, %ebx
cmovgel %eax, %ebx
cmpq 0xf8(%rsp), %r14
jle 0x4025da
movl %eax, 0xa8(%rsp)
fildl 0xa8(%rsp)
movl 0x2e0(%rsp), %eax
movl %eax, 0xac(%rsp)
fidivl 0xac(%rsp)
fldt 0xd4(%rsp)
fstpt 0x10(%rsp)
fstpt (%rsp)
callq 0xb110
fldt 0xe0(%rsp)
fmulp %st, %st(1)
fldt 0x74(%rsp)
faddp %st, %st(1)
fldt 0x44(%rsp)
jmp 0x4025e4
fldt 0x44(%rsp)
fldt 0x74(%rsp)
fxch %st(1)
fldt 0xec(%rsp)
fxch %st(2)
fucomi %st(2), %st
fstp %st(2)
ja 0x4025fb
incq %r14
jmp 0x40252b
fstp %st(1)
testl %ebx, %ebx
jg 0x402844
movq $0x0, 0x50(%rsp)
leaq 0x58(%rsp), %rbx
jmp 0x402651
vmovsd 0x88(%rsp), %xmm0
movq 0x80(%rsp), %rdi
leaq 0x58(%rsp), %rbx
movq %rbx, %rsi
callq 0x8b74a
movq 0x68(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x8d912
movb $0x1, %al
movq %rax, 0x50(%rsp)
fldt 0x44(%rsp)
xorl %r14d, %r14d
movl $0x0, 0x70(%rsp)
movb (%r15), %al
testb $0x1, %al
jne 0x40283d
cmpl 0xbc(%r13), %r14d
jge 0x40283d
fldt 0x110(%rsp)
fstpt 0x30(%rsp)
fstpt 0x20(%rsp)
leaq 0x128(%rsp), %rdi
leaq 0x160(%rsp), %rsi
movq %rbx, %rdx
movq %rbp, %rcx
fldt 0x94(%rsp)
fstpt 0x10(%rsp)
fldt 0x11c(%rsp)
fstpt (%rsp)
callq 0x403000
testl %eax, %eax
jne 0x4026f7
vmovsd 0x88(%rsp), %xmm0
movq 0x80(%rsp), %rdi
movq %rbx, %rsi
callq 0x8b74a
movl 0xc0(%r13), %eax
movq 0x68(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
imull %r14d, %eax
notl %eax
movslq %eax, %rcx
callq 0x8d912
movb $0x1, %al
movq %rax, 0x50(%rsp)
pushq $0x1
popq %rax
fldt 0xc8(%rsp)
fldt 0x44(%rsp)
movl %eax, %ebx
movb (%r15), %al
testb $0x1, %al
jne 0x4027db
leal -0x1(%rbx), %r12d
cmpl 0xc0(%r13), %r12d
jge 0x4027db
fstpt 0x20(%rsp)
leaq 0x128(%rsp), %rdi
leaq 0x160(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movq %rbp, %rcx
fldt 0x94(%rsp)
fstpt 0x10(%rsp)
fld %st(0)
fstpt 0x74(%rsp)
fstpt (%rsp)
callq 0x402dd0
testl %eax, %eax
je 0x4027e4
vcvtsi2sd %r12d, %xmm2, %xmm0
vucomisd 0xa0(%r13), %xmm0
jbe 0x4027bb
movl %eax, 0xa0(%rsp)
fildl 0xa0(%rsp)
movl 0x2e0(%rsp), %eax
movl %eax, 0xa4(%rsp)
fidivl 0xa4(%rsp)
fldt 0xd4(%rsp)
fstpt 0x10(%rsp)
fstpt (%rsp)
callq 0xb110
fldt 0xe0(%rsp)
fmulp %st, %st(1)
fldt 0x74(%rsp)
faddp %st, %st(1)
fldt 0x44(%rsp)
jmp 0x4027c5
fldt 0x44(%rsp)
fldt 0x74(%rsp)
fxch %st(1)
fldt 0xec(%rsp)
fxch %st(2)
fucomi %st(2), %st
fstp %st(2)
ja 0x4027db
incl %ebx
jmp 0x402707
fstp %st(1)
leaq 0x58(%rsp), %rbx
jmp 0x402831
vmovsd 0x88(%rsp), %xmm0
movq 0x80(%rsp), %rdi
leaq 0x58(%rsp), %r12
movq %r12, %rsi
callq 0x8b74a
movl 0xc0(%r13), %eax
movq 0x68(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
imull 0x70(%rsp), %eax
subl %ebx, %eax
movq %r12, %rbx
movslq %eax, %rcx
callq 0x8d912
movb $0x1, %al
movq %rax, 0x50(%rsp)
fldt 0x44(%rsp)
decl 0x70(%rsp)
incl %r14d
jmp 0x40265c
fstp %st(0)
jmp 0x4024a6
fstp %st(0)
movq 0xb0(%r13), %r8
movq 0x68(%rsp), %rdi
leaq 0x58(%rsp), %rdx
movq %rbp, %rsi
movl %ebx, %ecx
callq 0x8d99a
jmp 0x40249d
leaq 0x128(%rsp), %rdi
callq 0x393ac
leaq 0x160(%rsp), %rdi
callq 0x4032a4
leaq 0xc0(%rsp), %rdi
callq 0x8affa
leaq 0x60(%rsp), %rdi
callq 0x357fe
addq $0x2f8, %rsp # imm = 0x2F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4028b0
movq %rax, %rbx
jmp 0x4028d2
movq %rax, %rbx
jmp 0x4028df
movq %rax, %rbx
jmp 0x4028ec
jmp 0x4028c2
jmp 0x4028c2
jmp 0x4028c2
jmp 0x4028c2
leaq 0x128(%rsp), %rdi
movq %rax, %rbx
callq 0x393ac
leaq 0x160(%rsp), %rdi
callq 0x4032a4
leaq 0xc0(%rsp), %rdi
callq 0x8affa
leaq 0x60(%rsp), %rdi
callq 0x357fe
movq %rbx, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-optimizer-common.hpp |
baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>::solver_inequalities_Zcoeff(std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, int, int, baryonyx::itm::default_cost_type<long double> const&, std::vector<baryonyx::itm::merged_constraint, std::allocator<baryonyx::itm::merged_constraint>> const&) | solver_inequalities_Zcoeff(random_engine& rng_,
int m_,
int n_,
const cost_type& c_,
const std::vector<merged_constraint>& csts)
: logger("solver_inequalities_Zcoeff")
, rng(rng_)
, ap(csts, m_, n_)
, P(std::make_unique<Float[]>(ap.size()))
, A(std::make_unique<int[]>(ap.size()))
, R(std::make_unique<rc_data[]>(compute_reduced_costs_vector_size(csts)))
, Z(std::make_unique<subsolver_type[]>(m_))
, b(std::make_unique<bound_factor[]>(m_))
, pi(std::make_unique<Float[]>(m_))
, c(c_)
, m(m_)
, n(n_)
{
// Count the maximum function elements in the constraint where a least
// one coefficient is in Z. To be use with the branch-and-bound and
// exhaustive solvers.
std::size_t z_variables_max = 0;
// Count the maximum constraint number where at leat one coefficient is
// in Z. To be used with the exhaustive solver.
std::size_t z_constraint_exhaustive = 0;
int id = 0;
for (int i = 0, e = length(csts); i != e; ++i) {
int lower = 0, upper = 0;
std::size_t local_z_variables_max = 0;
Z[i] =
subsolver_type::linear; // Default, Z solver use the classical
// Bastert selection for 101 problem.
for (const auto& cst : csts[i].elements) {
bx_ensures(cst.factor);
A[id++] = cst.factor;
++local_z_variables_max;
if (cst.factor > 0)
upper += cst.factor;
else
lower += cst.factor;
if (cst.factor < -1 || cst.factor > 1) {
Z[i] = subsolver_type::branch_and_bound;
}
}
if (Z[i] == subsolver_type::branch_and_bound &&
local_z_variables_max < maximum_factor_exhaustive_solver)
Z[i] = subsolver_type::exhaustive;
if (csts[i].min == csts[i].max) {
b[i].min = csts[i].min;
b[i].max = csts[i].max;
} else {
if (lower >= csts[i].min || upper <= csts[i].max) {
if (Z[i] == subsolver_type::branch_and_bound)
Z[i] = subsolver_type::unconstrained_branch_and_bound;
else if (Z[i] == subsolver_type::exhaustive)
Z[i] = subsolver_type::unconstrained_exhaustive;
}
b[i].min = std::max(lower, csts[i].min);
b[i].max = std::min(upper, csts[i].max);
}
z_variables_max = std::max(z_variables_max, local_z_variables_max);
if (Z[i] == subsolver_type::exhaustive ||
Z[i] == subsolver_type::unconstrained_exhaustive) {
z_constraint_exhaustive++;
ex.build_constraints(i, csts[i].elements, b[i].min, b[i].max);
}
logger::log("Is Z: {} ({}) with {} <= {}\n",
static_cast<int>(Z[i]),
local_z_variables_max,
b[i].min,
b[i].max);
bx_ensures(b[i].min <= b[i].max);
}
if (z_constraint_exhaustive > 0)
ex.reserve(z_variables_max, z_constraint_exhaustive);
bb.reserve(z_variables_max);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %r13d
leaq 0x641a2(%rip), %rdx # 0x466abb
movq %r9, %r12
movq %r8, %rbp
movl %ecx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x1a
popq %rsi
callq 0xb8418
movq %r15, 0x8(%rbx)
leaq 0x10(%rbx), %r15
movq %r15, %rdi
movq %r12, 0x18(%rsp)
movq %r12, %rsi
movl %r13d, %edx
movl %r14d, %ecx
movq %rbx, 0x50(%rsp)
callq 0x3a4ca
movl 0x38(%rbx), %esi
leaq 0x50(%rbx), %r12
movq %r12, %rdi
movq %r15, 0x78(%rsp)
callq 0x8afb9
movl 0x38(%rbx), %esi
leaq 0x58(%rbx), %rdi
movq %rdi, 0x58(%rsp)
movq %r12, 0x70(%rsp)
callq 0x28eb6
movq 0x18(%rsp), %rdi
leaq 0x60(%rbx), %r15
callq 0x3a89d
movq %r15, %rdi
movq %rax, %rsi
callq 0x403308
movslq %r13d, %r12
leaq 0x68(%rbx), %rdi
movq %r12, %rsi
movq %rdi, 0x20(%rsp)
movq %r15, 0x68(%rsp)
callq 0x403348
leaq 0x70(%rbx), %rdi
movq %r12, %rsi
movq %rdi, 0x8(%rsp)
callq 0x403377
leaq 0x78(%rbx), %rdi
movq %r12, %rsi
movq %rdi, 0x60(%rsp)
callq 0x8afb9
movq 0x18(%rsp), %rcx
vxorps %xmm0, %xmm0, %xmm0
leaq 0x80(%rbx), %rax
vmovups %xmm0, 0x8c(%rbx)
vmovaps %xmm0, 0x80(%rbx)
vxorps %xmm0, %xmm0, %xmm0
movq %rax, 0x40(%rsp)
orl $-0x1, 0x9c(%rbx)
leaq 0x150(%rbx), %rax
vmovups %ymm0, 0xa0(%rbx)
vmovups %ymm0, 0xb0(%rbx)
vxorps %xmm0, %xmm0, %xmm0
andl $0x0, 0x150(%rbx)
andq $0x0, 0x158(%rbx)
andq $0x0, 0x140(%rbx)
vmovups %zmm0, 0x100(%rbx)
movq %rax, 0x160(%rbx)
movq %rax, 0x168(%rbx)
andq $0x0, 0x170(%rbx)
movq %rbp, 0x178(%rbx)
movl %r13d, 0x180(%rbx)
movl %r14d, 0x184(%rbx)
movq 0x8(%rcx), %rax
subq (%rcx), %rax
pushq $0x28
popq %rcx
cqto
xorl %r12d, %r12d
xorl %ebp, %ebp
idivq %rcx
leaq 0x100(%rbx), %rcx
movq $0x0, 0x28(%rsp)
movq $0x0, 0x48(%rsp)
movq %rcx, 0x10(%rsp)
movl %eax, %eax
movq %rax, 0x80(%rsp)
cmpq 0x80(%rsp), %r12
je 0x402c74
movq 0x20(%rsp), %rax
andq $0x0, 0x30(%rsp)
imulq $0x28, %r12, %rsi
movslq %ebp, %rbp
xorl %r11d, %r11d
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movb $0x4, (%rcx,%r12)
movq (%rax), %rax
leaq (%rax,%rsi), %rdx
movq (%rax,%rsi), %r8
movq 0x8(%rax,%rsi), %r9
movq 0x58(%rsp), %rax
movq (%rax), %r10
movb $0x4, %al
pushq $0x1
popq %r15
xorl %esi, %esi
xorl %edi, %edi
leaq (%r8,%r11), %rbx
cmpq %r9, %rbx
je 0x402b51
movl -0x8(%r8,%r15,8), %ebx
testl %ebx, %ebx
je 0x402cb5
movl %ebx, (%r10,%rbp,4)
movq %r15, 0x30(%rsp)
movl $0x0, %r14d
movl -0x8(%r8,%r15,8), %ebx
testl %ebx, %ebx
leal -0x2(%rbx), %r13d
cmovsl %ebx, %r14d
cmpl $-0x4, %r13d
ja 0x402b34
xorl %eax, %eax
movb $0x0, (%rcx,%r12)
movl %ebx, %r13d
sarl $0x1f, %r13d
addl %r14d, %edi
incq %r15
addq $0x8, %r11
incq %rbp
andnl %ebx, %r13d, %ebx
addl %ebx, %esi
jmp 0x402af3
movq 0x30(%rsp), %r10
testb %al, %al
sete %r8b
cmpq $0xa, %r10
setb %r9b
testb %r9b, %r8b
je 0x402b70
movb $0x1, %al
movb $0x1, (%rcx,%r12)
movl 0x18(%rdx), %r8d
movl 0x1c(%rdx), %r9d
movq 0x50(%rsp), %rbx
cmpl %r9d, %r8d
jne 0x402b97
movq 0x8(%rsp), %rcx
movq (%rcx), %r9
imulq $0xc, %r12, %rcx
movl %r8d, (%r9,%rcx)
movl %r8d, %ecx
jmp 0x402bdd
cmpl %r8d, %edi
jge 0x402ba1
cmpl %r9d, %esi
jg 0x402bb9
testb %al, %al
je 0x402bb3
movzbl %al, %r9d
cmpl $0x1, %r9d
jne 0x402bb9
movb $0x3, %al
jmp 0x402bb5
movb $0x2, %al
movb %al, (%rcx,%r12)
movq 0x8(%rsp), %r9
cmpl %r8d, %edi
movl %r8d, %ecx
cmovgl %edi, %ecx
imulq $0xc, %r12, %rdi
movq (%r9), %r9
movl %ecx, (%r9,%rdi)
movl 0x1c(%rdx), %edi
cmpl %esi, %edi
cmovll %edi, %esi
movl %esi, %r8d
movq 0x28(%rsp), %rsi
imulq $0xc, %r12, %r15
movzbl %al, %edi
movl %r8d, 0x4(%r9,%r15)
cmpq %r10, %rsi
cmovbeq %r10, %rsi
orl $0x2, %edi
movq %rsi, 0x28(%rsp)
cmpl $0x3, %edi
jne 0x402c2b
movq 0x10(%rsp), %rdi
movl %r12d, %esi
vzeroupper
callq 0x4033b4
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
incq 0x48(%rsp)
movq (%rax), %rax
movq (%rcx), %r9
movb (%rax,%r12), %al
leaq 0x4(%r9,%r15), %rsi
movsbl %al, %eax
addq %r15, %r9
movq %rbx, %rdi
movl %eax, 0x3c(%rsp)
movq %rsi, (%rsp)
pushq $0x1c
popq %rsi
leaq 0x63f05(%rip), %rdx # 0x466b50
leaq 0x3c(%rsp), %rcx
leaq 0x30(%rsp), %r8
vzeroupper
callq 0x36b838
movq 0x70(%rbx), %rax
movl (%rax,%r15), %ecx
cmpl 0x4(%rax,%r15), %ecx
jg 0x402cd9
incq %r12
jmp 0x402aa1
movq 0x48(%rsp), %rdx
movq 0x28(%rsp), %rbx
testq %rdx, %rdx
je 0x402c93
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
vzeroupper
callq 0x4035c8
movq 0x40(%rsp), %rdi
movq %rbx, %rsi
vzeroupper
callq 0x40364c
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5576e(%rip), %rdi # 0x45842a
leaq 0x63e13(%rip), %rsi # 0x466ad6
leaq 0x63e17(%rip), %rdx # 0x466ae1
leaq 0x63e7b(%rip), %rcx # 0x466b4c
vzeroupper
callq 0x2813f
leaq 0x5574a(%rip), %rdi # 0x45842a
leaq 0x575c2(%rip), %rsi # 0x45a2a9
leaq 0x63df3(%rip), %rdx # 0x466ae1
leaq 0x63e78(%rip), %rcx # 0x466b6d
callq 0x2813f
movq %rax, %r14
jmp 0x402d40
movq %rax, %r14
jmp 0x402d4a
movq %rax, %r14
jmp 0x402d54
movq %rax, %r14
jmp 0x402d5e
movq %rax, %r14
jmp 0x402d68
movq %rax, %r14
jmp 0x402d72
movq %rax, %r14
jmp 0x402d7c
jmp 0x402d1f
movq 0x10(%rsp), %rdi
movq %rax, %r14
callq 0x403676
movq 0x40(%rsp), %rdi
callq 0x40369e
movq 0x60(%rsp), %rdi
callq 0x8affa
movq 0x8(%rsp), %rdi
callq 0x4036be
movq 0x20(%rsp), %rdi
callq 0x4036d8
movq 0x68(%rsp), %rdi
callq 0x4036f2
movq 0x58(%rsp), %rdi
callq 0x28fb6
movq 0x70(%rsp), %rdi
callq 0x8affa
movq 0x78(%rsp), %rdi
callq 0x3a954
movq 0x50(%rsp), %rdi
callq 0xb853a
movq %r14, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
void baryonyx::itm::compute_order::init<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true> const&, baryonyx::bit_array const&) | void init(const Solver& s, const Xtype& x)
{
switch (order) {
case solver_parameters::constraint_order::infeasibility_decr:
case solver_parameters::constraint_order::infeasibility_incr:
infeasibility_local_compute_violated_constraints(s, x);
break;
case solver_parameters::constraint_order::pi_sign_change:
std::iota(R.begin(), R.end(), 0);
break;
case solver_parameters::constraint_order::none:
case solver_parameters::constraint_order::reversing:
case solver_parameters::constraint_order::random_sorting:
case solver_parameters::constraint_order::lagrangian_decr:
case solver_parameters::constraint_order::lagrangian_incr:
default:
compute_violated_constraints(s, x, R);
break;
}
} | movl 0x30(%rdi), %ecx
movq %rdi, %rax
leal -0x3(%rcx), %edi
cmpl $0x2, %edi
jae 0x402da4
movq %rax, %rdi
jmp 0x403be0
cmpl $0x7, %ecx
jne 0x402dc1
movq (%rax), %rcx
movq 0x8(%rax), %rax
xorl %edx, %edx
cmpq %rax, %rcx
je 0x402dcf
movl %edx, (%rcx)
incl %edx
addq $0x4, %rcx
jmp 0x402db2
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
jmp 0x403ce2
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::compute_order::run<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>, baryonyx::bit_array, long double>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>&, baryonyx::bit_array&, std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, long double, long double, long double) | int run(Solver& solver,
Xtype& x,
random_engine& rng,
Float kappa,
Float delta,
Float theta)
{
bool pi_changed = false;
int remaining = 0;
switch (order) {
case solver_parameters::constraint_order::reversing:
solver.compute_update_row(
x, R.crbegin(), R.crend(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::random_sorting:
std::shuffle(R.begin(), R.end(), rng);
solver.compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::infeasibility_decr:
std::sort(m_order.begin(),
m_order.end(),
[](const auto& lhs, const auto& rhs) {
return rhs.second < lhs.second;
});
solver.compute_update_row(
x, m_order.cbegin(), m_order.cend(), kappa, delta, theta);
return infeasibility_local_compute_violated_constraints(solver, x);
case solver_parameters::constraint_order::infeasibility_incr:
std::sort(m_order.begin(),
m_order.end(),
[](const auto& lhs, const auto& rhs) {
return lhs.second < rhs.second;
});
solver.compute_update_row(
x, m_order.cbegin(), m_order.cend(), kappa, delta, theta);
return infeasibility_local_compute_violated_constraints(solver, x);
case solver_parameters::constraint_order::lagrangian_decr:
std::sort(
R.begin(), R.end(), [&solver](const auto lhs, const auto rhs) {
return solver.pi[rhs] < solver.pi[lhs];
});
solver.compute_update_row(
x, R.cbegin(), R.cend(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::lagrangian_incr:
std::sort(
R.begin(), R.end(), [&solver](const auto lhs, const auto rhs) {
return solver.pi[lhs] < solver.pi[rhs];
});
solver.compute_update_row(
x, R.cbegin(), R.cend(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::pi_sign_change:
std::shuffle(R.begin(), R.end(), rng);
pi_changed = solver.compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta);
remaining = local_compute_violated_constraints(solver, x);
if (!pi_changed && remaining == 0)
return 0;
return remaining;
case solver_parameters::constraint_order::none:
default:
solver.compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
fldt 0xb0(%rsp)
fldt 0xa0(%rsp)
fldt 0x90(%rsp)
movl 0x30(%rdi), %eax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
decl %eax
cmpl $0x6, %eax
ja 0x402ef1
leaq 0x63638(%rip), %rdx # 0x466444
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
leaq 0x68(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, (%rdx)
movq (%r14), %rax
movq %rax, (%rcx)
fxch %st(2)
fstpt 0x20(%rsp)
fstpt 0x10(%rsp)
fstpt (%rsp)
callq 0x403dd8
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x403ce2
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rdi
movq 0x8(%r14), %rsi
fstpt 0x54(%rsp)
fstpt 0x48(%rsp)
movq %r15, %rdx
fstpt 0x3c(%rsp)
callq 0x408a1a
jmp 0x402f65
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
fstpt 0x54(%rsp)
fstpt 0x48(%rsp)
fstpt 0x3c(%rsp)
callq 0x408144
jmp 0x402eb0
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
fstpt 0x54(%rsp)
fstpt 0x48(%rsp)
fstpt 0x3c(%rsp)
callq 0x4085af
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
fldt 0x3c(%rsp)
fstpt 0x20(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
fldt 0x48(%rsp)
fstpt 0x10(%rsp)
fldt 0x54(%rsp)
fstpt (%rsp)
callq 0x4042c6
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x404534
movq (%r14), %rdx
movq 0x8(%r14), %rcx
fxch %st(2)
fstpt 0x20(%rsp)
fstpt 0x10(%rsp)
jmp 0x402f3a
movq (%r14), %rdi
movq 0x8(%r14), %rsi
fstpt 0x54(%rsp)
fstpt 0x48(%rsp)
movq %rcx, %rdx
fstpt 0x3c(%rsp)
callq 0x3ceed
movq (%r14), %rdx
movq 0x8(%r14), %rcx
fldt 0x3c(%rsp)
fstpt 0x20(%rsp)
fldt 0x48(%rsp)
fstpt 0x10(%rsp)
fldt 0x54(%rsp)
fstpt (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x404058
jmp 0x402f8e
movq (%r14), %rdi
movq 0x8(%r14), %rsi
fstpt 0x54(%rsp)
fstpt 0x48(%rsp)
movq %r15, %rdx
fstpt 0x3c(%rsp)
callq 0x408f6e
movq (%r14), %rdx
movq 0x8(%r14), %rcx
fldt 0x3c(%rsp)
fstpt 0x20(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
fldt 0x48(%rsp)
fstpt 0x10(%rsp)
fldt 0x54(%rsp)
fstpt (%rsp)
callq 0x404636
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x403ce2
movq (%r14), %rdi
movq 0x8(%r14), %rsi
fstpt 0x54(%rsp)
fstpt 0x48(%rsp)
movq %rcx, %rdx
fstpt 0x3c(%rsp)
callq 0x3ceed
movq (%r14), %rdx
movq 0x8(%r14), %rcx
fldt 0x3c(%rsp)
fstpt 0x20(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
fldt 0x48(%rsp)
fstpt 0x10(%rsp)
fldt 0x54(%rsp)
fstpt (%rsp)
callq 0x404058
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x4048a4
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::compute_order::push_and_run<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>, baryonyx::bit_array, long double>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>&, baryonyx::bit_array&, std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, long double, long double, long double, long double) | int push_and_run(Solver& solver,
Xtype& x,
random_engine& rng,
Float kappa,
Float delta,
Float theta,
Float objective_amplifier)
{
bool pi_changed = 0;
int remaining = 0;
if (use_cycle)
order = next_state(order);
switch (order) {
case solver_parameters::constraint_order::reversing:
solver.push_and_compute_update_row(x,
R.crbegin(),
R.crend(),
kappa,
delta,
theta,
objective_amplifier);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::random_sorting:
std::shuffle(R.begin(), R.end(), rng);
solver.push_and_compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta, objective_amplifier);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::infeasibility_decr:
std::sort(m_order.begin(),
m_order.end(),
[](const auto& lhs, const auto& rhs) {
return rhs.second < lhs.second;
});
solver.push_and_compute_update_row(x,
m_order.cbegin(),
m_order.cend(),
kappa,
delta,
theta,
objective_amplifier);
return infeasibility_local_compute_violated_constraints(solver, x);
case solver_parameters::constraint_order::infeasibility_incr:
std::sort(m_order.begin(),
m_order.end(),
[](const auto& lhs, const auto& rhs) {
return lhs.second < rhs.second;
});
solver.push_and_compute_update_row(x,
m_order.cbegin(),
m_order.cend(),
kappa,
delta,
theta,
objective_amplifier);
return infeasibility_local_compute_violated_constraints(solver, x);
case solver_parameters::constraint_order::lagrangian_decr:
std::sort(
R.begin(), R.end(), [&solver](const auto lhs, const auto rhs) {
return solver.pi[rhs] < solver.pi[lhs];
});
solver.push_and_compute_update_row(x,
R.cbegin(),
R.cend(),
kappa,
delta,
theta,
objective_amplifier);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::lagrangian_incr:
std::sort(
R.begin(), R.end(), [&solver](const auto lhs, const auto rhs) {
return solver.pi[lhs] < solver.pi[rhs];
});
solver.push_and_compute_update_row(x,
R.cbegin(),
R.cend(),
kappa,
delta,
theta,
objective_amplifier);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::pi_sign_change:
std::shuffle(R.begin(), R.end(), rng);
pi_changed = solver.push_and_compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta, objective_amplifier);
remaining = local_compute_violated_constraints(solver, x);
if (!pi_changed && remaining == 0)
return 0;
return remaining;
case solver_parameters::constraint_order::none:
default:
solver.push_and_compute_update_row(x,
R.cbegin(),
R.cend(),
kappa,
delta,
theta,
objective_amplifier);
return compute_violated_constraints(solver, x, R);
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
fldt 0xd0(%rsp)
fldt 0xc0(%rsp)
fldt 0xb0(%rsp)
fldt 0xa0(%rsp)
movl 0x30(%rdi), %eax
cmpb $0x1, 0x34(%rdi)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
jne 0x40304b
xorl %esi, %esi
leal 0x1(%rax), %edx
cmpl $0x7, %eax
cmovll %edx, %esi
movl %esi, %eax
movl %esi, 0x30(%r14)
decl %eax
cmpl $0x6, %eax
ja 0x403162
leaq 0x63403(%rip), %rdx # 0x466460
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
leaq 0x78(%rsp), %rdx
leaq 0x70(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, (%rdx)
movq (%r14), %rax
movq %rax, (%rcx)
fxch %st(3)
fstpt 0x30(%rsp)
fxch %st(1)
fstpt 0x20(%rsp)
fstpt 0x10(%rsp)
fstpt (%rsp)
callq 0x4094be
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x403ce2
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rdi
movq 0x8(%r14), %rsi
fstpt 0x64(%rsp)
fstpt 0x58(%rsp)
fstpt 0x4c(%rsp)
movq %r15, %rdx
fstpt 0x40(%rsp)
callq 0x40a86f
jmp 0x4031ef
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
fstpt 0x64(%rsp)
fstpt 0x58(%rsp)
fstpt 0x4c(%rsp)
fstpt 0x40(%rsp)
callq 0x409f99
jmp 0x403116
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
fstpt 0x64(%rsp)
fstpt 0x58(%rsp)
fstpt 0x4c(%rsp)
fstpt 0x40(%rsp)
callq 0x40a404
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
fldt 0x40(%rsp)
fstpt 0x30(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
fldt 0x4c(%rsp)
fstpt 0x20(%rsp)
fldt 0x58(%rsp)
fstpt 0x10(%rsp)
fldt 0x64(%rsp)
fstpt (%rsp)
callq 0x409a32
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x404534
movq (%r14), %rdx
movq 0x8(%r14), %rcx
fxch %st(3)
fstpt 0x30(%rsp)
fxch %st(1)
fstpt 0x20(%rsp)
fstpt 0x10(%rsp)
jmp 0x403212
movq (%r14), %rdi
movq 0x8(%r14), %rsi
fstpt 0x64(%rsp)
fstpt 0x58(%rsp)
fstpt 0x4c(%rsp)
movq %rcx, %rdx
fstpt 0x40(%rsp)
callq 0x3ceed
movq (%r14), %rdx
movq 0x8(%r14), %rcx
fldt 0x40(%rsp)
fstpt 0x30(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
fldt 0x4c(%rsp)
fstpt 0x20(%rsp)
fldt 0x58(%rsp)
fstpt 0x10(%rsp)
fldt 0x64(%rsp)
fstpt (%rsp)
callq 0x40977e
jmp 0x403220
movq (%r14), %rdi
movq 0x8(%r14), %rsi
fstpt 0x64(%rsp)
fstpt 0x58(%rsp)
fstpt 0x4c(%rsp)
movq %r15, %rdx
fstpt 0x40(%rsp)
callq 0x40adc3
movq (%r14), %rdx
movq 0x8(%r14), %rcx
fldt 0x40(%rsp)
fstpt 0x30(%rsp)
fldt 0x4c(%rsp)
fstpt 0x20(%rsp)
fldt 0x58(%rsp)
fstpt 0x10(%rsp)
fldt 0x64(%rsp)
fstpt (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x409ce6
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x403ce2
movq (%r14), %rdi
movq 0x8(%r14), %rsi
fstpt 0x64(%rsp)
fstpt 0x58(%rsp)
fstpt 0x4c(%rsp)
movq %rcx, %rdx
fstpt 0x40(%rsp)
callq 0x3ceed
movq (%r14), %rdx
movq 0x8(%r14), %rcx
fldt 0x40(%rsp)
fstpt 0x30(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
fldt 0x4c(%rsp)
fstpt 0x20(%rsp)
fldt 0x58(%rsp)
fstpt 0x10(%rsp)
fldt 0x64(%rsp)
fstpt (%rsp)
callq 0x40977e
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x4048a4
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
void baryonyx::itm::exhaustive_solver<baryonyx::itm::maximize_tag, long double>::build_constraints<std::vector<baryonyx::function_element, std::allocator<baryonyx::function_element>>>(int, std::vector<baryonyx::function_element, std::allocator<baryonyx::function_element>> const&, int, int) | void build_constraints(int k,
const C& constraint_elements,
int bk_min,
int bk_max)
{
const auto constraint_size = length(constraint_elements);
const auto start_it_flat_constraints = length(flat_constraints);
auto nb_solution = 0;
bx_ensures(k >= 0);
bx_ensures(constraint_size > 0);
walkers.resize(constraint_elements.size(), 0);
walkers.back() = 1;
bool end = false;
do {
auto i = length(walkers) - 1;
do {
int sum = 0;
for (int j = 0; j != constraint_size; ++j)
if (walkers[j])
sum += constraint_elements[j].factor;
if (bk_min <= sum && sum <= bk_max) {
++nb_solution;
for (int j = 0; j != constraint_size; ++j) {
flat_constraints.emplace_back(
walkers[j] ? constraint_elements[j].factor : 0);
}
}
++walkers[i];
if (walkers[i] > 1) {
walkers[i] = 0;
if (i == 0) {
end = true;
break;
} else {
--i;
}
} else {
break;
}
} while (!end);
} while (!end);
bx_expects(start_it_flat_constraints >= 0);
bx_expects(nb_solution > 0);
constraints.emplace(
k, start_it_flat_constraints, nb_solution, bk_min, bk_max);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movl %ecx, 0x10(%rsp)
movl %esi, %eax
movl %r8d, 0x14(%rsp)
movq 0x20(%rdi), %rcx
movq 0x8(%rdx), %rsi
subq 0x18(%rdi), %rcx
subq (%rdx), %rsi
andl $0x0, 0x4(%rsp)
shrq $0x2, %rcx
movl %ecx, 0x18(%rsp)
testl %eax, %eax
js 0x403544
movq %rsi, %rbp
shrq $0x3, %rbp
testl %ebp, %ebp
jle 0x403565
leaq 0x30(%rdi), %r13
sarq $0x3, %rsi
movq %rdx, %r15
movq %rsp, %rdx
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
movq %rcx, 0x30(%rsp)
movb $0x0, (%rdx)
movq %r13, %rdi
callq 0x36b9b6
movq 0x38(%rbx), %rax
andl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
movq $0x0, 0x8(%rsp)
movq %rbx, 0x28(%rsp)
movb $0x1, -0x1(%rax)
movq 0x30(%rbx), %rax
movl 0x38(%rbx), %ecx
subl %eax, %ecx
movslq %ecx, %r14
movq (%r13), %rax
movq (%r15), %rcx
xorl %esi, %esi
xorl %edx, %edx
cmpq %rsi, %rbp
je 0x403478
cmpb $0x0, (%rax,%rsi)
je 0x403473
addl (%rcx,%rsi,8), %edx
incq %rsi
jmp 0x403465
cmpl 0x10(%rsp), %edx
setl %cl
cmpl 0x14(%rsp), %edx
setg %dl
orb %cl, %dl
jne 0x4034cc
movq 0x8(%rsp), %rax
xorl %ebx, %ebx
incl %eax
movq %rax, 0x8(%rsp)
movl %eax, 0x4(%rsp)
cmpq %rbx, %rbp
je 0x4034c8
movq (%r13), %rax
cmpb $0x0, (%rax,%rbx)
je 0x4034b3
movq (%r15), %rax
movl (%rax,%rbx,8), %eax
jmp 0x4034b5
xorl %eax, %eax
movl %eax, (%rsp)
movq %r12, %rdi
movq %rsp, %rsi
callq 0x36b9e4
incq %rbx
jmp 0x40349c
movq (%r13), %rax
decq %r14
incb (%rax,%r14)
movq (%r13), %rax
cmpb $0x2, (%rax,%r14)
jl 0x4034ee
movb $0x0, (%rax,%r14)
testq %r14, %r14
jne 0x40345a
jmp 0x4034f8
movq 0x28(%rsp), %rbx
jmp 0x403452
cmpl $0x0, 0x30(%rsp)
js 0x403586
cmpl $0x0, 0x8(%rsp)
jle 0x4035a7
movq 0x28(%rsp), %rdi
leaq 0x24(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x4(%rsp), %rcx
leaq 0x20(%rsp), %r8
leaq 0x1c(%rsp), %r9
addq $0x48, %rdi
callq 0x40370c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x54edf(%rip), %rdi # 0x45842a
leaq 0x6361f(%rip), %rsi # 0x466b71
leaq 0x6361f(%rip), %rdx # 0x466b78
leaq 0x56b34(%rip), %rcx # 0x45a094
callq 0x2813f
leaq 0x54ebe(%rip), %rdi # 0x45842a
leaq 0x63668(%rip), %rsi # 0x466bdb
leaq 0x635fe(%rip), %rdx # 0x466b78
leaq 0x55bda(%rip), %rcx # 0x45915b
callq 0x2813f
leaq 0x54c51(%rip), %rdi # 0x4581de
leaq 0x6365b(%rip), %rsi # 0x466bef
leaq 0x635dd(%rip), %rdx # 0x466b78
leaq 0x6366c(%rip), %rcx # 0x466c0e
callq 0x2813f
leaq 0x54c30(%rip), %rdi # 0x4581de
leaq 0x6365d(%rip), %rsi # 0x466c12
leaq 0x635bc(%rip), %rdx # 0x466b78
leaq 0x6365f(%rip), %rcx # 0x466c22
callq 0x2813f
| /quesnel[P]baryonyx/lib/src/exhaustive-solver.hpp |
baryonyx::itm::exhaustive_solver<baryonyx::itm::maximize_tag, long double>::reserve(unsigned long, unsigned long) | void reserve(std::size_t max_variables, std::size_t max_z_constraints)
{
bx_assert(max_variables > 0);
bx_assert(max_z_constraints > 0);
items.reserve(max_variables);
flat_constraints.reserve(max_variables * max_z_constraints);
walkers.reserve(max_variables);
} | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x403609
movq %rdx, %r15
testq %rdx, %rdx
je 0x40362a
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4038be
imulq %rbx, %r15
leaq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x36bee8
addq $0x30, %r14
movq %rbx, %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x324c6
leaq 0x55b5c(%rip), %rdi # 0x45916c
leaq 0x63626(%rip), %rsi # 0x466c3d
leaq 0x6355a(%rip), %rdx # 0x466b78
leaq 0x5b3bb(%rip), %rcx # 0x45e9e0
callq 0x2813f
leaq 0x55b3b(%rip), %rdi # 0x45916c
leaq 0x63617(%rip), %rsi # 0x466c4f
leaq 0x63539(%rip), %rdx # 0x466b78
leaq 0x600bf(%rip), %rcx # 0x463705
callq 0x2813f
nop
| /quesnel[P]baryonyx/lib/src/exhaustive-solver.hpp |
int baryonyx::itm::compute_order::infeasibility_local_compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true> const, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true> const&, baryonyx::bit_array const&) | int infeasibility_local_compute_violated_constraints(Solver& solver,
const Xtype& x)
{
m_order.clear();
for (int k = 0, e = solver.m; k != e; ++k) {
sparse_matrix<int>::const_row_iterator it, et;
std::tie(it, et) = solver.ap.row(k);
int v = 0;
for (; it != et; ++it)
v += solver.factor(it->value) * x[it->column];
if (solver.bound_min(k) > v)
m_order.push_back(std::make_pair(k, solver.bound_min(k) - v));
else if (solver.bound_max(k) < v)
m_order.push_back(std::make_pair(k, v - solver.bound_max(k)));
}
return length(m_order);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x18(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
cmpq %rax, 0x20(%rdi)
je 0x403c02
movq %rax, 0x20(%rdi)
leaq 0x18(%rdi), %rax
leaq 0x10(%r15), %rcx
xorl %r12d, %r12d
movq %rdi, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movl 0x180(%r15), %eax
movq %rcx, 0x18(%rsp)
movq %rax, 0x28(%rsp)
cmpq 0x28(%rsp), %r12
je 0x403cc7
movq 0x18(%rsp), %rsi
movq %rsp, %rdi
movl %r12d, %edx
movq %r12, 0x30(%rsp)
callq 0x3c868
movq (%rsp), %r13
movq 0x8(%rsp), %r12
xorl %ebx, %ebx
cmpq %r13, %r12
je 0x403c7b
movslq (%r12), %rax
movq 0x58(%r15), %rcx
movl 0x4(%r12), %esi
movq %r14, %rdi
movl (%rcx,%rax,4), %ebp
callq 0x3664a
imull %ebp, %eax
addq $0x8, %r12
addl %eax, %ebx
jmp 0x403c53
movq 0x30(%rsp), %r12
movq 0x70(%r15), %rcx
imulq $0xc, %r12, %rdx
movl (%rcx,%rdx), %eax
subl %ebx, %eax
jle 0x403c9c
shlq $0x20, %rax
orq %r12, %rax
movq %rax, (%rsp)
jmp 0x403cad
subl 0x4(%rcx,%rdx), %ebx
jle 0x403cba
shlq $0x20, %rbx
orq %r12, %rbx
movq %rbx, (%rsp)
movq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x3c8c2
movq 0x20(%rsp), %rdi
incq %r12
jmp 0x403c28
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
shrq $0x3, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
bool baryonyx::itm::is_valid_constraint<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true> const&, int, baryonyx::bit_array const&) | bool
is_valid_constraint(const Solver& slv, int k, const Xtype& x)
{
typename sparse_matrix<int>::const_row_iterator it, et;
std::tie(it, et) = slv.ap.row(k);
int v = 0;
for (; it != et; ++it)
v += slv.factor(it->value) * x[it->column];
return slv.bound_min(k) <= v && v <= slv.bound_max(k);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %edx
leaq 0x10(%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
movq %r15, %rdi
callq 0x3c868
movq (%r15), %r12
movq 0x8(%r15), %r13
xorl %r15d, %r15d
cmpq %r12, %r13
je 0x403daa
movslq (%r13), %rax
movq 0x58(%rbx), %rcx
movl 0x4(%r13), %esi
movq %r14, %rdi
movl (%rcx,%rax,4), %ebp
callq 0x3664a
imull %ebp, %eax
addq $0x8, %r13
addl %eax, %r15d
jmp 0x403d82
movslq 0x4(%rsp), %rcx
movq 0x70(%rbx), %rax
imulq $0xc, %rcx, %rcx
cmpl %r15d, (%rax,%rcx)
jle 0x403dc1
xorl %eax, %eax
jmp 0x403dc9
cmpl 0x4(%rax,%rcx), %r15d
setle %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>::compute_update_row<baryonyx::bit_array, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>>(baryonyx::bit_array&, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>, long double, long double, long double) | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
Float pi_change;
int selected = -2;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, 0x58(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x58546(%rip), %rdx # 0x45c344
fldt 0xf0(%rsp)
fldt 0xe0(%rsp)
fldt 0xd0(%rsp)
fstpt 0x80(%rsp)
fstpt 0x70(%rsp)
fstpt 0x60(%rsp)
pushq $0x14
popq %rsi
leaq 0x80(%rsp), %rcx
leaq 0x70(%rsp), %r8
leaq 0x60(%rsp), %r9
callq 0x126c32
leaq 0x10(%r12), %rax
leaq 0x60(%r12), %rcx
leaq 0x100(%r12), %rdx
movq %rbx, 0x50(%rsp)
xorl %ebp, %ebp
movq %rax, 0x48(%rsp)
movq (%rbx), %rax
movq %rcx, 0x20(%rsp)
leaq 0x80(%r12), %rcx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x58(%rsp), %rcx
cmpq (%rcx), %rax
je 0x40403f
movl -0x4(%rax), %ebx
movq 0x48(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movl %ebx, %edx
callq 0x3de66
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rsi
fldt 0x60(%rsp)
movq %r12, %rdi
fstpt (%rsp)
callq 0x4048e6
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
movq %r15, %r14
callq 0x40490c
movq 0x68(%r12), %rcx
movslq %ebx, %r15
movl %eax, %r13d
movzbl (%rcx,%r15), %eax
pushq $-0x2
popq %r8
cmpq $0x4, %rax
ja 0x403ffe
leaq 0x62590(%rip), %rcx # 0x46647c
movslq %r13d, %rsi
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x4049f3
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x403f9d
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x4049f3
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x404f40
jmp 0x403ffb
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x4049f3
movq 0x70(%r12), %rax
imulq $0xc, %r15, %r15
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
callq 0x404ef8
cmpl $-0x2, %eax
jne 0x403ffb
movq 0x70(%r12), %rax
movl (%rax,%r15), %ecx
movl 0x4(%rax,%r15), %r8d
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %r13d, %edx
callq 0x404a26
jmp 0x403ffb
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x4049f3
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x404ef8
cmpl $-0x2, %eax
jne 0x403ffb
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl %ebx, %esi
movl %r13d, %ecx
callq 0x404d22
movl %eax, %r8d
movq 0x40(%rsp), %rdx
fldt 0x80(%rsp)
fldt 0x70(%rsp)
fstpt 0x10(%rsp)
fstpt (%rsp)
movq %r12, %rdi
movq %r14, %r15
movq %r14, %rsi
movl %ebx, %ecx
movl %r13d, %r9d
callq 0x404f88
movq 0x50(%rsp), %rcx
orb %al, %bpl
movq (%rcx), %rax
addq $-0x4, %rax
movq %rax, (%rcx)
jmp 0x403e74
andb $0x1, %bpl
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, long double, long double, long double) | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
Float pi_change;
int selected = -2;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, 0x58(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x582c6(%rip), %rdx # 0x45c344
fldt 0xf0(%rsp)
fldt 0xe0(%rsp)
fldt 0xd0(%rsp)
fstpt 0x80(%rsp)
fstpt 0x70(%rsp)
fstpt 0x60(%rsp)
pushq $0x14
popq %rsi
leaq 0x80(%rsp), %rcx
leaq 0x70(%rsp), %r8
leaq 0x60(%rsp), %r9
callq 0x126c32
leaq 0x10(%r12), %rax
movq %rax, 0x50(%rsp)
leaq 0x60(%r12), %rax
movq %rax, 0x20(%rsp)
leaq 0x100(%r12), %rax
movq %rax, 0x38(%rsp)
leaq 0x80(%r12), %rax
movq %rax, 0x30(%rsp)
xorl %eax, %eax
cmpq 0x58(%rsp), %r14
je 0x4042b2
movl (%r14), %ebx
movq 0x50(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movl %eax, 0x2c(%rsp)
movl %ebx, %edx
callq 0x3de66
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rsi
fldt 0x60(%rsp)
movq %r12, %rdi
fstpt (%rsp)
callq 0x4048e6
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
movq %r15, %rbp
callq 0x40490c
movq 0x68(%r12), %rcx
movslq %ebx, %r15
movl %eax, %r13d
movzbl (%rcx,%r15), %eax
pushq $-0x2
popq %r8
cmpq $0x4, %rax
ja 0x404277
leaq 0x6232b(%rip), %rcx # 0x466490
movslq %r13d, %rsi
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x4049f3
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x404216
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x4049f3
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x404f40
jmp 0x404274
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x4049f3
movq 0x70(%r12), %rax
imulq $0xc, %r15, %r15
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
callq 0x404ef8
cmpl $-0x2, %eax
jne 0x404274
movq 0x70(%r12), %rax
movl (%rax,%r15), %ecx
movl 0x4(%rax,%r15), %r8d
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %r13d, %edx
callq 0x404a26
jmp 0x404274
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x4049f3
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x404ef8
cmpl $-0x2, %eax
jne 0x404274
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl %ebx, %esi
movl %r13d, %ecx
callq 0x404d22
movl %eax, %r8d
movq 0x48(%rsp), %rdx
fldt 0x80(%rsp)
fldt 0x70(%rsp)
fstpt 0x10(%rsp)
fstpt (%rsp)
movq %r12, %rdi
movq %rbp, %r15
movq %rbp, %rsi
movl %ebx, %ecx
movl %r13d, %r9d
callq 0x404f88
movl 0x2c(%rsp), %ecx
addq $0x4, %r14
orb %al, %cl
movl %ecx, %eax
jmp 0x4040ec
andb $0x1, %al
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>, long double, long double, long double) | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
Float pi_change;
int selected = -2;
switch (Z[k]) {
case subsolver_type::branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::exhaustive:
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::unconstrained_branch_and_bound:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = bb.solve(R, r_size, b[k].min, b[k].max);
break;
case subsolver_type::unconstrained_exhaustive:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables(r_size, b[k].min, b[k].max);
if (selected == -2)
selected = ex.solve(k, R, r_size);
break;
case subsolver_type::linear:
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
selected = select_variables_101(r_size, b[k].min, b[k].max);
break;
}
pi_change = local_affect(
x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, 0x58(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x58058(%rip), %rdx # 0x45c344
fldt 0xf0(%rsp)
fldt 0xe0(%rsp)
fldt 0xd0(%rsp)
fstpt 0x80(%rsp)
fstpt 0x70(%rsp)
fstpt 0x60(%rsp)
pushq $0x14
popq %rsi
leaq 0x80(%rsp), %rcx
leaq 0x70(%rsp), %r8
leaq 0x60(%rsp), %r9
callq 0x126c32
leaq 0x10(%r12), %rax
movq %rax, 0x50(%rsp)
leaq 0x60(%r12), %rax
movq %rax, 0x20(%rsp)
leaq 0x100(%r12), %rax
movq %rax, 0x38(%rsp)
leaq 0x80(%r12), %rax
movq %rax, 0x30(%rsp)
xorl %eax, %eax
cmpq 0x58(%rsp), %r14
je 0x404520
movl (%r14), %ebx
movq 0x50(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movl %eax, 0x2c(%rsp)
movl %ebx, %edx
callq 0x3de66
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rsi
fldt 0x60(%rsp)
movq %r12, %rdi
fstpt (%rsp)
callq 0x4048e6
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
movq %r15, %rbp
callq 0x40490c
movq 0x68(%r12), %rcx
movslq %ebx, %r15
movl %eax, %r13d
movzbl (%rcx,%r15), %eax
pushq $-0x2
popq %r8
cmpq $0x4, %rax
ja 0x4044e5
leaq 0x620d1(%rip), %rcx # 0x4664a4
movslq %r13d, %rsi
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x4049f3
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rdx
movl (%rax,%rdx), %ecx
movl 0x4(%rax,%rdx), %r8d
jmp 0x404484
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x4049f3
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x404f40
jmp 0x4044e2
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x4049f3
movq 0x70(%r12), %rax
imulq $0xc, %r15, %r15
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%r15), %edx
movl 0x4(%rax,%r15), %ecx
callq 0x404ef8
cmpl $-0x2, %eax
jne 0x4044e2
movq 0x70(%r12), %rax
movl (%rax,%r15), %ecx
movl 0x4(%rax,%r15), %r8d
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %r13d, %edx
callq 0x404a26
jmp 0x4044e2
movq 0x60(%r12), %rdi
movq 0x8(%r12), %rdx
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x4049f3
movq 0x70(%r12), %rax
imulq $0xc, %r15, %rcx
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %ecx
callq 0x404ef8
cmpl $-0x2, %eax
jne 0x4044e2
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl %ebx, %esi
movl %r13d, %ecx
callq 0x404d22
movl %eax, %r8d
movq 0x48(%rsp), %rdx
fldt 0x80(%rsp)
fldt 0x70(%rsp)
fstpt 0x10(%rsp)
fstpt (%rsp)
movq %r12, %rdi
movq %rbp, %r15
movq %rbp, %rsi
movl %ebx, %ecx
movl %r13d, %r9d
callq 0x404f88
movl 0x2c(%rsp), %ecx
addq $0x8, %r14
orb %al, %cl
movl %ecx, %eax
jmp 0x40435a
andb $0x1, %al
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::compute_order::infeasibility_local_compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>&, baryonyx::bit_array const&) | int infeasibility_local_compute_violated_constraints(Solver& solver,
const Xtype& x)
{
m_order.clear();
for (int k = 0, e = solver.m; k != e; ++k) {
sparse_matrix<int>::const_row_iterator it, et;
std::tie(it, et) = solver.ap.row(k);
int v = 0;
for (; it != et; ++it)
v += solver.factor(it->value) * x[it->column];
if (solver.bound_min(k) > v)
m_order.push_back(std::make_pair(k, solver.bound_min(k) - v));
else if (solver.bound_max(k) < v)
m_order.push_back(std::make_pair(k, v - solver.bound_max(k)));
}
return length(m_order);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x18(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
cmpq %rax, 0x20(%rdi)
je 0x404556
movq %rax, 0x20(%rdi)
leaq 0x18(%rdi), %rax
leaq 0x10(%r15), %rcx
xorl %r12d, %r12d
movq %rdi, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movl 0x180(%r15), %eax
movq %rcx, 0x18(%rsp)
movq %rax, 0x28(%rsp)
cmpq 0x28(%rsp), %r12
je 0x40461b
movq 0x18(%rsp), %rsi
movq %rsp, %rdi
movl %r12d, %edx
movq %r12, 0x30(%rsp)
callq 0x3de66
movq (%rsp), %r13
movq 0x8(%rsp), %r12
xorl %ebx, %ebx
cmpq %r13, %r12
je 0x4045cf
movslq (%r12), %rax
movq 0x58(%r15), %rcx
movl 0x4(%r12), %esi
movq %r14, %rdi
movl (%rcx,%rax,4), %ebp
callq 0x3664a
imull %ebp, %eax
addq $0x8, %r12
addl %eax, %ebx
jmp 0x4045a7
movq 0x30(%rsp), %r12
movq 0x70(%r15), %rcx
imulq $0xc, %r12, %rdx
movl (%rcx,%rdx), %eax
subl %ebx, %eax
jle 0x4045f0
shlq $0x20, %rax
orq %r12, %rax
movq %rax, (%rsp)
jmp 0x404601
subl 0x4(%rcx,%rdx), %ebx
jle 0x40460e
shlq $0x20, %rbx
orq %r12, %rbx
movq %rbx, (%rsp)
movq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x3c8c2
movq 0x20(%rsp), %rdi
incq %r12
jmp 0x40457c
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
shrq $0x3, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/itm-common.hpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.