Lambdas from First Principles A Whirlwind Tour of C++

1

Plain old functions int plus1(int x) { return x+1; }

__Z5plus1i: leal 1(%rdi), %eax retq

2

Function overloading int plus1(int x) { return x+1; }

__Z5plus1i: leal 1(%rdi), %eax retq __Z5plus1d: addsd LCPI1_0(%rip), %xmm0 retq

double plus1(double x) { return x+1; } 3

Function templates template T plus1(T x) { return x+1; }

__Z5plus1IiET_S0_: leal 1(%rdi), %eax retq __Z5plus1IdET_S0_: addsd LCPI1_0(%rip), %xmm0 retq

auto y = plus1(42); auto z = plus1(3.14); 4

Function templates template T plus1(T x) { return x+1; } auto y = plus1(42); auto z = plus1(3.14);

Footnotes: Template type parameter T is deduced from the type of the argument passed in by the caller. 42 is an int, so the compiler deduces that the call must be to plus1. 3.14 is a double, so the compiler deduces that the call must be to plus1.

5

Function templates template T plus1(T x) { return x+1; }

Footnotes: We can call plus1 directly, via explicit specialization. The compiler deduces T in a few other contexts, too, such as in contexts requiring a function pointer of a specific type.

auto y = plus1(42); int (*z)(int) = plus1; 6

Function templates template T plus1(T x) { return x+1; }

Footnote: Using the name plus1 in contexts where its meaning is ambiguous is not allowed. The compiler will diagnose your error.

auto err = plus1; // oops test.cc:7: ... incompatible initializer of type ''

7

Puzzle #1 template auto kitten(T t) { static int x = 0; return (++x) + t; } int main() { printf("%d ", kitten(1)); printf("%g\n", kitten(3.14)); }

8

Puzzle #1 template auto kitten(T t) { static int x = 0; return (++x) + t; } int main() { printf("2 " , kitten(1)); printf("4.14\n", kitten(3.14)); }

9

Puzzle #1 template auto kitten(T t) { static int x = 0; return (++x) + t; } int main() { printf("2 " , kitten(1)); printf("4.14\n", kitten(3.14)); }

The rationale is made more apparent when we...

__ZZ6kittenIiEDaT_E1x: .long 0 __Z6kittenIiEDaT_: movq __ZZ6kittenIiEDaT_E1x, %rax movl (%rax), %ecx leal 1(%rcx), %edx movl %edx, (%rax) leal 1(%rcx,%rdi), %eax retq __ZZ6kittenIdEDaT_E1x: .long 0 __Z6kittenIdEDaT_: movq __ZZ6kittenIdEDaT_E1x, %rax movl (%rax), %ecx incl %ecx movl %ecx, (%rax) cvtsi2sdl %ecx, %xmm1 addsd %xmm0, %xmm1 movaps %xmm1, %xmm0 retq

10

Puzzle #1 template auto kitten(T t) { static T x = 0; return (x += 1) + t; } int main() { printf("2 " , kitten(1)); printf("4.14\n", kitten(3.14)); }

__ZZ6kittenIiEDaT_E1x: .long 0 ## int 0 __Z6kittenIiEDaT_: movq __ZZ6kittenIiEDaT_E1x, %rax movl (%rax), %ecx leal 1(%rcx), %edx movl %edx, (%rax) leal 1(%rcx,%rdi), %eax retq __ZZ6kittenIdEDaT_E1x: .quad 0 ## double 0.0 __Z6kittenIdEDaT_: movq __ZZ6kittenIdEDaT_E1x, %rax movl (%rax), %ecx incl %ecx movl %ecx, (%rax) cvtsi2sdl %ecx, %xmm1 addsd %xmm0, %xmm1 movaps %xmm1, %xmm0 retq

11

We’ll come back to templates later. 12

Class member functions class Plus { int value; public: Plus(int v);

__ZN4PlusC1Ei: movl %esi, (%rdi) retq __ZN4Plus6plusmeEi: addl (%rdi), %esi movl %esi, %eax retq

int plusme(int x) const { return x + value; } }; 13

