• via http://docs.google.com/View?id=ddjmqgw3_43gm6gvggf
• http://www.google.com/#hl=en&source=hp&q=pid+kalman&aq=f&aqi=&oq=&fp=7d15299a959dbb33

Roll Rate

File: In sw/airborne/fw_h_ctl.c we define the roll rate loop:

float cmd = throttle_dep_pgain * ( err + h_ctl_roll_rate_igain * roll_rate_sum_err / H_CTL_ROLL_RATE_SUM_NB_SAMPLES + h_ctl_roll_rate_dgain * d_err);

Note that the roll Pgain is variable with throttle and multiplies through the entire equation affecting the I and D terms as well for ease of tuning.

1. XML and Scheme
 1. Tools: SSAX, SXML, SXPath, SXSLT
 2. Applications, Examples, Sample Code
 3. Papers and Presentations
 4. SSAX-SXML Mailing list  SSAX-SXML SourceForge Project
 5. Miscellanea
 6. Papers and Presentations
 7. Functional XML parsing framework SAX/DOM and SXML parsers with support for XML Namespaces and validation
 8. SXML specification
 9. SXPath -- SXML query language, XPath implementation
 10. SXML traversals and transformations
 11. HSXML: Typed SXML
 12. Applications, Examples, Sample Code
 13. HTML/XML authoring in Scheme
 14. Writing LaTeX/PDF mathematical papers with SXML
 15. Joint processing of two immutable SXML documents with update cursors
 16. Literate XML/DTD programming
 17. SXML as a normalized database
 18. Complete examples of practical (context-sensitive) SXML Transformations
 19. Complete examples of stream-wise (SAX) and DOM parsing
...
1. Last updated March 4, 2007

Networks of coupled dynamical systems have been used to model ... and many other self-organizing systems. Ordinarily, the connection topology is assumed to be either completely regular or completely random. But many biological, technological and social networks lie somewhere between these two extremes. Here we explore simple models of networks that can be tuned through this middle ground: regular networks 'rewired' to introduce increasing amounts of disorder. We find that these systems can be highly clustered, like regular lattices, yet have small characteristic path lengths, like random graphs. We call them 'small-world' networks, by analogy with the small-world phenomenon (popularly 6 degrees of separation. The neural network of the worm Caenorhabditis elegans, the power grid of the western United States, and the collaboration graph of film actors are shown to be small-world networks.

For me, the web is URIs, a standard set of verbs and a standardized EVAL function. The verbs are mostly GET and POST and the standardized EVAL function is the concept of a browser that can EVAL HTML and can eval JavaScript. I don't thing we can afford to leave JavaScript out of the top level definition of what the Web is because there is too much at stake.

There is a huge difference between a web of algorithms and a web of data. For computing eons, we have known that a combination of algorithms and data structures lead to programs. Less well known (outside computer science) are the problems of trying to build applications using one without the other or trying to fake one using the other.

Lisp, TeX, SGML...all of these evidence the struggle between declarative and imperative methods. Today, the problems are all the same but the buzzwords are different: JavaScript, XSLT, XML...

via http://bitworking.org/news/427/js-rest-and-empty-windows

Operational transformation (OT) is a technology for supporting a range of collaboration functionalities in advanced groupware systems. OT was originally invented for consistency maintenance and concurrency control in collaborative editing of plain text documents. Two decades of research has extended its capabilities and expanded its applications to include group undo, locking, conflict resolution, operation notification and compression, group-awareness, HTML/XML and tree-structured document editing, collaborative office productivity tools, application-sharing, and collaborative computer-aided media design tools. Recently, OT has been adopted as a core technique behind its collaboration features in Google Wave, which took OT to a new range of web-based applications.

via http://www.youtube.com/watch?v=3ykZYKCK7AM&feature=channel

* http://mshook.appspot.com/z/d4m.htm?/mshook/scheme
* The Ten Commandments
   1. How to recur on a list of atoms, a number and an S-expression | 23 64 83
   2. Cons to build | 37
   3. Typical element, cons & recur | 45
   4. Change >= 1 arg closer to termination & test | 57 65 84
   5. +, X & cons; test 0,1,() | 67
   6. When to simplify | 94
   7. Subparts: sublists & subexpressions | 103
   8. Abstract reps w/ funcs | 107
   9. Abstract patterns w/ funcs | 134
  10. Funcs to collect > 1 value | 140
* The Five Rules
   1. Car 5
   2. Cdr 7
   3. Cons 9
   4. Null? 10
   5. Eq? 12
* Dimensions of functions
   o On lats (lists of atoms - flat), numbers or S-expression (hierarchy)
   o Test, insert (L/R), replace, remove
   o Straight/single function, abstracted/generalized
* Data types and structures
   o atom 3
   o number
   o list 3 & 4
   o S-expression 3 & 4
   o lat (list of atoms) 15
   o set 111
   o pair 117 & 118
   o rel 119
more at http://tinyurl.com/kll3de

About this document ... Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I

This document was generated using the LaTeX2HTML translator Version 2002-2-1 (1.70)

Copyright © 1993, 1994, 1995, 1996, Nikos Drakos, Computer Based Learning Unit, University of Leeds.
Copyright © 1997, 1998, 1999, Ross Moore, Mathematics Department, Macquarie University, Sydney.

The command line arguments were:
latex2html recursive.tex

The translation was initiated by John McCarthy on 2006-08-13

---

John McCarthy
2006-08-13

We want to write a function that generates accumulators-- a function that takes a number n, and returns a function that takes another number i and returns n incremented by i.

JavaScript

function foo(n) { return function (i) { return n += i } }

Scheme

(define (foo n) (lambda (i) (set! n (+ n i)) n))

Try

JavaScript

function main() { function foo (n) { return function (i) { return n += i } } ; a = foo(5); print(a(1)); print("n"); print(a(4)); }

Scheme

(define (foo n) (lambda (i) (set! n (+ n i)) n)) (define a (foo 5)) (a 1) (a 4)

• via Paul Graham's Revenge of the Nerds

(I wrote this article to help myself understand exactly what McCarthy discovered. You don't need to know this stuff to program in Lisp, but it should be helpful to anyone who wants to understand the essence of Lisp-- both in the sense of its origins and its semantic core. The fact that it has such a core is one of Lisp's distinguishing features, and the reason why, unlike other languages, Lisp has dialects.)

In 1960, John McCarthy published a remarkable paper in which he did for programming something like what Euclid did for geometry. He showed how, given a handful of simple operators and a notation for functions, you can build a whole programming language. He called this language Lisp, for "List Processing," because one of his key ideas was to use a simple data structure called a list for both code and data.

"Statement: If there exists a walk that starts and ends at the same point without retracing any lines, then each point must be connected to an even number of lines. To see this is true, pick any point with an odd number of lines attached to it. Any walk that traverses every line must, in particular, traverse all the lines attached to this point. The walk visits this point on one bridge, then leaves on another, revisits the point on a different bridge, then leaves on another bridge, and so on (the walk can certainly go elsewhere in between the visits, but we don’t need to know where to make our argument). At some point, because the number of bridges connected to the point is odd, the walk enters the point but can’t leave — unless a bridge is retraced. (If ... the point we picked was the starting point of the walk, the walk would eventually leave the point but couldn’t return without retracing a line.) we can conclude that every each point must be connected to an even number of lines."