Copyright 2006 by The BioBike Team (contact<EMAIL_ADDRESS>The purpose of this tutorial is to discuss the representation and analysis of graphs in BioLisp. I want to warn you up front that this is probably the hardest tutorial in the whole set. You probably will not be able to deeply understand it without some guidance from someone who understands it. That's okay, just let it flow over you.
First off, what's a graph? Graphs are networks of "nodes" (also sometimes called "vertices") connected by "arcs" (also called "edges"). Here's a graph from a paper by Li, et al. (2004) entitled: "The yeast cell-cycle network is robustly designed." It was published in the Proceedings of the National Academy of Sciences (PNAS) in 2004:
Most of the nodes in this graph represent proteins (except for the one called "cell size"), and the arcs represent activation (green) or inhibition relationships (red) between the proteins.
We'll work quite a lot with this graph in later tutorials, but for the moment, we're just going to talk about how to represent it, and do some simple computing on it.
The first thing that we need to do is to create some way of representing the graph so that we can analyze it. There are a number of ways that a graph can be represented. First, notice that the arcs in the graph just go between the nodes. Each arc connects two proteins, and indicates, as I said above, either an activation (green) or inhibition relationships (red) between them. Notice that the arcs are "directional" -- that is, they are arrows. So this is called a "directional" graph. (Graphs don't have to be directional, but most of the ones we'll deal with in symbolic biocomputing are directional.) We can represent a single arc by giving the protein it starts at, the protein it ends at, and whether the arc is an activation or inhibition arc. These could appear in any order we like as long as we're consistent about it. Let's make it be:
(from-protein arc-type to-protein)And we'll use a + or - instead of having to write out "activation" and "inhibition".
Given that, here are the arcs in the graph:
>> (setf *model-graph* >> '((size + cln3) >> (cln3 + mbf) >> (cln3 + sbf) >> (sbf + cln12) >> (cln12 - sic1) >> (cln12 - cdh1) >> (sic1 - clb56) >> (sic1 - clb12) >> (mbf + clb56) >> (clb56 + mcm1/sff) ; weird yellow/green in the paper >> (clb56 - sic1) >> (clb56 + clb12) ; weird yellow/green in the paper >> (clb56 - cdh1) >> (cdh1 - clb12) >> (clb12 - cdh1) >> (clb12 + mcm1/sff) >> (clb12 + cdc20&14) >> (clb12 - sic1) >> (clb12 - swi5) >> (clb12 - mbf) >> (clb12 - sbf) >> (mcm1/sff + cdc20&14) >> (mcm1/sff + swi5) >> (mcm1/sff + clb12) >> (cdc20&14 + swi5) >> (cdc20&14 + cdh1) >> (cdc20&14 - clb12) >> (cdc20&14 + sic1) >> (cdc20&14 - clb56) >> (swi5 + sic1) >> ))Can you see how each entry in the list above matches on arc in the graph? (Many of the problems one has in developing graph programs are just caused by simple errors in representing the graph itself!)
BioBike gives us a way to visualize graphs represented in this way:
>> (seegraph *model-graph*)Let's write some really simple programs that just ask questions about the graph (or any graph represented in this way). What kind of things might we want to know about the graph? Here's a short list:
What are the proteins in the model? What proteins directly control a given protein? What proteins indirectly control a given protein? What are the paths (the lists of arcs) that you have to cross to go from one protein to another?There's another whole set of questions having to do with simulating the system represented by the model, which is dealt with in another tutorial; for now, we're just going to analyze the model, not try to simulate it.
So, let's get to it:
What are the proteins in the model?
We can get this list directly from the graph. All we need to do is to loop over each arc and collect the proteins at the ends of the arc, and return them.
>> (xloop for (from +- to) in *model-graph* >> collect (list from to)) :: ((SIZE CLN3) (CLN3 MBF) (CLN3 SBF) (SBF CLN12) ...Well, that's sort of what we want -- that's the from and to proteins of every arc, but we want them in one long list. Turns out that XLoop has a tricky way to do that:
>> (xloop for (from +- to) in *model-graph* >> APPEND (list from to)) :: (SIZE CLN3 CLN3 MBF CLN3 SBF SBF CLN12 CLN12 SIC1 CLN12 ...Looks good! [You don't have to UPPERCASE the APPEND, I just did that so you could see the difference in the examples!]
But there's a problem; the list is very redundant; every protein appears many times. No problem, Lisp has a special function just for this occasion:
>> (remove-duplicates *)So here's our whole function:
>> (defun graph-proteins (graph) >> (remove-duplicates >> (xloop for (from +- to) in graph >> append (list from to)))) Let's try it: >> (graph-proteins *model-graph*) :: (SIZE CLN3 CLN12 MBF SBF MCM1/SFF CDH1 CLB12 CDC20&14 CLB56 SWI5 SIC1)Tada! Okay, next question:
What proteins directly control a given protein?
In other words, we're going to give the name of a protein, and we want to get back the list of proteins that have an arc directly connected to it -- that is, where the given protein appears as the TO (third) part of the arc [remember: (FROM +- TO)]
This too is just a simple loop, very similar to the previous one, but this time we only need certain arcs -- the ones going TO our target protein. We'll just copy and very slightly modify the previous function. Let's call it "proteins-directly-controlling" because it finds the proteins that directly control a given protein for a given graph. (Note that we'll have to give both the target TO protein and the graph!)
>> (defun proteins-directly-controlling (desired-to-protein graph) >> (remove-duplicates >> (xloop for (from-protein +- to-protein) in graph >> WHEN (EQUAL to-protein desired-to-protein) >> collect from-protein))) Let's try it: >> (proteins-directly-controlling 'sbf *model-graph*) :: (CLN3 CLB12)You should verify that this is the right answer, and try a few others while you're at it.
[Quiz: Why did we have to quote the 'sbf -- try doing the same thing without the single quote and see what happens.]
Okay, so far, so easy; Next question!
What are the proteins that indirectly control a given protein?
This is going to take some thought. Let's look back at the graph picture way above:
Our proteins-directly-controlling function figured out that clb12 and cln3 are directly controlling sbf by reading it right off the graph, but you can't read the indirectly controlling proteins right off the graph, you have to walk backwards in the graph to do that. For example, to ask what proteins are indirectly controlling, say, sbf, we start with the ones that are directly controlling it (okay, we know how to do that already), and then go back from each of those to the ones directly controlling those, and so on. That doesn't sound so hard. Let's try it by eye for one path:
clb12 directly controls sbf clb56 directly controls clb12 mbf directly controls clb56 cln3 directly controls mbf cell size directly controls cln3 nothing directly controls cell size... ...so we're done!There's a special name given to this sort of procedure: recursion -- we "recursed" (or "recurred" if you prefer) back from clb12 by the direct control concept (function) until we hit something with no direct controls.
There's one big complex in this.
 Hey wait a minute!!!Got it? You can follow this series of arcs forever and never find the beginning because its a loop! We'll have to watch out for those in our program.
Doing this right is really the heart of graph processing. I'm going to give you the function that does this, and then carefully go through how it works, because it's quite subtle.
>> (defun graph-walker (to-prot graph &optional seen) >> (let ((direct-controllers (proteins-directly-controlling to-prot graph))) >> (cond ((null direct-controllers) (list to-prot)) >> (t (xloop for prot in direct-controllers >> unless (member prot seen) >> collect (cons to-prot >> (graph-walker prot graph >> (cons prot seen))))))))(You might have gotten a compiler warning, something like: "Warning: While compiling these undefined functions were referenced: GRAPH-WALKER." when you did that just now. That's because GRAPH-WALKER recurses -- calls itself, which is very slightly confusing to the compiler, so it's just warning you that you're calling a function that doesn't exist yet. (Of course it doesn't, we're creating it now!) So don't worry about this. :-)
Okay, let's try it out on something simple:
>> (graph-walker 'cln3 *model-graph*) :: ((CLN3 SIZE))Okay, that looks right: Only cell size controls cln3 -- so there's one path:
cell size directly controls cln3 nothing directly controls cell size... ...so we're done!Now the more complex question:
>> (graph-walker 'sbf *model-graph*) :: ((SBF (CLN3 SIZE)) (SBF (CLB12 (SIC1 (CLN12 (SBF (CLN3 SIZE)))) (SIC1 (CLB56 (MBF (CLN3 SIZE))) (CLB56 (CDC20&14))) (SIC1 (CDC20&14 (MCM1/SFF (CLB56 (MBF (CLN3 SIZE)))))) (SIC1 (SWI5 (MCM1/SFF (CLB56 (MBF (CLN3 SIZE))) (CLB56))) (SWI5 (CDC20&14 (MCM1/SFF (CLB56 (MBF (CLN3 SIZE)))))))) (CLB12 (CLB56 (SIC1 (CLN12 (SBF (CLN3 SIZE)))) (SIC1 (CDC20&14)) (SIC1 (SWI5) (SWI5 (CDC20&14)))) (CLB56 (MBF (CLN3 SIZE))) (CLB56 (CDC20&14))) (CLB12 (CDH1 (CLN12 (SBF (CLN3 SIZE)))) (CDH1 (CLB56 (SIC1 (CLN12 (SBF (CLN3 SIZE)))) (SIC1 (CDC20&14)) (SIC1 (SWI5) (SWI5 (CDC20&14)))) (CLB56 (MBF (CLN3 SIZE))) (CLB56 (CDC20&14))) (CDH1 (CDC20&14 (MCM1/SFF (CLB56 (SIC1 (CLN12 (SBF (CLN3 SIZE)))) (SIC1)) (CLB56 (MBF (CLN3 SIZE))))))) (CLB12 (MCM1/SFF (CLB56 (SIC1 (CLN12 (SBF (CLN3 SIZE)))) (SIC1) (SIC1 (SWI5))) (CLB56 (MBF (CLN3 SIZE))) (CLB56))) (CLB12 (CDC20&14 (MCM1/SFF (CLB56 (SIC1 (CLN12 (SBF (CLN3 SIZE)))) (SIC1)) (CLB56 (MBF (CLN3 SIZE))))))))(If it doesn't look like this, you might have to "pretty print" it, by doing (pprint *).)
OMG!
It takes a little getting used to read things like that. Let's do a simpler example that will be a lot easier to figure out, then we can go back to this one.
Let's make a nice easy graph:
+----------<---+ | | v | A -> B -> C -> D -> E ^ | | | +-----<---+ >> (setf *simple-graph* >> '((a + b) >> (b + c) >> (c + d) >> (d + e) >> (e + c) >> (e + b))) Let's see it, just to be sure that it looks like what we want: >> (seegraph *simple-graph*)And we'll try our graph walker on it:
>> (graph-walker 'd *simple-graph*) :: ((D (C (B A) (B (E))) (C (E)))) Here's another way to see the same thing that slightly easier to read:: ((D (C (B A) (B (E))) (C (E))))Easier to read?! Well, here it's in the same form as we had up above:
d is directly controlled by c c is directly controlled by b b is directly controlled by a a is directly controlled by nothing ...so we're done!But it goes on:
d is directly controlled by c c is directly controlled by b b is directly controlled by a a is directly controlled by nothing ...so we're done that path! [back to b] b is also directly controlled by e [e is directly controlled by d, but we've seen d before... ...so we're done that path too! [back to c:] c is also directly controlled by e [as above: e is directly controlled by d, but we've seen d before... ...so we're done that path too! We've explored every part -- we're completely done!So you see, with a little paren work you can read off the paths from this result.
If you go back to the gigantic mess returned by our graph walk of the model graph from sbf, you'll actually be able to find all the control paths to sbf, but let's not go there just yet. There are also various ways to watch the graph walker in action, and we'll get to those in a moment, but let's go back to the function and pick apart how it works.
Here's the graph walker function again, this time with line numbers so that we can talk about them::
1: (defun graph-walker (to-prot graph &optional seen) 2: (let ((direct-controllers (proteins-directly-controlling to-prot graph))) 3: (cond ((null direct-controllers) (list to-prot)) 4: (t (xloop for prot in direct-controllers 5: unless (member prot seen) 6: collect (cons to-prot 7: (graph-walker prot graph 8: (cons prot seen))))))))The most important thing about this function is that it calls itself! Huh? Look at lines 7 and 8:
7: (graph-walker prot graph 8: (cons prot seen))))))))This is a call to the graph-walker function from inside the graph-walker function!! Remember "recursion", well, here it is, in the flesh!
Let's look at a simpler case of recursion, and then we'll get back to the graph walker. Let's write a program to compute the factorial of a number. The factorial of 5 is 5 times 4 times 3 times 2 times 1. (This comes out to 120.)
Notice that the factorial of 1 is just 1. The recursive way to think about this is just that the factorial of any number is the number (5) times the factorial of the number minus 1, until you get to 1, where the factorial is 1. In other words, (fact 5) = (* 5 (fact 4)), and (fact 4) = (* 4 (fact 3)) ...etc...
Here's how we can write that in Lisp:
>> (defun fact (n) >> (cond ((= n 1) 1) >> (t (* n (fact (- n 1)))))) Let's try it: >> (fact 5) :: 120 Great. How about a bigger one: >> (fact 10) :: 3628800 Okay, whatever.It turns out that there's a way to watch the recursion taking place:
>> (trace fact) >> (fact 5) 0[4]: (FACT 5) 1[4]: (FACT 4) 2[4]: (FACT 3) 3[4]: (FACT 2) 4[4]: (FACT 1) 4[4]: returned 1 3[4]: returned 2 2[4]: returned 6 1[4]: returned 24 0[4]: returned 120 :: 120Moving left it counting down, and moving right it's multiplying back up. This is critical to understanding recursion: What goes down, must come up!
FACT is a really good example of a recursive program. It's simple, and has the major components:
1: (defun fact (n) 2: (cond ((= n 1) 1) 3: (t (* n (fact (- n 1))))))First, FACT tests for completion. That's line 2: If N = 1, then don't call again, just stop, and return the right result for this case (Factorial of 1 is 1, so when N=1, return 1). This is called the "termination condition".
Second, FACT combines the current value (N) with the result of the recursion (FACT (- n 1)). The combination, in this case, is by multiplication. This is the key component of recursion: Combining simpler and simpler cases together until you get to the simplest case. This is called the recursive step.
You could write the template of a recursive function this way:
1: To make a recursive function, on an argument, 2: If this is the simplest case, return the simplest answer, 3: Otherwise, combine the current argument value with a recursive call on a simpler argument. Here's fact again: 1: (defun fact (n) 2: (cond ((= n 1) 1) 3: (t (* n (fact (- n 1))))))Written out in English, this might read: To take the factorial of a number, test of the number is 1. If it is, the factorial is 1, and we're done. Otherwise, multiply the number by the factorial of the number minus 1. Can you see how that reads into the function?
Before going back to the graph walker, I want to go through another couple of types of recursive functions. The first is just a list walker. The list walker take a list, like '(A BEE SEE DEE EEE ELEPHANT GEE!
We don't need recursion to do that, you can just do a loop:
>> (setf letters '(A BEE SEE DEE EEE ELEPHANT GEE! ACH EYE JAY KAY EEL >> EMU EN OH! PEE QUE ARE ES TEA EWE VEE DOUBLE-EWE EX WHY? ZEEEEEEEE)) >> (xloop for letter in letters >> as reverse-letter in (reverse letters) >> collect (list letter reverse-letter)) :: ((A ZEEEEEEEE) (BEE WHY?) (SEE EX) (DEE DOUBLE-EWE) (EEE VEE) (ELEPHANT EWE) (GEE! TEA) (ACH ES) (EYE ARE) (JAY QUE) (KAY PEE) (EEL OH!) (EMU EN) (EN EMU) (OH! EEL) (PEE KAY) (QUE JAY) (ARE EYE) (ES ACH) (TEA GEE!) (EWE ELEPHANT) (VEE EEE) (DOUBLE-EWE DEE) (EX SEE) (WHY? BEE) (ZEEEEEEEE A))That's sort weird and simplistic, and here's a recursive function that does the same thing:
>> (defun reverse-pairs (letters reverse-letters) >> (cond ((null letters) nil) >> (t (cons (list (car letters) >> (car reverse-letters)) >> (reverse-pairs (cdr letters) >> (cdr reverse-letters)))))) Let's try it to make sure it does the same thing: >> (reverse-pairs letters (reverse letters)) :: ((A ZEEEEEEEE) (BEE WHY?) (SEE EX) (DEE DOUBLE-EWE) (EEE VEE) (ELEPHANT EWE) (GEE! TEA) (ACH ES) (EYE ARE) (JAY QUE) (KAY PEE) (EEL OH!) (EMU EN) (EN EMU) (OH! EEL) (PEE KAY) (QUE JAY) (ARE EYE) (ES ACH) (TEA GEE!) (EWE ELEPHANT) (VEE EEE) (DOUBLE-EWE DEE) (EX SEE) (WHY? BEE) (ZEEEEEEEE A))Can you see how that works? Identify the termination condition. Identify the recursive step. Figure out how the recursive step combines the current head (car) of the letters and the current head (car) of the reversed-letters with the results of the recursion. Identify how the arguments to the recursion are simplified (by cdr'ing each of them!)
Okay, now let's go back to our graph walker and see if we can identify the recursive features we've just talked about:
1: (defun graph-walker (to-prot graph &optional seen) 2: (let ((direct-controllers (proteins-directly-controlling to-prot graph))) 3: (cond ((null direct-controllers) (list to-prot)) 4: (t (xloop for prot in direct-controllers 5: unless (member prot seen) 6: collect (cons to-prot 7: (graph-walker prot graph 8: (cons prot seen))))))))Let's go back to our two principles of recursive functions:
First, graph-walker tests for completion. That's line 3: If there are no direct controllers of the to-prot then don't call again, just stop, and return the right result for this case: the to-prot itself. (The LIST is just a convenience for how the results are combined, which we'll discuss next.)
Second, graph-walker combines the current value (to-prot) with the result of the recursion. The combination, in this case, is much more complex than multiplication, but the concept is the same. This all happens in lines 4-8, let's look at this recursive step in some detail:
4: (t (xloop for prot in direct-controllers 5: unless (member prot seen) 6: collect (cons to-prot 7: (graph-walker prot graph 8: (cons prot seen))))))))This is kind of complex for a recursive step. It has the same general structure as the fact recursive step:
2: (cond (...) 3: (t (* n (fact (- n 1)))))The t just tells cond that this is the default case. (In other words, if all the above tests fail, this one will happen; it's a test that always returns true (t) -- because it is true (t)!)
So, ignoring the t part, here the recursion:
4: (xloop for prot in direct-controllers 5: unless (member prot seen) 6: collect (cons to-prot 7: (graph-walker prot graph 8: (cons prot seen))))))In English this says: Consider each direct controller of the current to-prot (call each of these "prot" as you go through the loop...
4: (xloop for prot in direct-controllersUnless this protein has already been seen (or, put another way: if this protein has not already been seen...
5: unless (member prot seen)Gather up a path, beginning with the current to-prot...
6: collect (cons to-protAnd ending with the recursive call to graph walker starting at the current controlling protein...
7: (graph-walker prot graphAdding the current controlling protein to the "seen" list each time through:
8: (cons prot seen))))))This last part ensures that the "seen" list is updated so that if we come across the same protein again, we stop (care of the UNLESS clause above).
Let's see how this works for the simple graph:
>> (trace graph-walker) >> (graph-walker 'd *simple-graph*) :: 0[3]: (GRAPH-WALKER D ((A + B) (B + C) (C + D) (D + E) (E + C) (E + B))) 1[3]: (GRAPH-WALKER C ((A + B) (B + C) (C + D) (D + E) (E + C) (E + B)) (C)) 2[3]: (GRAPH-WALKER B ((A + B) (B + C) (C + D) (D + E) (E + C) (E + B)) (B C)) 3[3]: (GRAPH-WALKER A ((A + B) (B + C) (C + D) (D + E) (E + C) (E + B)) (A B C)) 3[3]: returned (A) 3[3]: (GRAPH-WALKER E ((A + B) (B + C) (C + D) (D + E) (E + C) (E + B)) (E B C)) 4[3]: (GRAPH-WALKER D ((A + B) (B + C) (C + D) (D + E) (E + C) (E + B)) (D E B C)) 4[3]: returned NIL 3[3]: returned ((E)) 2[3]: returned ((B A) (B (E))) 2[3]: (GRAPH-WALKER E ((A + B) (B + C) (C + D) (D + E) (E + C) (E + B)) (E C)) 3[3]: (GRAPH-WALKER D ((A + B) (B + C) (C + D) (D + E) (E + C) (E + B)) (D E C)) 3[3]: returned NIL 2[3]: returned ((E)) 1[3]: returned ((C (B A) (B (E))) (C (E))) 0[3]: returned ((D (C (B A) (B (E))) (C (E)))) > ((D (C (B A) (B (E))) (C (E))))First, notice that the graph itself is passed along every time through the recursion. (Identify this in the above, it's always the second argument to the function.) Let's take that out of the trace output, which will simplify our understanding it. I'll replace it with "---":
0[3]: (GRAPH-WALKER D ---) 1[3]: (GRAPH-WALKER C --- (C)) 2[3]: (GRAPH-WALKER B --- (B C)) 3[3]: (GRAPH-WALKER A --- (A B C)) 3[3]: returned (A) 3[3]: (GRAPH-WALKER E --- (E B C)) 4[3]: (GRAPH-WALKER D --- (D E B C)) 4[3]: returned NIL 3[3]: returned ((E)) 2[3]: returned ((B A) (B (E))) 2[3]: (GRAPH-WALKER E --- (E C)) 3[3]: (GRAPH-WALKER D --- (D E C)) 3[3]: returned NIL 2[3]: returned ((E)) 1[3]: returned ((C (B A) (B (E))) (C (E))) 0[3]: returned ((D (C (B A) (B (E))) (C (E))))Now, let's begin by identifying the calls versus the returns. The returns are labeled, and the calls are the rest. Let's mark them with "->" for calls, and "<-" for returns:
-> 0[3]: (GRAPH-WALKER D ---) -> 1[3]: (GRAPH-WALKER C --- (C)) -> 2[3]: (GRAPH-WALKER B --- (B C)) -> 3[3]: (GRAPH-WALKER A --- (A B C)) <- 3[3]: returned (A) -> 3[3]: (GRAPH-WALKER E --- (E B C)) -> 4[3]: (GRAPH-WALKER D --- (D E B C)) <- 4[3]: returned NIL <- 3[3]: returned ((E)) <- 2[3]: returned ((B A) (B (E))) -> 2[3]: (GRAPH-WALKER E --- (E C)) -> 3[3]: (GRAPH-WALKER D --- (D E C)) <- 3[3]: returned NIL <- 2[3]: returned ((E)) <- 1[3]: returned ((C (B A) (B (E))) (C (E))) <- 0[3]: returned ((D (C (B A) (B (E))) (C (E))))Next, let's identify all the arguments to the function in the calls. We've already identified and simplified the graph which never changes, and we replaced that with "---". But the other arguments: TO-PROT and SEEN do change in each call! I've marked them here in red (for the TO-PROT) and blue (for SEEN):
-> 0[3]: (GRAPH-WALKER D ---) -> 1[3]: (GRAPH-WALKER C --- (C)) -> 2[3]: (GRAPH-WALKER B --- (B C)) -> 3[3]: (GRAPH-WALKER A --- (A B C)) <- 3[3]: returned (A) -> 3[3]: (GRAPH-WALKER E --- (E B C)) -> 4[3]: (GRAPH-WALKER D --- (D E B C)) <- 4[3]: returned NIL <- 3[3]: returned ((E)) <- 2[3]: returned ((B A) (B (E))) -> 2[3]: (GRAPH-WALKER E --- (E C)) -> 3[3]: (GRAPH-WALKER D --- (D E C)) <- 3[3]: returned NIL <- 2[3]: returned ((E)) <- 1[3]: returned ((C (B A) (B (E))) (C (E))) <- 0[3]: returned ((D (C (B A) (B (E))) (C (E))))Okay, so now we're ready to watch the recursion happening: We go from D to C to B to A, and as we're doing that, we go from having no SEEN list, to (C) on the seen list, to (B C) on the seen list, to (A B C) on the seen list... and since A has no controlling proteins, that path is done, and we return (A). Notice now that we're back only to the B level, and B is also controlled by E, so next we go down to E, and the seen list is (E B C). E is controlled by D, so we next try D with seen=(D E B C) and the controllers of D is C... but C is already on the SEEN list!, so we break out of this path (return NIL)... and so on. Each time we come back up along the path we've gone down, the CONS in line 6 adds the current protein to the head of the list we're building.
Don't worry if you're slightly lost. This whole thing is very hard to envision, and pretty hard to explain too! It's something that you just have to get used to envisioning. It's like, the function is taking things apart on the way down, and putting them back together on the way back up from the recursion.
Now do the exact same thing as above, but permit the names of the nodes to be different. [Hint: This one's a lot HARDER than it seems! You might try first just testing graphs for being exactly equal, although with possibly different node names and the edges appearing in possibly different order, and then consider what it means for one to be a subset of the other. If you can't get this to work, just provide a detailed explanation of the solution in words and/or pseudocode.]
2. This has a number of parts that eventually come together.
First write a function that takes two numbers and computes their difference. As:
(compare-numbers 10 15) => 5 (compare-numbers 15 10) => 5(The ABS function will help!)
Next, use that function to take an ordered list of numbers, and select the first "most related" set (by your COMPARE-NUMBERS function). You'll have to give a cutoff to this function to tell what "most related" means.
For example:
(top-set 5 '(1 4 7 10 15 21 23 35 50 51 60 70)) => (1 4 7 10 15) The difference between 15 and 21 is more than 5, so it stopped there. Another example: (top-set 1000 '(1 4 7 10 15 21 23 35 50 51 60 70)) => (1 4 7 10 15 21 27 35 50 51 60 70) (top-set 0 '(1 4 7 10 15 21 23 35 50 51 60 70)) => (1)With a high enough cutoff of you should get back the whole set, and at a low enough cutoff you should get back just the first element.
Here's the outline of a solution to this part of the problem, with some of the recursive step left out. Fill in the ?????? and test the function.
(defun top-set (n l) (cond ((null (rest l)) l) ((<= (compare-numbers (first l) (second l)) n) (cons (first l) (top-set n ?????????))) (t (list (first l)))))[Note, you can also create a perfectly fine non-recursive solution to this part.]
Next -- and here's the hard one: Use your TOP-SET to write a recursive function which, given the same list of strings, does successive set differences until the set runs out, and gives you back the result as a set of top sets from each successive cut.
Examples:
(break-up 5 '(1 4 7 10 15 21 23 35 50 51 60 70)) => ((1 4 7 10 15) (21 23) (35) (50 51) (60) (70))Again, here the outline of a solution with the recursion missing (hint: it uses SUBSEQ and LENGTH). Replace the ????? and test this:
(defun break-up (n l) (let ((top-set (top-set n l))) (if top-set (cons top-set (break-up n ???????????????????????????)) l)))
Okay, now, here comes the good part: Remember from the BioBike tour the function SCORE-ALIGNMENT, which scored the alignment between a pair of genes. Go back and make sure you understand how that worked.
Good, now replace your COMPARE-NUMBERS above with SCORE-ALIGNMENT, making changes either to SCORE-ALIGNMENT or to other code here, as needed. The goal is to be able to pass in a set of genes, and an alignment difference cutoff, and cluster the genes into sets of pairs of genes with similar alignment scores. Use cutoffs of a few % and find a level that groups the genes (from the Tour) into a few groups.
[Hint: This isn't as hard as it sounds. It's very nearly just a matter of passing the sorted output of SCORE-ALIGNMENT -- that is, the sorted list of cross-alignments -- into the thing you've just written above!]
Copyright 2006 by The BioBike Team (contact jshrager@stanford.edu)


To use an icon simply apply the {{ iconSetClass }} class along with one of the following classes:
{{ iconSetClass }}
To use an icon apply the ux-icon component along with one of the following names. Click on an icon to view its implementation.
ux-icon


Public Comment Period is ScheduledNow OpenNow Closed
{{ period.dateStarted | amDateFormat:'MMMM Do, YYYY' }} - {{ period.dateCompleted | amDateFormat:'MMMM Do, YYYY' }}
This Public Comment Period is regarding the {{period.informationLabel}} and the {{period.ceaaInformationLabel}}.
The purpose of this comment period is for the public to see EAO’s draft conclusions before a decision is made, and be able to see how their comments in previous public comment periods have been addressed. Following the public comment period, EAO’s draft assessment report and/or conditions may be adjusted, if necessary, in response to the public comments.


Founded in 2020 by the Lucky sisters, our establishment has been serving up rich pizza sourced from artisan farmers in various regions of East and West Malaysia. We are dedicated to travelling the world, finding the best ingredients, and bringing back to you here in our shop.
 Join us for your daily routine, an outing with friends, or simply just to enjoy some alone time.
Graphic Designer
Umaira Safia binti Mohd ShukriWeb Developer
Syazwana binti MatBusiness Analyst
Asmahamiyah binti AmenSystem Administrator
Lyana Syakila binti Mohd HadiDatabase Administrator
Iffah Zulaikha binti Effendy


Josh's dogs
Great dane
Josh's dog's name is Kali. She is smaller than the typical great dane, but she makes up for it in love.
- Drools every time you're eating food near her
- Has to cuddle at all times
- Sleeps between her parents
- Only poops once a day
- Loves Daria's homemade treats
To learn more about Great Danes Click Here
Mark's dogs
Miniature schnauzer
Mark's dog's name is Atticus. He is afraid of wood surfaces.
- Licks his nose when he hears a toy squeak
- Poops with his leg lifted
- Disgusted by children's voices
- Jumps with his hind legs when his butt is scratched
To learn more about Minature Schnauzers Click Here


Click the below button
Vivekananda Institute Of Professional Studies
x
- Welcome to VIPS
It was in the year 1997, that Dr. S.C. Vats, founder of Vivekananda Institute of Professional Studies (VIPS), met Swami Jitatmanandaji, an eminent educationist,management expert, author of books on Modern Physics & Vedanta and Indian Ethos in Management, an active social worker and the editor of Prabudh Bharat(Awakened India), a journal started by Swami Vivekananda.
- About
Vivekananda Institute of Professional Studies is in Pitampura, New Delhi, India. It is a private college, affiliated with Guru Gobind Singh Indraprastha University.


System Architect Symbol details for "Agent/Lifespan"
Active (State)
end (Transition)
- From State:
Suspended
- To State:
Ended
end (Transition)
- From State:
Active
- To State:
Ended
Ended (State)
make active (Transition)
- From State:
Proposed
- To State:
Active
Proposed (State)
- Number:
0
suspend (Transition)
- From State:
Active
- To State:
Suspended
Suspended (State)
unsuspend (Transition)
- From State:
Suspended
- To State:
Active


Locally Linear Embedding¶
CodeSnippet
You can download all the code on this page from the code snippets directory
Locally linear embedding (LLE) approximates the input data with a low-dimensional surface and reduces its dimensionality by learning a mapping to the surface. Here we consider data generated randomly on an S-shaped 2D surface embedded in a 3D space:
The surface is defined by the function
>>> def s_distr(npoints, hole=False):
... """Return a 3D S-shaped surface. If hole is True, the surface has
... a hole in the middle."""
... t = mdp.numx_rand.random(npoints)
... y = mdp.numx_rand.random(npoints)*5.
... theta = 3.*mdp.numx.pi*(t-0.5)
... x = mdp.numx.sin(theta)
... z = mdp.numx.sign(theta)*(mdp.numx.cos(theta) - 1.)
... if hole:
... indices = mdp.numx.where(((0.3>t) | (0.7<t)) | ((1.>y) | (4.<y)))
... return x[indices], y[indices], z[indices], t[indices]
... else:
... return x, y, z, t
We generate 1000 points on this surface, then define an LLENode with parameters k=15 (number of neighbors) and output_dim=2 (the number of dimensions of the reduced representation), then train and execute the node to obtain the projected data:
>>> n, k = 1000, 15
>>> x, y, z, t = s_distr(n, hole=False)
>>> data = mdp.numx.array([x,y,z]).T
>>> lle_projected_data = mdp.nodes.LLENode(k, output_dim=2)(data)
The projected data forms a nice parametric representation of the S-shaped surface:
The problem becomes more difficult if the surface has a hole in the middle:
In this case, the LLE algorithm has some difficulty finding the correct representation. The lines
>>> x, y, z, t = s_distr(n, hole=True)
>>> data = mdp.numx.array([x,y,z]).T
>>> lle_projected_data = mdp.nodes.LLENode(k, output_dim=2)(data)
return a distorted mapping:
The Hessian LLE Node takes the local curvature of the surface into account, and is able to find a better representation:
>>> hlle_projected_data = mdp.nodes.HLLENode(k, output_dim=2)(data)


Report an incident or accident
Determine the type of incident
Were multiple incident types involved?
Yes
No
Select the most severely impacted incident type
People
Assets
Environment
Security
Who sustained this incident?
Me
Another Person
When did this incident occur?
Start date:
Time:
Incident Category:
--Select time category--
Approved Recess(eg. lunch)
Domestic travel
On Duty( example: doing research work)
Travelling to or from work
Where did this incident occur?
Select location:
--Select location of incident--
Location 1
Location 2
Location 3
Location 4
Location Details:
Submit


RESOURCES
Course OverviewASSIGNMENTS
STAFF
ANNOUNCEMENTS
We posted practice finals. The solutions to the first practice final are up, and the solutions to the second practice final will be posted on Friday.
We put together a demo of all the search algorithms (to be updated as we learn more). Check it out:
Come one, come all! This Friday December 2nd, 3:30pm-4:30pm in Bishop Auditorium we'll be holding the last YEAH hours of the quarter. A reminder that you may not use a late day for Trailblazer, so we definitely recommend you start early!
The YEAH hours for Huffman Encoding will be this Thursday, November 17 8-9pm at 320-105! Huffman encoding is an awesome algorithm, but it definitely can be tricky, so I envision these YEAH hours to be particularly useful. We will try to film, as usual. See you there!
We'll be holding PQueue YEAH hours this Thursday November 10, 8-9pm at 320-105 (note that this is a different room than usual). Even though the assignment was released on Monday, we won't be going over Binary Heaps (a large part of the PQueue assignment concerns heaps) until Wednesday, which is why we're holding YEAH hours slightly later this time around. We will once more try to record the session.
Midterm exams have been handed back electronically via gradescope. To help you get a big picture of how you are doing we published the class distribution, and midterm solutions. Good work! We were impressed.
Update: we posted the second practice midterm and solutions to the first.
We made a midterm info page (and will continue to update it) with practice midterms, reference sheets and tips for taking exams by hand. The first practice midterm is up.
The midterm will be on Thursday November 3rd 7:00-9:00pm. We suggest you arrive a few minutes early, so that we can start on time. We will be located in two different rooms. You will go to a room depending on the first letter of your last name, as follows:
Last name starts with A-R: Cemex Auditorium (GSB)
Last name starts with S-Z: Braun Auditorium (Mudd Chemistry Building)
If you're in Braun, there's construction all around, so you may have a harder-than-usual time getting there. Plan accordingly and arrive early!
We will be holding a Midterm Review Session Sunday October 30th at 7:00-8:30pm in Bishop Auditorium. We'll be going over the various topics for the midterm, working out problems for each of them, and discussing strategies for studying and for taking the written exam. You won't want to miss it!
YEAH Hours for the fourth assignment, Boggle, will be Monday, October 24th 7-8pm in 420-041. This is among the most involved assignments in this class, so it's definitely a session you won't want to miss!
We will be recording the session.
Excited to get a head start on the third assignment? YEAH hours for Homework 3: Meta Academy will be this Monday October 17 at 7:00pm-8:00pm in 420-041. The YEAH hour will be recorded, for those who can't make it. See you there!
A student astutely pointed out that we didn't have a particularly diverse set of texts for the Serafini homework assignment. We have rectified this by adding the following texts:
You can download the texts via this link: Other texts for Serafini
To install the texts so you can use them in your program:
There have been a number of posts asking about why our Scatter example output is less blurry than yours. It turns out that in our solution, we interpreted "radius" to just be to the right and down on the image (not left/up, as well), which is contrary to our responses on Piazza and in office hours / LaIR.
So, we will accept solutions that meet either criteria. In other words, if you interpreted the scatter radius to be to the left/right and up/down distance away from the original pixel, that's fine. Or, if you interpreted the scatter radius to just be to one side and one vertical direction, we will accept that, too.
To reiterate: if your solution for Scatter is coming out much more blurry than our solution, that is probably fine, and we will accept it if you have a reasonable interpretation of the problem.
We're very sorry for the confusion, and thanks to everyone who posted a question about it!
Please respond in this thread in Piazza if you have further questions or concerns.
Excited to get a head start on the second assignment? YEAH hours for Homework 2: ADTs will be this Friday October 7 at 4:00pm-5:00pm in 420-041. The YEAH hour will be recorded, though we will have a secret surprise to those who come to the session. See you there!
See the video below for Anton's introduction to the Fauxtoshop assignment.
See below for a short instructional video on how to create a blank project from a copy of another project.
Fauxtoshop, the first assignment, is out! It is due next Friday (Oct 7th) at noon. Get started early and come to YEAH hours (which will be recorded) Wednesday September 28 at 7:00pm-8:00pm in 420-041.
We'll be holding special Qt help session hours in the LaIR (second floor of the Old Union) 8-9pm Thursday September 29. Please come only if you've tried installing Qt Creator and have problems that are not addressed in the FAQ or the troubleshooting guide!
CS106B will be recorded this quarter, and will be available at 7:00pm same day of class lecture. Lectures are not downloadable, but are streamable throughout the Fall '16 quarter. These recordings are for on-campus students only - CS106B is not an SCPD course this quarter. The link to access these videos is:
Every CS106B assignment will have YEAH (Your Early Assignment Help) hours. In these one-hour sessions we will delve into the homework collectively and try to tackle any questions or immediate issues we have with the write-up or what the assignment requires. These are super useful, and can cut many hours of head scratching for you when dealing with the assignments in this course.
The first YEAH hour will be this Wednesday September 28 at 7:00pm-8:00pm in 420-041. See you there!
This is a very simple assignment that demonstrates that you have successfully installed Qt Creator on your computer and can run a short test program. Your only submission requirement is to put the result of the program (you will see what this means when you run it!) into a Google Form, located here:
This assignment is not meant to be stressful – we just want you to get Qt Creator going early so you don’t get realistically stressed out for the first real assignment.
This quarter CS106B is using Piazza to facilitate questions. Go to piazza.com/stanford/fall2016/cs106b/home to sign up. You can ask course related questions and see answers to other student questions. For personal questions please feel free to email Anton or either Chris.
Welcome to CS106B! We are looking forward to a fun quarter. Class starts Monday Sept 26th at 12:30am in Hewlett 200.


Spoilers: Jade frames young Hope for arson in cruel Corrie scheme
Scheming nanny Jade Rowan (Lottie Henshall) has taken another step into the dark side after she has shamelessly framed a young child for starting a fire in Coronation Street. The tutor clearly has an axe to grind with Fiz Stape (Jennie McAlpine) and Tyrone Dobbs (Alan Halsall) and she certainly managed to cause a big rift in the family tonight.
As a fire took hold out in the back yard, Fiz and Tyrone were horrified to find Hope watching it in a trance while the flames almost injured Jack Webster. As Fiz deduced that Hope must have been responsible for the arson, Tyrone was staggered when she admitted that she believes her daughter was also behind the fire at the factory several months ago.
As Tyrone let rip at Hope, telling her he didn’t want to be around an arsonist, Fiz tried to calm things down while Jade watched and offered to take Hope up to her room. As she did so, she assured the youngster that she believes her, even if her mummy doesn’t.
Advertisement Advertisement
With Hope taking confidence from this, Jade smirked to herself and stuffed a box of matches in her own back pocket, confirming that she had in fact started the fire in order to frame Hope. But what is her motive for wanting to bring harm to the family?
It is just the beginning of her spiteful vendetta too as future scenes will see her make accusations of child abuse against Fiz and Tyrone, leading to the couple facing court. And when social services take their children away, they are broken hearted.
As viewers begin to learn more about Jade and what she has against the family, another revelation will come this week – but the nightmare is only just starting for Fiz and Tyrone.
But how far will Jade go to destroy them?


Task #{{task_id}}
The seat has been {{ action }} on {{ departure_date }}, from {{ departure_point }} to {{ destination_point }}
Details:
Train:
{{ train }}
Car:
{{ car }}
Seat:
{{ seat }}


#include <dcache.h>
Public Member Functions | |
| DCache (int lineSize, int nbLines, int nbWays) | |
| ~DCache () | |
| int | LoadLine (int physaddress) |
| void | Lock (int flag) |
| void | Print (void) |
Private Attributes | |
| DCacheLine ** | cacheLines |
| int | nbLines |
| int | lineSize |
| int | nbWays |
| int | nbSets |
| int | locked |
| unsigned long int | lastUse |
The data cache is virtually addressed and physically tagged. Its size and associativity can be set (parameters to the constructor). The cache has a LRU replacement policy. It has a cache locking capability to freeze its contents with its current contents
|
|
Create a new empty instruction cache with the specified dimensions |
|
|
Deletes the instruction cache (frees its contents) ---------------------------------------------------------------------- |
|
|
Load a cache line with instructions from given address has no effect if locked != CACHE_UNLOCKED and all corresponding cache lines are valid, or if the address is already in cache. Return CACHE_HIT if there was a cache hit, CACHE_MISS if there was a miss. |
|
|
Lock the cache if flag != CACHE_UNLOCKED, unlock otherwise |
|
|
Display the cache contents |
|
|
Cache contents |
|
|
Used for the LRU cache replacement policy |
|
|
Line size in bytes |
|
|
if non-zero, allow replacement of any cache line |
|
|
Number of cache lines |
|
|
Number of sets (= nbLines/nbWays) |
|
|
Set associativity of the cache (1 for direct-mapped) |


{% extends 'basics/base.html' %} {% block content %}
You need:
we need electricity!
You helped:
Irgend eine Beschreibung
Need Toothpaste
need a few bed sheets


It's possible to create your own status widget just by listening to "status" events from thebe, but the library also includes an easy to use status widget, with minimal styling that you can add to you page.
To add the widget. just add an element with the
.thebe-status
class to your page:
And set mountStatusWidget:true
to the
thebe
options.
This cell will turn into the live cell:
%matplotlib inline import numpy as np import matplotlib.pyplot as plt x = np.linspace(0,10) plt.plot(x, np.sin(x)) plt.plot(x, np.cos(x))


Research Interest
I am interested in the relationships between religion and politics in general, and, specifically, in the interactions of religion, secularism, and nationalism. My regional concentration is on the Middle East, the Caucasus, and Central Asia.
Dissertation
My dissertation examines the interaction of religion, secularism and nationalism in Iranian (Southern) Azerbaijan and Caucasian Azerbaijan (now the independent Republic of Azerbaijan). Azerbaijanis were part of the same political establishment until their split in 1828. Why did Northern Azerbaijanis establish two independent states, interrupted by a period as a Soviet Republic, while Iranian Azerbaijanis—the largest minority in the Middle East with a population two times the size of Northern Azerbaijan—remained a part of Iran, even at times of permissive political conditions for secession and independence?
Goals
As a professor, my purpose is to design and teach my courses in a way that helps my students learn the course content, improve their critical and analytic thinking skills, and become systematic observers of social and political phenomena. I want students to demonstrate the skills of deep inquiry and to be skeptical consumers of knowledge in the current media-saturated environment. Moreover, I want my students to communicate effectively with others and to articulate, defend, and revise their own ideas. Furthermore, I aim to help my students use their newly acquired knowledge and skills in their daily lives, both to improve their own lives and the lives of others.
Courses Taught


To practice as a Medical Physicist in North America one has to become certified by the ABR. As of 2014, only those who have graduated from a CAMPEP accredited Medical Physics residency are eligible to take the ABR exams, and thus able to pursue the practice.
Something nice that has come from this is that CAMPEP requires schools to post several statistics pertaining to enrolment and employment of their students. However, there are no regulations for how this data is to be presented, resulting in a situation where each school posts the stats in a different way. Some schools post a .pdf on their homepage, others bury it with grad school admission statistics, others are accessible using only the skeleton key provided to the dean.
I wanted to get an overview of these statistics, and to do so I combed through all of the schools on the accredited schools list and compiled it here, with a convenient Shiny app to allow some data exploration. Here is the app:
I was somewhat surprised to see that, despite much naysaying on the part of JACMP, MSc degrees have similar rates for obtaining residencies as do their PhD counterparts.
Of note also is the approximate number of graduates. JACMP has mentioned that in North America there is a need for 150-175 new Medical Physicists each year, however the number of graduates in 2012 was close to 250. The number of graduates drops under 150 for 2013, but this may be due to incomplete reporting of 2013 statistics at the time of data compilation. Clearly there is a bit of a mismatch between supply and demand. CAMPEP has stated that they are working to increase the number of residency positions to meet the increased demand.
There are several things to note about the above app:


Delete a Category
Are you sure you want to delete this category?
Deleting this category will also delete all subcategories, assignments, and scores.
Yes
No
Delete Category


Introduction
Hello there, awesome person!
This is a link to GitHub!
This is the link to Google
The link to Pinterest


Bromine.Test Class
A Test Instance
Constructor
Bromine.Test
-
options
Parameters:
-
options
Object-
[init]
Function optionala function to execute before test start
-
[destroy]
Function optionala function to execute after the test ends (should be used for cleanup)
-
[tests]
Array optionala queue of functions to run
-
[depend]
String optionala test dependancy
-
[fail_timeout=10s]
Integer optionalhow much time to wait for tests to finish before reporting failure
-
Item Index
Methods
Methods
next
()
calls the next function in the stack
-
message
signifies a test failure. Will stop any more steps from running
Parameters:
-
message
String
next
()
calls the next function in the stack
current
()
calls the current function in the stack
prev
()
calls the previous function in the stack
done
-
state
-
[message]
Called when tests are done
Parameters:
-
state
Boolwhether test passed or failed
-
[message]
String optionalonly used on failure
done
-
state
-
[message]
Called when tests are done
Parameters:
-
state
Boolwhether test passed or failed
-
[message]
String optionalonly used on failure
current
()
calls the current function in the stack
prev
()
calls the previous function in the stack
addEvent
-
the
-
a
Adds an event
addEvents
-
literal
Helper to add multiple events at once
Parameters:
-
literal
Objectobject of event types => callbacks
fireEvent
-
event
-
arguments
dispatches an event
Parameters:
-
event
Stringtype
-
arguments
Mixedto pass with the event
removeEvent
-
event
-
function
removes a function from an event
addEventOnce
-
the
-
a
Adds an event for one execution, then removes it
fireLatchedEvent
-
the
-
arguments
Fires a latched event
Parameters:
-
the
Stringevent type
-
arguments
Mixedto pass with the event
-
message
signifies a test failure. Will stop any more steps from running
Parameters:
-
message
String
run
()
runs the tests
run
()
runs the tests
Properties
Events
destory
fires on object destruction
destory
fires on object destruction
done
fires if and when the test has finished running successfuly
done
fires if and when the test has finished running successfuly
fail
fires if and when the test has finished running but failed
fail
fires if and when the test has finished running but failed
start
fires when test starts running. Latched
start
fires when test starts running. Latched


Octree container.
More...
#include <Octree.hpp>
|
| uint8_t | findNodeNb (T_Node const &node) const |
| | Method use to find the index of node inside the root node. More...
|
| |
| void | setChild (T_Node &parent, T_Node &child) |
| | Set child as child of parent. More...
|
| |
| void | setChild (T_Node &parent, T_Node &child, uint8_t childId) |
| | Set child as child of parent. More...
|
| |
| void | removeParent (T_Node &child) |
| | Remove the parent node of child from the octree. More...
|
| |
| T_Node * | removeChild (T_Node &parent, uint8_t id) |
| | Remove the child with id from the parent node. More...
|
| |
| T_Node * | findParentNode (T_Node &parent, T_Node &node, uint8_t &childId) const |
| | Find node inside parent that can contain node. More...
|
| |
| T_Node * | push (T_Node &parent, T_Node &node) |
| | Push node inside parent. More...
|
| |
| T_Node * | push (T_Node &parent, T_Node &child, uint8_t childId) |
| | Push node inside parent. More...
|
| |
| void | insertNode (T_Node &child, T_Node &newChild) |
| | Create parent node that can contain child and newChild and push it into octree. More...
|
| |
| void | merge (T_Node ¤tNode, T_Node &newNode) |
| | Merge two nodes. More...
|
| |
template<class T_Node>
class voxomap::Octree< T_Node >
Octree container.
Definition at line 22 of file Octree.hpp.
◆ Node
◆ Octree() [1/3]
◆ Octree() [2/3]
◆ Octree() [3/3]
◆ ~Octree()
Default virtual destructor.
◆ operator=() [1/2]
Assignement operator.
- Parameters
-
- Returns
- Reference to this
◆ operator=() [2/2]
Assignement move operator.
- Parameters
-
- Returns
- Reference to this
◆ push() [1/3]
Pushes node into the octree.
- Parameters
-
◆ pop()
template<class T_Node >
| virtual std::unique_ptr<T_Node> voxomap::Octree< T_Node >::pop |
( |
T_Node & |
node | ) |
|
|
virtual |
Removes node from the octree.
- Returns
◆ findNode()
template<class T_Node >
| T_Node* voxomap::Octree< T_Node >::findNode |
( |
int |
x, |
|
|
int |
y, |
|
|
int |
z, |
|
|
int |
size |
|
) |
| const |
Search the node that corresponds to the parameters.
- Parameters
-
| x | X coordinate of the node |
| y | Y coordinate of the node |
| z | Z coordinate of the node |
| size | Size of the node |
- Returns
- Pointer to the node if it exists otherwise nullptr
◆ clear()
Clear the octree Removes all nodes and all elements.
◆ getRootNode()
Getter of the root node.
- Returns
- The root node
◆ findNodeNb()
Method use to find the index of node inside the root node.
- Parameters
-
- Returns
- The index
◆ setChild() [1/2]
template<class T_Node >
| void voxomap::Octree< T_Node >::setChild |
( |
T_Node & |
parent, |
|
|
T_Node & |
child |
|
) |
| |
|
protected |
Set child as child of parent.
- Parameters
-
| parent | Parent node |
| child | Child node |
◆ setChild() [2/2]
template<class T_Node >
| void voxomap::Octree< T_Node >::setChild |
( |
T_Node & |
parent, |
|
|
T_Node & |
child, |
|
|
uint8_t |
childId |
|
) |
| |
|
protected |
Set child as child of parent.
- Parameters
-
| parent | Parent node |
| child | Child node |
| childId | Id of the child inside parent's children array |
◆ removeParent()
Remove the parent node of child from the octree.
◆ removeChild()
template<class T_Node >
| T_Node* voxomap::Octree< T_Node >::removeChild |
( |
T_Node & |
parent, |
|
|
uint8_t |
id |
|
) |
| |
|
protected |
Remove the child with id from the parent node.
- Returns
- The removed node
◆ findParentNode()
template<class T_Node >
| T_Node* voxomap::Octree< T_Node >::findParentNode |
( |
T_Node & |
parent, |
|
|
T_Node & |
node, |
|
|
uint8_t & |
childId |
|
) |
| const |
|
protected |
Find node inside parent that can contain node.
- Parameters
-
| parent | Parent node |
| node | The new node |
| childId | Id of the node inside the found parent |
- Returns
- The found parent node, nullptr if not exist
◆ push() [2/3]
Push node inside parent.
- Parameters
-
| parent | Parent node |
| node | Node to push |
- Returns
- Node added, can be different than node if a similar node already exist
◆ push() [3/3]
template<class T_Node >
| T_Node* voxomap::Octree< T_Node >::push |
( |
T_Node & |
parent, |
|
|
T_Node & |
child, |
|
|
uint8_t |
childId |
|
) |
| |
|
protected |
Push node inside parent.
- Parameters
-
| parent | Parent node |
| child | Child node |
| childId | Id of the child inside parent's children array |
- Returns
- Node added, can be different than node if a similar node already exist
◆ insertNode()
template<class T_Node >
| void voxomap::Octree< T_Node >::insertNode |
( |
T_Node & |
child, |
|
|
T_Node & |
newChild |
|
) |
| |
|
protected |
Create parent node that can contain child and newChild and push it into octree.
◆ merge()
template<class T_Node >
| void voxomap::Octree< T_Node >::merge |
( |
T_Node & |
currentNode, |
|
|
T_Node & |
newNode |
|
) |
| |
|
protected |
Merge two nodes.
- Parameters
-
| currentNode | Node already present in the octree |
| newNode | Node to merge inside |
◆ _rootNode
Main node of the octree.
Definition at line 153 of file Octree.hpp.
The documentation for this class was generated from the following files:
- C:/Users/micce/projects/voxomap/octree/Node.hpp
- C:/Users/micce/projects/voxomap/octree/Octree.hpp


South African photographer depicts children's emotions at Paris art fair
by Isabelle MartinettiJustice Mukheli was one of the South African photographers featured at the 4th edition of the Also Known As Africa (AKAA) contemporary art fair in Paris, running from 9 to 11 November.
45 galleries from 19 countries showcase artists from Africa. Among them, Justice Mukheli from South Africa's Dyman Gallery.
Justice Mukheli grew up in the township of Soweto, Johannesburg.
After working in advertising as an art director, he became a photographer "by chance," as he told RFI at the AKAA Fair.
"South Africa is predominately black. But when I was working in advertising, photographs were not showing black people the way I see them, from a black person's point of view. "
"When you google South Africa and Soweto, where I come from, you find images that do not truly represent the reality I know, and the reality of now. […] I realised that the biggest struggle now for South African youth is the way we are seen."
Listen to the interview
In the work presented at the AKAA Fair in Paris, Mukheli shows a series of pictures representing two children named Thabelo and Maanda.
Through the series, Mukheli captures emotions that he was told not to express as a child in the Soweto township in Johannesburg.
"In my upbringing as a kid, I didn’t have much options or opportunities to express how I felt about things that made me sad. Crying, being sad or angry, anything that wasn’t happiness, emotions that, as boys, we were not allowed to feel."


| title | color | order | courses | #segments | #parents | #children | #dependencies | actions |
|---|---|---|---|---|---|---|---|---|
| {{concept.title}} | {{concept.order}} | {{concept.courses}} | {{concept.segments.length}} | {{concept.parents.length}} | {{concept.children.length}} | {{concept.dependencies.length}} | edit |


|
View PIT_TRACE_LEVEL_V PIT_TRACE_LEVEL values with translated name, display_name and description |
| Columns |
| Name | Type | Optional | Default | Comments |
| PTL_ID | NUMBER | Y | ||
| PTL_NAME | VARCHAR2(128) | |||
| PTL_DISPLAY_NAME | VARCHAR2(800) | Y | ||
| PTL_DESCRIPTION | CLOB | Y |
| SQL |
create or replace view pit_trace_level_v as select ptl_id, ptl_name, pti_display_name ptl_display_name, pti_description ptl_description from pit_trace_level join pit_translatable_item_v on ptl_pti_id = pti_id; comment on table PIT_TRACE_LEVEL_V is 'PIT_TRACE_LEVEL values with translated name, display_name and description';


How often has it been the case where you want to travel to a location but have no idea where to start? Even if you start you end up opening thousands of tabs.
ChatIT is a Social Itinerary Application which provides an easy and social alternative
to build up a travel itinerary for any location you choose. We bring passionate travelers who want to share their experiences on a platform and also allow others to go out into the world and explore.
Lets explore the unexplored
beautiful places brought up by the experiences of previous travelers and travel like a local!
Created by travelers for travelers!
Details of each perssonal experience!
24/7 Available Chatbot Service


Please use the Work Orders form for the Laundry Machines. (Room #: L12-Laundry)
*Note Room # is not required to submit a form. Use the description to describe the issue.
Work Orders
The advising tool for planning and tracking your classes and graduation requirements now exists in Public ->
Advising Tool. It's very helpful; you should check it out!


At least 27 dead as Congo plane crashes in Goma
The aircraft crashed into residential homes near Goma’s airport in the North Kivu province.
by APAt least 27 people were killed, including some on the ground, when a small plane crashed into a densely populated neighbourhood in the city of Goma in eastern Democratic Republic of Congo on Sunday, a rescue official said.
The propeller plane, which was operated by local company Busy Bee, crashed shortly after take-off en route to the city of Beni, about 250 km to the north, officials said.
The company said the 19-seater Dornier 228-200 had 16 passengers and two crew members on board.
There was no word yet on what might have caused the accident.
Joseph Makundi, the coordinator of rescue services in Goma, told Reuters that 27 bodies had been recovered from the rubble, including those of several people hit by falling debris.
“I was at a restaurant with my family when I saw the plane spinning three times in the air and emitting a lot of smoke,” said Djemo Medar, an eyewitness. ”After that we saw the plane crash into this house,” he said.
Air accidents are relatively frequent in Congo because of lax safety standards and poor maintenance. All Congolese commercial carriers, including Busy Bee, are banned from operating in the European Union.
The U.N. mission in Congo said it has sent an Emergency Crash and Rescue team with two fire engines to support Congolese authorities.


This web server is based on rest.bitcoin.com. Go there to view an interactive UI of the REST API endpoints.


Jumo harnesses RFID technology to log student athlete practice hours. This is handled in the back end so coaches now only need to tap in and out with an RFID card and we do the rest.
Logging practice hours for a whole team is not only a hassle for coaches, but it also cuts into their busy schedule. With Jumo, coaches no longer need to spend hours of their time trying to remember what time Johnny practiced.
RFID technology removes the human error that the world is prone to. The old days of mistakenly logging incorrect log sheets are no more.


.
The Living Knowledge Network is an emergent property of community projects working to build the Internet of Science from first principles. The Foundation will coordinate code compatiabilty and create an universal knowlege token, a new currency to value science.
Open permissionless participation.


---
layout: post
title: President Obama You Lied
date: 2011-08-10 03:43:37.000000000 -05:00
comments: true
categories: []
published: true
---
Please don't get me wrong. I am one of those people that supported your nascent campaign once you declared in Illinois. If I could have voted in 2008, I would have voted for you.
Even though I am not Congressman Wilson, I have to say it, you lied!

As is evidenced from the way you recklessly managed the debt ceiling issue, you clearly had the 2012 re-election campaign in your sights.
The right thing for the country, and the world, would have been for you to stick to loose fiscal policy in the immediate-short term, and lay out a credible medium term plan for reigning in the deficits and paying down the debt once the economy has fully recovered. But you did just the opposite - with allowing the Republicans to cajoling you into short-term spending cuts and shirking the responsibility for the real tough decisions (like tackling social security, and medicare reform) to a Congressional Committee.
The ironic thing is, as you can see from the markets reaction, if the economy continues to deteriorate and slips back into a recession just in the nick of time of the next re-election - you will likely be the worst combination of what you wanted.
A mediocre one-term president.
That would be a travesty, because you had so much potential.


Michelin-starred chef’s blinged up pot noodles
Daily Dish: How to transform noodles into an indulgent dinner for one
When I was a student, this was my favourite snack. I used to make it for myself before Kendo club. In those days, I just followed the instructions on the packet though. Place the noodles in water, boil, and then add the flavoured powder in the sachet.
I think this is a universally loved student dish, be it Pot Noodle or Koka noodles. But in Japan I had Nissin Noodles, Japan’s favourite noodles. Over the years, I have tweaked the recipe and finessed the presentation.
It is still my go-to comfort food and it’s a quick and tasty meal for when I’m busy. When I eat this, I am transported back to my student days in Japan and I still love this dish to this day.
What you’ll need:
Serves one
1 packet Nissin demae icchou (Kyushu tonkotsu flavour), or any instant noodle pot or packet
100g mussels
80g beansprouts
50g bacon or cooked ham
50g shredded cabbage
30g onion
30g carrot
1 ready-made Thai fish cake (from freezer aisles at Asian stores)
1 soft boiled egg (optional)
800ml water
20ml milk
Pinch salt
Pinch white pepper
Dash vegetable oil
Dash sesame oil
Irish Times
Food&Drink Club
Exclusive events, competitions, reviews & recipes Join now
How to make it:
1. To make soft boiled egg, drop egg gently into boiling water and boil for six to seven minutes. Put the boiled egg under cold running water until the egg gets cold. Peel the shell off carefully.
2. Slice carrot, onion and bacon or ham into strips. Chop spring cabbage and fish cake into slices.
3. Place a dash of vegetable oil into a frying pan and heat well. Stir fry the bacon or ham, carrot, onion and cabbage. Season with salt and white pepper.
4. Add 800ml of water and the mussels to the frying pan and bring to the boil with the ham and vegetables.
5. Add the flavoured powder in the sachet and the noodles. Boil for two minutes.
6. Add the milk, sliced fish cake and beansprouts. Boil for 30 seconds.
7. Place the noodles into a bowl, pour over the liquid and place the vegetables, ham and mussels on top.
8. Drizzle a dash of sesame oil over the top.
Takashi Miyazaki is chef patron at Michelin-starred Ichigo Ichie in Cork city, ichigoichie.ie


I am a Front End Web Developer.
In the past I worked as an Engineer for the oil industry in Brasil and in Norway. In the UK I worked as a Test Engineer for an Alarm Signalling Company. I learned programming at University and later taught myself web development through online courses.
Feel free to download my CV or scroll down for more information about me.
MSc in Marine Technology - Marine Operations
(2015 NTNU - Trondheim, Norway)
B.Eng. in Naval Architecture and Marine Engineering
(2011 UFRJ - Rio de Janeiro, Brazil)
Free Code Camp's Responsive Web Design Certification (May 2019)
Free Code Camp's JavaScript Algorithms and Data Structures Certification (April 2019)
Udacity's Configuring Linux Web Servers (May 2017)
Udacity's Intro to Relational Databases (May 2017)
Free Code Camp's Front End Development Certification (March 2017)
Udacity's JavaScript Basics (March 2017)
Udacity's Intro to jQuery (March 2017)
Udacity's Responsive Web Design Fundamentals (February 2017)
Udacity's How to use Git and GitHub (January 2017)
Udacity's Intro to HTML and CSS (January 2017)
Udacity's Intro to Computer Science (November 2016)
: JavaScript, CSS, HTML, Python, PostgreSQL, jQuery, Bootstrap, Sass, Git, Windows, Linux, MacOS, VitualBox, Docker
A Simon-like game. Remember 20 combinations and win the game. Try it in strict mode for a bigger challenge.
A Pomodoro Timer. Are you familiar with the Pomodoro Method? Set your work and rest intervals and start working knowing that your next break is coming in no time.
A Weather app that shows current weather at user location. (You will need to allow your browser to know your location.)
A Calculator.
A Wikipedia Viewer. Search wikipedia or be surprised by a random search.
A Technical Documentation Page.
A Survey Form for a fictional turism company.
A mockup Product Landing Page.
© 2019 NMR. All rights reserved. Icons provided by Glyphicons.


Items and projectiles
Now that the player and enemy are both in isometric space, and 30 is no longer hard-coded anywhere in our code changing the items and the projectiles to be isometric as well is going to be super easy. You might even be able to do it without this guide.
First, we update the sprites to use isometric version. Next, we want to make sure that both projectiles and items work in our debug overhead view. Finally, we apply the isometric projection with the helper function that lives in Map.cs. And that's pretty much it.
Here is the updates isometric.png sheet that has items and bullets on it:
New projet?
You can either do this in a brand new project, or keep working int he lat isometric one. I'll leave it up to you.
Updating tile sprites
The source rectangle for an item is defined in the constructor of the Item
object. We make new items (call the constructor) in Map.cs in the AddItem
function, which just forwards the source
argument. The AddItem
function is actually called in Game.cs. Find the following lines in Game.cs
room1.AddItem(spriteSheets, new Rectangle(350, 255, 16, 16), 10, new Point(4 * TILE_W + 7, 2 * TILE_H + 7));
room1.AddItem(spriteSheets, new Rectangle(381, 256, 13, 15), 20, new Point(5 * TILE_W + 7, 4 * TILE_H + 7));
room2.AddItem(spriteSheets, new Rectangle(412, 256, 16, 15), 30, new Point(4 * TILE_W + 7, 2 * TILE_H + 7));
Let's update the source rectangle, all items are going to use the same image. The new source rectangle is: Rectangle(20, 198, 44, 49). While editing these, go ahead and remove all the + 7 parts. 7 is the number we hard coded to put each item in the middle of a tile, now that tile sizes are different, 7 holds no meaning.
Also, this line is not valid:
room1.AddItem(spriteSheets, new Rectangle(20, 198, 44, 49), 10, new Point(4 * TILE_W, 2 * TILE_H));
This is because i accidentally changed where one of the obstacles are. instead of the obstacle being at tile 5, 2 it's at 4, 2. Meaning this items is directly inside an obstacle! Update it's position to be at 3, 2.
Go int Tile.cs and let's add an if statement to the Render
function to render the debug view of the item. Add an if statement, if Game.ViewWorldSpace
is true we render a debug square, if it's false we render the texture like normal.
The debug rectangle should be at the position specified by the Position
member variable. It should be of color Color.DarkSeaGreen
. As for size, both the width and the height are going to be Source.Width / 2. The size of the item works the same as the size of the player, so width is sprite width / 2 and height is width.
While we are in the render function, find where we offset the y pixel position of the tile: int yTile = (Position.Y - 1) / Game.TILE_H;
, get rid of the -1 offset. Because isometric tiles use a different registration point than cartesian tiles, we no longer need to apply this offset.
Run the game, you should now be seeing green item squares on the debug map. So long as your looking at the top down debug map you can even move around and collect the items!
Adding a shooting sprite
Shooting already works in the debug view. Go ahead, try it. The thing is, bullets never had a sprite to begin with, so we must provide them with one!
Let's start by adding two new variables to Bullet.cs. First, an integer, name it spriteSheetHandle
, next a Rectangle, name it sourceRect
. The initial value of sourceRect will be 43, 161, 22, 20
Update the Rect
getter to return a rectangle at the location of the Position
variable, with a width and height of source width / 2. The same logic that dictates the player width / height also dictates the bullet width / height.
Change the constructor to take a third argument, the new argument is an integer and is a sprite sheetreference. In the constructor, set spriteSheetHandle
equal to this new value.
In the Render
function, change ``Rectangle renderRectto
PoinF renderPoint. If
Game.ViewWorldSpaceis true, draw a red rectangle, use the
Rect``` getter for the actual rectangle object to draw.
If Game.ViewWorldSpace
is flse, draw the new bullet sprite. The spriteSheet is spriteSheetHandle
, the render poisition is renderPoint
, scale is 1 and the source rectangle is sourceRect
Trying to compile the game now you will get some compiler errors. This is because we changed the constructor, but not where it gets called.
In Game.cs make a new member integer, let's call it spriteSheetInstnace
. In the Initialize function, load the isometric sprite sheet into this. In the Shutdown function, don't forget to unload the image. Finally, where the new bullet is added, pass spriteSheetInstnace
in as the last argument.
Run the game, everything should more or less work as before. The bullet being shot in overhead view might look a little off center, but that's ok.
Isometric projection
Now that both bullets and items work in a 2D verhead view (that is, they work in world space) lets make them work in an isometric view by applying the proper projections and offsets!
In Bullet.cs take the renderPoint
variable and project it into isometric space using Map.CartToIso
. Of course, only do this after all offsets have been applyed. If you look where we first set the position, we subtract 5 from the X and Y. Remove the -5. It worked when we where in a top down view, but we don't need it anymore (right now i should say)
In Item.cs move the renderPosition
into isometric space.
Run the game, shoot some bullets, and check out where the items are. You will notice that both bullet shooting and item positions are way off from where we expect them to be. But why?
Remember how the player's registration point needed to be the same as the base tiles registration point? Well that holds true for all objects! Here is a picture:
Just like we offset player by 25, we're going to offset the present by 50 and the bullet by 57. The above image shows both bullet and present as having some height (y offset), don't let that fool you we're only going to apply an X offset.
In Bullet.cs, after you have converted renderPoint
into isometric space, add 57 to it's X value
In Item.cs, after you have converted renderPosition
into isometric space, add 50 to it's X value.
That's it! Run the game and you should have an awesome, interactive isometric world ready to go!


You may be trying to access this site from a secured browser on the server. Please enable scripts and reload this page.
The HRCompass Website
The site is currently down for maintenance


@@include('./header.html')
The Sport Scope 25’ is an endzone camera system that is manually operated by a pan and tilt system, which allows the operator the ability to smoothly and precisely control the movement of the camera. This system is perfect for quick-action sports, such as soccer. The Sport Scope 25’ is very easy and simple to setup, and like all of our other end zone video systems, it comes standard with everything you need to film right out of the box.
Ships within 48 hours
The Sport Scope comes standard with a High Definition Sony camcorder and a 32GB memory card. We always make sure that we use the best camcorders that have the most important features our customers are looking for, which is why we only use Sony camcorders. Sony has the most dependable and advanced consumer camcorders available, which allow our customers to get HD quality film, transfer it quickly to their computers, and upload to their favorite editing software.
Each Sport Scope end zone camera comes standard with an extended battery for the camcorder. This battery lasts 6 hrs, which will allow you to film several games with your end zone camera on one charge.
The Sport Scope is the only endzone camera that comes standard with a high definition monitor and a long lasting battery to power that monitor. This battery will power your HD monitor for 5-6 hrs and also comes with a 12v adapter that can be plugged into a power outlet for unlimited use.
The Sony camera remote allows the user to zoom in and out as they record with their endzone camera. You can also turn on/off the camcorder with this remote, which means you can conserve battery during halftime, between quarters, etc. The user can also put the camcorder in record or standby mode, allowing for the operator to only record the plays they want. This allows for smaller, more precise clips of only the action in the plays, which cuts down on transfer and analysis time.
The Sport Scope 25' is a manually controlled system which pans and tilts the camera while is sits on a pivoting pan/tilt camera plate. The pan/tilt camera plate comes with a quick release plate on top of it to allow the operator to easily attach and position the camera.
The Sport Scope comes standard with a 9" LCD monitor for clear viewing. The monitor attaches to the monitor plate and can be sat comfortably in the operator's lap while they sit down and film with their endzone camera.
The hard case protects and organizes all the important electronics that make up our complete end zone camera package. The hard case is an important part of our system because it ensures that the most vulnerable parts of the endzone camera are always safe and accounted for.
The Sport Scope 25' is the only endzone camera that supplies the user with everything they need to comfortably sit down while they operate their end zone camera. The sports stool packs up and fits in the larger travel bag.
The Sport Scope comes with a lens hood and rain cover that protects both the camcorder and the pan/tilt head for both the Sport Scope 30' and 25' from harsh weather. The lens hood screws on the front of the camcorder and the 100% waterproof cover protects the camcorder and pan/tilt head.
Each Sport Scope comes standard with a magnetic level that allows for the user to perfectly level their end zone camera before the poles are raised. Leveling the end zone camera ensures that the poles will be structurally sound and that the film itself with be level too.
Each Sport Scope comes standard with a memory card reader that allows for quick and easy transferring of video from the memory card to a computer. We know that some computers do not have memory cards slots, so we supply one as part of our complete endzone camera package.
The Sport Scope 30' or 25' and all accessories fit inside the portable travel bag. The bag is made of ballistic nylon and is padded on all sides, which prevents damage during transportation. Some end zone cameras either do not come with a travel bag or they come with several, which makes the process of moving the end zone camera much more complicated. The Sport Scope's wheel plate also connects to the bag making transportation a breeze even through thick grass and mud. Other system's bags either come with small plastic wheels or with no wheels at all, which makes transporting the end zone camera much more difficult.
Each Sport Scope comes with a custom cable. Our single cable end zone camera system allows for a quick and easy set up. The cable is also protected with an abrasion resistant cover to protect the life of the cable.
The Sport Scope comes standard with ground stakes that stake through each leg's foot. The ground stakes ensure that the endzone camera tower will not fall over in windy conditions. If you play on turf you can place sandbags on each foot of the endzone camera.
The Sport Scope 25' end zone camera comes standard with a clear cover for the camera remote that is 100% waterproof and a clear cover that protects the 9" monitor and battery from harsh weather. Without this important piece of rain gear it would be too risky to use an endzone camera is harsh weather.
The Sport Scope 25' allows the operator to pan and tilt the camera with a tilt handle and cable reel. The handle is attached to the 25' mast and pans the camera right and left while the cable reel attaches to the camera plate at the top of the mast. The camera will tilt up and down as the tilt handle is moved up and down. For more information check out our Sport Scope 25' set up video.


!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
word FileRename( const char * oldName, /* Relative to working directory */ const char * newName); /* Name only, without path */
This routine changes a file's name. It cannot move a file to a different directory; to do that, call
FileMove()
. If the routine is successful, it returns zero; otherwise, it returns a
FileError
. Common errors include
See Also: FileMove()
.
Include: file.h
DiskHandle FileResolveStandardPath( char ** buffer, /* Write path here; update pointer * to point to end of path */
word bufSize, /* Size of buffer (in bytes) */ const char * path, /* Relative path of file */ FileResolveStandardPathFlags flags, /* Flags are described below */ FileAttrs *attrsPtr); /* Empty buffer, will be filled with attrs of passed file, if any */
This routine finds a file relative to the current location, then writes the full path to the file, starting at the root of the disk ( not at a standard path). It writes the path to the passed buffer, updating the pointer to point to the null at the end of the path string; it also returns the handle of the disk. If it cannot find the file it returns a null path.
Structures: A record of
FileResolveStandardPathFlags
is passed to
FileResolveStandardPath()
. The following flags are available:
FileResolveStandardPath()
should not check whether the passed path actually exists; instead, it should assume that the path exists in the first directory comprising the standard path, and return accordingly.Include: file.h
word
FileSetAttributes( /* returns error value */
const char * path, /* file's path relative to current
* working directory */
FileAttrs attr); /* new attributes for the file */
This routine changes the standard DOS attributes of a DOS or GEOS file. Note that you can also change the attributes of a file by setting the extended attribute FEA_FILE_ATTR.
See Also: FileAttrs
,
FileGetAttributes()
.
Include: file.h
DiskHandle FileSetCurrentPath( DiskHandle disk, /* May be a standard path constant */ const char * path); /* path string, null-terminated */
This routine changes the current path. It is passed two parameters: The first is the handle of the disk containing the new current path (this may be a standard path constant). The second is a null-terminated path string. It is specified with normal DOS conventions: directories are separated by backslashes; a period (".") indicates the current directory; and a pair of periods ("..") indicates the parent of the current directory. The string may not contain wildcard characters.
If
disk
is a disk handle, the path is relative to the root directory of that disk; if
disk
is a standard path constant, the path is relative to the standard path; if it is null, the path is relative to the current working directory.
FileSetCurrentPath()
returns the disk handle associated with the new current path; this may be a standard path constant. If
FileSetCurrentPath()
fails, it returns a null handle.
See Also: FileSetStandardPath()
.
Include: file.h
word
FileSetDateAndTime( /* returns error */
FileHandle fh, /* handle of open file */
FileDateAndTime dateAndTime); /* new modification time */
This routine changes a file's last-modification time-stamp. This routine can be called on GEOS or non-GEOS files. Note that you can also change the modification time of a file by changing the extended attribute FEA_MODIFICATION. If unsuccessful, this routine returns an error and sets the thread's error value (accessible via
ThreadGetError()
).
See Also: FileDateAndTime
,
FileGetDateAndTime()
.
Include: file.h


--- layout: post title: P4 Boot Camp, Fall 2015 date: 2015-11-23 header-img: img/p4-background.png ---
Hosted by: Barefoot Networks Inc.
Dates: Thursday, November 19, 2015 – Friday, November 20, 2015
Agenda:
Thursday, November 19, 2015
8:00-8:30am: Check-in and Breakfast
8:30-9:00am: Welcome Keynote, by Nick McKeown (No Slides or Video for this portion)
9:00-9:30am: Introduction to P4, by Chang Kim (Slides) (Video)
9:30-10:00am: Demo of new and existing networking features developed in P4, by Chang Kim (Video)
10:00-10:15am: Break
10:15-12:00pm: P4 Walkthrough, by Vladimir Gurevich (Slides) (Video 1, Video 2)
12:00-1:00pm: Lunch Onsite
1:00-1:30pm: P4 Development Tools, by Vladimir Gurevich (Lab VM*) (Slides) (Video)
(* For instructions on using the Lab VM check out the Slides/Video for this section.)
1:30-4:30pm: Labs Part I: Hands-on training of P4 development environment, by Antonin Bas, Vladimir Gurevich, Praveen Kumar (GitHub) (Slides) (Video)
4:30-4:45pm: Break
4:45-6:00pm: Panel Discussion and Q&A with Participants from Industry (No Slides or Video for this portion)
Friday, November 20, 2015
8:30-9:00am: Breakfast
9:00-12:00pm: Labs Part II: Hands-on training of P4 development environment, by Antonin Bas, Vladimir Gurevich, Praveen Kumar, Chang Kim (GitHub) (Slides) (Video)
12:00-1:30pm: Lunch Onsite
1:30-2:30pm: Discussion on Language Evolution and Research Topic, by Mihai Budiu (No Slides or Video for this portion)
2:30-6:00pm: Participants’ presentation/s and discussion, Led by all students (No Slides or Video for this portion)
7:00-10:00pm: Free form coding/debugging session (a.k.a. P4 Party!) (No Slides or Video for this portion)


Book Trader
menu
ADD TO CART
DELETE FROM CART
BUY NOW
Your Shopping Cart
Purchase Book
Book ISBN:
Quantity:
Address:
Add to Cart
ISBN:
Delete From Cart
ISBN:


{% load util %} {% load i18n %}
{% trans "Only use this if you own the facility" %}
{% elif entity_name == "Exchange" %}{% trans "Only use this if you own the exchange" %}
{% elif entity_name == "Carrier" %}{% trans "Only use this if you own the carrier" %}
{% elif entity_name == "Campus" %}{% trans "Only use this if you own the campus" %}
{% endif %} {% if entity_name != "Carrier" and entity_name != "Campus" %} {% blocktrans trimmed %} Add a new {{ entity_name }} to your Organization. Note that the newly created {{ entity_name }} will need to be approved by PeeringDB staff before it will appear in the search results or the API listings{% endblocktrans %} {% elif entity_name == "Campus" %} {% blocktrans trimmed %} Add a new {{ entity_name }} to your Organization. Note that your campus will not be visible to other users until it has at least 2 facilities in it. {% endblocktrans %} {% elif entity_name == "Carrier" %} {% trans "Add a new carrier to your Organization." %} {% endif %} {% if entity_name == "Facility" %}{% blocktrans trimmed %} To be listed as a Facility in PeeringDB we would expect that you offer colocation, data center and/or meet-me-room services to the public. {% endblocktrans %}
{% elif entity_name == "Exchange" %}
{% blocktrans trimmed %}
To be listed as an Internet Exchange in PeeringDB we would expect that you meet the following criteria:
{% endblocktrans %}
{% blocktrans trimmed %}
An Internet Exchange Point (IXP) is a network facility that enables the interconnection of more than two independent Autonomous Systems, primarily for the purpose of facilitating the exchange of Internet traffic.
{% endblocktrans %}
{% blocktrans trimmed %}
An IXP provides interconnection only for Autonomous Systems. An IXP does not require the Internet traffic passing between any pair of participating Autonomous Systems to pass through any third Autonomous System, nor does it alter or otherwise interfere with such traffic
{% endblocktrans %}


Class MonsterCreationMetadata
Class that represents the creation metadata for monsters.
Inheritance
Implements
Inherited Members
Namespace: Fibula.Creatures
Assembly: Fibula.Creatures.dll
Syntax
public class MonsterCreationMetadata : ICreatureCreationMetadata
Constructors
| Improve this Doc View SourceMonsterCreationMetadata(UInt16)
Initializes a new instance of the MonsterCreationMetadata class.
Declaration
public MonsterCreationMetadata(ushort raceId)
Parameters
| Type | Name | Description |
|---|---|---|
| System.UInt16 | raceId | The id of the race of monster to create. |
Properties
| Improve this Doc View SourceCorpse
Gets nothing. Not supported on this class. This value is taken from the monster type found in the catalog instead.
Declaration
public ushort Corpse { get; }
Property Value
| Type | Description |
|---|---|
| System.UInt16 |
Hitpoints
Gets nothing. Not supported on this class. This value is taken from the monster type found in the catalog instead.
Declaration
public ushort Hitpoints { get; }
Property Value
| Type | Description |
|---|---|
| System.UInt16 |
Id
Gets the monster's race id as a string.
Declaration
public string Id { get; }
Property Value
| Type | Description |
|---|---|
| System.String |
Manapoints
Gets nothing. Not supported on this class. This value is taken from the monster type found in the catalog instead.
Declaration
public ushort Manapoints { get; }
Property Value
| Type | Description |
|---|---|
| System.UInt16 |
MaxHitpoints
Gets nothing. Not supported on this class. This value is taken from the monster type found in the catalog instead.
Declaration
public ushort MaxHitpoints { get; }
Property Value
| Type | Description |
|---|---|
| System.UInt16 |
MaxManapoints
Gets nothing. Not supported on this class. This value is taken from the monster type found in the catalog instead.
Declaration
public ushort MaxManapoints { get; }
Property Value
| Type | Description |
|---|---|
| System.UInt16 |
Name
Gets nothing. Not supported on this class. This value is taken from the monster type found in the catalog instead.
Declaration
public string Name { get; }
Property Value
| Type | Description |
|---|---|
| System.String |


public interface NogChatServer extends Remote
| Modifier and Type | Method and Description |
|---|---|
void |
addChatRoom(Client creator)
addChatRoom
|
void |
addPrivateChatRoom(Client creator,
Client c)
addPrivateChatRoom
|
void |
deRegisterClient(Client client)
deRegisterClient
|
void |
destroyChatRoom(int id)
destroyChatRoom
|
ArrayList<ChatRoom> |
getChatRooms(Client c)
getChatRooms
|
Client |
getClient(String username)
getClient
|
ArrayList<Client> |
getUsers()
getUsers
|
void |
joinChatRoom(Client client,
int id)
joinChatRoom
|
void |
leaveChatRoom(int id,
Client client)
leaveChatRoom
|
void |
registerClient(Client client)
registerClient
|
ArrayList<ChatRoom> getChatRooms(Client c) throws RemoteException
c
- client that requests the list of chatrooms. (Needed to filter out
private chatrooms)RemoteException
- thrown when problem with remote method-call occurs.ArrayList<Client> getUsers() throws RemoteException
RemoteException
- thrown when problem with remote method-call occurs.Client getClient(String username) throws RemoteException
username
- username of the client reference to be retrievedRemoteException
- thrown when problem with remote method-call occurs.void addChatRoom(Client creator) throws RemoteException
creator
- reference to the client that creates the chatroom.RemoteException
- thrown when problem with remote method-call occurs.void registerClient(Client client) throws RemoteException, NameAlreadyTakenException
client
- client to be registeredRemoteException
- thrown when problem with remote method-call occurs.NameAlreadyTakenException
- Thrown when the username is already taken by another client.void deRegisterClient(Client client) throws RemoteException
client
- client to deRegister from the serverRemoteException
- thrown when problem with remote method-call occurs.void joinChatRoom(Client client, int id) throws RemoteException
client
- client that wants to joinid
- id of the chatroomRemoteException
- thrown when problem with remote method-call occurs.void destroyChatRoom(int id) throws RemoteException
id
- id of the chatroomRemoteException
- thrown when problem with remote method-call occurs.void leaveChatRoom(int id, Client client) throws RemoteException
id
- id of the chatroomclient
- client that wants to leaveRemoteException
- thrown when problem with remote method-call occurs.void addPrivateChatRoom(Client creator, Client c) throws RemoteException
creator
- client that initiates the private chatroomc
- the other clientRemoteException
- thrown when problem with remote method-call occurs.Copyright © 2015. All rights reserved.


:(
There was an unexpected error. Please open a bug report on the project's Github page or contact one of
the developers.
Stacktrace:
{{ currentReport.stacktrace }}
Error datetime
{{ currentReport.datetime | date:'YYYY-MM-dd HH:mm:ss' }}
Logs:
{{ currentReport.logs }}
Config file:
{{ currentReport.config | json }}
:(
Error report not found.


Hello, change me to blue please!
Please turn me red!
Turn this li to green!
Turn this li to pink!
Turn me brown!
Click me!
Feed me more
Some text
Blogs
Post Blog


Brief in English
Python activity in Finland
- Discussion Group (don't hesitate to post English questions)
{% extends "_base.html" %}
{% block content %}
Python activity in Finland
Brief in English
Email: hallitus (at) python.fi
{% endblock %}


B.Tech-Computer Science and Engineering, National
Institute of Technology, Warangal
Aggregate CGPA: 8.0/10
Expected Graduation:
MAY, 2020
12th Intermediate-PCM, Board of Secondary Education,
Ajmer
Aggregate Percentage: 90.60%
Passed:
APRIL, 2015
10th High School, Board of Secondary Education, Ajmer
Aggregate Percentage: 80.00%
Passed:
APRIL, 2013


Who are we?
We are your lifeboat, your get-out-of-jail, your fairy godmother. We are a select team of highly specialized software developers writing code to help you. We are Escape. It’s nice to meet you.
Evan Slaton
Evan is a full stack java developer. He graduated from the Ohio State University and worked as an IT Recruiter for 5 years. After deciding that he wanted to solve big, important problems using technology, he relocated to Seattle to join one of the most talented tech communities in the world.
Daniel Logerstedt
Daniel is a veteran of the Army with three & a half years of service as a Satellite Network Manager. Daniel wants to use his experience with communications to create better networks and hopefully make the world little closer. He self studied programming as well as attended a boot camp and is now a Software Developer utilizing Java and JavaScript. Dan enjoys Snowboarding when he can & video games.
Jeff Borda
Jeff is an Army veteran, with two years of service and experience as both a fixed and rotary wing pilot. Jeff is now a full stack Java web developer in the greater Seattle Area seeking new challenges and continuous learning opportunities. Jeff has a Bachelors of Science in Flight Technology from Central Washington University. Jeff enjoys playing the Guitar as well as the Accordion, & also likes flying around the Pacific Northwest.
Pablo Rosales
Pablo is a Latino developer in the greater Seattle area with an emphasis on client relations and has strong ties to the hispanic community. He studied Object Oriented Programming and Data Structures at Arizona State University in Java, is a web developer, and has a keen eye for detail. He enjoys being a collaborator and has a focus on customer oriented output. When hes not coding, he enjoys art and exploring the forests with his camera.


Facetracking example
outline
home
home
This is an example of face tracking using the javascript library clmtrackr. The fitting method is generally called "Non-rigid/deformable face tracking/alignment using constrained local models".
Note that this example works best in Google Chrome, with a computer that supports WebGL and floating point textures. It should however work in any modern browser.
To try it out:
- allow the page to use your webcamera
- make sure that your face is clearly visible in the video, and click start
- see the model fitted to your face
There was some problem trying to capture your webcamera, please check that your browser supports WebRTC. Using a fallback video instead. To try it out:
- click start
- see the model fitted to the face


Big Dreams Have Little Ears
What Does It Mean to Dream Big?
Big dreams are the goals that make your heart jump with fear or excitement or both! Often, just saying these dreams out loud will make you scream with delight and expand your landscape of possibilities. At first blush, monumental dreams seem impossibly out of reach.  Right now, your soul is aching to be heard. Its role is to guide the unfolding of your life. Listen to it.  If you like to dream big, it’s almost guaranteed that you’ll face criticism. That criticism usually comes from well-meaning family, friends, and colleagues who want to protect you from disappointment. But the most damaging criticism often comes from within.
You’re going to come across more than a few people who’ll tell you that your dreams are unrealistic and aiming too high will set you up for disappointment. But just because someone else says, “No, you can’t” or “No, that’s not possible,” doesn’t mean you have to agree with their version of reality. You won’t always be victorious, but you never know what’s truly possible unless you try. What seemingly “unrealistic” dream are you working to bring to life? What, if anything, has been stopping you until now? Dare to Dream Big All of life’s excitement and growth comes from knowing how to dream big — and making big dreams a reality. If you hold yourself back you will rob countless people of the goodness and joy and healing and growth that only your unique contributions can offer.


mutex_state
Return information about the state of mutex m
.
Possible states are:
- Task T: the mutex is in the locked/owned state and task T is the owner of the mutex.
- 'not_owned: the mutex is in the locked/not-owned state.
- 'abandoned: the mutex is in the unlocked/abandoned state.
- 'not_abandoned: the mutex is in the unlocked/not-abandoned state.
Also see:
Core Module Index | Contents


Henry Salliss, front end developer
About me
- My name is Henry Salliss, I am from near London in the UK! I am learning to become a front end web developer, I am new to the industry and eager to learn and gain more clients to create slick code while ensuring the best quality and service to my clients.
- I just started learning to code about 10 months ago, but I have created multiple websites showcasing multiple different skills
Strengths and areas of interest
Since beginning to learn to code I have picked up and developed many different skills which are both technical and interpersonal skills:
- Writing HTML effectively
- Using CSS to style web pages
- Using GIT command line for version control
- Using Github to communicate and participate in open source coding projects
- Communication and customer service
- Using FlexBox to make web pages responsive for all devices
- Using basic Javascript to create repsonsive experiences on the web
- Linking JQuery and Javascript together
Below is a link to some of my HTML and CSS projects...
Below is a link to some of my Javascript projects...
Get in contact with me!
If you have any questions about anything then please email me:
Or use get in contact with me on my social media and look at my repositories on Github:


EtherChannel Load-Balancing
26 Feb 2017 | knowledgeThe balancing method is locally significant and outbound. So it is OK for one side of a LAG to be src-MAC and the other side to be dest-IP.
To configure the load-balancing method by using theport-channel load-balance
global configuration command. EtherChannel load-balancing can use MAC Address or IP address, source or destination address, or both source and destination address.
The selected load balancing mode applies to all ether channels on a switch.
With source-MAC address forwarding, packets are distributed across the ports based on the source-MAC of the incoming packet. So packets from the same host use the same port in the channel.
With destination-MAC address forwarding, packets are distributed across the ports of the channel based on the destination-MAC of the incoming packet. So packets destined to the same host use the same port in the channel.
With source-and-destination MAC address forwarding, packets are distributed across the ports in a channel based on both the source and the destination MAC address. This is often used if it is not clear whether source-MAC or destination-MAC would be more appropriate.
IP based forwarding has the same principles as the MAC based forwarding outlined above.
To chose the appropriate load-balancing method, you must analyze the position of the EtherChannel in the network. For example, if you have 4 hosts going towards one router, you would be much better load-balancing based on source-MAC than destination-MAC from the switch. On the router, you will be better off using destination-MAC.
To configure EtherChannel load-balancing, in global config use the following:
`port-channel load-balance {dst-ip | dst-mac | src-dst-ip | src-dst-mac | src-ip | src-mac}
` The default is src-mac.
One negative of EtherChannel is that flows cannot exceed the bandwidth of an individual link. EtherChannel adds lanes to the highway but it doesn’t increase the speed limit.