“Which function do we call?”

auto plus = Plus(1); auto x = plus.plusme(42); assert(x == 43);

14

C++ is not Java!

15

The Java approach auto plus = Plus(1); auto x = plus.plusme(42); assert(x == 43); static code and data

stack

heap plus

vtable for class Plus __ZN4Plus6plusmeEi: addl 8(%rdi), %esi movl %esi, %eax retq

C++ lets you do this, but it's not the default.

anonymous Plus object

vptr value

16

The C++ approach auto plus = Plus(1); auto x = plus.plusme(42);

movl leaq callq movl leaq callq

$1, %esi -16(%rbp), %rdi __ZN4PlusC1Ei $42, %esi -16(%rbp), %rdi __ZN4Plus6plusmeEi

assert(x == 43); static code and data

stack

heap

plus, a Plus object

value __ZN4Plus6plusmeEi: addl (%rdi), %esi movl %esi, %eax retq

17

The C++ approach auto plus = Plus(1); auto x = plus.plusme(42);

movl leaq callq movl leaq callq

$1, %esi -16(%rbp), %rdi __ZN4PlusC1Ei $42, %esi -16(%rbp), %rdi __ZN4Plus6plusmeEi

assert(x == 43); static code and data

stack

heap

plus, a Plus object

Static typing FTW!

value

__ZN4Plus6plusmeEi: addl (%rdi), %esi movl %esi, %eax retq

18

Class member functions (recap) class Plus { int value; public: Plus(int v);

__ZN4PlusC1Ei: movl %esi, (%rdi) retq __ZN4Plus6plusmeEi: addl (%rdi), %esi movl %esi, %eax retq

int plusme(int x) const { return x + value; } auto };

plus = Plus(1); auto x = plus.plusme(42); 19

Operator overloading class Plus { int value; public: Plus(int v);

__ZN4PlusC1Ei: movl %esi, (%rdi) retq __ZN4PlusclEi: addl (%rdi), %esi movl %esi, %eax retq

int operator() (int x) const { return x + value; } auto plus };

= Plus(1); auto x = plus(42); 20

So now we can make something kind of nifty...

21

Lambdas reduce boilerplate class Plus { int value; public: Plus(int v): value(v) {} int operator() (int x) const { return x + value; } }; auto plus = Plus(1); assert(plus(42) == 43); 22

Lambdas reduce boilerplate

auto plus = [value=1](int x) { return x + value; };

assert(plus(42) == 43); 23

Same implementation auto plus = [value=1](int x) { return x + value; };

static code and data

stack

movl leaq callq movl leaq callq

$1, %esi -16(%rbp), %rdi __ZN3$_0C1Ei $42, %esi -16(%rbp), %rdi __ZN3$_0clEi

heap

plus, a $_0 object

Static typing FTW!

value

__ZN3$_0clEi: addl (%rdi), %esi movl %esi, %eax retq

24

Closures without garbage collection using object = std::map; void sort_by_property(std::vector& v, std::string prop) { auto pless = [p=prop](object& a, object& b) { return a[p] < b[p]; }; std::sort(v.begin(), v.end(), pless); }

25

Closures without garbage collection ... std::string prop ...

static code and data

stack

heap prop

"hello"

26

Closures without garbage collection ... std::string prop ... auto pless = [p=prop](object& a, object& b) { return a[p] < b[p]; }; static code and data

stack

heap prop

__ZN3$_1clEi: ...

"hello"

pless, a $_1 object "hello"

p 27

Closures without garbage collection ... std::string prop ... auto pless = [prop](object& a, object& b) { return a[prop] < b[prop]; }; static code and data

stack

heap prop

__ZN3$_1clEi: ...

"hello"

pless, a $_1 object "hello"

prop 28

Copy semantics by default ... std::string prop ... auto pless = [=](object& a, object& b) { return a[prop] < b[prop]; }; static code and data

stack

heap prop

__ZN3$_1clEi: ...

"hello"

pless, a $_1 object "hello"

prop 29

Copy semantics by default ... std::string prop ... auto pless = [=](object& a, object& b) { return a[prop] < b[prop]; }; static code and data

