name string | code string | asm string | file string |
|---|---|---|---|
andres::marray_detail::OperateHelperBinaryScalar<(unsigned short)4, andres::marray_detail::MinusEqual<short, int>, short, int, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, int const&, andres::marray_detail::MinusEqual<short, int>, short*) | static inline void operate
(
View<T1, false, A>& v,
const T2& x,
Functor f,
T1* data
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinaryScalar<N-1, Functor, T1, T2, A>::operate(
v, x, f, data);
data += v.strid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x3, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x126aab
xorl %r13d, %r13d
movl $0x2, %esi
movq %rbx, %rdi
callq 0x11d5e0
testq %rax, %rax
je 0x126a67
xorl %ebp, %ebp
movq %r14, %r12
movq %rbx... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinaryScalar<(unsigned short)8, andres::marray_detail::MinusEqual<short, int>, short, int, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, int const&, andres::marray_detail::MinusEqual<short, int>, short*) | static inline void operate
(
View<T1, false, A>& v,
const T2& x,
Functor f,
T1* data
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinaryScalar<N-1, Functor, T1, T2, A>::operate(
v, x, f, data);
data += v.strid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x7, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x126d67
xorl %r13d, %r13d
movl $0x6, %esi
movq %rbx, %rdi
callq 0x11d5e0
testq %rax, %rax
je 0x126d23
xorl %ebp, %ebp
movq %r14, %r12
movq %rbx... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinaryScalar<(unsigned short)10, andres::marray_detail::MinusEqual<short, int>, short, int, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, int const&, andres::marray_detail::MinusEqual<short, int>, short*) | static inline void operate
(
View<T1, false, A>& v,
const T2& x,
Functor f,
T1* data
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinaryScalar<N-1, Functor, T1, T2, A>::operate(
v, x, f, data);
data += v.strid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x9, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x126ec5
xorl %r13d, %r13d
movl $0x8, %esi
movq %rbx, %rdi
callq 0x11d5e0
testq %rax, %rax
je 0x126e81
xorl %ebp, %ebp
movq %r14, %r12
movq %rbx... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)2, andres::marray_detail::MinusEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> const... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x126feb
xorl %r13d, %r13d
movq %r14, %rdi
xorl %esi, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x126f74
xorl %eb... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)3, andres::marray_detail::MinusEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> const... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x12709d
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x126eee
movl $0x2, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)5, andres::marray_detail::MinusEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> const... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x1271f5
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1270da
movl $0x4, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)6, andres::marray_detail::MinusEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> const... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x5, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x1272a1
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x127186
movl $0x5, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)7, andres::marray_detail::MinusEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> const... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x6, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x12734d
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x127232
movl $0x6, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)8, andres::marray_detail::MinusEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> const... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x7, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x1273f9
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1272de
movl $0x7, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)10, andres::marray_detail::MinusEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> cons... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x9, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x127551
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x127436
movl $0x9, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::marray_detail::operate<andres::marray_detail::TimesEqual<short, short>, short, std::allocator<unsigned long>>(andres::View<short, false, std::allocator<unsigned long>>&, short const&, andres::marray_detail::TimesEqual<short, short>) | inline void
operate
(
View<T, false, A>& v,
const T& x,
Functor f
)
{
if(v.isSimple()) {
T* data = &v(0);
for(std::size_t j=0; j<v.size(); ++j) {
f(data[j], x);
}
}
else if(v.dimension() == 1)
OperateHelperBinaryScalar<1, Functor, T, T, A>::operate(... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x11cea8
cmpb $0x1, 0x3c(%r14)
jne 0x1275e6
leaq 0x8(%rsp), %rsi
movl $0x0, (%rsi)
movq %r14, %rdi
callq 0x11ddbe
movq 0x30(%r14), %rcx
testq %rcx, %rcx
je 0x1278c3
xorl %edx, %edx
movzwl (%rax,%rdx,2), %esi
imulw (%rbx),... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinaryScalar<(unsigned short)2, andres::marray_detail::TimesEqual<short, short>, short, short, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, short const&, andres::marray_detail::TimesEqual<short, short>, short*) | static inline void operate
(
View<T1, false, A>& v,
const T2& x,
Functor f,
T1* data
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinaryScalar<N-1, Functor, T1, T2, A>::operate(
v, x, f, data);
data += v.strid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x1279d7
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x12799d
xorl %r13d, %r13d
movq %r14, %rbp
movzwl ... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinaryScalar<(unsigned short)4, andres::marray_detail::TimesEqual<short, short>, short, short, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, short const&, andres::marray_detail::TimesEqual<short, short>, short*) | static inline void operate
(
View<T1, false, A>& v,
const T2& x,
Functor f,
T1* data
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinaryScalar<N-1, Functor, T1, T2, A>::operate(
v, x, f, data);
data += v.strid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x3, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x127ab9
xorl %r13d, %r13d
movl $0x2, %esi
movq %rbx, %rdi
callq 0x11d5e0
testq %rax, %rax
je 0x127a75
xorl %ebp, %ebp
movq %r14, %r12
movq %rbx... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinaryScalar<(unsigned short)6, andres::marray_detail::TimesEqual<short, short>, short, short, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, short const&, andres::marray_detail::TimesEqual<short, short>, short*) | static inline void operate
(
View<T1, false, A>& v,
const T2& x,
Functor f,
T1* data
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinaryScalar<N-1, Functor, T1, T2, A>::operate(
v, x, f, data);
data += v.strid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x5, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x127c17
xorl %r13d, %r13d
movl $0x4, %esi
movq %rbx, %rdi
callq 0x11d5e0
testq %rax, %rax
je 0x127bd3
xorl %ebp, %ebp
movq %r14, %r12
movq %rbx... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinaryScalar<(unsigned short)10, andres::marray_detail::TimesEqual<short, short>, short, short, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, short const&, andres::marray_detail::TimesEqual<short, short>, short*) | static inline void operate
(
View<T1, false, A>& v,
const T2& x,
Functor f,
T1* data
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinaryScalar<N-1, Functor, T1, T2, A>::operate(
v, x, f, data);
data += v.strid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x9, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x127ed3
xorl %r13d, %r13d
movl $0x8, %esi
movq %rbx, %rdi
callq 0x11d5e0
testq %rax, %rax
je 0x127e8f
xorl %ebp, %ebp
movq %r14, %r12
movq %rbx... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::marray_detail::operate<andres::marray_detail::TimesEqual<short, int>, short, int, false, std::allocator<unsigned long>>(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> const&, andres::marray_detail::TimesEqual<short, int>) | inline void
operate
(
View<T1, false, A>& v,
const View<T2, isConst, A>& w,
Functor f
)
{
if(!MARRAY_NO_ARG_TEST) {
Assert(v.size() != 0 && w.size() != 0);
Assert(w.dimension() == 0 || v.dimension() == w.dimension());
if(w.dimension() != 0) {
for(std::size_t j=0; j... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpq $0x0, 0x30(%rdi)
je 0x128868
movq %rsi, %r14
cmpq $0x0, 0x30(%rsi)
je 0x128868
cmpq $0x0, (%r14)
je 0x128886
movq %rdi, %rbx
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x128066
cmpq $0x0, (%rbx)
je 0x1288a4
cmpq %rax, 0x28(%rbx)
jne ... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinaryScalar<(unsigned short)4, andres::marray_detail::TimesEqual<short, int>, short, int, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, int const&, andres::marray_detail::TimesEqual<short, int>, short*) | static inline void operate
(
View<T1, false, A>& v,
const T2& x,
Functor f,
T1* data
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinaryScalar<N-1, Functor, T1, T2, A>::operate(
v, x, f, data);
data += v.strid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x3, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x128b3b
xorl %r13d, %r13d
movl $0x2, %esi
movq %rbx, %rdi
callq 0x11d5e0
testq %rax, %rax
je 0x128af7
xorl %ebp, %ebp
movq %r14, %r12
movq %rbx... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinaryScalar<(unsigned short)6, andres::marray_detail::TimesEqual<short, int>, short, int, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, int const&, andres::marray_detail::TimesEqual<short, int>, short*) | static inline void operate
(
View<T1, false, A>& v,
const T2& x,
Functor f,
T1* data
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinaryScalar<N-1, Functor, T1, T2, A>::operate(
v, x, f, data);
data += v.strid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x5, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x128c99
xorl %r13d, %r13d
movl $0x4, %esi
movq %rbx, %rdi
callq 0x11d5e0
testq %rax, %rax
je 0x128c55
xorl %ebp, %ebp
movq %r14, %r12
movq %rbx... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinaryScalar<(unsigned short)10, andres::marray_detail::TimesEqual<short, int>, short, int, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, int const&, andres::marray_detail::TimesEqual<short, int>, short*) | static inline void operate
(
View<T1, false, A>& v,
const T2& x,
Functor f,
T1* data
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinaryScalar<N-1, Functor, T1, T2, A>::operate(
v, x, f, data);
data += v.strid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x9, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x128f55
xorl %r13d, %r13d
movl $0x8, %esi
movq %rbx, %rdi
callq 0x11d5e0
testq %rax, %rax
je 0x128f11
xorl %ebp, %ebp
movq %r14, %r12
movq %rbx... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)2, andres::marray_detail::TimesEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> const... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x129081
xorl %r13d, %r13d
movq %r14, %rdi
xorl %esi, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x12900a
xorl %eb... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)4, andres::marray_detail::TimesEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> const... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x3, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x1291df
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1290c4
movl $0x3, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)6, andres::marray_detail::TimesEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> const... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x5, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x129337
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x12921c
movl $0x5, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)7, andres::marray_detail::TimesEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> const... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x6, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x1293e3
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1292c8
movl $0x6, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)8, andres::marray_detail::TimesEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> const... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x7, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x12948f
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x129374
movl $0x7, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinaryScalar<(unsigned short)8, andres::marray_detail::DividedByEqual<short, int>, short, int, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, int const&, andres::marray_detail::DividedByEqual<short, int>, short*) | static inline void operate
(
View<T1, false, A>& v,
const T2& x,
Functor f,
T1* data
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinaryScalar<N-1, Functor, T1, T2, A>::operate(
v, x, f, data);
data += v.strid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x7, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x12ae9f
xorl %r13d, %r13d
movl $0x6, %esi
movq %rbx, %rdi
callq 0x11d5e0
testq %rax, %rax
je 0x12ae5b
xorl %ebp, %ebp
movq %r14, %r12
movq %rbx... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinaryScalar<(unsigned short)10, andres::marray_detail::DividedByEqual<short, int>, short, int, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, int const&, andres::marray_detail::DividedByEqual<short, int>, short*) | static inline void operate
(
View<T1, false, A>& v,
const T2& x,
Functor f,
T1* data
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinaryScalar<N-1, Functor, T1, T2, A>::operate(
v, x, f, data);
data += v.strid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x9, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x12affd
xorl %r13d, %r13d
movl $0x8, %esi
movq %rbx, %rdi
callq 0x11d5e0
testq %rax, %rax
je 0x12afb9
xorl %ebp, %ebp
movq %r14, %r12
movq %rbx... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)4, andres::marray_detail::DividedByEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> c... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x3, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x12b285
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x12b16a
movl $0x3, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)5, andres::marray_detail::DividedByEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> c... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x12b331
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x12b216
movl $0x4, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)6, andres::marray_detail::DividedByEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> c... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x5, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x12b3dd
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x12b2c2
movl $0x5, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)7, andres::marray_detail::DividedByEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> c... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x6, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x12b489
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x12b36e
movl $0x6, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)8, andres::marray_detail::DividedByEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> c... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x7, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x12b535
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x12b41a
movl $0x7, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::OperateHelperBinary<(unsigned short)10, andres::marray_detail::DividedByEqual<short, int>, short, int, false, std::allocator<unsigned long>, std::allocator<unsigned long>>::operate(andres::View<short, false, std::allocator<unsigned long>>&, andres::View<int, false, std::allocator<unsigned long>> ... | static inline void operate
(
View<T1, false, A1>& v,
const View<T2, isConst, A2>& w,
Functor f,
T1* data1,
const T2* data2
)
{
for(std::size_t j=0; j<v.shape(N-1); ++j) {
OperateHelperBinary<N-1, Functor, T1, T2, isConst, A1, A2>::operate(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl $0x9, %esi
callq 0x11d5e0
testq %rax, %rax
je 0x12b68d
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x12b572
movl $0x9, %esi
movq %r14, %rdi
callq 0x120b... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<MyTestType, false, std::allocator<unsigned long>>::assign<unsigned long*>(unsigned long*, unsigned long*, MyTestType*, andres::CoordinateOrder const&, andres::CoordinateOrder const&, std::allocator<MyTestType> const&) | inline void
View<T, isConst, A>::assign
(
ShapeIterator begin,
ShapeIterator end,
pointer data,
const CoordinateOrder& externalCoordinateOrder,
const CoordinateOrder& internalCoordinateOrder,
const allocator_type& allocator
)
{
// the invariant is not tested as a pre-condition of this
//... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rax
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %r9
movq %r12, %rdi
movq %r8, %rcx
movq %rax, %r8
callq 0x118e4a
leaq 0x8(%r14), %r15
cmpq %r15, %r12
je 0x12b788
movq 0x30(%rsp), %rax
movq 0x10(%r14), %rdi
movq 0x28(%r14),... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<MyTestType, false, std::allocator<unsigned long>>::testInvariant() const | inline const std::size_t
Geometry<A>::dimension() const
{
return dimension_;
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x12b83c
cmpq $0x0, (%rdi)
je 0x12b91d
movq 0x10(%rdi), %rcx
movl $0x1, %edx
xorl %esi, %esi
imulq (%rcx,%rsi,8), %rdx
incq %rsi
cmpq %rsi, %rax
jne 0x12b7fa
cmpq %rdx, 0x30(%rdi)
jne 0x12b93b
cmpl $0x0, 0x38(%rdi)
movq 0x18(%rdi), %rdx
movl $0x... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<MyTestType, false, std::allocator<unsigned long>>::view<unsigned long*, unsigned long*>(unsigned long*, unsigned long*, andres::View<MyTestType, false, std::allocator<unsigned long>>&) const | inline void
View<T, isConst, A>::view
(
BaseIterator bit,
ShapeIterator sit,
View<T, isConst, A>& out
) const
{
view(bit, sit, coordinateOrder(), out);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
callq 0x12b7d8
movq %r15, %rdi
callq 0x12b7d8
leaq 0x10(%rsp), %rdx
movq $0x0, (%rdx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x12ba54
movq (%r15), %r8
testq %r8, %r8
je 0x12ba0e
leaq 0x38(%r15), %... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<MyTestType, false, std::allocator<unsigned long>>::coordinatesToOffset<unsigned long*>(unsigned long*, unsigned long&) const | inline void
View<T, isConst, A>::coordinatesToOffset
(
CoordinateIterator it,
std::size_t& out
) const
{
testInvariant();
out = 0;
for(std::size_t j=0; j<this->dimension(); ++j, ++it) {
marray_detail::Assert(MARRAY_NO_ARG_TEST || static_cast<std::size_t>(*it) < shape(j));
out += stat... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x12b7d8
movq $0x0, (%rbx)
cmpq $0x0, (%r15)
je 0x12bab4
xorl %r12d, %r12d
cmpq 0x28(%r15), %r12
jae 0x12bad2
movq (%r14,%r12,8), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x12bc30
cmpq %rax, %r13
jae 0x12badc
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<MyTestType, false, std::allocator<unsigned long>>::assign<unsigned long*, unsigned long const*>(unsigned long*, unsigned long*, unsigned long const*, MyTestType*, andres::CoordinateOrder const&, std::allocator<MyTestType> const&) | inline void
View<T, isConst, A>::assign
(
ShapeIterator begin,
ShapeIterator end,
StrideIterator it,
pointer data,
const CoordinateOrder& internalCoordinateOrder,
const allocator_type& allocator
)
{
// the invariant is not tested as a pre-condition of this
// function to allow for unsafe... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rax
movq %r8, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %r9
movq %r12, %rdi
movq %rax, %r8
callq 0x1193ee
leaq 0x8(%r14), %r15
cmpq %r15, %r12
je 0x12bbdf
movq 0x30(%rsp), %rax
movq 0x10(%r14), %rdi
movq 0x28(%r14), %rcx
cmpq %rcx,... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<MyTestType, false, std::allocator<unsigned long>>::shape(unsigned long) const | inline const std::size_t
View<T, isConst, A>::shape
(
const std::size_t dimension
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || data_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || dimension < this->dimension());
return geometry_.shape(dimension);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x12b7d8
cmpq $0x0, (%r14)
je 0x12bc5b
cmpq %rbx, 0x28(%r14)
jbe 0x12bc79
movq 0x10(%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x270b0
movq %rax, %rbx
leaq 0xced3(%rip), %rsi # 0x138b42
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<MyTestType, false, std::allocator<unsigned long>>::strides(unsigned long) const | inline const std::size_t
View<T, isConst, A>::strides
(
const std::size_t dimension
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || data_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || dimension < this->dimension());
return geometry_.strides(dimension);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x12b7d8
cmpq $0x0, (%r14)
je 0x12bceb
cmpq %rbx, 0x28(%r14)
jbe 0x12bd09
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x270b0
movq %rax, %rbx
leaq 0xce43(%rip), %rsi # 0x138b42
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<unsigned char, false, std::allocator<unsigned long>>::assign<unsigned long*>(unsigned long*, unsigned long*, unsigned char*, andres::CoordinateOrder const&, andres::CoordinateOrder const&, std::allocator<unsigned char> const&) | inline void
View<T, isConst, A>::assign
(
ShapeIterator begin,
ShapeIterator end,
pointer data,
const CoordinateOrder& externalCoordinateOrder,
const CoordinateOrder& internalCoordinateOrder,
const allocator_type& allocator
)
{
// the invariant is not tested as a pre-condition of this
//... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rax
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %r9
movq %r12, %rdi
movq %r8, %rcx
movq %rax, %r8
callq 0x118e4a
leaq 0x8(%r14), %r15
cmpq %r15, %r12
je 0x12be0e
movq 0x30(%rsp), %rax
movq 0x10(%r14), %rdi
movq 0x28(%r14),... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<unsigned char, false, std::allocator<unsigned long>>::testInvariant() const | inline const std::size_t
Geometry<A>::dimension() const
{
return dimension_;
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x12bec2
cmpq $0x0, (%rdi)
je 0x12bfa3
movq 0x10(%rdi), %rcx
movl $0x1, %edx
xorl %esi, %esi
imulq (%rcx,%rsi,8), %rdx
incq %rsi
cmpq %rsi, %rax
jne 0x12be80
cmpq %rdx, 0x30(%rdi)
jne 0x12bfc1
cmpl $0x0, 0x38(%rdi)
movq 0x18(%rdi), %rdx
movl $0x... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::BinaryViewExpression<andres::View<unsigned char, false, std::allocator<unsigned long>>, unsigned char, andres::View<int, false, std::allocator<unsigned long>>, int, andres::marray_detail::Plus<unsigned char, int, int>>::BinaryViewExpression(andres::ViewExpression<andres::View<unsigned char, false, std::allocato... | BinaryViewExpression(const ViewExpression<E1, T1>& e1,
const ViewExpression<E2, T2>& e2)
: e1_(e1), e2_(e2), // cast!
binaryFunctor_(BinaryFunctor())
{
if(!MARRAY_NO_DEBUG) {
marray_detail::Assert(e1_.size() != 0 && e2_.size() != 0);
marra... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
cmpq $0x0, 0x30(%rsi)
je 0x12c0ed
cmpq $0x0, 0x30(%rdx)
je 0x12c0ed
cmpq $0x0, (%rsi)
je 0x12c10b
cmpq $0x0, (%rdx)
je 0x12c129
movq 0x28(%rsi), %rax
cmpq 0x28(%rdx), %rax
jne 0x12c147
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq 0x28(%rsi), %r14
jae 0x1... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<unsigned char, false, std::allocator<unsigned long>>::shape(unsigned long) const | inline const std::size_t
View<T, isConst, A>::shape
(
const std::size_t dimension
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || data_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || dimension < this->dimension());
return geometry_.shape(dimension);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x12be5e
cmpq $0x0, (%r14)
je 0x12c1b1
cmpq %rbx, 0x28(%r14)
jbe 0x12c1cf
movq 0x10(%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x270b0
movq %rax, %rbx
leaq 0xc97d(%rip), %rsi # 0x138b42
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<unsigned char, false, std::allocator<unsigned long>>::operator()(unsigned long) const | inline typename View<T, isConst, A>::reference
View<T, isConst, A>::operator()
(
const std::size_t value
) const
{
testInvariant();
if(dimension() == 0) {
marray_detail::Assert(MARRAY_NO_ARG_TEST || value == 0);
return data_[0];
}
else {
std::size_t offset;
indexT... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x12be5e
movq (%rbx), %rax
testq %rax, %rax
je 0x12c263
cmpq $0x0, 0x28(%rbx)
je 0x12c254
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x12c2c8
movq (%rbx), %rax
addq (%r15), %rax
jmp 0x12c259
testq %r1... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<unsigned char, false, std::allocator<unsigned long>>::indexToOffset(unsigned long, unsigned long&) const | inline void
View<T, isConst, A>::indexToOffset
(
std::size_t index,
std::size_t& out
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_ARG_TEST || index < this->size());
if(isSimple()) {
out = index;
}
else {
out = 0;
if(coordinateOrder() == FirstMajorOrder)... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x12be5e
cmpq %r15, 0x30(%r14)
jbe 0x12c451
movq %r14, %rdi
callq 0x12be5e
cmpb $0x1, 0x3c(%r14)
jne 0x12c2fd
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x12be5e
cmpl $0x0, 0x38(%r14)... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::BinaryViewExpression<andres::View<unsigned char, false, std::allocator<unsigned long>>, unsigned char, andres::View<int, false, std::allocator<unsigned long>>, int, andres::marray_detail::Minus<unsigned char, int, int>>::BinaryViewExpression(andres::ViewExpression<andres::View<unsigned char, false, std::allocat... | BinaryViewExpression(const ViewExpression<E1, T1>& e1,
const ViewExpression<E2, T2>& e2)
: e1_(e1), e2_(e2), // cast!
binaryFunctor_(BinaryFunctor())
{
if(!MARRAY_NO_DEBUG) {
marray_detail::Assert(e1_.size() != 0 && e2_.size() != 0);
marra... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
cmpq $0x0, 0x30(%rsi)
je 0x12c5ad
cmpq $0x0, 0x30(%rdx)
je 0x12c5ad
cmpq $0x0, (%rsi)
je 0x12c5cb
cmpq $0x0, (%rdx)
je 0x12c5e9
movq 0x28(%rsi), %rax
cmpq 0x28(%rdx), %rax
jne 0x12c607
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq 0x28(%rsi), %r14
jae 0x1... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::BinaryViewExpression<andres::View<int, false, std::allocator<unsigned long>>, int, andres::View<unsigned char, false, std::allocator<unsigned long>>, unsigned char, andres::marray_detail::Plus<int, unsigned char, int>>::BinaryViewExpression(andres::ViewExpression<andres::View<int, false, std::allocator<unsigned... | BinaryViewExpression(const ViewExpression<E1, T1>& e1,
const ViewExpression<E2, T2>& e2)
: e1_(e1), e2_(e2), // cast!
binaryFunctor_(BinaryFunctor())
{
if(!MARRAY_NO_DEBUG) {
marray_detail::Assert(e1_.size() != 0 && e2_.size() != 0);
marra... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
cmpq $0x0, 0x30(%rsi)
je 0x12c717
cmpq $0x0, 0x30(%rdx)
je 0x12c717
cmpq $0x0, (%rsi)
je 0x12c735
cmpq $0x0, (%rdx)
je 0x12c753
movq 0x28(%rsi), %rax
cmpq 0x28(%rdx), %rax
jne 0x12c771
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq 0x28(%rsi), %r14
jae 0x1... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<int, false, std::allocator<unsigned long>>::coordinatesToOffset<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, unsigned long&) const | inline void
View<T, isConst, A>::coordinatesToOffset
(
CoordinateIterator it,
std::size_t& out
) const
{
testInvariant();
out = 0;
for(std::size_t j=0; j<this->dimension(); ++j, ++it) {
marray_detail::Assert(MARRAY_NO_ARG_TEST || static_cast<std::size_t>(*it) < shape(j));
out += stat... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xe9fe4
movq $0x0, (%rbx)
cmpq $0x0, (%r15)
je 0x12c97a
xorl %r12d, %r12d
cmpq 0x28(%r15), %r12
jae 0x12c998
movq (%r14,%r12,8), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x44fd4
cmpq %rax, %r13
jae 0x12c9a2
mo... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<int, false, std::allocator<unsigned long>>::coordinatesToIndex<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, unsigned long&) const | inline void
View<T, isConst, A>::coordinatesToIndex
(
CoordinateIterator it,
std::size_t& out
) const
{
testInvariant();
out = 0;
for(std::size_t j=0; j<this->dimension(); ++j, ++it) {
marray_detail::Assert(MARRAY_NO_ARG_TEST || static_cast<std::size_t>(*it) < shape(j));
out += stat... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xe9fe4
movq $0x0, (%rbx)
cmpq $0x0, (%r15)
je 0x12ca4a
xorl %r12d, %r12d
cmpq 0x28(%r15), %r12
jae 0x12ca68
movq (%r14,%r12,8), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x44fd4
cmpq %rax, %r13
jae 0x12ca72
cm... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<int, true, std::allocator<unsigned long>>::coordinatesToIndex<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, unsigned long&) const | inline void
View<T, isConst, A>::coordinatesToIndex
(
CoordinateIterator it,
std::size_t& out
) const
{
testInvariant();
out = 0;
for(std::size_t j=0; j<this->dimension(); ++j, ++it) {
marray_detail::Assert(MARRAY_NO_ARG_TEST || static_cast<std::size_t>(*it) < shape(j));
out += stat... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xea468
movq $0x0, (%rbx)
cmpq $0x0, (%r15)
je 0x12cb3a
xorl %r12d, %r12d
cmpq 0x28(%r15), %r12
jae 0x12cb58
movq (%r14,%r12,8), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x4511a
cmpq %rax, %r13
jae 0x12cb62
cm... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<int, true, std::allocator<unsigned long>>::assign<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, __gnu_cxx::__normal_iterator<unsigned long... | inline void
View<T, isConst, A>::assign
(
ShapeIterator begin,
ShapeIterator end,
pointer data,
const CoordinateOrder& externalCoordinateOrder,
const CoordinateOrder& internalCoordinateOrder,
const allocator_type& allocator
)
{
// the invariant is not tested as a pre-condition of this
//... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rax
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %r9
movq %r12, %rdi
movq %r8, %rcx
movq %rax, %r8
callq 0xea8ec
leaq 0x8(%r14), %r15
cmpq %r15, %r12
je 0x12cc88
movq 0x30(%rsp), %rax
movq 0x10(%r14), %rdi
movq 0x28(%r14), ... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<int, true, std::allocator<unsigned long>>::assign<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, __gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(__gnu_cxx::__normal_iterator<unsigned long... | inline void
View<T, isConst, A>::assign
(
ShapeIterator begin,
ShapeIterator end,
StrideIterator it,
pointer data,
const CoordinateOrder& internalCoordinateOrder,
const allocator_type& allocator
)
{
// the invariant is not tested as a pre-condition of this
// function to allow for unsafe... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rax
movq %r8, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %r9
movq %r12, %rdi
movq %rax, %r8
callq 0xf2002
leaq 0x8(%r14), %r15
cmpq %r15, %r12
je 0x12d023
movq 0x30(%rsp), %rax
movq 0x10(%r14), %rdi
movq 0x28(%r14), %rcx
cmpq %rcx, ... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, false, std::allocator<unsigned long>>::operator=(int const&) | inline View<T, isConst, A>&
View<T, isConst, A>::operator=
(
const T& value
)
{
marray_detail::Assert(MARRAY_NO_DEBUG || data_ != 0);
if(isSimple()) {
for(std::size_t j=0; j<geometry_.size(); ++j) {
data_[j] = value;
}
}
else if(dimension() == 1)
marray_detail::O... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
cmpq $0x0, (%rdi)
je 0x12d3b9
movq %rsi, %r14
movq %rdi, %rbx
callq 0xe9fe4
cmpb $0x1, 0x3c(%rbx)
jne 0x12d1a1
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0x12d3a9
movq (%rbx), %rax
movl (%r14), %ecx
leaq 0x3(%rsi), %rdx
andq $-0x4, %rdx
decq %rsi
mo... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::marray_detail::AssignmentOperatorHelper<false, int, int, std::allocator<unsigned long>, std::allocator<unsigned long>>::execute(andres::View<int, true, std::allocator<unsigned long>> const&, andres::View<int, false, std::allocator<unsigned long>>&) | static void execute
(
const View<TFrom, true, AFrom>& from,
View<TTo, false, ATo>& to
)
{
typedef typename View<TFrom, true, AFrom>::const_iterator FromIterator;
typedef typename View<TTo, false, ATo>::iterator ToIterator;
if(!MARRAY_NO_ARG_TEST) {
Assert(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpq $0x0, (%rdi)
je 0x12d9aa
movq %rsi, %rbx
cmpq $0x0, (%rsi)
je 0x12d9c8
movq %rdi, %r14
movq 0x28(%rdi), %rax
cmpq 0x28(%rbx), %rax
jne 0x12d9aa
xorl %r15d, %r15d
cmpq 0x28(%r14), %r15
jae 0x12d4c5
movq %r14, %rdi
movq %r15, %rsi
cal... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::marray_detail::AssignmentOperatorHelper<true, int, int, std::allocator<unsigned long>, std::allocator<unsigned long>>::execute<true>(andres::View<int, true, std::allocator<unsigned long>> const&, andres::View<int, true, std::allocator<unsigned long>>&) | static void execute
(
const View<TFrom, isConstFrom, AFrom>& from,
View<TTo, true, ATo>& to
)
{
Assert(MARRAY_NO_ARG_TEST || sizeof(TFrom) == sizeof(TTo));
to.data_ = static_cast<const TTo*>(
static_cast<const void*>(from.data_)); // copy pointer
to.geomet... | movq (%rdi), %rax
movq %rax, (%rsi)
cmpq %rsi, %rdi
je 0x12dba7
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rax
movq 0x10(%rsi), %rdi
movq 0x28(%rsi), %rcx
cmpq %rcx, %rax
je 0x12db7b
leaq 0x8(%rbx), %r15
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rsi
callq 0x271a0
movq 0x28(%r14), %rax... | /bjoern-andres[P]marray/include/andres/marray.hxx |
int& andres::View<int, false, std::allocator<unsigned long>>::operator()<int>(unsigned long, int const) const | inline typename View<T, isConst, A>::reference
View<T, isConst, A>::operator()
(
const std::size_t value,
const Args... args
) const
{
testInvariant();
marray_detail::Assert( MARRAY_NO_DEBUG || ( data_ != 0 && sizeof...(args)+1 == dimension() ) );
return data_[ strides(0) * static_cast<std::size_t>... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xe9fe4
movq (%rbx), %r12
testq %r12, %r12
je 0x12dc1d
cmpq $0x2, 0x28(%rbx)
jne 0x12dc1d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xeaae4
movq %rax, %r15
movslq %ebp, %r13
movl $0x1, %esi
mov... | /bjoern-andres[P]marray/include/andres/marray.hxx |
int& andres::View<int, false, std::allocator<unsigned long>>::operator()<int, int, int>(unsigned long, int const, int const, int const) | inline typename View<T, isConst, A>::reference
View<T, isConst, A>::operator()
(
const std::size_t value,
const Args... args
)
{
testInvariant();
marray_detail::Assert( MARRAY_NO_DEBUG || ( data_ != 0 && sizeof...(args)+1 == dimension() ) );
return data_[strides(0)*value + elementAccessHelper(sizeo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, 0x4(%rsp)
movl %ecx, %ebp
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %r14
callq 0xe9fe4
movq (%r14), %rbx
testq %rbx, %rbx
je 0x12dd1a
cmpq $0x4, 0x28(%r14)
jne 0x12dd1a
movq %r14, %rdi
xorl %esi, %esi
callq 0xeaae4
movq %rax, %r12... | /bjoern-andres[P]marray/include/andres/marray.hxx |
int& andres::View<int, false, std::allocator<unsigned long>>::operator()<int, int, int>(unsigned long, int const, int const, int const) const | inline typename View<T, isConst, A>::reference
View<T, isConst, A>::operator()
(
const std::size_t value,
const Args... args
) const
{
testInvariant();
marray_detail::Assert( MARRAY_NO_DEBUG || ( data_ != 0 && sizeof...(args)+1 == dimension() ) );
return data_[ strides(0) * static_cast<std::size_t>... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, 0x4(%rsp)
movl %ecx, %ebp
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %r14
callq 0xe9fe4
movq (%r14), %rbx
testq %rbx, %rbx
je 0x12de18
cmpq $0x4, 0x28(%r14)
jne 0x12de18
movq %r14, %rdi
xorl %esi, %esi
callq 0xeaae4
movq %rax, %r12... | /bjoern-andres[P]marray/include/andres/marray.hxx |
unsigned long andres::View<int, false, std::allocator<unsigned long>>::elementAccessHelper<int>(unsigned long, unsigned long, int const) const | inline std::size_t
View<T, isConst, A>::elementAccessHelper
(
const std::size_t Dim,
const std::size_t value,
const Args... args
) const
{
marray_detail::Assert(MARRAY_NO_ARG_TEST || (value < shape(Dim-1-sizeof...(args)) ) );
return value * strides(Dim-1-sizeof...(args)) + elementAccessHelper(Di... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x2(%rsi), %r12
movq %r12, %rsi
callq 0x44fd4
cmpq %r15, %rax
jbe 0x12dfa2
movq %r14, %rdi
movq %r12, %rsi
callq 0xeaae4
movq %rax, %r12
movslq %ebp, %r13
decq %rbx
movq %r1... | /bjoern-andres[P]marray/include/andres/marray.hxx |
int const& andres::View<int, true, std::allocator<unsigned long>>::operator()<int, int, int>(unsigned long, int const, int const, int const) const | inline typename View<T, isConst, A>::reference
View<T, isConst, A>::operator()
(
const std::size_t value,
const Args... args
) const
{
testInvariant();
marray_detail::Assert( MARRAY_NO_DEBUG || ( data_ != 0 && sizeof...(args)+1 == dimension() ) );
return data_[ strides(0) * static_cast<std::size_t>... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, 0x4(%rsp)
movl %ecx, %ebp
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %r14
callq 0xea468
movq (%r14), %rbx
testq %rbx, %rbx
je 0x12e278
cmpq $0x4, 0x28(%r14)
jne 0x12e278
movq %r14, %rdi
xorl %esi, %esi
callq 0xeab74
movq %rax, %r12... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, true, std::allocator<unsigned long>>::reference andres::marray_detail::AccessOperatorHelper<false>::execute<int, __gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, true, std::allocator<unsigned long>>(andres::View<int, true, std::allocator<unsigned... | static typename View<T, isConst, A>::reference
execute(const View<T, isConst, A>& v, U it)
{
v.testInvariant();
Assert(MARRAY_NO_DEBUG || v.data_ != 0);
Assert(MARRAY_NO_DEBUG || v.dimension() != 0 || *it == 0);
std::size_t offset;
v.coordinatesToOffset(it, offset);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xea468
cmpq $0x0, (%rbx)
je 0x12e32c
cmpq $0x0, 0x28(%rbx)
jne 0x12e305
cmpq $0x0, (%r14)
jne 0x12e34a
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xead9c
movq (%r15), %rax
shlq $0x2, %rax
addq (%rbx)... | /bjoern-andres[P]marray/include/andres/marray.hxx |
unsigned long andres::View<int, true, std::allocator<unsigned long>>::elementAccessHelper<int>(unsigned long, unsigned long, int const) const | inline std::size_t
View<T, isConst, A>::elementAccessHelper
(
const std::size_t Dim,
const std::size_t value,
const Args... args
) const
{
marray_detail::Assert(MARRAY_NO_ARG_TEST || (value < shape(Dim-1-sizeof...(args)) ) );
return value * strides(Dim-1-sizeof...(args)) + elementAccessHelper(Di... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x2(%rsi), %r12
movq %r12, %rsi
callq 0x4511a
cmpq %r15, %rax
jbe 0x12e402
movq %r14, %rdi
movq %r12, %rsi
callq 0xeab74
movq %rax, %r12
movslq %ebp, %r13
decq %rbx
movq %r1... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<int, false, std::allocator<unsigned long>>::view<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, __gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(__gnu_cxx::__normal_iterator<unsigned long*... | inline void
View<T, isConst, A>::view
(
BaseIterator bit,
ShapeIterator sit,
View<T, isConst, A>& out
) const
{
view(bit, sit, coordinateOrder(), out);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
callq 0xe9fe4
movq %r15, %rdi
callq 0xe9fe4
leaq 0x10(%rsp), %rdx
movq $0x0, (%rdx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x12c91a
movq (%r15), %rax
testq %rax, %rax
je 0x12e4e4
leaq 0x38(%r15), ... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<int, false, std::allocator<unsigned long>>::assign<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, unsigned long const*>(__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, __gnu_cxx::__normal... | inline void
View<T, isConst, A>::assign
(
ShapeIterator begin,
ShapeIterator end,
StrideIterator it,
pointer data,
const CoordinateOrder& internalCoordinateOrder,
const allocator_type& allocator
)
{
// the invariant is not tested as a pre-condition of this
// function to allow for unsafe... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rax
movq %r8, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %r9
movq %r12, %rdi
movq %rax, %r8
callq 0xeaf78
leaq 0x8(%r14), %r15
cmpq %r15, %r12
je 0x12e5e5
movq 0x30(%rsp), %rax
movq 0x10(%r14), %rdi
movq 0x28(%r14), %rcx
cmpq %rcx, ... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<int, true, std::allocator<unsigned long>>::view<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, __gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(__gnu_cxx::__normal_iterator<unsigned long*,... | inline void
View<T, isConst, A>::view
(
BaseIterator bit,
ShapeIterator sit,
View<T, isConst, A>& out
) const
{
view(bit, sit, coordinateOrder(), out);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
callq 0xea468
movq %r15, %rdi
callq 0xea468
leaq 0x10(%rsp), %rdx
movq $0x0, (%rdx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xead9c
movq (%r15), %rax
testq %rax, %rax
je 0x12e6b2
leaq 0x38(%r15), %... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Iterator<int, false, std::allocator<unsigned long>>::operator--() | inline Iterator<T, isConst, A>&
Iterator<T, isConst, A>::operator--()
{
marray_detail::Assert(MARRAY_NO_DEBUG || (view_ != 0 && index_ > 0));
--index_;
if(view_->isSimple()) {
--pointer_;
}
else {
if(index_ == view_->size()) {
// decrement from end iterator
-... | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x12e890
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x12e890
decq %rax
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0xe9fe4
cmpb $0x1, 0x3c(%r14)
jne 0x12e738
addq $-0x4, 0x8(%rbx)
jmp 0x12e87d
movq (%rbx), %r14
movq 0x10(%rbx), %rax
c... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, false, std::allocator<unsigned long>>::boundView(unsigned long, unsigned long) const | View<T, isConst, A>
View<T, isConst, A>::boundView
(
const std::size_t dimension,
const std::size_t value
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_ARG_TEST || (dimension < this->dimension()
&& value < shape(dimension)));
if(this->dimension() == 1) {
View v(&((*this)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xe9fe4
cmpq $0x0, (%r14)
je 0x12f4c0
cmpq %r12, 0x28(%r14)
jbe 0x12f4a2
movq %r14, %rdi
movq %r12, %rsi
callq 0x44fd4
cmpq %r15, %rax
jbe 0x12f4a2
cmp... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, false, std::allocator<unsigned long>>::squeeze() | void
View<T, isConst, A>::squeeze()
{
testInvariant();
if(dimension() != 0) {
std::size_t newDimension = dimension();
for(std::size_t j=0; j<dimension(); ++j) {
if(shape(j) == 1) {
--newDimension;
}
}
if(newDimension != dimension()) {
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xe9fe4
cmpq $0x0, (%rbx)
je 0x12f7cd
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x12f734
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x44fd4
cmpq $0x0, (%rbx)
je 0x12f741
incq %r15
xorl %ecx, %ecx
cmpq $0x1, %rax
sete %cl
subq %rcx, %r14
movq 0x28(%rbx)... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, true, std::allocator<unsigned long>>::boundView(unsigned long, unsigned long) const | View<T, isConst, A>
View<T, isConst, A>::boundView
(
const std::size_t dimension,
const std::size_t value
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_ARG_TEST || (dimension < this->dimension()
&& value < shape(dimension)));
if(this->dimension() == 1) {
View v(&((*this)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xea468
cmpq $0x0, (%r14)
je 0x12fb36
cmpq %r12, 0x28(%r14)
jbe 0x12fb18
movq %r14, %rdi
movq %r12, %rsi
callq 0x4511a
cmpq %r15, %rax
jbe 0x12fb18
cmp... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, true, std::allocator<unsigned long>>::squeeze() | void
View<T, isConst, A>::squeeze()
{
testInvariant();
if(dimension() != 0) {
std::size_t newDimension = dimension();
for(std::size_t j=0; j<dimension(); ++j) {
if(shape(j) == 1) {
--newDimension;
}
}
if(newDimension != dimension()) {
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xea468
cmpq $0x0, (%rbx)
je 0x12fe43
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x12fdaa
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4511a
cmpq $0x0, (%rbx)
je 0x12fdb7
incq %r15
xorl %ecx, %ecx
cmpq $0x1, %rax
sete %cl
subq %rcx, %r14
movq 0x28(%rbx)... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, false, std::allocator<unsigned long>>::transpose(unsigned long, unsigned long) | void
View<T, isConst, A>::transpose
(
const std::size_t c1,
const std::size_t c2
)
{
testInvariant();
marray_detail::Assert(MARRAY_NO_ARG_TEST ||
(dimension() != 0 && c1 < dimension() && c2 < dimension()));
std::size_t j1 = c1;
std::size_t j2 = c2;
std::size_t c;
std::size_t d;
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0xe9fe4
cmpq $0x0, (%rbx)
je 0x12ffc5
movq 0x28(%rbx), %rax
cmpq %r14, %rax
jbe 0x12ffe6
cmpq %r15, %rax
jbe 0x12ffe6
movq 0x10(%rbx), %rcx
movq (%rcx,%r15,8), %rax
movq (%rcx,%r14,8), %rdx
movq %rdx, (%rcx,%r15,8)
cmpq %r14, 0x28(%r... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, true, std::allocator<unsigned long>>::transpose(unsigned long, unsigned long) | void
View<T, isConst, A>::transpose
(
const std::size_t c1,
const std::size_t c2
)
{
testInvariant();
marray_detail::Assert(MARRAY_NO_ARG_TEST ||
(dimension() != 0 && c1 < dimension() && c2 < dimension()));
std::size_t j1 = c1;
std::size_t j2 = c2;
std::size_t c;
std::size_t d;
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0xea468
cmpq $0x0, (%rbx)
je 0x1301f3
movq 0x28(%rbx), %rax
cmpq %r14, %rax
jbe 0x130214
cmpq %r15, %rax
jbe 0x130214
movq 0x10(%rbx), %rcx
movq (%rcx,%r15,8), %rax
movq (%rcx,%r14,8), %rdx
movq %rdx, (%rcx,%r15,8)
cmpq %r14, 0x28(%r... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<int, false, std::allocator<unsigned long>>::permute<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>) | void
View<T, isConst, A>::permute
(
CoordinateIterator begin
)
{
testInvariant();
if(!MARRAY_NO_ARG_TEST) {
marray_detail::Assert(dimension() != 0);
std::set<std::size_t> s1, s2;
CoordinateIterator it = begin;
for(std::size_t j=0; j<dimension(); ++j) {
s1.insert(j... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0xe9fe4
cmpq $0x0, (%rbx)
je 0x1306cd
cmpq $0x0, 0x28(%rbx)
je 0x1306eb
leaq 0x40(%rsp), %rcx
xorl %eax, %eax
movl %eax, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<int, true, std::allocator<unsigned long>>::permute<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>) | void
View<T, isConst, A>::permute
(
CoordinateIterator begin
)
{
testInvariant();
if(!MARRAY_NO_ARG_TEST) {
marray_detail::Assert(dimension() != 0);
std::set<std::size_t> s1, s2;
CoordinateIterator it = begin;
for(std::size_t j=0; j<dimension(); ++j) {
s1.insert(j... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0xea468
cmpq $0x0, (%rbx)
je 0x130dbd
cmpq $0x0, 0x28(%rbx)
je 0x130ddb
leaq 0x40(%rsp), %rcx
xorl %eax, %eax
movl %eax, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, false, std::allocator<unsigned long>>::shift(int) | inline void
View<T, isConst, A>::shift
(
const int n
)
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || dimension() != 0);
if(n <= -static_cast<int>(dimension()) || n >= static_cast<int>(dimension())) {
shift(n % static_cast<int>(dimension()));
}
else {
if(n > 0) {
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0xe9fe4
cmpq $0x0, (%rbx)
je 0x131004
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x131022
movl %esi, %eax
negl %eax
cmpl %r14d, %eax
setl %cl
movl %r14d, %eax
subl %esi, %eax
setl %dl
testb %dl, %cl
je 0x130f77
testl %r14d, %r14d
jle 0x130f97
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, true, std::allocator<unsigned long>>::shift(int) | inline void
View<T, isConst, A>::shift
(
const int n
)
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || dimension() != 0);
if(n <= -static_cast<int>(dimension()) || n >= static_cast<int>(dimension())) {
shift(n % static_cast<int>(dimension()));
}
else {
if(n > 0) {
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0xea468
cmpq $0x0, (%rbx)
je 0x1311a4
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x1311c2
movl %esi, %eax
negl %eax
cmpl %r14d, %eax
setl %cl
movl %r14d, %eax
subl %esi, %eax
setl %dl
testb %dl, %cl
je 0x131117
testl %r14d, %r14d
jle 0x131137
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, true, std::allocator<unsigned long>>::asString[abi:cxx11](andres::StringStyle const&) const | std::string
View<T, isConst, A>::asString
(
const StringStyle& style
) const
{
testInvariant();
std::ostringstream out(std::ostringstream::out);
if(style == MatrixStyle) {
if(dimension() == 0) {
// scalar
out << "A = " << (*this)(0) << std::endl;
}
else i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, 0x68(%rsp)
movq %rsi, %rdi
callq 0xea468
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movl $0x10, %esi
callq 0x27160
movl (%rbx), %eax
testl %eax, %eax
je 0x131331
cmpl $0x1, ... | /bjoern-andres[P]marray/include/andres/marray.hxx |
int const& andres::View<int, true, std::allocator<unsigned long>>::operator()<unsigned long>(unsigned long, unsigned long const) const | inline typename View<T, isConst, A>::reference
View<T, isConst, A>::operator()
(
const std::size_t value,
const Args... args
) const
{
testInvariant();
marray_detail::Assert( MARRAY_NO_DEBUG || ( data_ != 0 && sizeof...(args)+1 == dimension() ) );
return data_[ strides(0) * static_cast<std::size_t>... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xea468
movq (%r14), %r13
testq %r13, %r13
je 0x131dbb
cmpq $0x2, 0x28(%r14)
jne 0x131dbb
movq %r14, %rdi
xorl %esi, %esi
callq 0xeab74
movq %rax, %r12
movl $0x1, %esi
movq %r14, %rdi
callq 0x4511a
cmpq %rbx, %r... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::Iterator<int, true, std::allocator<unsigned long>>::coordinate<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>) const | inline void
Iterator<T, isConst, A>::coordinate
(
CoordinateIterator it
) const
{
marray_detail::Assert(MARRAY_NO_DEBUG || view_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || index_ < view_->size());
if(view_->isSimple()) {
view_->indexToCoordinates(index_, it);
}
else {
for... | pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x131e91
movq %rdi, %r14
movq 0x10(%rdi), %rax
cmpq 0x30(%r15), %rax
jae 0x131eaf
movq %rsi, %rbx
movq %r15, %rdi
callq 0xea468
cmpb $0x0, 0x3c(%r15)
je 0x131e60
movq (%r14), %rdi
movq 0x10(%r14), %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
j... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<int, false, std::allocator<unsigned long>>::asString[abi:cxx11](andres::StringStyle const&) const | std::string
View<T, isConst, A>::asString
(
const StringStyle& style
) const
{
testInvariant();
std::ostringstream out(std::ostringstream::out);
if(style == MatrixStyle) {
if(dimension() == 0) {
// scalar
out << "A = " << (*this)(0) << std::endl;
}
else i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, 0x68(%rsp)
movq %rsi, %rdi
callq 0xe9fe4
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movl $0x10, %esi
callq 0x27160
movl (%rbx), %eax
testl %eax, %eax
je 0x131fbb
cmpl $0x1, ... | /bjoern-andres[P]marray/include/andres/marray.hxx |
int& andres::View<int, false, std::allocator<unsigned long>>::operator()<unsigned long>(unsigned long, unsigned long const) const | inline typename View<T, isConst, A>::reference
View<T, isConst, A>::operator()
(
const std::size_t value,
const Args... args
) const
{
testInvariant();
marray_detail::Assert( MARRAY_NO_DEBUG || ( data_ != 0 && sizeof...(args)+1 == dimension() ) );
return data_[ strides(0) * static_cast<std::size_t>... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xe9fe4
movq (%r14), %r13
testq %r13, %r13
je 0x132a45
cmpq $0x2, 0x28(%r14)
jne 0x132a45
movq %r14, %rdi
xorl %esi, %esi
callq 0xeaae4
movq %rax, %r12
movl $0x1, %esi
movq %r14, %rdi
callq 0x44fd4
cmpq %rbx, %r... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Iterator<int, true, std::allocator<unsigned long>>::Iterator(andres::View<int, false, std::allocator<unsigned long>>&, unsigned long) | inline Iterator<T, isConst, A>::Iterator
(
View<T, false, A>& view,
const std::size_t index
)
: view_(reinterpret_cast<view_pointer>(&view)),
pointer_(0),
index_(index),
coordinates_(std::vector<std::size_t>(view.dimension()))
// Note for developers: If isConst==true, the construction
// v... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
cmpq $0x0, (%rsi)
je 0x132c7d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq 0x28(%rsi), %rsi
leaq 0xb(%rsp), %rdx
movq %r14, %rdi
callq 0x44d3e
cmpq $0x0, 0x3... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Iterator<TestType, false, std::allocator<unsigned long>>::operator++() | inline Iterator<T, isConst, A>&
Iterator<T, isConst, A>::operator++()
{
marray_detail::Assert(MARRAY_NO_DEBUG || view_ != 0);
if(index_ < view_->size()) { // view initialized and iterator not at the end
++index_;
if(view_->isSimple()) {
++pointer_;
}
else {
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x132efe
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq 0x30(%r14), %rax
jae 0x132ee7
incq %rax
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x13316e
cmpb $0x1, 0x3c(%r14)
jne 0x132d9f
addq $0x8, 0x8(%rbx)
jmp 0x132ee7
movq (%rbx), ... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Iterator<TestType, true, std::allocator<unsigned long>>::operator++() | inline Iterator<T, isConst, A>&
Iterator<T, isConst, A>::operator++()
{
marray_detail::Assert(MARRAY_NO_DEBUG || view_ != 0);
if(index_ < view_->size()) { // view initialized and iterator not at the end
++index_;
if(view_->isSimple()) {
++pointer_;
}
else {
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x133108
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq 0x30(%r14), %rax
jae 0x1330f1
incq %rax
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x134110
cmpb $0x1, 0x3c(%r14)
jne 0x132fa9
addq $0x8, 0x8(%rbx)
jmp 0x1330f1
movq (%rbx), ... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<TestType, false, std::allocator<unsigned long>>::testInvariant() const | inline const std::size_t
Geometry<A>::dimension() const
{
return dimension_;
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1331d2
cmpq $0x0, (%rdi)
je 0x1332b3
movq 0x10(%rdi), %rcx
movl $0x1, %edx
xorl %esi, %esi
imulq (%rcx,%rsi,8), %rdx
incq %rsi
cmpq %rsi, %rax
jne 0x133190
cmpq %rdx, 0x30(%rdi)
jne 0x1332d1
cmpl $0x0, 0x38(%rdi)
movq 0x18(%rdi), %rdx
movl $0x... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Iterator<TestType, false, std::allocator<unsigned long>>::Iterator(andres::View<TestType, false, std::allocator<unsigned long>>&, unsigned long) | inline Iterator<T, isConst, A>::Iterator
(
View<T, false, A>& view,
const std::size_t index
)
: view_(reinterpret_cast<view_pointer>(&view)),
pointer_(0),
index_(index),
coordinates_(std::vector<std::size_t>(view.dimension()))
// Note for developers: If isConst==true, the construction
// v... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
cmpq $0x0, (%rsi)
je 0x1334ff
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq 0x28(%rsi), %rsi
leaq 0xb(%rsp), %rdx
movq %r14, %rdi
callq 0x44d3e
cmpq $0x0, 0x3... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<TestType, false, std::allocator<unsigned long>>::shape(unsigned long) const | inline const std::size_t
View<T, isConst, A>::shape
(
const std::size_t dimension
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || data_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || dimension < this->dimension());
return geometry_.shape(dimension);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x13316e
cmpq $0x0, (%r14)
je 0x133607
cmpq %rbx, 0x28(%r14)
jbe 0x133625
movq 0x10(%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x270b0
movq %rax, %rbx
leaq 0x5527(%rip), %rsi # 0x138b42
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<TestType, false, std::allocator<unsigned long>>::indexToCoordinates<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(unsigned long, __gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>) const | inline void
View<T, isConst, A>::indexToCoordinates
(
std::size_t index, // copy to work on
CoordinateIterator outit
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || this->dimension() > 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || index < this->size());
if(coordinateOrder()... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x13316e
cmpq $0x0, (%r14)
je 0x133898
cmpq $0x0, 0x28(%r14)
je 0x1338b6
cmpq %r15, 0x30(%r14)
jbe 0x1338d4
movq %r14, %rdi
callq 0x13316e
cmpl $0x0, 0x38(%r14)
movq (%r14), %rax
je 0x133802
testq %rax, %rax
je 0x1338f2
movq 0x28(%r1... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<TestType, false, std::allocator<unsigned long>>::reference andres::marray_detail::AccessOperatorHelper<true>::execute<TestType, int, false, std::allocator<unsigned long>>(andres::View<TestType, false, std::allocator<unsigned long>> const&, int const&) | static typename View<T, isConst, A>::reference
execute(const View<T, isConst, A>& v, const U& index)
{
v.testInvariant();
Assert(MARRAY_NO_DEBUG || v.data_ != 0);
Assert(MARRAY_NO_DEBUG || v.dimension() != 0 || index == 0);
std::size_t offset;
v.indexToOffset(index, offse... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x13316e
cmpq $0x0, (%rbx)
je 0x133e06
cmpq $0x0, 0x28(%rbx)
setne %cl
movl (%r14), %eax
testl %eax, %eax
sete %dl
orb %cl, %dl
je 0x133e24
movslq %eax, %rsi
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x133e6c
movq (%r14), %rax
shlq $0x3,... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<TestType, false, std::allocator<unsigned long>>::indexToOffset(unsigned long, unsigned long&) const | inline void
View<T, isConst, A>::indexToOffset
(
std::size_t index,
std::size_t& out
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_ARG_TEST || index < this->size());
if(isSimple()) {
out = index;
}
else {
out = 0;
if(coordinateOrder() == FirstMajorOrder)... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x13316e
cmpq %r15, 0x30(%r14)
jbe 0x133ff5
movq %r14, %rdi
callq 0x13316e
cmpb $0x1, 0x3c(%r14)
jne 0x133ea1
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x13316e
cmpl $0x0, 0x38(%r14)... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<TestType, false, std::allocator<unsigned long>>::strides(unsigned long) const | inline const std::size_t
View<T, isConst, A>::strides
(
const std::size_t dimension
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || data_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || dimension < this->dimension());
return geometry_.strides(dimension);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x13316e
cmpq $0x0, (%r14)
je 0x1340ab
cmpq %rbx, 0x28(%r14)
jbe 0x1340c9
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x270b0
movq %rax, %rbx
leaq 0x4a83(%rip), %rsi # 0x138b42
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<TestType, true, std::allocator<unsigned long>>::testInvariant() const | inline const std::size_t
Geometry<A>::dimension() const
{
return dimension_;
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x134174
cmpq $0x0, (%rdi)
je 0x134255
movq 0x10(%rdi), %rcx
movl $0x1, %edx
xorl %esi, %esi
imulq (%rcx,%rsi,8), %rdx
incq %rsi
cmpq %rsi, %rax
jne 0x134132
cmpq %rdx, 0x30(%rdi)
jne 0x134273
cmpl $0x0, 0x38(%rdi)
movq 0x18(%rdi), %rdx
movl $0x... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Iterator<TestType, true, std::allocator<unsigned long>>::Iterator(andres::View<TestType, true, std::allocator<unsigned long>> const&, unsigned long) | inline Iterator<T, isConst, A>::Iterator
(
const View<T, true, A>& view,
const std::size_t index
)
: view_(&view),
pointer_(0),
index_(index),
coordinates_(std::vector<std::size_t>(view.dimension()))
// Note for developers: If isConst==false, the construction view_(&view)
// fails due to i... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
cmpq $0x0, (%rsi)
je 0x1344a1
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq 0x28(%rsi), %rsi
leaq 0xb(%rsp), %rdx
movq %r14, %rdi
callq 0x44d3e
cmpq $0x0, 0x3... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<TestType, true, std::allocator<unsigned long>>::shape(unsigned long) const | inline const std::size_t
View<T, isConst, A>::shape
(
const std::size_t dimension
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || data_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || dimension < this->dimension());
return geometry_.shape(dimension);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x134110
cmpq $0x0, (%r14)
je 0x1345a9
cmpq %rbx, 0x28(%r14)
jbe 0x1345c7
movq 0x10(%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x270b0
movq %rax, %rbx
leaq 0x4585(%rip), %rsi # 0x138b42
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<TestType, true, std::allocator<unsigned long>>::operator()(unsigned long) const | inline typename View<T, isConst, A>::reference
View<T, isConst, A>::operator()
(
const std::size_t value
) const
{
testInvariant();
if(dimension() == 0) {
marray_detail::Assert(MARRAY_NO_ARG_TEST || value == 0);
return data_[0];
}
else {
std::size_t offset;
indexT... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x134110
movq (%rbx), %rax
testq %rax, %rax
je 0x13465f
cmpq $0x0, 0x28(%rbx)
je 0x134650
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x134e0e
movq (%r15), %rax
shlq $0x3, %rax
addq (%rbx), %rax
jmp 0x... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<TestType, true, std::allocator<unsigned long>>::indexToCoordinates<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(unsigned long, __gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>) const | inline void
View<T, isConst, A>::indexToCoordinates
(
std::size_t index, // copy to work on
CoordinateIterator outit
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || this->dimension() > 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || index < this->size());
if(coordinateOrder()... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x134110
cmpq $0x0, (%r14)
je 0x13483a
cmpq $0x0, 0x28(%r14)
je 0x134858
cmpq %r15, 0x30(%r14)
jbe 0x134876
movq %r14, %rdi
callq 0x134110
cmpl $0x0, 0x38(%r14)
movq (%r14), %rax
je 0x1347a4
testq %rax, %rax
je 0x134894
movq 0x28(%r1... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Iterator<TestType, true, std::allocator<unsigned long>>::testInvariant() const | inline void
Iterator<T, isConst, A>::testInvariant() const
{
if(!MARRAY_NO_DEBUG) {
if(view_ == 0) {
marray_detail::Assert(coordinates_.size() == 0
&& index_ == 0
&& pointer_ == 0);
}
else {
if(view_->size() == 0) { // un-initialize... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x13498a
movq 0x30(%rdi), %rsi
testq %rsi, %rsi
je 0x1349c7
movq 0x10(%rbx), %rax
cmpq %rsi, %rax
ja 0x134c1d
movq 0x8(%rbx), %r14
jne 0x134a04
decq %rsi
callq 0x13460e
addq $0x8, %rax
cmpq %rax, %r14
je 0... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<TestType, true, std::allocator<unsigned long>>::reference andres::marray_detail::AccessOperatorHelper<true>::execute<TestType, int, true, std::allocator<unsigned long>>(andres::View<TestType, true, std::allocator<unsigned long>> const&, int const&) | static typename View<T, isConst, A>::reference
execute(const View<T, isConst, A>& v, const U& index)
{
v.testInvariant();
Assert(MARRAY_NO_DEBUG || v.data_ != 0);
Assert(MARRAY_NO_DEBUG || v.dimension() != 0 || index == 0);
std::size_t offset;
v.indexToOffset(index, offse... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x134110
cmpq $0x0, (%rbx)
je 0x134da8
cmpq $0x0, 0x28(%rbx)
setne %cl
movl (%r14), %eax
testl %eax, %eax
sete %dl
orb %cl, %dl
je 0x134dc6
movslq %eax, %rsi
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x134e0e
movq (%r14), %rax
shlq $0x3,... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<TestType, true, std::allocator<unsigned long>>::indexToOffset(unsigned long, unsigned long&) const | inline void
View<T, isConst, A>::indexToOffset
(
std::size_t index,
std::size_t& out
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_ARG_TEST || index < this->size());
if(isSimple()) {
out = index;
}
else {
out = 0;
if(coordinateOrder() == FirstMajorOrder)... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x134110
cmpq %r15, 0x30(%r14)
jbe 0x134f97
movq %r14, %rdi
callq 0x134110
cmpb $0x1, 0x3c(%r14)
jne 0x134e43
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x134110
cmpl $0x0, 0x38(%r14)... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<TestType, true, std::allocator<unsigned long>>::strides(unsigned long) const | inline const std::size_t
View<T, isConst, A>::strides
(
const std::size_t dimension
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || data_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || dimension < this->dimension());
return geometry_.strides(dimension);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x134110
cmpq $0x0, (%r14)
je 0x13504d
cmpq %rbx, 0x28(%r14)
jbe 0x13506b
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x270b0
movq %rax, %rbx
leaq 0x3ae1(%rip), %rsi # 0x138b42
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
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.