name string | code string | asm string | file string |
|---|---|---|---|
ear::throw_if_not_implemented::operator()(ear::PolarObjectDivergence const&) const | void operator()(const PolarObjectDivergence& divergence) const {
if (divergence.divergence != 0.0) throw not_implemented("divergence");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd (%rsi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4aebb
jp 0x4aebb
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x14290
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6cc64(%rip), %r... | /ebu[P]libear/src/object_based/gain_calculator_objects.cpp |
ear::throw_if_not_implemented::operator()(ear::CartesianObjectDivergence const&) const | void operator()(const CartesianObjectDivergence& divergence) const {
if (divergence.divergence != 0.0) throw not_implemented("divergence");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd (%rsi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4af6b
jp 0x4af6b
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x14290
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6cbb4(%rip), %r... | /ebu[P]libear/src/object_based/gain_calculator_objects.cpp |
ear::PolarExtentCoreSimd<xsimd::avx512bw>::run(ear::PolarExtentCoreContext&) const | void run(PolarExtentCoreContext &ctx) const override {
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx++)
ctx.results[speaker_idx] = 0.0;
for (size_t i = 0; i < ctx.num_points; i += batch::size) {
PositionBatch<batch> pos;
pos.x = batch::load_alig... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x40, %rsp
subq $0x100, %rsp # imm = 0x100
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x4b5c5
movq 0x90(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x14330
cmpq $0x0, (%rbx)
je 0x4b77c... | /ebu[P]libear/src/object_based/polar_extent_simd.hpp |
ear::PolarExtentCoreSimd<xsimd::avx512bw>::weight_stadium(ear::PolarExtentCoreContext&, ear::PositionBatch<xsimd::batch<float, xsimd::avx512bw>> const&) const | batch weight_stadium(PolarExtentCoreContext &ctx,
const PositionBatch<batch> &position) const {
PositionBatch<batch> position_t = position.transform(ctx.flippedBasis);
PositionBatch<batch> position_t_right = position_t;
position_t_right.x = xsimd::abs(position_t.x);
au... | pushq %r14
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rsi), %rax
movq 0x58(%rsi), %rcx
movq 0x60(%rsi), %rsi
movq 0x68(%rbx), %rdi
shldq $0x20, %rdi, %rax
movq %rdi, %r8
shldq $0x20, %rsi, %r8
shrdq $0x20, %rsi, %rcx
vmovq %rdi, %xmm0
vmovq %rcx, %xmm1
vpbroadcastd ... | /ebu[P]libear/src/object_based/polar_extent_simd.hpp |
ear::PolarExtentCoreSimd<xsimd::avx512bw>::weight_from_cos(ear::PolarExtentCoreContext&, xsimd::batch<float, xsimd::avx512bw>) const | inline batch_bool<float, A> ge(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
{
return _mm512_cmp_ps_mask(self, other, _CMP_GE_OQ);
} | vcmpgeps 0x78(%rsi){1to16}, %zmm0, %k1
kortestw %k1, %k1
jb 0x4ba8c
vbroadcastss 0x7c(%rsi), %zmm1
vcmpleps %zmm1, %zmm0, %k0
kortestw %k0, %k0
jb 0x4ba97
vbroadcastsd 0x80d7a(%rip), %zmm2 # 0xcc700
vandps %zmm2, %zmm0, %zmm3
vbroadcastss 0x64a32(%rip), %zmm4 # 0xb03c8
vcmpltps %zmm3, %zmm4, %k2
vbroadcastss 0x64a19(%r... | /ebu[P]libear/submodules/xsimd/include/xsimd/types/../arch/./xsimd_avx512f.hpp |
ear::PolarExtentCoreSimd<xsimd::avx512bw>::weight_from_sin(ear::PolarExtentCoreContext&, xsimd::batch<float, xsimd::avx512bw>) const | inline batch_bool<float, A> le(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
{
return _mm512_cmp_ps_mask(self, other, _CMP_LE_OQ);
} | vcmpleps 0x80(%rsi){1to16}, %zmm0, %k1
kortestw %k1, %k1
jb 0x4bb7e
vbroadcastss 0x84(%rsi), %zmm1
vcmpleps %zmm0, %zmm1, %k0
kortestw %k0, %k0
jb 0x4bb89
vandpd 0x80c30(%rip){1to8}, %zmm0, %zmm2 # 0xcc700
vbroadcastss 0x648ee(%rip), %zmm3 # 0xb03c8
vcmpltps %zmm2, %zmm3, %k2
vbroadcastss 0x6a39d(%rip), %zmm4 # 0xb5e88... | /ebu[P]libear/submodules/xsimd/include/xsimd/types/../arch/./xsimd_avx512f.hpp |
ear::PolarExtentCoreSimd<xsimd::fma3<xsimd::avx2>>::weight_stadium(ear::PolarExtentCoreContext&, ear::PositionBatch<xsimd::batch<float, xsimd::fma3<xsimd::avx2>>> const&) const | batch weight_stadium(PolarExtentCoreContext &ctx,
const PositionBatch<batch> &position) const {
PositionBatch<batch> position_t = position.transform(ctx.flippedBasis);
PositionBatch<batch> position_t_right = position_t;
position_t_right.x = xsimd::abs(position_t.x);
au... | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
vbroadcastss 0x44(%rsi), %ymm0
vbroadcastss 0x48(%rsi), %ymm1
vbroadcastss 0x4c(%rsi), %ymm2
vmovaps (%rdx), %ymm3
vmovaps 0x20(%rdx), %ymm4
vmovaps 0x40(%rdx), %ymm5
vmulps %ymm2, %ymm5, %ymm2
vfmadd231ps %ymm1, %ymm4, %ymm2 # ymm2 = (ymm4 * ymm1) ... | /ebu[P]libear/src/object_based/polar_extent_simd.hpp |
ear::PolarExtentCoreSimd<xsimd::fma3<xsimd::avx2>>::weight_from_cos(ear::PolarExtentCoreContext&, xsimd::batch<float, xsimd::fma3<xsimd::avx2>>) const | inline batch<float, A> broadcast(float val, requires_arch<avx>) noexcept
{
return _mm256_set1_ps(val);
} | vbroadcastss 0x78(%rsi), %ymm1
vcmpleps %ymm0, %ymm1, %ymm2
vpcmpeqd %ymm1, %ymm1, %ymm1
vtestps %ymm1, %ymm2
jae 0x4bf2a
vbroadcastss 0x69f63(%rip), %ymm1 # 0xb5e88
jmp 0x4c077
vmovsd 0x7c(%rsi), %xmm3
vbroadcastss %xmm3, %ymm3
vcmpleps %ymm3, %ymm0, %ymm4
vtestps %ymm1, %ymm4
vxorps %xmm1, %xmm1, %xmm1
jb 0x4c077
vbr... | /ebu[P]libear/submodules/xsimd/include/xsimd/types/../arch/./xsimd_avx.hpp |
ear::PolarExtentCoreSimd<xsimd::avx>::run(ear::PolarExtentCoreContext&) const | void run(PolarExtentCoreContext &ctx) const override {
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx++)
ctx.results[speaker_idx] = 0.0;
for (size_t i = 0; i < ctx.num_points; i += batch::size) {
PositionBatch<batch> pos;
pos.x = batch::load_alig... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0xa0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x4c221
movq 0x90(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x14330
cmpq $0x0, (%rbx)
je 0x4c3d4
xorl %r12d, %r12d
vxorps ... | /ebu[P]libear/src/object_based/polar_extent_simd.hpp |
ear::PolarExtentCoreSimd<xsimd::avx>::weight_stadium(ear::PolarExtentCoreContext&, ear::PositionBatch<xsimd::batch<float, xsimd::avx>> const&) const | batch weight_stadium(PolarExtentCoreContext &ctx,
const PositionBatch<batch> &position) const {
PositionBatch<batch> position_t = position.transform(ctx.flippedBasis);
PositionBatch<batch> position_t_right = position_t;
position_t_right.x = xsimd::abs(position_t.x);
au... | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
vbroadcastss 0x44(%rsi), %ymm0
vbroadcastss 0x48(%rsi), %ymm1
vbroadcastss 0x4c(%rsi), %ymm2
movq %rdi, %r14
vmovaps (%rdx), %ymm3
vmovaps 0x20(%rdx), %ymm4
vmovaps 0x40(%rdx), %ymm5
vmulps %ymm2, %ymm5, %ymm2
vmulps %ymm4, %ymm1, %ymm1
vaddps %ymm2, %ymm1, %ymm1
v... | /ebu[P]libear/src/object_based/polar_extent_simd.hpp |
ear::PolarExtentCoreSimd<xsimd::avx>::weight_from_cos(ear::PolarExtentCoreContext&, xsimd::batch<float, xsimd::avx>) const | inline batch<float, A> broadcast(float val, requires_arch<avx>) noexcept
{
return _mm256_set1_ps(val);
} | vbroadcastss 0x78(%rsi), %ymm1
vcmpleps %ymm0, %ymm1, %ymm2
vxorps %xmm1, %xmm1, %xmm1
vcmptrueps %ymm1, %ymm1, %ymm4
vtestps %ymm4, %ymm2
jae 0x4c577
vbroadcastss 0x69916(%rip), %ymm1 # 0xb5e88
jmp 0x4c6d8
vbroadcastss 0x7c(%rsi), %ymm3
vcmpleps %ymm3, %ymm0, %ymm5
vtestps %ymm4, %ymm5
jb 0x4c6d8
vpermilps $0x0, 0x88(... | /ebu[P]libear/submodules/xsimd/include/xsimd/types/../arch/./xsimd_avx.hpp |
ear::PolarExtentCoreSimd<xsimd::avx>::weight_from_sin(ear::PolarExtentCoreContext&, xsimd::batch<float, xsimd::avx>) const | inline batch<float, A> broadcast(float val, requires_arch<avx>) noexcept
{
return _mm256_set1_ps(val);
} | vbroadcastss 0x80(%rsi), %ymm1
vcmpleps %ymm1, %ymm0, %ymm2
vxorps %xmm1, %xmm1, %xmm1
vcmptrueps %ymm1, %ymm1, %ymm4
vtestps %ymm4, %ymm2
jae 0x4c70a
vbroadcastss 0x69783(%rip), %ymm1 # 0xb5e88
jmp 0x4c811
vbroadcastss 0x84(%rsi), %ymm3
vcmpleps %ymm0, %ymm3, %ymm5
vtestps %ymm4, %ymm5
jb 0x4c811
vbroadcastss 0x88(%rs... | /ebu[P]libear/submodules/xsimd/include/xsimd/types/../arch/./xsimd_avx.hpp |
ear::PolarExtentCoreSimd<xsimd::sse4_2>::run(ear::PolarExtentCoreContext&) const | void run(PolarExtentCoreContext &ctx) const override {
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx++)
ctx.results[speaker_idx] = 0.0;
for (size_t i = 0; i < ctx.num_points; i += batch::size) {
PositionBatch<batch> pos;
pos.x = batch::load_alig... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x4c88e
movq 0x90(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x14330
cmpq $0x0, (%rbx)
je 0x4ca1a
xorl %r12d, %r12d
movq %rsp, %r15
xorl %r13d, %r13d
leaq (,%r13,4), %r... | /ebu[P]libear/src/object_based/polar_extent_simd.hpp |
ear::PolarExtentCoreSimd<xsimd::sse4_2>::weight_from_sin(ear::PolarExtentCoreContext&, xsimd::batch<float, xsimd::sse4_2>) const | batch weight_from_sin(PolarExtentCoreContext &ctx, batch sin_angle) const {
auto start = sin_angle <= ctx.sin_start_angle;
auto end = sin_angle >= ctx.sin_end_angle;
if (xsimd::all(start)) return batch{1.0};
if (xsimd::all(end)) return batch{0.0};
auto ramp = ctx.m * xsimd::asin(sin_angle... | movaps %xmm0, %xmm1
movups 0x80(%rsi), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movaps %xmm1, %xmm2
cmpnleps %xmm0, %xmm2
movmskps %xmm2, %eax
testl %eax, %eax
je 0x4ce00
movups 0x84(%rsi), %xmm4
shufps $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0]
cmpnleps %xmm1, %xmm4
movmskps %xmm4, %eax
testl %e... | /ebu[P]libear/src/object_based/polar_extent_simd.hpp |
ear::PolarExtentCoreSimd<xsimd::sse2>::run(ear::PolarExtentCoreContext&) const | void run(PolarExtentCoreContext &ctx) const override {
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx++)
ctx.results[speaker_idx] = 0.0;
for (size_t i = 0; i < ctx.num_points; i += batch::size) {
PositionBatch<batch> pos;
pos.x = batch::load_alig... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x4ce86
movq 0x90(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x14330
cmpq $0x0, (%rbx)
je 0x4d01f
xorl %r12d, %r12d
movq %rsp, %r15
xorl %r13d, %r13d
leaq (,%r13,4), %r... | /ebu[P]libear/src/object_based/polar_extent_simd.hpp |
ear::PolarExtentCoreSimd<xsimd::sse2>::weight_stadium(ear::PolarExtentCoreContext&, ear::PositionBatch<xsimd::batch<float, xsimd::sse2>> const&) const | batch weight_stadium(PolarExtentCoreContext &ctx,
const PositionBatch<batch> &position) const {
PositionBatch<batch> position_t = position.transform(ctx.flippedBasis);
PositionBatch<batch> position_t_right = position_t;
position_t_right.x = xsimd::abs(position_t.x);
au... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movups 0x44(%rsi), %xmm5
movups 0x48(%rsi), %xmm0
movups 0x4c(%rsi), %xmm4
movups 0x50(%rsi), %xmm6
shufps $0x0, %xmm5, %xmm5 # xmm5 = xmm5[0,0,0,0]
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
shufps $0x0, %xmm4, %xmm4 # xmm4 = x... | /ebu[P]libear/src/object_based/polar_extent_simd.hpp |
ear::PolarExtentCoreSimd<xsimd::sse2>::weight_from_sin(ear::PolarExtentCoreContext&, xsimd::batch<float, xsimd::sse2>) const | batch weight_from_sin(PolarExtentCoreContext &ctx, batch sin_angle) const {
auto start = sin_angle <= ctx.sin_start_angle;
auto end = sin_angle >= ctx.sin_end_angle;
if (xsimd::all(start)) return batch{1.0};
if (xsimd::all(end)) return batch{0.0};
auto ramp = ctx.m * xsimd::asin(sin_angle... | movaps %xmm0, %xmm1
movups 0x80(%rsi), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movaps %xmm1, %xmm2
cmpnleps %xmm0, %xmm2
movmskps %xmm2, %eax
testl %eax, %eax
je 0x4d44b
movups 0x84(%rsi), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
cmpnleps %xmm1, %xmm0
movmskps %xmm0, %eax
testl %e... | /ebu[P]libear/src/object_based/polar_extent_simd.hpp |
ear::distance(Eigen::Matrix<double, 3, 1, 0, 3, 1>) | EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from)
{
EIGEN_DEBUG_UNALIGNED_LOAD
return _mm_loadu_pd(from);
} | movupd (%rdi), %xmm0
mulpd %xmm0, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x10(%rdi), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
retq
| /ebu[P]libear/submodules/eigen/Eigen/src/Core/arch/SSE/PacketMath.h |
ear::cart(double, double, double) | Eigen::Vector3d cart(double azimuth, double elevation, double distance) {
return Eigen::Vector3d(
sin(radians(-azimuth)) * cos(radians(elevation)) * distance,
cos(radians(-azimuth)) * cos(radians(elevation)) * distance,
sin(radians(elevation)) * distance);
} | pushq %rbx
subq $0x60, %rsp
movaps %xmm2, 0x50(%rsp)
movsd %xmm1, 0x8(%rsp)
movq %rdi, %rbx
mulsd 0x7f125(%rip), %xmm0 # 0xccbf0
movsd %xmm0, 0x10(%rsp)
callq 0x14130
movapd %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x682f6(%rip), %xmm0 # 0xb5de0
movsd %xmm0, 0x8(%rsp)
callq 0x14b60
movapd %xmm0, 0x30(%rsp)
... | /ebu[P]libear/src/common/geom.cpp |
ear::toCartesianVector3d(ear::PolarSpeakerPosition) | Eigen::Vector3d toCartesianVector3d(PolarSpeakerPosition position) {
return cart(position.azimuth, position.elevation, position.distance);
} | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movsd (%rsi), %xmm1
movsd 0x28(%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x50(%rsi), %xmm0
movaps %xmm0, 0x50(%rsp)
mulsd 0x7f041(%rip), %xmm1 # 0xccbf0
movsd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
callq 0x14130
movapd %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x6820e(... | /ebu[P]libear/src/common/geom.cpp |
ear::toCartesianVector3d(boost::variant<ear::PolarSpeakerPosition, ear::CartesianSpeakerPosition>) | Eigen::Vector3d toCartesianVector3d(SpeakerPosition position) {
return boost::apply_visitor(
[](const auto& p) { return toCartesianVector3d(p); }, position);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp # imm = 0x130
movq %rdi, %rbx
movl (%rsi), %ecx
movl %ecx, %eax
sarl $0x1f, %eax
xorl %ecx, %eax
cmpl $0x13, %eax
ja 0x4df6e
movq %rsi, %r14
addq $0x8, %rsi
leaq 0x7ef93(%rip), %rcx # 0xccc10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2... | /ebu[P]libear/src/common/geom.cpp |
ear::toPolarPosition(ear::CartesianPosition) | PolarPosition toPolarPosition(CartesianPosition position) {
auto cart_array = toCartesianVector3d(position);
return PolarPosition(azimuth(cart_array), elevation(cart_array),
distance(cart_array));
} | pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movaps 0x50(%rsp), %xmm2
movaps %xmm2, 0x10(%rsp)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movaps %xmm2, %xmm1
unpckhpd %xmm2, %xmm1 # xmm1 = xmm1[1],xmm2[1]
movaps %xmm1, 0x20(%rsp)
movaps %xmm2, %xmm0
callq 0x140d0
movaps %xmm0, 0x30(%rsp)
movaps 0x10(%rsp)... | /ebu[P]libear/src/common/geom.cpp |
ear::toCartesianVector3d(ear::PolarPosition) | Eigen::Vector3d toCartesianVector3d(PolarPosition position) {
return cart(position.azimuth, position.elevation, position.distance);
} | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movsd 0x70(%rsp), %xmm1
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x80(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
mulsd 0x7eb44(%rip), %xmm1 # 0xccbf0
movsd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
callq 0x14130
movapd %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x67... | /ebu[P]libear/src/common/geom.cpp |
ear::toCartesianPosition(ear::PolarPosition) | CartesianPosition toCartesianPosition(PolarPosition position) {
auto cartesian = toCartesianVector3d(position);
return CartesianPosition(cartesian[0], cartesian[1], cartesian[2]);
} | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movsd 0x70(%rsp), %xmm1
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x80(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
mulsd 0x7ea75(%rip), %xmm1 # 0xccbf0
movsd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
callq 0x14130
movapd %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x67... | /ebu[P]libear/src/common/geom.cpp |
ear::toNormalisedVector3d(ear::PolarPosition) | Eigen::Vector3d toNormalisedVector3d(PolarPosition position) {
return cart(position.azimuth, position.elevation, 1.0);
} | pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movsd 0x60(%rsp), %xmm0
movsd 0x68(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
mulsd 0x7e9b4(%rip), %xmm0 # 0xccbf0
movsd %xmm0, 0x10(%rsp)
callq 0x14130
movapd %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x67b85(%rip), %xmm0 # 0xb5de0
movsd %xmm0, 0x8(%rsp)
callq 0x14b60
mo... | /ebu[P]libear/src/common/geom.cpp |
ear::toPositionsMatrix(std::vector<ear::PolarPosition, std::allocator<ear::PolarPosition>> const&) | Eigen::MatrixXd toPositionsMatrix(
const std::vector<PolarPosition>& positions) {
Eigen::MatrixXd ret(positions.size(), 3);
for (unsigned int i = 0; i < positions.size(); ++i) {
ret.row(i) = toCartesianVector3d(positions[i]);
}
return ret;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq $-0x18, %rsi
jle 0x4e4bd
movq %rdi, %rbx
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
movq %rsi, %rdx
im... | /ebu[P]libear/src/common/geom.cpp |
void Eigen::internal::call_dense_assignment_loop<Eigen::Transpose<Eigen::Matrix<double, 3, 1, 0, 3, 1>>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_quotient_op<double, double>, Eigen::PartialReduxExpr<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::internal::member_sum<double, double>, 0> const, Eigen::CwiseNullaryO... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const internal::assign_op<T1,T2> &/*func*/)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if(((dst.rows()!=dstRows) || (dst.cols()!=dstCols)))
dst.resize(dstRows, dstCols);
eigen_assert(dst.rows(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpq $0x3, 0x20(%rsi)
jne 0x4ec72
movq 0x8(%rsi), %r12
movsd 0x28(%rsi), %xmm0
movsd %xmm0, 0x10(%rsp)
movq (%rdi), %r13
xorl %ebp, %ebp
leaq 0x50(%rsp), %rbx
leaq 0xf(%rsp), %r14
leaq 0x18(%rsp), %r15
movq (%r12), %rdx
movq 0x8(%r12), %... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h |
double Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double, double>, Eigen::internal::redux_evaluator<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true>>, 3, 0>::run<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true>>(Eigen::internal::redux_evaluator<Eigen::Bl... | static Scalar run(const Evaluator &eval, const Func& func, const XprType& xpr)
{
const Index size = xpr.size();
const Index packetSize = redux_traits<Func, Evaluator>::PacketSize;
const int packetAlignment = unpacket_traits<PacketScalar>::alignment;
enum {
alignment0 = (bool(Evaluator::Flag... | movq (%rdx), %rcx
movq 0x8(%rdx), %rax
movq %rax, %rsi
testb $0x7, %cl
jne 0x4ecb1
shrl $0x3, %ecx
andl $0x1, %ecx
cmpq %rax, %rcx
cmovgeq %rax, %rcx
movq %rcx, %rsi
movq %rax, %r9
subq %rsi, %r9
leaq 0x3(%r9), %r8
testq %r9, %r9
cmovnsq %r9, %r8
leaq 0x1(%r9), %rdx
movq (%rdi), %rcx
cmpq $0x3, %rdx
jae 0x4ecf4
movsd (... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/Redux.h |
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Product<Eigen::CwiseBinaryOp<Eigen::internal::scalar_difference_op<double, double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Replicate<Eigen::Transpose<Eigen::Matrix<double, 3, 1, 0, 3, 1>>, -1, 1> const>, Eige... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq (%rsi), %r13
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %rbx
movq 0x28(%rsi), %r12
cmpq %rbx, 0x8(%rdi)
je 0x4edd7
testq %rbx, %rbx
js 0x4ee69
movl $0x1, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x4476c
cmpq %rbx, 0x8(%r14)
jne 0x4... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h |
ear::RegionHandler::RegionHandler(Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>) | RegionHandler::RegionHandler(Eigen::VectorXi outputChannels,
Eigen::MatrixXd positions)
: _outputChannels(outputChannels), _positions(positions){} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0xbcb3e(%rip), %rax # 0x10b9f8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x55da6
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x44694
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %r... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::RegionHandler::handleRemap(Eigen::Matrix<double, 3, 1, 0, 3, 1>, int) const | boost::optional<Eigen::VectorXd> RegionHandler::handleRemap(
Eigen::Vector3d position, int numberOfChannels) const {
boost::optional<Eigen::VectorXd> pv = handle(position);
if (pv) {
Eigen::VectorXd _pv = pv.get();
Eigen::VectorXd out = Eigen::VectorXd::Zero(numberOfChannels);
for (int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movups (%rdx), %xmm0
leaq 0x50(%rsp), %rax
movaps %xmm0, (%rax)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rax)
movq (%rsi), %rcx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rax, %rdx
callq *(%rcx)
movb (%r15), %al
... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::Triplet::Triplet(Eigen::Matrix<int, 3, 1, 0, 3, 1>, Eigen::Matrix<double, 3, 3, 0, 3, 3>) | Triplet::Triplet(Eigen::Vector3i outputChannels, Eigen::Matrix3d positions)
: RegionHandler(outputChannels, positions) {
_basis = _positions.inverse();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl $0xc, %edi
callq 0x147f0
testq %rax, %rax
je 0x4f1e0
movq %rax, %r15
movq %rax, 0x30(%rsp)
movq $0x3, 0x38(%rsp)
movl 0x8(%r12), %eax
movl %eax, 0x8(%r15)
movq (%r12), %rax
movq %rax, (%r15)
xorps %xmm0, %x... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::Triplet::handle(Eigen::Matrix<double, 3, 1, 0, 3, 1>) const | boost::optional<Eigen::VectorXd> Triplet::handle(
Eigen::Vector3d position) const {
Eigen::VectorXd pv = position.transpose() * _basis;
double epsilon = -1e-11;
if (pv(0) >= epsilon && pv(1) >= epsilon && pv(2) >= epsilon) {
pv /= pv.norm();
return pv.cwiseMax(0.0).cwiseMin(1.0).eval();
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
movl $0x18, %edi
callq 0x147f0
testb $0xf, %al
jne 0x4f50a
testq %rax, %rax
je 0x4f529
addq $0x30, %r14
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq $0x3, 0x8(%r12)
le... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::VirtualNgon::handle(Eigen::Matrix<double, 3, 1, 0, 3, 1>) const | boost::optional<Eigen::VectorXd> VirtualNgon::handle(
Eigen::Vector3d position) const {
for (const auto& region : _regions) {
boost::optional<Eigen::VectorXd> pv = region->handleRemap(
position, static_cast<int>(_centreDownmix.size() + 1));
if (pv) {
// downmix the last channel c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, 0x20(%rsp)
movq 0x58(%rsi), %rbp
movq 0x60(%rsi), %rbx
cmpq %rbx, %rbp
je 0x4fc70
movq %rdx, %r15
movq %rsi, %r14
leaq 0x28(%rsp), %r12
leaq 0x50(%rsp), %r13
movq (%rbp), %rsi
movq 0x10(%r15), %rax
movq %rax, 0x60(%rsp)
movdqu... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::QuadRegion::QuadRegion(Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>) | QuadRegion::QuadRegion(Eigen::VectorXi outputChannels,
Eigen::MatrixXd positions)
: RegionHandler(outputChannels, positions) {
_order = ngonVertexOrder(positions);
Eigen::MatrixXd reorderedPositions =
positions(_order, Eigen::indexing::all);
Eigen::MatrixXd reorderedAn... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x55da6
leaq 0xe0(%rsp), %rdi
movq %r14, %rsi
callq 0x44694
leaq 0x28(%rsp), %rsi
leaq 0xe0(%rsp), %rdx
movq %rbx, %rdi
callq 0x4eea8
movq 0xe0(%rsp), %rdi
callq 0x14720
movq 0x28(%rsp), %rdi
callq 0... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::QuadRegion::_calcPolyBasis(Eigen::Matrix<double, -1, -1, 0, -1, -1>) | Eigen::Matrix3d QuadRegion::_calcPolyBasis(Eigen::MatrixXd positions) {
Eigen::Vector3d a = positions.row(0);
Eigen::Vector3d b = positions.row(1);
Eigen::Vector3d c = positions.row(2);
Eigen::Vector3d d = positions.row(3);
Eigen::Matrix3d polyBasis;
polyBasis << //
(b - a).cross(c - d... | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdi, %rbx
movq (%rdx), %rax
movq 0x10(%rdx), %rsi
testq %rax, %rax
sete %cl
testq %rsi, %rsi
setns %dil
orb %cl, %dil
je 0x505c4
movq 0x8(%rdx), %rcx
testq %rcx, %rcx
jle 0x505a5
cmpq $0x3, %rsi
jne 0x505e3
cmpq $0x1, %rcx
je 0x505a5
cmpq $0x2, %rcx... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::QuadRegion::handle(Eigen::Matrix<double, 3, 1, 0, 3, 1>) const | boost::optional<Eigen::VectorXd> QuadRegion::handle(
Eigen::Vector3d position) const {
boost::optional<double> x = _pan(position, _polyBasisX);
boost::optional<double> y = _pan(position, _polyBasisY);
if (x == boost::none || y == boost::none) {
return boost::none;
}
Eigen::VectorXd pvs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdx), %rcx
leaq 0xb0(%rsp), %rax
movq %rcx, 0x10(%rax)
movups (%rdx), %xmm0
movaps %xmm0, (%rax)
addq $0x40, %rsi
leaq 0x110(%rsp), %rdx
movl $0x9, %ecx... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::QuadRegion::_pan(Eigen::Matrix<double, 3, 1, 0, 3, 1>, Eigen::Matrix<double, 3, 3, 0, 3, 3>) const | std::pair<std::vector<Channel>, Eigen::MatrixXd> extraPosVerticalNominal(
Layout layout) {
std::vector<Channel> extraChannels;
Eigen::MatrixXd downmix = Eigen::MatrixXd::Identity(
layout.channels().size(), layout.channels().size());
Layout midLayerLayout;
std::copy_if(layout.channels().be... | pushq %rbx
subq $0x30, %rsp
movupd (%rsi), %xmm1
movupd 0x8(%rsi), %xmm2
movapd %xmm1, %xmm0
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movupd (%rdx), %xmm3
mulpd %xmm0, %xmm3
movupd 0x18(%rdx), %xmm4
movapd %xmm2, %xmm0
movsd 0x28(%rdx), %xmm5
movhpd 0x40(%rdx), %xmm5 # xmm5 = xmm5[0],mem[0]
mulpd... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::PolarPointSourcePanner::PolarPointSourcePanner(std::vector<std::unique_ptr<ear::RegionHandler, std::default_delete<ear::RegionHandler>>, std::allocator<std::unique_ptr<ear::RegionHandler, std::default_delete<ear::RegionHandler>>>>, boost::optional<int>) | PolarPointSourcePanner::PolarPointSourcePanner(
std::vector<std::unique_ptr<RegionHandler>> regions,
boost::optional<int> numberOfChannels)
: _regions(std::move(regions)) {
if (!numberOfChannels) {
_numberOfOutputChannels = _numberOfRequiredChannels();
} else {
_numberOfOutputChann... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0xbacc9(%rip), %rax # 0x10ba98
addq $0x10, %rax
movq %rax, (%rdi)
movups (%rsi), %xmm0
movups %xmm0, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::PointSourcePannerDownmix::handle(Eigen::Matrix<double, 3, 1, 0, 3, 1>) | boost::optional<Eigen::VectorXd> PointSourcePannerDownmix::handle(
Eigen::Vector3d position) {
boost::optional<Eigen::VectorXd> pv = _psp->handle(position);
if (pv) {
Eigen::VectorXd _pv = pv.get();
_pv = _downmix.transpose() * _pv;
_pv /= _pv.norm();
return _pv;
}
return b... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq 0x10(%rdx), %rcx
leaq 0x50(%rsp), %rax
movq %rcx, 0x10(%rax)
movdqu (%rdx), %xmm0
movdqa %xmm0, (%rax)
movq (%rsi), %rcx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rdx
callq *(%rcx)
movb (%r15), %al
cmpb $... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::extraPosVerticalNominal(ear::Layout) | std::pair<std::vector<Channel>, Eigen::MatrixXd> extraPosVerticalNominal(
Layout layout) {
std::vector<Channel> extraChannels;
Eigen::MatrixXd downmix = Eigen::MatrixXd::Identity(
layout.channels().size(), layout.channels().size());
Layout midLayerLayout;
std::copy_if(layout.channels().be... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3d8, %rsp # imm = 0x3D8
movq %rdi, %r12
xorpd %xmm0, %xmm0
movapd %xmm0, 0x150(%rsp)
movq $0x0, 0x160(%rsp)
movq %rsi, 0x28(%rsp)
movq %rsi, %rdi
callq 0x45100
movq (%rax), %r14
movq 0x8(%rax), %rbx
movq 0x28(%rsp), %rdi
callq 0x45100
... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::_adjacent_verts(std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>>, int) | Facet _adjacent_verts(std::vector<Facet> facets, int vert) {
std::set<int> ret;
for (const auto& facetVerts : facets) {
if (std::find(facetVerts.begin(), facetVerts.end(), vert) !=
facetVerts.end()) {
ret.insert(facetVerts.begin(), facetVerts.end());
}
}
ret.erase(vert);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::configureFullPolarPanner(ear::Layout const&) | std::shared_ptr<PointSourcePanner> configureFullPolarPanner(
const Layout& layout) {
std::vector<Eigen::Vector3d> positionsReal;
std::vector<Eigen::Vector3d> positionsNominal;
std::set<int> virtualVerts;
Eigen::MatrixXd downmix;
std::tie(positionsReal, positionsNominal, virtualVerts, downmix) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rsi, %rbx
movq %rdi, %r15
xorl %eax, %eax
movq %rax, 0xb0(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0xa0(%rsp)
movq %rax, 0x170(%rsp)
movapd %xmm0, 0x160(%rsp)
leaq 0x1d8(%rsp), %r12
movl $0x0, (%r12)
movq %r... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::StereoPannerDownmix::handle(Eigen::Matrix<double, 3, 1, 0, 3, 1>) const | boost::optional<Eigen::VectorXd> StereoPannerDownmix::handle(
Eigen::Vector3d position) const {
Eigen::MatrixXd downmix(2, 5);
downmix << 1.0, 0.0, std::sqrt(3.0) / 3.0, std::sqrt(0.5), 0.0, //
0.0, 1.0, std::sqrt(3.0) / 3.0, 0.0, std::sqrt(0.5);
// pan with 0+5+0, downmix and power normalis... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x68(%rsp)
pxor %xmm0, %xmm0
leaq 0x70(%rsp), %r14
movdqa %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movl $0xa, %esi
movl $0x2, %edx
movl $0x5, %ecx
movq %r14, %rdi
callq 0x3e05a
movq %r14, 0x30(%rsp)
... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::checkScreenSpeakers(ear::Layout const&) | void checkScreenSpeakers(const Layout& layout) {
for (auto& channel : layout.channels()) {
if (channel.name() == "M+SC" || channel.name() == "M-SC") {
double abs_az = std::abs(channel.polarPosition().azimuth);
if (!((5.0 <= abs_az && abs_az < 25.0) ||
(35.0 <= abs_az && abs_az < ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
callq 0x45106
movq (%rax), %rbx
movq 0x8(%rax), %r13
cmpq %r13, %rbx
je 0x5463e
leaq 0x5b934(%rip), %r14 # 0xafecd
leaq 0x8(%rsp), %r15
leaq 0x5b92d(%rip), %r12 # 0xafed2
movq %rbx, %rdi
callq 0x44bf2
movq %rax, %rdi
movq %r14, %... | /ebu[P]libear/src/common/point_source_panner.cpp |
ear::configureAllocentricPanner(ear::Layout const&) | std::shared_ptr<PointSourcePanner> configureAllocentricPanner(
const Layout& layout) {
checkScreenSpeakers(layout);
return std::make_shared<AllocentricPanner>();
} | pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5456f
movl $0x18, %edi
callq 0x145c0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0xb75a4(%rip), %rcx # 0x10bd10
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0xb7472(%rip), %rdx # 0x10bbf0
addq $0x10, %rdx
movq ... | /ebu[P]libear/src/common/point_source_panner.cpp |
Eigen::CommaInitializer<Eigen::IndexedView<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::internal::SingleRange>>::operator,(double const&) | EIGEN_DEVICE_FUNC
CommaInitializer& operator,(const Scalar& s)
{
if (m_col==m_xpr.cols())
{
m_row+=m_currentBlockRows;
m_col = 0;
m_currentBlockRows = 1;
eigen_assert(m_row<m_xpr.rows()
&& "Too many rows passed to comma initializer (operator<<)");
}
eigen_assert(m_col... | pushq %rax
movq 0x10(%rdi), %rax
cmpq $0x1, %rax
jne 0x54ca0
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
addq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
cmpq 0x10(%rax), %rcx
jge 0x54d20
xorl %eax, %eax
jmp 0x54ca6
jge 0x54d3f
cmpq $0x1, 0x18(%rdi)
jne 0x54d01
movsd (%rsi), %xmm0
movq ... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/CommaInitializer.h |
bool ear::doIntersect<std::_Rb_tree_const_iterator<int>, std::_Rb_tree_const_iterator<int>>(std::_Rb_tree_const_iterator<int>, std::_Rb_tree_const_iterator<int>, std::_Rb_tree_const_iterator<int>, std::_Rb_tree_const_iterator<int>) | bool doIntersect(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2) {
while (first1 != last1 && first2 != last2) {
if (*first1 < *first2)
++first1;
else if (*first2 < *first1)
++first2;
else {
return true;
}
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
cmpq %rsi, %rdi
setne %al
cmpq %rcx, %rdx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x554e1
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movl 0x20(%r12), %eax
movl 0x20(%r15), %ecx
cmpl %ecx, %eax
jge 0x554c6
movq %r12, %rdi
callq 0x146f0
movq %... | /ebu[P]libear/src/common/helpers/eigen_helpers.hpp |
bool Eigen::RefBase<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>>::construct<Eigen::Map<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::Stride<-1, 0>>>(Eigen::Map<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::Stride<-1, 0>>&) | EIGEN_DEVICE_FUNC
inline ScalarWithConstIfNotLvalue* data() { return this->m_data; } | movq (%rsi), %r8
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rcx
movq %r8, (%rdi)
movq %rax, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
testq %r8, %r8
sete %sil
movq %rdx, %r8
orq %rax, %r8
setns %r8b
orb %sil, %r8b
je 0x5757e
testq %rcx, %rcx
cmoveq %rax, %rcx
cmpq $0x1, %rdx
cmoveq %rax, %rcx
movq %rcx, 0x18(%r... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/MapBase.h |
void Eigen::internal::outer_product_selector_run<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, -1, false>, Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, 1, true>, -1, 1, false>, Eigen::Block<Eigen::Block... | void EIGEN_DEVICE_FUNC outer_product_selector_run(Dst& dst, const Lhs &lhs, const Rhs &rhs, const Func& func, const false_type&)
{
evaluator<Rhs> rhsEval(rhs);
ei_declare_local_nested_eval(Lhs,lhs,Rhs::SizeAtCompileTime,actual_lhs);
// FIXME if cols is large enough, then it might be useful to make sure that lhs i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rcx, 0x10(%rsp)
movq %rdi, %r14
movq (%rdx), %r15
movq 0x30(%rdx), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsi), %rbp
addq $0x10, %rsi
leaq 0x110(%rsp)... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h |
void Eigen::internal::generic_product_impl<Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, 1, true>, -1, 1, false>, Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1, -1, false>, 1, -1, false>, Eige... | EIGEN_DEVICE_FUNC void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() += src; } | pushq %rax
movq 0x8(%rsi), %rax
cmpq 0x28(%rdx), %rax
jne 0x578b3
movq (%rsi), %rcx
movq %rax, %rdi
testb $0x7, %cl
jne 0x57815
movl %ecx, %edi
shrl $0x3, %edi
andl $0x1, %edi
cmpq %rax, %rdi
cmovgeq %rax, %rdi
movsd 0x18(%rdx), %xmm0
movq 0x20(%rdx), %rdx
movq %rax, %r8
subq %rdi, %r8
movq %r8, %rsi
shrq $0x3f, %rsi
a... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h |
bool Eigen::RefBase<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>>::construct<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, -1, false>>(Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, ... | EIGEN_DEVICE_FUNC
inline ScalarWithConstIfNotLvalue* data() { return this->m_data; } | movq (%rsi), %r8
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rcx
movq 0x18(%rcx), %rcx
movq %r8, (%rdi)
movq %rax, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
testq %r8, %r8
sete %sil
movq %rdx, %r8
orq %rax, %r8
setns %r8b
orb %sil, %r8b
je 0x5791c
testq %rcx, %rcx
cmoveq %rax, %rcx
cmpq $0x1, %rdx
cmoveq %rax, %... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/MapBase.h |
Eigen::internal::triangular_solver_selector<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1, 5, 0, -1>::run(Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const&, Eigen::R... | static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
{
typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsProductTraits::extract(lhs);
const Index size = lhs.rows();
const Index othersize = Side==OnTheLeft? rhs.cols() : rhs.rows();
typedef internal::gemm_blocking_s... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x8(%rdi), %r14
movq 0x10(%rsi), %r15
movq 0x8(%rsi), %rax
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, -0x10(%rsi)
movq %rax, (%rsi)
movq %r15, 0x8(%rsi)
leaq 0x20(%rsp), %r13
movq %r14, (%r13)
leaq 0... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/SolveTriangular.h |
Eigen::internal::triangular_solve_matrix<double, long, 1, 5, false, 0, 0, 1>::run(long, long, double const*, long, double*, long, long, Eigen::internal::level3_blocking<double, double>&) | EIGEN_DONT_INLINE void triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor,OtherInnerStride>::run(
Index size, Index otherSize,
const Scalar* _tri, Index triStride,
Scalar* _other, Index otherIncr, Index otherStride,
level3_blocking<Scalar,Scalar>& blocking)
{
In... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rcx, -0xc0(%rbp)
movq %rdx, -0x130(%rbp)
cmpq $0x1, %r9
jne 0x581f8
movq 0x18(%rbp), %rbx
movq 0x10(%rbx), %rcx
movq 0x20(%rbx), %rax
cmpq %rdi, %rcx
movq %rdi, -0x68(%rbp)
cmovgeq %rdi, %r... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/products/TriangularSolverMatrix.h |
void Eigen::internal::evaluateProductBlockingSizesHeuristic<double, double, 4, long>(long&, long&, long&, long) | void evaluateProductBlockingSizesHeuristic(Index& k, Index& m, Index& n, Index num_threads = 1)
{
typedef gebp_traits<LhsScalar,RhsScalar> Traits;
// Explanations:
// Let's recall that the product algorithms form mc x kc vertical panels A' on the lhs and
// kc x nc blocks B' on the rhs. B' has to fit into L2/L... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xb882b(%rip), %rax # 0x110ba8
movb (%rax), %al
testb %al, %al
je 0x58688
leaq 0xb8802(%rip), %rax # 0x110b90
movq (%rax), %rsi
movq 0x8(%rax), %r11
movq 0x10(%rax), %rcx
cmpq $0x2, %r12
j... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/products/GeneralBlockPanelKernel.h |
Eigen::internal::gemm_pack_rhs<double, long, Eigen::internal::blas_data_mapper<double, long, 0, 0, 1>, 4, 0, false, true>::operator()(double*, Eigen::internal::blas_data_mapper<double, long, 0, 0, 1> const&, long, long, long, long) | EIGEN_DONT_INLINE void gemm_pack_rhs<Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
::operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
{
EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK RHS COLMAJOR");
EIGEN_UNUSED_VARIABLE(stride);
EIGEN_UNUSED_VARIABL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq %rcx, %r9
jl 0x58865
movq %rcx, %rbx
movq 0x60(%rsp), %rcx
cmpq %r9, %rcx
jg 0x58865
movq %rsi, (%rsp)
leaq 0x3(%r8), %rdi
testq %r8, %r8
cmovnsq %r8, %rdi
movq %rdi, %r10
andq $-0x4, %r10
movq %r8, 0x10(%rsp)
cmpq $0x4, %r8
movq %r... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/products/GeneralBlockPanelKernel.h |
void Eigen::internal::generic_product_impl<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::DenseShape, Eigen::DenseShape, 8>::subTo<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::Oute... | static void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
{
if((rhs.rows()+dst.rows()+dst.cols())<EIGEN_GEMM_TO_COEFFBASED_THRESHOLD && rhs.rows()>0)
lazyproduct::eval_dynamic(dst, lhs, rhs, internal::sub_assign_op<typename Dst::Scalar,Scalar>());
else
scaleAndAddTo(dst, lhs, rhs, Scalar(-1));
... | subq $0x88, %rsp
movq 0x8(%rdx), %rax
testq %rax, %rax
jle 0x58933
movq 0x8(%rdi), %r8
movq 0x10(%rdi), %rcx
leaq (%r8,%rax), %r9
addq %rcx, %r9
cmpq $0x13, %r9
jg 0x58933
cmpq %rax, 0x10(%rsi)
jne 0x58952
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq (%rsi), %r9
movq %r9, 0x18(%rsp)
movq 0x18(%rsi), %r9
movq %r9, 0x... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/products/GeneralMatrixMatrix.h |
void Eigen::internal::generic_product_impl<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::DenseShape, Eigen::DenseShape, 8>::scaleAndAddTo<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eig... | static void scaleAndAddTo(Dest& dst, const Lhs& a_lhs, const Rhs& a_rhs, const Scalar& alpha)
{
eigen_assert(dst.rows()==a_lhs.rows() && dst.cols()==a_rhs.cols());
if(a_lhs.cols()==0 || a_lhs.rows()==0 || a_rhs.cols()==0)
return;
if (dst.cols() == 1)
{
// Fallback to GEMV if either the lh... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq 0x8(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x58b9a
movq %rdi, %r15
movq 0x10(%rdi), %rdi
cmpq 0x10(%rbx), %rdi
jne 0x58b9a
testq %rdi, %rdi
je 0x58b8e
testq %rdx, %rdx
je 0x58b8e
movq %rsi, %r14
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x5... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/products/GeneralMatrixMatrix.h |
Eigen::internal::dense_assignment_loop<Eigen::internal::restricted_packet_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>>, Eigen::internal::evaluator<Eigen::Product<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStr... | void run(Kernel &kernel)
{
typedef typename Kernel::Scalar Scalar;
typedef typename Kernel::PacketType PacketType;
enum {
packetSize = unpacket_traits<PacketType>::size,
requestedAlignment = int(Kernel::AssignmentTraits::InnerRequiredAlignment),
alignable = packet_traits<Scalar>::Aligned... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq (%rax), %r12
testb $0x7, %r12b
je 0x58cc3
cmpq $0x0, 0x10(%rax)
jle 0x58e56
xorl %r12d, %r12d
xorl %r14d, %r14d
cmpq $0x0, 0x8(%rax)
jle 0x58cb1
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x8(%rbx... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h |
Eigen::internal::product_evaluator<Eigen::Product<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1>, 8, Eigen::DenseShape, Eigen::DenseShape, double, double>::coeff(long, long) const | const CoeffReturnType coeff(Index row, Index col) const
{
return (m_lhs.row(row).transpose().cwiseProduct( m_rhs.col(col) )).sum();
} | pushq %rbx
movq (%rdi), %r8
movq (%r8), %rax
movq 0x10(%r8), %rcx
testq %rax, %rax
sete %r9b
testq %rcx, %rcx
setns %r10b
orb %r9b, %r10b
je 0x58f33
testq %rsi, %rsi
js 0x58f4a
cmpq %rsi, 0x8(%r8)
jle 0x58f4a
movq 0x8(%rdi), %r9
movq (%r9), %rdi
movq 0x8(%r9), %r10
testq %rdi, %rdi
sete %r11b
testq %r10, %r10
setns %bl... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h |
void Eigen::internal::generic_product_impl<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const, Eigen::DenseShape, Eigen::DenseShape, 7>::scaleAndAddTo<Eigen::Block<Eigen::... | static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
{
// Fallback to inner product if both the lhs and rhs is a runtime vector.
if (lhs.rows() == 1 && rhs.cols() == 1) {
dst.coeffRef(0,0) += alpha * lhs.row(0).conjugate().dot(rh... | subq $0x28, %rsp
movq %rsi, %rax
movq 0x8(%rsi), %r10
movq 0x10(%rsi), %rsi
cmpq $0x1, %r10
jne 0x59083
movq (%rax), %r9
testq %r9, %r9
sete %r8b
testq %rsi, %rsi
setns %r10b
orb %r8b, %r10b
je 0x590d8
movq (%rdx), %r8
movq 0x8(%rdx), %rdx
testq %r8, %r8
sete %r10b
testq %rdx, %rdx
setns %r11b
orb %r10b, %r11b
je 0x590... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h |
void Eigen::internal::generic_product_impl<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const, 1, -1, false> const, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::DenseShape, Eigen::DenseShape, 7>::scaleAndAddTo<Eigen::Block<Eigen:... | static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
{
// Fallback to inner product if both the lhs and rhs is a runtime vector.
if (lhs.rows() == 1 && rhs.cols() == 1) {
dst.coeffRef(0,0) += alpha * lhs.row(0).conjugate().dot(rh... | subq $0x88, %rsp
cmpq $0x1, 0x10(%rdx)
jne 0x591fa
movq (%rsi), %r9
movq 0x10(%rsi), %rax
testq %r9, %r9
sete %r8b
testq %rax, %rax
setns %r10b
orb %r8b, %r10b
je 0x59279
movq (%rdx), %r8
movq 0x8(%rdx), %rdx
testq %r8, %r8
sete %r10b
testq %rdx, %rdx
setns %r11b
orb %r10b, %r11b
je 0x59290
cmpq %rdx, %rax
jne 0x592af
... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h |
void Eigen::internal::gemv_dense_selector<2, 1, true>::run<Eigen::Transpose<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const>, Eigen::Transpose<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const, 1, -1, false> const>, Eigen::Transpose<... | static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
{
typedef typename Lhs::Scalar LhsScalar;
typedef typename Rhs::Scalar RhsScalar;
typedef typename Dest::Scalar ResScalar;
typedef internal::blas_traits<Lhs> LhsBlasTraits;
typedef typename Lh... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x10(%rsi), %r13
movq %r13, %rax
shrq $0x3d, %rax
jne 0x5935c
movq %rdx, %r14
movq (%rdi), %r12
movq (%rsi), %r15
movq 0x18(%rsi), %rdx
movsd (%rcx), %xmm0
leaq (,%r13,8), %rdi
cmpq $0x4001, %r13 # imm = 0x... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/GeneralProduct.h |
Eigen::internal::gemm_functor<double, long, Eigen::internal::general_matrix_matrix_product<long, double, 0, false, double, 0, false, 0, 1>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::... | void operator() (Index row, Index rows, Index col=0, Index cols=-1, GemmParallelInfo<Index>* info=0) const
{
if(cols==-1)
cols = m_rhs.cols();
Gemm::run(rows, cols, m_lhs.cols(),
&m_lhs.coeffRef(row,0), m_lhs.outerStride(),
&m_rhs.coeffRef(0,col), m_rhs.outerStride(),
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rax
movq %r8, %r14
movq %rdx, %r11
movq %rdi, %r10
movq 0x8(%rdi), %rdi
cmpq $-0x1, %r8
jne 0x594ad
movq 0x10(%rdi), %r14
leaq (,%rsi,8), %rbx
movq (%r10), %r8
addq (%r8), %rbx
movq 0x10(%r10), %r12
movq 0x10(%r8), %rdx
movq 0x18(%rdi), %r15
movq %r15, %... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/products/GeneralMatrixMatrix.h |
Eigen::PermutationMatrix<-1, -1, int>& Eigen::PermutationBase<Eigen::PermutationMatrix<-1, -1, int>>::operator=<Eigen::Transpositions<-1, -1, int>>(Eigen::TranspositionsBase<Eigen::Transpositions<-1, -1, int>> const&) | Derived& operator=(const TranspositionsBase<OtherDerived>& tr)
{
setIdentity(tr.size());
for(Index k=size()-1; k>=0; --k)
applyTranspositionOnTheRight(k,tr.coeff(k));
return derived();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
callq 0x5956a
movq 0x8(%rbx), %r15
testq %r15, %r15
jle 0x59560
decq %r15
movq (%r14), %rax
movslq (%rax,%r15,4), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x59648
leaq -0x1(%r15), %rax
incq %r15
cmpq $0x1, %r15
movq %rax, %r15
ja 0x... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/PermutationMatrix.h |
void Eigen::PartialPivLU<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::_solve_impl<Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::Matrix<double, 3, 3, 0, 3, 3>>(Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<double>, Eigen::Matrix<double, -1,... | inline const PermutationType& permutationP() const
{
eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
return m_p;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x0, 0x41(%rdi)
je 0x598d8
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rax, 0x20(%rdi)
jne 0x598f7
cmpq $0x3, %rax
jne 0x59916
cmpq $0x3, 0x8(%rsi)
jne 0x59916
movq %rdx, %rbx
movq 0x18(%r14), %rax
xorl %ecx, %ecx
movsd 0x557c3(%rip), %xmm0 # 0xaf008
movl (%rax,%rc... | /ebu[P]libear/submodules/eigen/Eigen/src/LU/PartialPivLU.h |
Eigen::internal::triangular_solver_selector<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Matrix<double, 3, 3, 0, 3, 3>, 1, 5, 0, -1>::run(Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3>&) | static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
{
typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsProductTraits::extract(lhs);
const Index size = lhs.rows();
const Index othersize = Side==OnTheLeft? rhs.cols() : rhs.rows();
typedef internal::gemm_blocking_s... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, -0x10(%rsi)
movl $0x3, %r13d
movq %r13, (%rsi)
movq %r13, 0x8(%rsi)
leaq 0x20(%rsp), %r12
movq %r14, (%r12)
leaq 0x38(%rsp), %rdx
movq %r13,... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/SolveTriangular.h |
Eigen::internal::triangular_solver_selector<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Matrix<double, 3, 3, 0, 3, 3>, 1, 2, 0, -1>::run(Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3>&) | static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
{
typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsProductTraits::extract(lhs);
const Index size = lhs.rows();
const Index othersize = Side==OnTheLeft? rhs.cols() : rhs.rows();
typedef internal::gemm_blocking_s... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, -0x10(%rsi)
movl $0x3, %r13d
movq %r13, (%rsi)
movq %r13, 0x8(%rsi)
leaq 0x20(%rsp), %r12
movq %r14, (%r12)
leaq 0x38(%rsp), %rdx
movq %r13,... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/SolveTriangular.h |
Eigen::internal::triangular_solve_matrix<double, long, 1, 2, false, 0, 0, 1>::run(long, long, double const*, long, double*, long, long, Eigen::internal::level3_blocking<double, double>&) | EIGEN_DONT_INLINE void triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor,OtherInnerStride>::run(
Index size, Index otherSize,
const Scalar* _tri, Index triStride,
Scalar* _other, Index otherIncr, Index otherStride,
level3_blocking<Scalar,Scalar>& blocking)
{
In... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdx, -0xd0(%rbp)
cmpq $0x1, %r9
jne 0x5a361
movq %rcx, %r13
movq 0x18(%rbp), %rbx
movq 0x10(%rbx), %r15
movq 0x20(%rbx), %rcx
cmpq %rdi, %r15
movq %rdi, -0x38(%rbp)
cmovgeq %rdi, %r15
movq ... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/products/TriangularSolverMatrix.h |
double Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double, double>, Eigen::internal::redux_evaluator<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const>>, 3, 0>::run<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<double>, Eigen::Matrix<double, -... | EIGEN_CONSTEXPR
Index rows() const EIGEN_NOEXCEPT { return m_xpr.rows(); } | movq (%rdx), %rax
movq 0x8(%rax), %rax
leaq 0x3(%rax), %rsi
testq %rax, %rax
cmovnsq %rax, %rsi
leaq 0x1(%rax), %rdx
movq 0x8(%rdi), %rcx
cmpq $0x3, %rdx
jae 0x5a60b
movsd (%rcx), %xmm0
mulsd %xmm0, %xmm0
retq
movq %rax, %rdx
shrq $0x3f, %rdx
addq %rax, %rdx
andq $-0x2, %rdx
movapd (%rcx), %xmm1
mulpd %xmm1, %xmm1
cmpq... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/CwiseUnaryOp.h |
void Eigen::internal::call_assignment<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false> const, Eigen::Product<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0,... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if< evaluator_assume_aliasing<Src>::value, void*>::type = 0)
{
typename plain_matrix_type<Src>::type tmp(src);
call_assignment_no_alias(dst, tmp, func);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
leaq 0xf(%rsp), %rdx
callq 0x5a93c
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rbx
cmpq %rbx, 0x8(%r14)
je 0x5a890
testq %rbx, %rbx
js 0x5a8e7
movl $0x1, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq ... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h |
Eigen::internal::dense_assignment_loop<Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::internal::evaluator<Eigen::Product<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false>, 1>>, Eigen::in... | Index size() const EIGEN_NOEXCEPT { return m_dstExpr.size(); } | pushq %rbx
movq 0x18(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, %rcx
shrq $0x3f, %rcx
addq %rax, %rcx
andq $-0x2, %rcx
cmpq $0x2, %rax
jl 0x5ab3d
xorl %edx, %edx
movq (%rdi), %rsi
movq 0x8(%rdi), %r8
movq (%rsi), %rsi
movq 0x40(%r8), %r9
movq 0x48(%r8), %r8
movupd (%r9,%rdx,8), %xmm0
movsd (%r8), %xmm1
unpcklpd %xmm1,... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h |
Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::PlainObjectBase<Eigen::IndexedView<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::internal::AllRange<-1>>>(Eigen::DenseBase<Eigen::IndexedView<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -... | EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
: m_storage()
{
_check_template_params();
resizeLike(other);
_set_noalias(other);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x10(%rsi), %r8
movq 0x18(%rsi), %rcx
testq %r8, %r8
sete %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
jne 0x5ac40
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %ed... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/PlainObjectBase.h |
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::IndexedView<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, 4, 1, 0, 4, 1>, Eigen::internal::AllRange<-1>>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Indexed... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq 0x20(%rsi), %r14
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq $0x4, 0x8(%rdi)
jne 0x5aea1
cmpq %r14, 0x10(%r15)
jne 0x5aea1
movb $0x1, %dl
movl $0x4, %eax
movq %r14, %rcx
jmp 0x5aede
testq %r14, %r14
js 0x5af7e
... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h |
Eigen::internal::product_evaluator<Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0>, 7, Eigen::DenseShape, Eigen::DenseShape, double, double>::product_evaluator(Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::Matrix<dou... | void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
dst.resize(dstRows, dstCols);
// FIXME shall we handle nested_eval here?
generic_product_i... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq $0x0, (%rdi)
movq 0x8(%rsi), %rax
movq 0x10(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
testq %rcx, %rcx
js 0x5b055
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
movl $0x1, %edx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x5b0a8
movq 0x8(%r15), %rdi
mo... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h |
Eigen::DenseStorage<double, -1, 1, -1, 1>::resize(long, long, long) | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index, Index cols)
{
if(size != _Rows*m_cols)
{
internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols);
if (size>0) // >0 and not simply !=0 to let the compiler knows that size cannot be neg... | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
cmpq %rsi, 0x8(%rdi)
je 0x5b127
movq %rsi, %r15
movq (%r14), %rdi
callq 0x14720
testq %r15, %r15
jle 0x5b122
movq %r15, %rax
shrq $0x3d, %rax
jne 0x5b0f4
leaq (,%r15,8), %rdi
callq 0x147f0
cmpq $0x1, %r15
setne %cl
testb $0xf, %al
setne %dl
testb %dl, %cl... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/DenseStorage.h |
void Eigen::internal::generic_product_impl<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::DenseShape, Eigen::DenseShape, 7>::scaleAndAddTo<Eigen::Matrix<double, 1, -1, 1, 1, -1>>(Eigen::Matrix<double, 1, -1, 1, 1, -1>&, Eigen::Transpose<Eigen::Matrix<double, -... | static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
{
// Fallback to inner product if both the lhs and rhs is a runtime vector.
if (lhs.rows() == 1 && rhs.cols() == 1) {
dst.coeffRef(0,0) += alpha * lhs.row(0).conjugate().dot(rh... | pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
cmpq $0x1, 0x10(%rdx)
jne 0x5b22b
movq (%rsi), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
testq %rsi, %rsi
sete %r8b
testq %rax, %rax
setns %r9b
orb %r8b, %r9b
je 0x5b26f
movq (%rdx), %r8
movq 0x8(%rdx), %r9
testq %r8, %r8
sete %r10b
testq %r9, %r9
setns %r11b
orb %r10b, %r1... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h |
double Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double, double>, Eigen::internal::redux_evaluator<Eigen::CwiseBinaryOp<Eigen::internal::scalar_conj_product_op<double, double>, Eigen::Transpose<Eigen::Block<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>> const, 1, -1, true> const> const, Eigen... | explicit variable_if_dynamic(T value = 0) EIGEN_NO_THROW : m_value(value) {} | movq 0x40(%rdx), %rax
leaq 0x3(%rax), %r8
testq %rax, %rax
cmovnsq %rax, %r8
leaq 0x1(%rax), %rsi
movq 0x8(%rdi), %rdx
movq 0x20(%rdi), %rcx
cmpq $0x3, %rsi
jae 0x5b30e
movsd (%rdx), %xmm0
mulsd (%rcx), %xmm0
retq
movq %rax, %rsi
shrq $0x3f, %rsi
addq %rax, %rsi
andq $-0x2, %rsi
movupd (%rdx), %xmm0
movupd (%rcx), %xmm... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/util/XprHelper.h |
void Eigen::internal::gemv_dense_selector<2, 1, true>::run<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1> const>, Eigen::Transpose<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>> const>, Eigen::Transpose<Eigen::Matrix<double, 1, -1, 1, 1, -1>>>(Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -... | static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
{
typedef typename Lhs::Scalar LhsScalar;
typedef typename Rhs::Scalar RhsScalar;
typedef typename Dest::Scalar ResScalar;
typedef internal::blas_traits<Lhs> LhsBlasTraits;
typedef typename Lh... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq (%rsi), %rax
movq 0x8(%rax), %r15
movq %r15, %rdx
shrq $0x3d, %rdx
jne 0x5b4b0
movq (%rdi), %r12
movsd (%rcx), %xmm0
movq (%rax), %rax
testq %rax, %rax
je 0x5b401
xorl %ebx, %ebx
jmp 0x5b44b
leaq (,%r15,8), %rdi... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/GeneralProduct.h |
void Eigen::internal::call_assignment<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Product<Eigen::Transpose<Eigen:... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if< evaluator_assume_aliasing<Src>::value, void*>::type = 0)
{
typename plain_matrix_type<Src>::type tmp(src);
call_assignment_no_alias(dst, tmp, func);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq (%rsi), %rax
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x5b79d
js 0x5b87c
movq %r12, %rax
shrq $0x3d, %rax
jne 0x5b84e
leaq (,%r12,8), %r15
movq %r15, %rdi
callq 0x147f0
cmpq $0x1, %... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h |
void Eigen::internal::generic_product_impl<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::DenseShape, Eigen::DenseShape, 7>::scaleAndAddTo<Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Transpose<Eigen::Matrix<double, -... | static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
{
// Fallback to inner product if both the lhs and rhs is a runtime vector.
if (lhs.rows() == 1 && rhs.cols() == 1) {
dst.coeffRef(0,0) += alpha * lhs.row(0).conjugate().dot(rh... | pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
movq (%rsi), %r9
cmpq $0x1, 0x10(%r9)
jne 0x5b9cd
movq (%r9), %rsi
movq 0x8(%r9), %rax
testq %rsi, %rsi
sete %dil
testq %rax, %rax
setns %r8b
orb %dil, %r8b
je 0x5b9fe
movq (%rdx), %r8
movq 0x8(%rdx), %rdi
testq %r8, %r8
sete %r10b
testq %rdi, %rdi
setns %r11b
orb %r10b, %r11... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h |
void Eigen::internal::gemv_dense_selector<2, 1, true>::run<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, Eigen::... | static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
{
typedef typename Lhs::Scalar LhsScalar;
typedef typename Rhs::Scalar RhsScalar;
typedef typename Dest::Scalar ResScalar;
typedef internal::blas_traits<Lhs> LhsBlasTraits;
typedef typename Lh... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq 0x8(%rsi), %r15
movq %r15, %rax
shrq $0x3d, %rax
jne 0x5bb54
movq %rdx, %r14
movq (%rdi), %r12
movsd (%rcx), %xmm0
movq (%rsi), %rax
testq %rax, %rax
je 0x5baa8
xorl %ebx, %ebx
jmp 0x5baf2
leaq (,%r15,8), %rdi
cmpq $0x4000, %r1... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/GeneralProduct.h |
double Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double, double>, Eigen::internal::redux_evaluator<Eigen::CwiseBinaryOp<Eigen::internal::scalar_conj_product_op<double, double>, Eigen::Transpose<Eigen::Block<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>> const, 1, -1, true> const> const, Eig... | T value() const { return m_value; } | movq 0x40(%rdx), %rax
leaq 0x3(%rax), %r8
testq %rax, %rax
cmovnsq %rax, %r8
leaq 0x1(%rax), %rsi
movq 0x8(%rdi), %rdx
movq 0x20(%rdi), %rcx
cmpq $0x3, %rsi
jae 0x5bc06
movsd (%rdx), %xmm0
mulsd (%rcx), %xmm0
retq
movq %rax, %rsi
shrq $0x3f, %rsi
addq %rax, %rsi
andq $-0x2, %rsi
movupd (%rdx), %xmm0
movupd (%rcx), %xmm... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/util/XprHelper.h |
Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::PlainObjectBase<Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>>(Eigen::DenseBase<Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>> c... | EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
: m_storage()
{
_check_template_params();
resizeLike(other);
_set_noalias(other);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r8
movq 0x8(%rsi), %rcx
testq %r8, %r8
sete %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
jne 0x5bd03
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idi... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/PlainObjectBase.h |
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::CwiseNullaryOp<Eigen::int... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq (%rsi), %rbx
movq 0x8(%rsi), %r14
cmpq %rbx, 0x8(%rdi)
jne 0x5bdb6
movq %r14, %rax
movq %rbx, %rcx
cmpq %r14, 0x10(%r15)
je 0x5be07
movq %r14, %rax
orq %rbx, %rax
js 0x5bf39
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x5bdea
movabsq $0x7fff... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h |
void Eigen::internal::generic_product_impl<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::DenseShape, Eigen::DenseShape, 7>::scaleAndAddTo<Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Ma... | static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
{
// Fallback to inner product if both the lhs and rhs is a runtime vector.
if (lhs.rows() == 1 && rhs.cols() == 1) {
dst.coeffRef(0,0) += alpha * lhs.row(0).conjugate().dot(rh... | subq $0x28, %rsp
movq 0x8(%rsi), %rax
movsd (%rcx), %xmm0
cmpq $0x1, %rax
jne 0x5c68f
movq (%rsi), %rax
movq 0x10(%rsi), %rcx
testq %rax, %rax
sete %sil
testq %rcx, %rcx
setns %r8b
orb %sil, %r8b
je 0x5c6e6
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
testq %rsi, %rsi
sete %r8b
testq %rdx, %rdx
setns %r9b
orb %r8b, %r9b
je 0... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h |
double Eigen::internal::redux_impl<Eigen::internal::scalar_max_op<double, double, 0>, Eigen::internal::redux_evaluator<Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false>>, 3, 0>::run<Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false>>(Eigen::internal::redux_evaluator<Eigen::Block<Eigen::... | static Scalar run(const Evaluator &eval, const Func& func, const XprType& xpr)
{
const Index size = xpr.size();
const Index packetSize = redux_traits<Func, Evaluator>::PacketSize;
const int packetAlignment = unpacket_traits<PacketScalar>::alignment;
enum {
alignment0 = (bool(Evaluator::Flag... | movq (%rdx), %rcx
movq 0x8(%rdx), %rax
movq %rax, %rsi
testb $0x7, %cl
jne 0x5c779
shrl $0x3, %ecx
andl $0x1, %ecx
cmpq %rax, %rcx
cmovgeq %rax, %rcx
movq %rcx, %rsi
movq %rax, %r9
subq %rsi, %r9
leaq 0x3(%r9), %r8
testq %r9, %r9
cmovnsq %r9, %r8
leaq 0x1(%r9), %rdx
movq (%rdi), %rcx
cmpq $0x3, %rdx
jae 0x5c7c4
movsd (... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/Redux.h |
ear::GainCalculatorDirectSpeakersImpl::_applyScreenEdgeLock(ear::PolarSpeakerPosition) | PolarSpeakerPosition GainCalculatorDirectSpeakersImpl::_applyScreenEdgeLock(
PolarSpeakerPosition pos) {
std::tie(pos.azimuth, pos.elevation) =
_screenEdgeLockHandler.handleAzimuthElevation(
pos.azimuth, pos.elevation, pos.screenEdgeLock);
return pos;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movsd (%rdx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rdx), %xmm0
movsd %xmm0, 0x8(%rsp)
movb $0x0, 0x18(%rsp)
cmpb $0x1, 0x78(%rdx)
jne 0x5e2a9
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r1... | /ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp |
ear::GainCalculatorDirectSpeakersImpl::_applyScreenEdgeLock(ear::CartesianSpeakerPosition) | CartesianSpeakerPosition
GainCalculatorDirectSpeakersImpl::_applyScreenEdgeLock(
CartesianSpeakerPosition pos) {
std::tie(pos.X, pos.Y, pos.Z) = _screenEdgeLockHandler.handleVector(
toCartesianVector3d(pos), pos.screenEdgeLock);
return pos;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x68(%rsp), %rax
movl $0xf, %ecx
movq %rax, %rdi
movq %rdx, %rsi
rep movsq (%rsi), %es:(%rdi)
movb $0x0, 0x78(%rax)
cmpb $0x1, 0x78(%rdx)
jne 0x5e4f7
leaq 0xe8(%rsp), %rdi
leaq 0x... | /ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp |
ear::GainCalculatorDirectSpeakersImpl::_applyScreenEdgeLock(boost::variant<ear::PolarSpeakerPosition, ear::CartesianSpeakerPosition> const&) | SpeakerPosition GainCalculatorDirectSpeakersImpl::_applyScreenEdgeLock(
const SpeakerPosition& position) {
return boost::apply_visitor(
[this](const auto& p) {
return SpeakerPosition(_applyScreenEdgeLock(p));
},
position);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
movl (%rdx), %ecx
movl %ecx, %eax
sarl $0x1f, %eax
xorl %ecx, %eax
cmpl $0x13, %eax
ja 0x5eaa0
movq %rdx, %r15
movq %rsi, %r14
leaq 0x8(%rdx), %rsi
leaq 0x777fe(%rip), %rcx # 0xd6040
movslq (%rcx,%rax,4), %rax
add... | /ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp |
ear::GainCalculatorDirectSpeakersImpl::_isLfeChannel(ear::DirectSpeakersTypeMetadata const&, std::function<void (ear::Warning const&)> const&) | bool GainCalculatorDirectSpeakersImpl::_isLfeChannel(
const DirectSpeakersTypeMetadata& metadata, const WarningCB& warning_cb) {
bool has_lfe_freq = (metadata.channelFrequency.lowPass != boost::none &&
metadata.channelFrequency.lowPass.get() <= 200 &&
metadata... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x90(%rsp)
cmpb $0x1, 0xe8(%rsi)
jne 0x5eb65
movsd 0x77602(%rip), %xmm0 # 0xd6130
ucomisd 0xf0(%r12), %xmm0
jb 0x5eb70
testb $0x1, 0xf8(%r12)
jne 0x5eb70
movq (%r12), %rbp
movq 0x8(%r12), %rc... | /ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp |
ear::GainCalculatorDirectSpeakersImpl::_nominalSpeakerLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string GainCalculatorDirectSpeakersImpl::_nominalSpeakerLabel(
const std::string& label) {
std::string ret = label;
std::smatch idMatch;
if (std::regex_search(label, idMatch, SPEAKER_URN_REGEX)) {
ret = idMatch[1].str();
}
if (_substitutions.count(label)) {
ret = _substitution... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x36894
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x160... | /ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp |
ear::GainCalculatorDirectSpeakersImpl::_findCandidates(ear::PolarSpeakerPosition const&, bool, double) | std::vector<std::pair<int, double>>
GainCalculatorDirectSpeakersImpl::_findCandidates(
const PolarSpeakerPosition& pos, bool isLfe, double tol) {
Eigen::RowVector3d cartPosition = toCartesianVector3d(pos);
std::vector<std::pair<int, double>> candidates;
double azMin = boost::get_optional_value_or(po... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movsd %xmm0, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
leaq 0x120(%rsp), %rax
movl $0xf, %ecx
movq %rax, %rdi
movq %rdx, %rsi
rep movsq (%rsi), %es:(%rdi)
movb $0x0, 0x78(... | /ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp |
ear::GainCalculatorDirectSpeakersImpl::_findCandidates(ear::CartesianSpeakerPosition const&, bool, double) | std::vector<std::pair<int, double>>
GainCalculatorDirectSpeakersImpl::_findCandidates(
const CartesianSpeakerPosition& pos, bool isLfe, double tol) {
Eigen::RowVector3d cartPosition = toCartesianVector3d(pos);
std::vector<std::pair<int, double>> candidates;
double XMin = boost::get_optional_value_o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movsd %xmm0, 0x8(%rsp)
movl %ecx, 0x1c(%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbp
leaq 0x120(%rsp), %rax
movl $0xf, %ecx
movq %rax, %rdi
movq %rdx, %rsi
rep movsq (%rsi), %es:(%rdi)
movb $0x0, 0x78(%... | /ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp |
ear::GainCalculatorDirectSpeakersImpl::_findChannelWithinBounds(boost::variant<ear::PolarSpeakerPosition, ear::CartesianSpeakerPosition> const&, bool, double) | boost::optional<int>
GainCalculatorDirectSpeakersImpl::_findChannelWithinBounds(
const SpeakerPosition& position, bool isLfe, double tol) {
std::vector<std::pair<int, double>> candidates =
_findCandidates(position, isLfe, tol);
if (candidates.size() == 0) {
return boost::none;
} else i... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movsd %xmm0, (%rsp)
callq 0x5fd16
movq (%r14), %rbx
movq 0x8(%r14), %r14
movq %r14, %r15
subq %rbx, %r15
movq %r15, %rax
sarq $0x4, %rax
je 0x5fe3f
cmpq $0x1, %rax
je 0x5fe77
cmpq %r14,... | /ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp |
ear::GainCalculatorDirectSpeakersImpl::calculate(ear::DirectSpeakersTypeMetadata const&, ear::OutputGains&, std::function<void (ear::Warning const&)> const&) | void GainCalculatorDirectSpeakersImpl::calculate(
const DirectSpeakersTypeMetadata& metadata, OutputGains& direct,
const WarningCB& warning_cb) {
if (metadata.audioPackFormatID && metadata.speakerLabels.size() == 0)
throw adm_error(
"common definitions audioPackFormatID specified without... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x1, 0x108(%rsi)
jne 0x5fedd
movq 0x8(%r15), %rax
cmpq (%r15), %rax
je 0x604b8
movslq 0xb8(%r14), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
call... | /ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp |
ear::ScreenEdgeLockHandler::handleAzimuthElevation(double, double, ear::ScreenEdgeLock) | std::pair<double, double> handleAzimuthElevation(
double azimuth, double elevation, ScreenEdgeLock screenEdgeLock) {
if (screenEdgeLock.horizontal || screenEdgeLock.vertical)
throw not_implemented("screenEdgeLock");
return std::make_pair(azimuth, elevation);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, (%rsi)
jne 0x60ca2
cmpb $0x1, 0x28(%rsi)
je 0x60ca2
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x14290
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x75740(%rip), %rsi # 0xd63ff
lea... | /ebu[P]libear/src/direct_speakers/../common/screen_edge_lock.hpp |
ear::ScreenEdgeLock::~ScreenEdgeLock() | struct EAR_EXPORT ScreenEdgeLock {
/// `screenEdgeLock` attribute on `position` element with
/// `coordinate="azimuth"` or `coordinate="X"`
boost::optional<std::string> horizontal;
/// `screenEdgeLock` attribute on `position` element with
/// `coordinate="elevation"` or `coordinate="Z"`
boost::o... | pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x60d52
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x60d4e
movq (%rax), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0x28(%rbx)
cmpb $0x1, (%rbx)
jne 0x60d72
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x60d6f
movq (%rax), %rsi
incq %... | /ebu[P]libear/include/ear/metadata.hpp |
ear::ScreenEdgeLockHandler::handleVector(Eigen::Matrix<double, 3, 1, 0, 3, 1>, ear::ScreenEdgeLock) | std::tuple<double, double, double> handleVector(
Eigen::Vector3d pos, ScreenEdgeLock screenEdgeLock) {
if (screenEdgeLock.horizontal || screenEdgeLock.vertical)
throw not_implemented("screenEdgeLock");
return std::make_tuple(pos(0), pos(1), pos(2));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, (%rcx)
jne 0x60dab
cmpb $0x1, 0x28(%rcx)
je 0x60dab
movups 0x8(%rdx), %xmm0
shufps $0x4e, %xmm0, %xmm0 # xmm0 = xmm0[2,3,0,1]
movups %xmm0, (%rdi)
movsd (%rdx), %xmm0
movsd %xmm0, 0x10(%rdi)
movq %rdi, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
... | /ebu[P]libear/src/direct_speakers/../common/screen_edge_lock.hpp |
ear::CartesianSpeakerPosition::~CartesianSpeakerPosition() | struct EAR_EXPORT CartesianSpeakerPosition {
CartesianSpeakerPosition(double X = 0.0, double Y = 1.0, double Z = 0.0)
: X(X), Y(Y), Z(Z){};
double X;
boost::optional<double> XMin;
boost::optional<double> XMax;
double Y;
boost::optional<double> YMin;
boost::optional<double> YMax;
... | pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0xa0(%rdi)
jne 0x60e68
movq 0xa8(%rbx), %rdi
leaq 0xb8(%rbx), %rax
cmpq %rax, %rdi
je 0x60e61
movq (%rax), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0xa0(%rbx)
cmpb $0x1, 0x78(%rbx)
jne 0x60e90
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax, %rdi
je 0x60e8c
movq (%rax), %rsi
i... | /ebu[P]libear/include/ear/metadata.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.