stack

heap prop

__ZN3$_1clEi: ...

"hello"

pless, a $_1 object "hello"

prop 30

Capturing a reference ... std::string prop ... auto pless = [p=?????](object& a, object& b) { return a[p] < b[p]; }; static code and data

stack

heap prop

__ZN3$_1clEi: ...

"hello"

pless, a $_1 object

p 31

Capturing a reference ... std::string prop ... auto pless = [p=std::ref(prop)](object& a, object& b) { return a[p] < b[p]; }; static code and data

stack

heap prop

__ZN3$_1clEi: ...

"hello"

pless, a $_1 object

p 32

Capturing by reference ... std::string prop ... auto pless = [&p=prop](object& a, object& b) { return a[p] < b[p]; }; static code and data

stack

heap prop

__ZN3$_1clEi: ...

"hello"

pless, a $_1 object

p 33

Capturing by reference ... std::string prop ... auto pless = [&prop](object& a, object& b) { return a[prop] < b[prop]; }; static code and data

stack

heap prop

__ZN3$_1clEi: ...

"hello"

pless, a $_1 object

prop 34

Capturing by reference ... std::string prop ... auto pless = [&](object& a, object& b) { return a[prop] < b[prop]; }; static code and data

stack

heap prop

__ZN3$_1clEi: ...

"hello"

pless, a $_1 object

prop 35

Beware of dangling references ... std::string prop ... auto pless = [&](object& a, object& b) { return a[prop] < b[prop]; }; static code and data

stack

heap prop

__ZN3$_1clEi: ...

"hello"

pless, a $_1 object

prop 36

Capturing by value vs. by reference auto GOOD_increment_by(int y) { return [=](int x) { return x+y; }; } auto BAD_increment_by(int y) { return [&](int x) { return x+y; }; } auto plus5 = GOOD_increment_by(5); int seven = plus5(2); 37

Other features of lambdas ● Convertible to raw function pointer (when there are no captures involved) ● Variables with file/global scope are not captured ● Lambdas may have local state (but not in the way you think)

38

Puzzle #2 #include int g = 10; auto kitten = [=]() { return g+1; }; auto cat = [g=g]() { return g+1; }; int main() { g = 20; printf("%d %d\n", kitten(), cat()); }

39

Puzzle #2 #include int g = 10; auto kitten = [=]() { return g+1; }; auto cat = [g=g]() { return g+1; }; int main() { g = 20; printf("21 11\n", kitten(), cat()); }

40

Puzzle #2 footnote int g = 10; auto ocelot = [g]() { return g+1; }; The above is ill-formed and requires a diagnostic. 5.1.2 [expr.prim.lambda]/10: The identifier in a simple-capture is looked up using the usual rules for unqualified name lookup (3.4.1); each such lookup shall find an entity. An entity that is designated by a simple-capture is said to be explicitly captured, and shall be this or a variable with automatic storage duration declared in the reaching scope of the local lambda expression.

However, this is just a warning in GCC (it’s an error in Clang). 41

Puzzle #3 auto make_kitten(int c) { static int a = 0; return [=](int d) { static int b = 0; return (a++) + (b++) + c + d; }; }

a — static outside the lambda b — static inside the lambda c — captured by value d — the lambda’s own argument

int main() { auto k1 = make_kitten(1), k2 = make_kitten(2); printf("%d ", k1(20)); printf("%d\n", k1(30)); printf("%d ", k2(20)); printf("%d\n", k2(30)); }

42

Puzzle #3 auto make_kitten(int c) { static int a = 0; return [=](int d) { static int b = 0; return (a++) + (b++) + c + d; }; }

a — static outside the lambda b — static inside the lambda c — captured by value d — the lambda’s own argument

int main() { auto k1 = make_kitten(1), k2 = make_kitten(2); printf("21 ", k1(20)); printf("33\n", k1(30)); printf("26 ", k2(20)); printf("38\n", k2(30)); }

43

Puzzle #3 ... static int a = 0; return [=](int d) { static int b = 0; return (a++) + (b++) + c + d; }; ... auto k1 = make_kitten(1), k2 = make_kitten(2); ... static code and data __ZZ11make_kitteniE1a

a __ZZZ11make_kitteniENK3$_0clEiE1b

b

stack

heap k1, a $_0 object

c (1)

k2, a $_0 object

c (2) __ZZ11make_kitteniENK3$_0clEi: ...

44

Per-lambda mutable state ... [c](int d) { static int b; ... } ... static code and data

stack

heap k1, a $_0 object

c (1) b (0) k2, a $_0 object

c (2)

45

Per-lambda mutable state ... [c](int d) { static int b; ... } ... static code and data

stack

heap k1, a $_0 object

c (1) b (1) k2, a $_0 object

c (2)

46

Per-lambda mutable state static code and data

stack

heap k1, a $_0 object

c (1) b (0)

k2, a $_0 object

c (2) b (0)

47

Per-lambda mutable state static code and data

stack

heap k1, a $_0 object

c (1) b (1)

k2, a $_0 object

c (2) b (0)

48

Per-lambda mutable state [c,b=0](int d) mutable { ... b++ ... } Footnote: mutable is all-ornothing. Generally speaking, captures aren’t modifiable... and you wouldn’t want them to be.

stack

heap k1, a $_0 object

c (1) b (0)

k2, a $_0 object

c (2) b (0)

49

Lambdas + Templates = Generic Lambdas 50

Class member function templates class Plus { int value; public: Plus(int v); template T plusme(T x) const { return x + value; } };

__ZNK4Plus6plusmeIiEET_S1_: addl (%rdi), %esi movl %esi, %eax retq __ZNK4Plus6plusmeIdEET_S1_: cvtsi2sdl (%rdi), %xmm1 addsd %xmm0, %xmm1 movaps %xmm1, %xmm0 retq

auto plus = Plus(1); auto x = plus.plusme(42); auto y = plus.plusme(3.14);

51

Class member function templates class Plus { int value; public: Plus(int v);

};

__ZNK4PlusclIiEET_S1_: addl (%rdi), %esi movl %esi, %eax retq __ZNK4PlusclIdEET_S1_: cvtsi2sdl (%rdi), %xmm1 addsd %xmm0, %xmm1 movaps %xmm1, %xmm0 retq

template T operator()(T x) const { return x + value; auto } auto

plus = Plus(1); x = plus(42); auto y = plus(3.14);

52

So now we can make something kind of nifty...

53

Generic lambdas reduce boilerplate class Plus { int value; public: Plus(int v): value(v) {} template auto operator() (T x) const { return x + value; } }; auto plus = Plus(1); assert(plus(42) == 43); 54

Generic lambdas reduce boilerplate

auto plus = [value=1](auto x) { return x + value; };

assert(plus(42) == 43); 55

Puzzle #3 redux auto kitten = [](auto t) { static int x = 0; return (++x) + t; }; int main() { printf("%d ", kitten(1)); printf("%g\n", kitten(3.14)); }

56

Puzzle #1 redux auto kitten = [](auto t) { static int x = 0; return (++x) + t; }; int main() { printf("2 " , kitten(1)); printf("4.14\n", kitten(3.14)); }

__ZZNK3$_0clIiEEDaT_E1x: .long 0 __ZN3$_08__invokeIiEEDaT_: movq __ZZNK3$_0clIiEEDaT_E1x, %rax movl (%rax), %ecx leal 1(%rcx), %edx movl %edx, (%rax) leal 1(%rcx,%rdi), %eax retq __ZNK3$_0clIdEEDaT_E1x: .long 0 __ZN3$_08__invokeIdEEDaT_: movq __ZZNK3$_0clIdEEDaT_E1x, %rax movl (%rax), %ecx incl %ecx movl %ecx, (%rax) cvtsi2sdl %ecx, %xmm1 addsd %xmm0, %xmm1 movaps %xmm1, %xmm0 retq

57

Generic lambdas are just templates under the hood. 58

Variadic function templates class Plus { int value; public: Plus(int v);

__ZNK4PlusclIJidiEEEDaDpT_: cvtsi2sdl %esi, %xmm2 addl (%rdi), %edx cvtsi2sdl %edx, %xmm1 addsd %xmm1, %xmm0 addsd %xmm2, %xmm0 retq

__ZNK4PlusclIJPKciEEEDaDpT_:

};

addl (%rdi), %edx template movslq %edx, %rax auto operator()(P... p) { addq %rsi, %rax retq return sum(p..., value); auto plus = Plus(1); } auto x = plus(42, 3.14,

1); auto y = plus("foobar", 2);

59

Variadic lambdas reduce boilerplate class Plus { int value; public: Plus(int v): value(v) {} template auto operator() (P... p) const { return sum(p..., value); } }; auto plus = Plus(1); assert(plus(42, 3.14, 1) == 47.14); 60

Variadic lambdas reduce boilerplate

auto plus = [value=1](auto... p) { return sum(p..., value); };

assert(plus(42, 3.14, 1) == 47.14); 61

Capturing a whole parameter-pack using object = std::map; template void sort_by_properties(std::vector& v, P... props) { auto pless = [props...](object& a, object& b) { return tie(a[props]...) < tie(b[props]...); }; std::sort(v.begin(), v.end(), pless); } 62

Capturing “by move” ... std::string prop ... auto pless = [p=prop](object& a, object& b) { return a[p] < b[p]; }; static code and data

stack

heap prop

__ZN3$_1clEi: ...

"hello"

pless, a $_1 object "hello"

p 63

Capturing “by move” ... std::string prop ... auto pless = [p=std::move(prop)](object& a, object& b) { return a[p] < b[p]; }; static code and data

stack

heap prop

__ZN3$_1clEi: ...

"hello"

pless, a $_1 object

p 64

Capturing a whole parameter-pack “by move”? template void sort_by_properties(std::vector& v, P... props) { auto pless = [p=std::move(props)...](object& a, object& b) { return tie(a[p]...) < tie(b[p]...); }; std::sort(v.begin(), v.end(), pless); } 65

Capturing a whole parameter-pack “by move”? template void sort_by_properties(std::vector& v, P... props) { auto pless = [p=std::move(props)...](object& a, object& b) { return tie(a[p]...) < tie(b[p]...); }; std::sort(v.begin(), v.end(), pless); } 66

Capturing a whole parameter-pack “by move”? template void sort_by_properties(std::vector& v, P... props) { auto tprops = std::make_tuple(std::move(props)...); auto pless = [tp=std::move(tprops)](object& a, object& b) { return YUCK; }; std::sort(v.begin(), v.end(), pless); } 67

Questions? Otherwise we’ll talk about std::bind. 68

std::bind is obsolete as of C++14 It lets you wrap up certain arguments to a function call while leaving others unspecified until later. But you have to define the code itself out-of-line. int add(int x, int y) { return x + y; } auto plus5 = std::bind(add, std::placeholders::_1, 5); auto plus5 = [](auto x, auto...) { return add(std::forward(x), 5); }; auto z = plus5(42); assert(z == 47); 69

EMC++ Item 34 // at time t, make sound s for duration d void setAlarm(Time t, Sound s, Duration d); // setSoundL ("L" for "Lambda") is a function object // allowing a sound to be specified for a 30-sec alarm // to go off an hour after it's set auto setSoundL = [](Sound s) { using namespace std::chrono; using namespace std::literals; setAlarm(steady_clock::now() + 1h, s, 30s); }; 70

EMC++ Item 34 // at time t, make sound s for duration d void setAlarm(Time t, Sound s, Duration d); // setSoundB ("B" for "Bind") is a function object // allowing a sound to be specified for a 30-sec alarm // to go off an hour after it's set... or is it? using namespace std::chrono; using namespace std::literals; auto setSoundB = std::bind( setAlarm, steady_clock::now() + 1h, _1, 30s ); 71

We must defer the call to now() // at time t, make sound s for duration d void setAlarm(Time t, Sound s, Duration d); // setSoundB ("B" for "Bind") is a function object // allowing a sound to be specified for a 30-sec alarm // to go off an hour after it's set... or is it? using namespace std::chrono; using namespace std::literals; auto setSoundB = std::bind( setAlarm, std::bind(steady_clock::now) + 1h, _1, 30s ); 72

We must defer the call to operator+ // at time t, make sound s for duration d void setAlarm(Time t, Sound s, Duration d); // setSoundB ("B" for "Bind") is a function object // allowing a sound to be specified for a 30-sec alarm // to go off an hour after it's set... or is it? using namespace std::chrono; using namespace std::literals; auto setSoundB = std::bind( setAlarm, std::bind(steady_clock::now) + 1h, _1, 30s ); 73

The corrected std::bind code using namespace std::chrono; using namespace std::literals; auto setSoundB = std::bind( setAlarm, std::bind( std::plus<>{}, std::bind( steady_clock::now), 1h), _1, 30s); 74

Lambdas FTW

auto setSoundL = [](Sound s) { using namespace std::chrono; using namespace std::literals; setAlarm(steady_clock::now() + 1h, s, 30s); };

75

Questions? Otherwise we’ll talk about std::function. 76

std::function provides type erasure int fplus(int x) { return x + 1; } auto lplus = [value=1](int x) { return x + 1; }; static_assert(!is_same_v);

// different

using i2i = std::function; i2i wrappedf = fplus; i2i wrappedl = lplus; static_assert(is_same_v);

// same 77

std::function is a vocabulary type Before we can talk about , we need double. Before we can talk about stringstreams, we need std::string. Before we can talk about callbacks, we need std::function. std::function allows us to pass lambdas, functor objects, etc., across module boundaries.

78

Type erasure in a nutshell struct ContainerBase { virtual int callme(int) = 0; virtual ~ContainerBase() = default; }; template struct Container : ContainerBase { Wrapped wrapped_value; Container(const Wrapped& wv) : wrapped_value(wv) {} virtual int callme(int i) override { return wrapped_value(i); } }; class i2i { // equivalent to std::function ContainerBase *m_ctr; public: template i2i(const F& wv) : m_ctr(new Container(wv)) {} void operator()(int i) { return m_ctr->callme(i); } // virtual dispatch ~i2i() { delete m_ctr; } // virtual dispatch };

79

Java++ static code and data

stack

heap

vtable for Container<$_0> object of type Container<$_0>

virtual void callme() virtual destructor

vptr

__ZN9ContainerI3$_0E6callmeEv:

...

myfunc

__ZN9ContainerI3$_0ED1Ev: ...

wrapped_value of type $_0

m_ctr

__ZNK3$_0clEv:

...

80

static code and data

stack

heap

vtable for Container<$_0>

object of type Container<$_0>

virtual void callme()

vptr

kitten1

virtual destructor

m_ctr

__ZN9ContainerI3$_0E6callmeEv: ... __ZN9ContainerI3$_0ED1Ev: ... __ZNK3$_0clEv:

wrapped_value of type $_0

object of type Container<$_0>

kitten2 m_ctr

vptr wrapped_value of type $_0

vtable for Container<$_1> virtual void callme()

object of type Container<$_1>

virtual destructor

vptr

cat1 __ZN9ContainerI3$_1E6callmeEv: ... __ZN9ContainerI3$_1ED1Ev: ... __ZNK3$_1clEv:

m_ctr

wrapped_value of type $_1 $_1’s captures...

...

81

return x + value - GitHub

movl %esi, (%rdi) retq. __ZN4Plus6plusmeEi: ... static code and data auto plus = Plus(1); ... without garbage collection using object = std::map;.
Download PDF
271KB Sizes 4 Downloads 276 Views
Report

Recommend Documents

return - GitHub
Jul 2, 2012 - x00000001000d56e4:mov. %r11,%rax понедельник, 2 июля 2012 г. Page 2. @indutny. Twitter / Github / IRC понедельник, 2 июля 2012 г.
Value category cheatsheet - GitHub
Any function call returning a non-reference value type, including pointers, yields a prvalue. ... A non-static data member of an lvalue is also an lvalue. int &&a{ 77 }; ...
Unified Communication X (UCX) - GitHub
100. 6.14.4.4 uct_ep_am_short(uct_ep_h ep, uint8_t id, uint64_t header, ...... the context configuration, including memory domains, transport resources, and ...... In addition the application is responsible to free the descriptor back to UCP library.
Porting to BamTools 2.x Attention! - GitHub
Oct 11, 2011 - Our development philosophy with BamTools so far has been to allow ... Please be aware that the coordinate issue will affect any code that uses the multi-reader's ... I hope to update the API tutorial soon to reflect these new.
IOV: A Universal Value System - GitHub
Abstract. A Universal Value System would allow users to store and exchange multiple types of values without the need to download an electronic wallet each time a new blockchain is being created. The decentralization of blockchains has created a diver
Return on relationships (ROR): the value of ... - Ingenta Connect
Relationship marketing, Customer relations, Intellectual capital,. Balanced scorecard, Business-to-business marketing. Abstract. This article is about ongoing ...
IOV: A Universal Value System - GitHub
tributed ledgers. Cosmos became the first player working to eliminate the dependence on exchanges and create a decentralized network that allows the ..... pdf). 2. Buterin V, , et al. (2014) A next-generation smart contract and decentralized applicat
lecture 5: matrix diagonalization, singular value ... - GitHub
We can decorrelate the variables using spectral principal axis rotation (diagonalization) α=XT. L. DX. L. • One way to do so is to use eigenvectors, columns of X. L corresponding to the non-zero eigenvalues λ i of precision matrix, to define new
Operation manual for BLHeli SiLabs Rev14.x - GitHub
Added Disable TX Programming by PC Setup Application therfore changed EEPROM_LAYOUT_REVISION = 8. Added Vdd Monitor as reset source when ...
Operation manual for BLHeli Atmel Rev14.x - GitHub
Bidirectional operation. All codes run the motor smoothly and with good throttle linearity. All codes support a damped light mode (on hardware that support it).
x 6 = x 8 = x 10 = x 12 = x 6 = x 8 = x 10 = x 12
All of the above. 10b. The table below shows the total cost of potatoes, y, based on the number of pounds purchased, x. Number of. Pounds. Total Cost. 2. $3.00. 4. $6.00. 7. $10.50. 10. $15.00. Which of the following shows the correct keystrokes to e
x
Curtin University of Technology ... Data association, information extraction from text, machine translation .... Group meeting 1 Bookmark cafe, Library, CBS.
x
(q0, x0) which we call the Aubinproperty and also through the lower semicontinuity of L around (q0 .... Our interest will center especially on the critical cone associated with (2) for ..... We start by recording a background fact about our underlyin
9 x 10 4 x 10 2 x 10 0 x 10 3 x 10 8 x 10 11 x 10 7 x 10 1 ...
Tens TIME: (2 minutes) (90 seconds) (75 seconds). 9 x 10. 4 x 10. 2 x 10. 0 x 10. 3 x 10. 8 x 10. 11 x 10. 7 x 10. 1 x 10. 10 x 10. 5 x 10. 12 x 10. 6 x 10. 3 x 10. 8.
Return-To-Neveryon-Return-To-Neveryon.pdf
... Hugo and Nebula award-winner Samuel R. Delany appropriated the conceits of ... personally to only get PDF formatted books to download that are safer and ...
Return to Thedas!
Dragon Age video game series and those inspired and adapted to showcase ... Spell Expertise talent and provide a host of new options. The rest of the chapter ...
x = f(x; _x) + G(x)u - IEEE Xplore
Apr 2, 2010 - Composite Adaptation for Neural. Network-Based Controllers. Parag M. Patre, Shubhendu Bhasin, Zachary D. Wilcox, and. Warren E. Dixon.
matematika x b;x c;x d;x e;.pdf
Cho nửa đường tròn (O; R) đường kính BC. Lấy điểm A trên tia đối ...... matematika x b;x c;x d;x e;.pdf. matematika x b;x c;x d;x e;.pdf. Open. Extract. Open with.