text:
The Sway Reference Manual/Variables and Environments

Suppose you found an envelope lying on the street and on the front of the envelope was printed the name numberOfDog'sTeeth. Suppose further that you opened the envelope and inside was a piece of paper with the number 42 written upon it. What might you conclude from such an encounter? Now suppose you kept walking and found another envelope labeled meaningOfLifeUniverseEverything and, again, upon opening it you found a slip of paper with the number 42 on it. Further down the road, you find two more envelopes, entitled numberOfDotsOnPairOfDice and StatuteOfLibertyArmLength, both of which contain the number 42.

Finally, you find one last envelope labeled sixTimesNine and inside you, yet again, find the number 42. At this point, you're probably thinking 'somebody has an odd affection for the number 42' but then the times table that is stuck somewhere in the dim recesses of your brain begins yelling at you saying '54! It's 54!'. After this goes on for an embarrassingly long time, you realize that 6 * 9 is not 42, but 54. So you cross out the 42 in the last envelope and write 54 instead and put the envelope back where you found it.

This strange little story, believe it or not, has profound implications for writing programs that both humans and computers can understand. For programming languages, the envelope is a metaphor for something called a variable, which can be thought of as a label for a place in memory where a primitive value can reside. In many programming languages, one can change the value at that memory location, much like replacing the contents of an envelope. A variable is our first encounter with a concept known as abstraction, a concept that is fundamental to the whole of computer science.

Variables
Most likely, you've encountered the term variable before. Consider the slope-intercept form of an algebraic equation of a particular line:

$$   y = 2x - 3 $$

You probably can tell from this equation that the slope of this line is 2 and that it intercepts the y-axis at -3. But what role do the letters y and x actually play? The names x and y are placeholders and stand for the x- and y-coordinates of any conceivable point on that line. Without placeholders, the line would have to be described by listing every point on the line. Since there are an infinite number of points, clearly an exhaustive list is not feasible. As you learned in your algebra class, the common name for a place holder for a specific value is the term variable.

One can generalize the above line resulting in an equation that describes every line.

$$   y = mx + b $$

Here, the variable m stands for the slope and b stands for the y-intercept. Clearly, this equation was not dreamed up by a computer scientist since a cardinal rule is to choose good names for variables, such as s for slope and i for intercept. But alas, for historical reasons, we are stuck with m and b.

The term variable is also used in most programming languages, including Sway, and the term has roughly the equivalent meaning. The difference is programming languages use the envelope metaphor while algebra does not (the difference is purely philosophical and not worth going into at this time). Suppose you found three envelopes, marked m, x, and b, and inside those three envelopes you found the numbers 6, 9, and -12 respectively. If you were asked to make a y envelope, what number should you put inside? If the number 42 in the sixTimesNine envelope in the previous story did not bother you (e.g., your internal times table was nowhere to be found), perhaps you might need a little help in completing your task. We can have Sway calculate this number with the following dialog:

sway> var m = 6; INTEGER: 6 sway> var x = 9; INTEGER: 9 sway> var b = -12; INTEGER: -12 sway> var y = m * x + b;   INTEGER: 42 sway> y;   INTEGER: 42

One creates variables in Sway with the var keyword.

The creation of a variable is known as a declaration or definition. In Sway, the token after the keyword var is the variable being defined and the value after the equals sign is the initial value of the variable. The last definition shows that the initial value can be an expression which refers to other variables. The Sway interpreter, when asked to compute the value of an expression containing variables, goes to those envelopes (so to speak) and retrieves the values stored there. Note also that Sway requires the use of the multiplication sign to multiply the slope m by the x value. In the algebraic equation, the multiplication sign is elided, but is required here.

Here are some more examples of variable creation using the var keyword:

sway> var dots = 42; INTEGER: 42

This interaction defines a variable named dots whose value is bound to the number 42. The response of the interpreter to a variable declaration is to display the value bound to the variable.

sway> var bones = 206; INTEGER: 206

sway> dots; INTEGER: 42

sway> bones; INTEGER: 206

sway> var CLXIV = bones - dots; INTEGER: 164

After the declaration of variable, the variable and its value can be used interchangeably. Thus, one use of variables is to set up constants that will be used over and over again. For example, it is an easy matter to set up an equivalence between the variable PI and the real number 3.14159.

var PI = 3.14159; var radius = 10; var area = PI * radius * radius; var circumference = 2 * PI * radius;

Notice how the expressions used to compute the values of the variables area and circumference are more readable than if 3.14159 was used instead of PI. In fact, that is one of the main uses of variables, to make code more readable. The second is if the value of PI should change (e.g. a more accurate value of PI is desired, we would only need to change the definition of PI (this assumes, of course, we can store those definitions for later retrieval and do not need to type them into the interpreter again).

Environments
The variables and their values are stored in a structure called an environment. You can think of an environment as shoebox full of envelopes. When we define a variable, we put a new envelope, with the name of the variable on the outside, at the front of the box. Inside each envelope is the initialization value of the variable. When we need the value of a variable, we start looking in the shoebox, from front to back, looking for the right envelope. When we find the properly labeled envelope, we retrieve the value inside the envelope.

The environment is said to hold variables and their bindings (i.e., the values in the envelopes). A variable is said to be bound with respect to an environment if it has a binding in that environment. When asked to evaluate a variable, Sway simply looks up the variable in the environment and retrieves its value. Sometimes, the value bound to a variable is another environment. In fact, there is a variable named this that is that holds the location of the current environment (the this variable is predefined so you do not need to define it yourself). If you wish to see what bindings are in effect, you can ask the interpreter by issuing the command

pp(this); If we do so after defining all the variables above, we get the following response from the interpreter:

sway> pp(this); : context:  dynamicContext: null this:  constructor: null dots: 42 bones: 206 CLXIV: 164 PI: 3.141590 radius: 10 area: 314.159000 circumference: 62.831800 OBJECT:

Issuing the pp command is, in programming language parlance, an example of 'calling a function' and 'passing an argument'. We will learn more about functions later, but the main idea is that a function performs some useful task or set of tasks. In this case, the task is to show the current set of variable - value pairs.

In addition to the bindings of the variables we previously defined, we see some additional bindings for constructor, dynamicContext, context, and this. These variables are predefined by Sway for every environment. In this particular case, the variable context is bound to the environment that has the Sway built-in functions defined. As you will later see, sometimes we will try to look up a variable in the current environment. If we don't find it, we will look up the value of the context variable instead and continue our search using that environment instead. We will discuss the other predefined variables further at a later time.

If you were to ask the interpreter to display the bindings of context, you would get a long list:

sway> pp(context); : array?:  string?:  real?:  integer?:  ...       +:  -:  *:  /:  ...       if:  while:  ...       ||:  &&: <function &&> ...       catch: <function catch($a)> =: <function =($a,b)> .: <function .(a,$b)> ...   OBJECT: <OBJECT 137>

Note that even though the variables context and this are bound to environments, the pp function says they are bound to objects. In Sway, unlike other languages, objects and environments are the same thing. In fact, the terms object and environment should all be considered equivalent. You will learn more about objects in a later chapter.

After displaying the bindings, the interpreter displays the result of evaluating the pp command, which is always the thing passed to the pp function. The fact that something was displayed other than the returned value is known as a side-effect. The side-effect is not part of the value of the expression. It is these very side-effects that make it dangerous to depend on the order of operand evaluation.

The ability to look at the current set of bindings is a useful tool for figuring out why a program is not behaving as you think it should. The process of fixing such problems is known as debugging.

Variable naming
Unlike many languages, Sway is quite liberal in regards to legal variable names and to what entities variables can be bound. Consider the following variable declarations:

sway> var times = *; BUILT-IN: <function *> sway> 6 times 7; INTEGER: 42 sway> var dots+bones = 5; INTEGER: 5 sway> dots+bones; INTEGER: 5 sway> dots + bones; INTEGER: 248 The first declaration defines a variable named times and gives it the same value as the operator *. Note that the response of the interpreter tells us that times has been bound to the function originally bound to *. At this point, both the variables times and * are bound to the same function and can be used interchangeably, as the next interaction shows. From this example, we can see that operators are regular variables which happen to be bound to appropriate built-in functions. As stated earlier, this allows the Sway programmer great latitude in creating new operators. From the next interactions, we can see that whitespace is very important in delineating variable names: dots+bones is a single variable name while dots + bones is a combination of two distinct variables named dots and bones; in particular they are combined with the built-in function bound to the variable +.

Variables are the next layer in a programming languages, resting on the primitive expressions and combinations of expressions (which are expressions themselves). In fact, variables can be thought of as an abstraction of the primitives. As an analogy, consider your name. Your name is not you, but it is a convenient (and abstract) way of referring to you. In the same way, variables can be thought of the names of things. They aren't the thing itself, but a convenient way to referring to the thing.

While Sway lets you name variables in wild ways, you should temper your creativity if it gets out of hand. For example, rather than use the variable m for the slope, we could use the name slope instead:

var slope = 6;

We could have also used a different name:

var !@#$% = 6;

The name !@#$% is a perfectly good variable name from Sway's point of view. It is a particularly poor name from the point of making your Sway programs readable by you and others. It is important that your variable names reflect their purpose. In the example above, which is the better name: m, slope, or !@#$%''?


text:
IIS and FastCGI/Package Components

Some of the key files installed by FastCGI for IIS are
 * fcgiconfig.js: Configuration assistant script
 * fcgiext.dll: The ISAPI extension, CGI Glue
 * fcgiext.ini: Configuration file

These files can often be located in the default C:\WINDOWS\system32\inetsrv

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

title: IIS and FastCGI/Package Components


text:
The Sway Reference Manual/Assignment

Once a variable has been declared, it is possible to change its binding using the assignment operator. Consider the following interaction with the interpreter:

sway> var BLACK = 1;       //initialization! INTEGER: 1 sway> var BROWN = 2; INTEGER: 2 sway> var GREEN = 3; INTEGER: 3 sway> var eyeColor = BLACK; INTEGER: 1 sway> eyeColor; INTEGER: 1 sway> eyeColor = GREEN;    //assignment! INTEGER: 3 sway> eyeColor == BROWN;   //equality? SYMBOL: :false sway> eyeColor == GREEN; SYMBOL: :true

The operator/variable = (equals sign) is bound to the assignment function. The assignment function, however, is not a true function, like those bound to + and *. Recall that + and the like evaluate the things on either side (recall that those things on either side are generically known as operands) before combining them. For =, the left operand is not evaluated (if it were, the assignment

eyeColor = GREEN would attempt to change the meaning of 1 to be 3). In general, an operator which does not evaluate all its arguments is known as a special form.

Now we can see a variable definition has two steps. In the first step, the variable is created and in the second step, a value is assigned to that variable.

The last two expressions given to the interpreter in the previous interaction refer to the == (equality) operator. The operator == returns true if its operands refer to the same thing and false otherwise. In the interaction above, the variables BLACK, GREEN, and BROWN are not meant to change from their initial values. We denote variables whose values aren't supposed to change by naming the variable using (mostly) capital letters (this convention is borrowed from earlier programming languages). The use of caps emphasizes the constant nature of the (not too) variable.

In the above interaction with the interpreter, we use the integers 1, 2, and 3 to represent the colors black, brown, and green. By abstracting 1, 2, and 3 and giving them meaningful names (i.e., BLACK, BROWN, and GREEN) we find it easy to read code that assigns and tests eye color. We do this because it is difficult to remember which integer is assigned to which color. Without the variables BLACK, BROWN, and GREEN, we have to keep little notes somewhere to remind ourselves what's what. Here is an equivalent interaction with the interpreter without the use of the variables BLACK, GREEN, and BROWN.

sway> var eyeColor = 1; INTEGER: 1 sway> eyeColor; INTEGER: 1 sway> eyeColor = 3; INTEGER: 3 sway> eyeColor == 2; SYMBOL: :false sway> eyeColor == 3; SYMBOL: :true In this interaction, the meaning of the test eyeColor == 3 is not so obvious.

Another approach to constants is to use symbols. Since Sway has symbols as primitives, we can dispense with the constant-like variables and the integers altogether:

sway> var eyeColor = :black; SYMBOL: :black sway> eyeColor; SYMBOL: :black sway> eyeColor = :green; SYMBOL: :green sway> eyeColor == :brown; SYMBOL: :false sway> eyeColor == :green; SYMBOL: :true

sway> println("eye color is ",eyeColor); eye color is green SYMBOL: :green Note how much more readable this version of the interaction is. Also note that symbols, when printed, are printed without the colon.

Precedence and Associativity of Assignment
Assignment has the lowest precedence among the binary operators. It is also right associative. The right associativity allows for statements like

a = b = c = d = 0;

which conveniently assigns a zero to four variables at once and is equivalent to:

(a = (b = (c = (d = 0))));

because of the right associative nature of the operator. Since the resulting value of the assignment operation is the value assigned, this statement works as desired.

How it works
Sway takes a novel approach to assignment. Every time a value is retrieved, its address is (usually) saved in an internal register. The assignment operator takes advantage of this fact by:

 * 1) looking up the value of the left-hand-side
 * 2) checking for a valid address in the internal register
 * 3) writing the value of the right hand side to the valid address

For example, the assignment

x = 3;

proceeds by looking up the value of x. The current value of x is ignored, but the internal register now contains the location of x. The value of 3 is then copied to the address and x has a new value.

By this method, one can write to array and list elements as well as objects:

a[y] = z;   head(tail(items)) = :green; a. f. b = "hello";

There are some limitations to assignment. For example, you cannot use the assignment operator to change the tail of a list. For example, this attempt will fail:

tail(items) = list(a,b,c);

because the tail of a list does not have not a normal address in Sway. To change the tail of the list, one uses the tail= operator, instead:

items tail= list(a,b,c);

or

tail=(items,list(a,b,c));

if you prefer function call syntax.

There is a head= operator for changing the head of the list, but it is bound to the regular assignment operator, so you can use either.

Assigning to Thunks
If the code in a thunk has a regular Sway address, you can use the assignment operator to update the value at that address. This is how a forEach function would work:

function forEach($target,items,$body) {       while (items != null) {           $target = head(items); force($body); items = tail(items); }       }

Here, the thunk $target is repeatedly updated with the (new) head of the list. Once the update is made with the assignment operator, the body of the forEach is forced and the process repeated. The forEach function can be called with a simple variable, as in

var i;   forEach(i,range(0,4)) {       println("i is ",i); }

or with an array or list location, as in

var i = array(1,2,3); forEach(i[2],range(0,4)) {       println("i[2] is ",i[2]); }

or with an object member, as in

function bundle(a,b) { this; } var i = bundle(1,2); forEach(i . a,range(0,4)) {       println("i . a is ",i . a); }

title: The Sway Reference Manual/Assignment


text:
User:Suicidalhamster

Wikipedia user page - Wikisource user page - Commons user page Wikiquote user page - Wikinews user page - Meta user page - Wikispecies user page - Wikibooks user page - Wiktionary user page - Multi-lingual Wikisource user page - Wikiversity user page

title: User:Suicidalhamster


text:
IIS and FastCGI/Trouble shooting

This page is a wiki list of problems and causes along with solutions.

Lack a working FCGI wrapper
Seen a screen like the following? If you're using Perl, or the ilk, you probably forgot to set up an FCGI wrapper. This can occur if you try to replace CGI, with FastCGI and don't use something like IIS::FCGI, or an MVC fastcgi wrapper. Reference this book's perl-specific documentation at ../Scripting languages/Perl/.

Another common cause is a misconfiguration script, or a script that crashes on startup. Make sure your fcgi script runs outside of the webserver environment (run it explicitly in the cmd shell).

Network failure
These two errors can occur if you try to redirect stderr to the webserver rather than to stdout. Catalyst::Engine::FastCGI is known to have had this bug.

title: IIS and FastCGI/Trouble shooting


text: Template:Antelope sub-family

title: Template:Antelope sub-family


text:
The Science of Programming/EncapsulatingOperations

=Encapsulating Sequences of Operations=

Defining Functions
Recall, the series of expressions we evaluated to find the y-value of a point on the line

$$   y = 6x - 12 $$ given an x-value:

Now, suppose we wished to find the y-value corresponding to a different x-value or, worse yet, for a different x-value on a different line. All the work we did would have to be repeated. A function is a way to encapsulate all these operations so we can repeat them with a minimum of effort.

First, we will define a not too useful function that calculates y give a slope of 6, a y-intercept of -12, and an x-value of 9 (exactly as above).

Notice that the interpreter prompt changes to when it the input is incomplete. In the case of the function definition above, that occurs when the curly close brace is entered (1).

Once the function is defined, we can find the value of y repeatedly:

This function is not too useful in that we cannot use it to compute similar things, such as the y-value for a different value of x. A hallmark of a good function is that is lets you compute more than one thing. We can modify our function to take in the value of x we are interested in. We do this by passing in an argument, in this case, the value of x.

We give names to the values being passed in by placing variable names between the function definition parentheses. In this case, we chose x as the name. Notice that since we are passing in x, we no longer need (or want) the definition of x, so we delete it. Now we can compute y for an infinite number of x's.

What if we wish to compute a y-value for a given x for a different line? One approach would be to pass in the slope and intercept as well as x:

If we wish to calculate using a different line, we just pass in the new slope and intercept along with our value of x. This certainly works as intended, but is not the best way. One problem is that we keep on having to type in the slope and intercept even if we are computing y-values on the same line. Anytime you find yourself doing the same thing over and over, be assured that someone has thought of a way to avoid that particular tedium. So assuming that is true, how do we customize our function so that we only have to enter the slope and intercept once per particular line? We will explore three different ways for doing this. In reading further, it is not important if you understand all that is going on. What is important is that you know other approaches exist and understand the pros and cons of each approach:

Creating functions on the fly
At this point, you should see that you can create functions and should be able to create other functions through pattern matching. For example, you ought to be able to define a function that squares a given number:

Since creating functions is hard work (lots of typing) and Computer Scientists avoid hard work like the plague, somebody early on got the idea of writing a function that itself creates functions! Brilliant! We can do this for our line problem. We will tell our creative function to create a findY function for a particular slope and intercept!

See how our creative function defines a findY function and then returns it. Now we can create a bunch of different findY's.

Notice how findYa and findYb remember the slope and intercept supplied when they were create. While this is decidedly cool, the problem is many languages (C and Java included) do not allow you to define functions that create other functions.

Using objects
Another approach to our line problem is to use something called an object. In Sway, an object is simply an environment and we have seen those before. So there is nothing new here except in how to use objects to achieve our goal. Here, we define a creating function (known as a constructor) that creates and returns a line object.

The this variable always points to the current environment, which, in this case, includes slope and intercept. By returning this, we return this environment, and we can look up the values of slope and intercept at our leisure. To prove that slope and intercept exist, we can use the built-in bindings function:

We access the variables in an object with the '.' (dot) operator:

Now we modify our findY function to take in a line object as well as x and use the dot operator to extract the line's slope and intercept:

In this scenario, we create different lines, then pass each line to our new findY function:

The problem with this approach is we have separated line objects from finding y values, yet these two concepts are closely related. As an example, suppose we have parabola objects as well as line objects. Our findY function would fail miserably for parabola objects even though the concept of (x,y) points on a parabola is just as valid as points on a line (2). In the object oriented world, we solve this problem by bundling the object and functions that work specifically on that object together. In our case, we make the findY function part of the line object:

This is very similar to the functions-on-the-fly approach, but we return this instead of findY. Now we call the findY function via the line object.

Should we have a parabola object, it would have its own findY function with a different implementation. We would call it just the same, however:

This approach is supported in object oriented languages such as Java. The earlier approach (where the function was separated from the object) is supported in procedural languages such as C.

Exercises
(1) Typing a long construct into the interpreter is tedious. Later we will learn how to store our code in a file and have the interpreter execute the code in that file. If we need to make changes to our code, we simply edit the file. That way, we do not need to type in the modified code into the interpreter from scratch.

(2) Here is a concrete example of trying to generalize, so that our function works for all objects for which the concept of the function is valid.


title: File:Ssa4.jpg


title: File:Ssa5.jpg


title: File:Ssa6.jpg


title: File:Ssa8.jpg


title: File:Ssa9.jpg


title: File:Ssa7.jpg


text:
Celestia/Celx Scripting/CELX Lua Methods/Celx position

= Celx Scripting: Position =

position
A "position" object contains the exact coordinates of a point in space. A "position" object is relative to a coordinate system (i.e. a frame of reference, see Celx Scripting: Frame) and may need to be converted to or from universal coordinates before further use.

Within a CELX script, the position methods need to be prefixed with the obtained "position" object, separated with a colon.

The following methods can be used to obtain a "position" object:
 * Using the celestia:newposition method.
 * Using the celestia:newposition(base64) method.
 * Using the observer:getposition method.
 * Using the object:getposition method.
 * Using the position:addvector method.
 * Using the frame:to method.
 * Using the frame:from method.
 * Using the phase:getposition method.

Notes:
 * 1) Position components (X,Y,Z) in Celestia are stored in millionths of a light year. So when you have your own positions defined in km or miles, you have to convert these positions. Therefore, you can use a constant, which must be initialized first within your script:
 * 2) * From km to millionths of a light year, use a constant uly_to_km = 9460730.4725808.
 * 3) * From miles to millionths of a light year, use a constant uly_to_mls = 5912956.5453630.
 * 4) Next you can convert km or miles to millionths of a light year as follows:
 * 5) * millionths_of_a_light_year = number:km / uly_to_km
 * 6) * millionths_of_a_light_year = number:miles / uly_to_mls
 * 7) Internally "position" objects use 128 bit per component and therefore have higher precision than available directly in Lua (which typically uses 64-bit IEEE754 double precision floating point numbers). The calculations that you can perform however on a "position" object are limited, so you'll often want to convert "position" objects to normal Lua numbers. In order to avoid precision problems, the usual practice is to convert a "position" object to a "vector" object, relative to the origin (such as the Sun or Solar System Barycenter). You can do this by subtracting the origin's position from the object- or observer position to get a "vector" object like this:

-- Get a vector giving the heliocentric position of the Earth function earthpos(jd) local sun = celestia:find("Sol") local earth = celestia:find("Sol/Earth") return earth:getposition(jd) - sun:getposition(jd) end

Operators
"Position" objects can be added and subtracted from each other. It is also possible to add a "position" object with a "vector" object, or subtract a "vector" object from a "position" object.

 * position + vector → position
 * position + position → position
 * position - position → vector
 * position - vector → position

Note:Subtracting two "position" objects produces a "vector" object and NOT a "position" object.

Members
You can access and assign the x, y, and z components of a "position" object directly, e.g.

earth = celestia:find("Sol/Earth") earthpos = earth:getposition ep_x = earthpos.x ep_y = earthpos.y ep_z = earthpos.z

obs = celestia:getobserver obspos = obs:getposition obspos.x = 1 obspos.y = 0 obspos.x = 0 obs = celestia:setpostion(obspos)

Note: Accessing components this way returns normal Lua numbers, which have less precision than the 128-bit values stored in a "position" object.

Methods
This chapter contains a list of all available position methods, which can be used on "position" objects.

addvector
position

Add a vector to the position and return the result as a "position" object.

Notes:
 * 1) You can also use position = position + vector instead of this position:addvector method. Both have the same result.
 * 2) Like position components, the vector components (X,Y,Z) in Celestia are also stored in millionths of a light year.
 * 3) A CELX "position" object contains the exact coordinates of a point in space. A position is relative to a coordinate system and may need to be converted to or from universal coordinates before further use.
 * 4) The position methods can be used on a CELX "position" object. "Position" objects can also be used in other methods, requiring a "position" object as an argument.

Example: Goto a position in space just beside the path where Earth will be over 1 day. Look from that position at Earth and see how Earth comes towards you and just misses you (time is sped up 3600x).

-- Find and select Earth earth = celestia:find("Sol/Earth") celestia:select(earth) obs = celestia:getobserver -- Set frame of reference to "universal". obs:setframe(celestia:newframe("universal")) -- Determine the actual position of Earth now = celestia:gettime posearth = earth:getposition(now) -- Determine and goto new observer position, to just miss Earth within 1 day newpos = earth:getposition(now+1) vec = celestia:newvector(0, 0, 0.002) newpos = newpos:addvector(vec) obs:goto(newpos,1.0) wait(0.0) -- Look at Earth and see how it comes towards you upvec = celestia:newvector(0,1,0) obs:lookat(newpos, posearth, upvec) celestia:settimescale(3600) obs:track(earth)

Return to the position method index.

vectorto
vector

Return the "vector" object, pointing from this position to the target position.

Notes:
 * 1) You can also use vector = position target - position source instead of this position:vectorto method. Both have the same result.
 * 2) The precision of a vector (IEEE754 double precision floating point) may be insufficient to express this distance exactly.
 * 3) A CELX "vector" object is a geometric object that has both a length and direction [X, Y, Z] in a 3 dimensional coordinate system.
 * 4) The vector methods can be used on a CELX "vector" object. "Vector" objects can also be used in other methods, requiring a "vector" object as an argument.

Example: Get a vector, giving the heliocentric position of the Earth

now = celestia:gettime sunpos = celestia:find("Sol"):getposition(now) earthpos = celestia:find("Sol/Earth"):getposition(now) heliovector = sunpos:vectorto(earthpos)

Return to the position method index.

distanceto
number

Return the distance in kilometers from this position to the target position, as a number.

Example: Determine and display the actual distance from the obserber to Neptune.

now = celestia:gettime neptunepos = celestia:find("Sol/Neptune"):getposition(now) obs = celestia:getobserver obspos = obs:getposition distance = obspos:distanceto(neptunepos) celestia:print("The center of Neptune is " .. distance .. " km away", 10.0, -1, -1, 2, 4) wait(10.0)

Return to the position method index.

orientationto
rotation

Return a "rotation" object which can be used to orient a viewer to point from this position toward the target position.

Notes:
 * 1) A CELX "rotation" object is internally a Quaternion, which is one possibility to mathematically describe a rotation in 3 dimensions (i.e. it can be converted to a rotation matrix). A rotation can also be used to describe the orientation of objects or the observer (i.e. where the observer is looking to, and where "up" is).
 * 2) The rotation methods can be used on a CELX "rotation" object. "Rotation" objects can also be used in other methods, requiring a "rotation" object as an argument.

Example: Goto a position just beside Mars and orient the observer towards the planet.

obs = celestia:getobserver -- Set frame of reference to "universal". obs:setframe(celestia:newframe( "universal")) -- Find the actual position of Mars. mars = celestia:find("Sol/Mars") marspos = mars:getposition -- Calculate new position just far away from Mars. newpos = marspos + celestia:newvector(0, 0, 0.002) obs:goto(newpos, 0.0) wait(0.0) -- view towards Mars and follow the planet rotation = newpos:orientationto(marspos, celestia:newvector(0, 1, 0)) obs:setorientation(rotation) obs:follow(mars)

Return to the position method index.

getx
number

Return the X coordinate of the position as a number.

Notes:
 * 1) The precision is returned as a double-precision floating point value and may not have sufficient precision to express the exact position.

Example: Get the actual position of Earth and display the X-, Y- and Z-components of that position in the lower left corner of the screen.

now = celestia:gettime earthpos = celestia:find("Sol/Earth"):getposition(now) earthpos_x = earthpos:getx earthpos_y = earthpos:gety earthpos_z = earthpos:getz celestia:print("Universal position of Earth:\nX = " .. earthpos_x ..                "\nY = " .. earthpos_y .. "\nZ = " .. earthpos_z, 10.0, -1, -1, 2, 7) wait(10.0)

Return to the position method index.

gety
number

Return the Y coordinate of the position as a number.

Notes:
 * 1) The precision is returned as a double-precision floating point value and may not have sufficient precision to express the exact position.

Example: Get the actual position of Earth and display the X-, Y- and Z-components of that position in the lower left corner of the screen.

now = celestia:gettime earthpos = celestia:find("Sol/Earth"):getposition(now) earthpos_x = earthpos:getx earthpos_y = earthpos:gety earthpos_z = earthpos:getz celestia:print("Universal position of Earth:\nX = " .. earthpos_x ..                "\nY = " .. earthpos_y .. "\nZ = " .. earthpos_z, 10.0, -1, -1, 2, 7) wait(10.0)

Return to the position method index.

getz
number

Return the Z coordinate of the position as a number.

Notes:
 * 1) The precision is returned as a double-precision floating point value and may not have sufficient precision to express the exact position.

Example: Get the actual position of Earth and display the X-, Y- and Z-components of that position in the lower left corner of the screen.

now = celestia:gettime earthpos = celestia:find("Sol/Earth"):getposition(now) earthpos_x = earthpos:getx earthpos_y = earthpos:gety earthpos_z = earthpos:getz celestia:print("Universal position of Earth:\nX = " .. earthpos_x ..                "\nY = " .. earthpos_y .. "\nZ = " .. earthpos_z, 10.0, -1, -1, 2, 7) wait(10.0)

Return to the position method index.


text:
Metabolomics/Metabolites/Carbohydrates/Sucrose and Other Dissacharides

Back to Previous Chapter: Introduction to Metabolomics Next chapter: Hormones Next Category: Lipids Go to: Polysaccharides Go back to: Glucose

Introduction
Sucrose also known as table sugar is one of the few natural chemicals consumed in pure form (other examples are H2O and NaCl). Its average annual consumption is 175 pounds per person in the United States. Table sugar is isolated from sugar cane and sugar beets where it is roughly 14-20% of the weight making it easily extracted. The world production of sugar is around 150 million tons per year.

Disaccharide Structure

Sucrose is not a simple monosaccharide, but a disaccharide composed of two units, glucose and fructose. The structure of sucrose can be deduced from its chemical behavior. Acid hydrolysis will split the molecule into glucose and fructose. Sucrose is a nonreducing sugar meaning it does not have an aldehyde group or is capable of forming one through isomerism. Sucrose also does not form osazones or undergo mutarotation. These findings suggest that the component monosaccharide units are linked by an acetal bridge connecting the two anomeric carbons. X-ray structural analysis confirms this hypothesis: Sucrose is a disaccharide in which the α-D-glucopyranose from of glucose is attached to β-D-fructofuranose in this way. Sucrose has a specific rotation of +66.5 and when treated with aqueous acid the rotation will decrease to a value of -20. This same effect can be achieved using the enzyme invertase on sucrose. The phenomenon is known as the inversion of sucrose and is related to the mutarotation of monosaccharides. The inversion of sucrose includes three separate reactions: hydrolysis of itself to α-D-glucopyranose and β-D-fructofuranose, mutarotation of α-D-glucopyranose to the equilibrium mixture with the β form, and mutarotation of β-D-fructofuranose to the more stable β-D-fructopyranose. Because the value for the rotation of fructose is -92 and the rotation value for glucose is +52.7, the net rotation is negative. This gives an "invert sugar" because it becomes inverted relative to the original solution.

Role of Sucrose when Exposed to Atrazine and Oxidative Stress
Soluble sugars act as metabolite signaling molecules that activate specific or hormone-crosstalk transduction pathways, in addition to playing a central role in plant structure and metabolism. Research was conducted on the different roles of exogenous sucrose in Arabidopsis thaliana plantlets when exposed to the herbicide atrazine and oxidative stress. A transcriptomic approach was utilized along with the employment of CATMAs (complete arabidopsis transcriptome microarrays).

Conditions of xenobiotic stress (stresses from natural substances that are foreign to the human body) and sucrose-induced tolerance in the presence of atrazine, of sucrose, and of sucrose plus atrazine were compared. This comparison displayed atrazine's effect on gene expression and, therefore, the physiology of seedlings. There was as well, due to the larger-than-anticipated impact of atrazine on seedling physiology, potential impairment of protein translation and of reactive-oxygen-species (ROS) defense mechanisms. In addition, there were significant modifications of gene expression pertaining to ROS defense, and repair mechanisms, when there was sucrose-induced protection against atrazine injury. These alterations resulted from the combined influences of sucrose and atrazine. This highlights the significance of the interactions between sucrose and xenobiotic signaling, or of sucrose and ROS signaling.

The resulting sucrose interactions produced characteristic differential expression of gene families including ascorbate peroxidases, glutathione-S-transferases and cytochrome P450s. Using these genes as molecular markers is expected to substantially progress future research of xenobiotic tolerance and phytoremediation (the use of certain plants to clean up soil, sediment, and water contaminated with metals and/or organic contaminants).

Comparative observations between the atrazine-induced stress situation and the sucrose-atrazine protection situation via the transcriptomic approach has provided new insight into xenobiotic-signaling pathways, xenobiotic tolerance pathways, and identifying novel xenobiotic tolerance pathways. Research conducted on these reactions, in environments containing high concentrations of atrazine, prior to the transcriptomic approach produced trivial data.

Early TF and gene target studies involving sucrose-induced tolerance are expected to be more useful when investigating sugar-induced tolerances towards other xenobiotics. Sucrose has, as well, been proven to induce a tolerance towards other xenobiotics.

References:

Organic Chemisty 6th Edition by Vollhardt (pg1142-1143)

http://www.pubmedcentral.nih.gov/articlerender.fcgi?tool=pubmed&pubmedid=18053238

www.medterms.com

http://www.envirotools.org/factsheets/phytoremediation.shtml

http://www.catma.org/database/ KEGG:

Web source 1

1.[]

2. The main focus of this source is to provide a definition of disaccharides along with a general description of basic aspects such as composition, structure, formation, and a list of common disaccharides including sucrose, lactose, maltose, trehalose, and cellulobiose, and what monosaccharides they’re composed of, and their linkage types.

3. Reducing disaccharide : monosaccharide components bonded by hydroxyl groups. Non-reducing disaccharide : components bond through their anomeric centers Dehydration reaction : chemical reaction involving loss of water from reacting molecule Glycosidic bond : functional group bonding a carbohydrate molecule to another molecule. The bond between hemiacetal group of the saccharide and hydroxyl group of another organic compound. Diastereoisomers : stereoisomers that are not enantiomers (mirror images) and that have different physical properties and react differently from one another.

4. This source briefly discusses formation of disaccharides which we covered in class using sucrose. It also describes alpha and beta linkages between the components of common disaccharides, some of which we’ve discussed in class.

Web source 2

1.[]

2. This source primarily focuses on the difference between reducing and non-reducing disaccharides. For both types, it lists the names, discusses and shows images of the structures of the disaccharide, and provides some information about the uses or sources of the disaccharide.

3. Cellobiose : 4-O-β-D-glucopyranosyl-D-glucose, results from the hydrolysis of cellulose by bacteria Endocellulase : enzyme that hydrolyzes cellulose Lactose intolerance : A condition in which the enzyme lactase is absent or non-functioning and lactose cannot be broken down into its monosaccharide components Galactosemia : A condition that is an inability to process the resulting D-galactose after hydrolysis. Furanosyl unit : five of these are present in sucrose

3.This source connects to the course material through it’s description of the structures of the components of the disaccharides, discussion of the meaning of reducing and non-reducing sugars, and alpha and beta linkages.

Web source 3

1.[]

2. The purpose of this source is to provide information about the pathway of sucrose synthesis, which occurs in plants. It includes an illustration of the process, and provides information pertaining to the starting products, intermediate, and enzymes required.

3. Photosynthesis : carbohydrates are synthesized from CO2 and water, releasing oxygen, and using light to provide energy. Activated glucose : uridine disphospate (UDP) glucose, which consists of the pyrophosphate group, the pentose sugar ribose, glucose, and uracil. Nucleotide group : phosphorylated pentose sugar that is linked via an N-glycosidic bond to a purine or pyrimidine base. Photophosphorylation : production of ATP using the energy of sunlight for the phosphorylation reaction

4. The purpose of this source is to provide information about sucrose synthesis as a pathway, which we discussed in class as part of the topic of photosynthesis.

Peer-reviewed Articles:

“Fermentation of High Concentrations of Maltose by Saccharomyces cerevisiae Is Limited by the COMPASS Methylation Complex”

1.[]

2. This source is about late stage fermentation of high concentrations of maltose (main carbohydrate in brewer’s wort) in yeast used to produce beer. It discusses the COMPASS methylation complex, which methylates lysine 4 on histone H3, controls maltose utilization genes in late-stage fermentation.

3. Fermentation : oxidation of organic compounds that result in energy production, with sugars as a typical substrate, and ethanol, hydrogen, and lactic acid as typical byproducts. Methylation : replacement of a hydrogen atom with a methyl group. Telomeric region : DNA region at the end of a chromosome that consists of repeated sequences and protects the genetic material from damage. Northern blotting : a method of RNA analyzation using electrophoresis. Western blotting : a method of detecting specific proteins using electrophoresis.

“Adaptation of Sucrose Metabolism in the Escherichia coli Wild-Type Strain EC3132†”

1.[]

2.This article pertains to an experiment involving the cloning, sequencing, and analysis of the csc gene locus from E. coli wild-type strain EC3132 that allows cells to utilize sucrose as a carbon source.

3. Sucrose permease : Fructokinase : Sucrose hydrolase : Phosphoenolpyruvate :

“Metabolic Fluxes in Corynebacterium glutamicum during Lysine Production with Sucrose as Carbon Source”

1.[]

2. Metabolic fluxes were determined for Corynebacterium glutamicum grown on sucrose medium in a study about the process of molasses based industrial production.

3. Metabolic flux : Pentose Phosphate Pathway : Fructose-specific phosphotransferase system (PTS): Isocitrate dehydrogenase : NADPH :

=Articles and Web Pages for Review and Inclusion=


text:
IIS and FastCGI/Scripting languages/Perl

This tutorial will teach you how to get IIS working with FastCGI, and Perl. We will be using FCGI::IIS. These steps should be followed in order. Further documentation on FCGI::IIS, can be found directly on CPAN.

Install FCGI::IIS

 * Strawberry Perl
 * perl -MCPAN -e'install FCGI::IIS'

 * ActiveState

 * ppm install FCGI
 * ppm install http://www.cosmicscripts.com/modules/perl/FCGI-IIS.ppd

Additions to fcgiext.ini
Add the following to the [Perl] stanza:

Which should make the .ini file read something like:

Notice FCGI::IIS=test: this gets a test up and running. To develop or run production with FCGI::IIS, or after your test succeeds remove the FCGI::IIS. Further information can be found in FCGI::IIS docs.

Restart website
To restart a website: Start → Administrative Tools → IIS → Expand left panel to Websites → Right click website Stop → Right click website Start.

From this point it should be easily to install Catalyst or whatever other perl framework you'd like.


text:
Celestia/Celx Scripting/CELX Lua Methods/Celx phase

= Celx Scripting: Phase =

phase
The phase class is NOT available until Celestia version 1.6.0.

The timeline of an object is subdivided into one or more phases. Each phase has its own:
 * trajectory;
 * rotation model;
 * orbit frame;
 * body frame.

An object's phase(s) can be obtained in one of two ways:
 * Using the object:getphase method, which returns the active phase at a specified time, or
 * Using the object:phases method, which returns an iterator over all of the phases in an object's timeline.

Example: The timeline for the Huygens probe might have three phases:
 * 1) Attached to Cassini:
 * 2) * body fixed frame of Cassini;
 * 3) * trajectory is just a fixed position.
 * 4) Free flight after separation:
 * 5) * Saturn-centered frame;
 * 6) * trajectory from an xyz file or SPICE
 * 7) On the surface of Titan (default not implemented yet in Celestia ):
 * 8) * Titan-fixed frame;
 * 9) * trajectory is a fixed position.

Methods
This chapter contains a list of all available phase methods, which can be used on "phase" objects.

timespan
number, number

Return the start and end times for this timeline phase as two TDB (Barycentric Dynamical Time) Julian date numbers.

Notes:
 * 1) The start time of a phase will always be equal to the end time of the previous phase.
 * 2) For a phase valid at any time, the start time and end time will be equal to the special floating point values -infinity and +infinity.
 * 3) The TDB time scale is a bit different from the more familiar UTC. By using TDB, Celestia places objects much more accurately. As of January 1, 2008, the difference between the two is about 65 seconds. For more information, see Celestia/Time Scales.
 * 4) To convert between UTC and TDB times, you can use the  celestia:utctotdb and  celestia:tdbtoutc methods.
 * 5) To convert between normal calender dates and julian days, you can use the celestia:tojulianday and celestia:fromjulianday methods.

Example: Retrieve the start and end times of the phases of Cassini's timeline.

object = celestia:find("Sol/Cassini") count = 0 for phase in object:phases do   count = count + 1 begintime, endtime = phase:timespan celestia:print("Phase [" .. count .. "] of " .. object:name ..                   "\nStart: " .. begintime .. " End: " .. endtime, 5.0, -1, -1, 2, 4) wait(5.0) end

Return to the phase method index.

orbitframe
frame

Return the orbit frame for this timeline phase, as a "frame" object.

Example: Display orbit frame reference object of Huygens during Free flight after separation from Cassini.

tdbtime = celestia:utctotdb(2005, 01, 01) celestia:settime(tdbtime) object = celestia:find("huygens") celestia:select(object) phase = object:getphase(tdbtime) -- Orbit frame obj_orbf = phase:orbitframe object2 = obj_orbf:getrefobject -- Goto object and print message obs = celestia:getobserver obs:gotolonglat(object, math.rad(42), math.rad(14), 0.033, 2.0) celestia:print("Orbit frame reference object during this phase of " ..               object:name .. " is: " .. object2:name, 10.0, -1, -1, 2, 4) wait(10.0)

Return to the phase method index.

bodyframe
frame

Return the body frame for this timeline phase, as a "frame" object.

Example: Display body frame reference object of Huygens during it flight on Cassini to Saturn.

tdbtime = celestia:utctotdb(2004, 06, 01) celestia:settime(tdbtime) object = celestia:find("huygens") celestia:select(object) phase = object:getphase(tdbtime) -- Body frame obj_bodyf = phase:bodyframe object2 = obj_bodyf:getrefobject -- Goto object and print message obs = celestia:getobserver obs:gotolonglat(object, math.rad(42), math.rad(14), 0.033, 2.0) celestia:print("Body frame reference object during this phase of " ..               object:name .. " is: " .. object2:name, 10.0, -1, -1, 2, 4) wait(10.0)

Return to the phase method index.

getposition
position

Return the position in frame coordinates at the specified time, as a "position" object.

Notes:
 * 1) Position components (X,Y,Z) in Celestia are stored in millionths of a light year. So when you want your positions defined in km or miles, you have to convert these positions. Therefore, you can use a constant, which must be initialized first within your script:
 * 2) * From millionths of a light year to km, use a constant uly_to_km = 9460730.4725808.
 * 3) * From millionths of a light year to miles, use a constant uly_to_mls = 5912956.5453630.
 * 4) Next you can convert millionths of a light year to km or miles as follows:
 * 5) * km = number:millionths_of_a_light_year * uly_to_km
 * 6) * miles = number:millionths_of_a_light_year * uly_to_mls
 * 7) The position methods can be used on a CELX "position" object. "Position" objects can also be used in other methods, requiring a "position" object as an argument.
 * 8) The TDB time scale is a bit different from the more familiar UTC. By using TDB, Celestia places objects much more accurately. As of January 1, 2008, the difference between the two is about 65 seconds. For more information, see Celestia/Time Scales.
 * 9) To convert between UTC and TDB times, you can use the  celestia:utctotdb and  celestia:tdbtoutc methods.
 * 10) To convert between normal calender dates and julian days, you can use the celestia:tojulianday and celestia:fromjulianday methods.

Example-1: Get position of Huygens at a specific time during first phase.

uly_to_km = 9460730.4725808 tdbtime = celestia:utctotdb(2004, 06, 01) celestia:settime(tdbtime) object = celestia:find("huygens") celestia:select(object) phase = object:getphase(tdbtime) obj_posf = phase:getposition(tdbtime) -- Goto object and print message obs = celestia:getobserver obs:gotolonglat(object, math.rad(42), math.rad(14), 0.033, 2.0) celestia:print(object:name .. " frame coordinates at 2004, 06, 01, 00:00:00 hr are:\n" ..               "X: " .. obj_posf.x*uly_to_km*1000 .. " meter\n" ..                 "Y: " .. obj_posf.y*uly_to_km*1000 .. " meter\n" ..                "Z: " .. obj_posf.z*uly_to_km*1000 .. " meter", 10.0, -1, -1, 2, 6) wait(10.0)

Example-2: Get position of Huygens at a specific time during second phase.

uly_to_km = 9460730.4725808 tdbtime = celestia:utctotdb(2005, 01, 01) celestia:settime(tdbtime) object = celestia:find("huygens") celestia:select(object) phase = object:getphase(tdbtime) obj_posf = phase:getposition(tdbtime) -- Goto object and print message obs = celestia:getobserver obs:gotolonglat(object, math.rad(42), math.rad(14), 0.033, 2.0) celestia:print(object:name .. " frame coordinates at 2005, 01, 01, 00:00:00 hr are:\n" ..               "X: " .. obj_posf.x*uly_to_km .. " km\n" ..                 "Y: " .. obj_posf.y*uly_to_km .. " km\n" ..                "Z: " .. obj_posf.z*uly_to_km .. " km", 10.0, -1, -1, 2, 6) wait(10.0)

Return to the phase method index.

getorientation
rotation

Return the orientation in frame coordinates at the specified time, as a "rotation" object.

Notes:
 * 1) The rotation methods can be used on a CELX "rotation" object. "Rotation" objects can also be used in other methods, requiring a "rotation" object as an argument.
 * 2) The TDB time scale is a bit different from the more familiar UTC. By using TDB, Celestia places objects much more accurately. As of January 1, 2008, the difference between the two is about 65 seconds. For more information, see Celestia/Time Scales.
 * 3) To convert between UTC and TDB times, you can use the  celestia:utctotdb and  celestia:tdbtoutc methods.
 * 4) To convert between normal calender dates and julian days, you can use the celestia:tojulianday and celestia:fromjulianday methods.

Example:

tdbtime = celestia:utctotdb(2005, 01, 01) celestia:settime(tdbtime) object = celestia:find("huygens") celestia:select(object) phase = object:getphase(tdbtime) obj_rotf = phase:getorientation(tdbtime) ...

Return to the phase method index.


text:
Cookbook talk:Cuisine of Indonesia

hi

Hi, I'm from Jakarta. The term Nasi Gurih does not ring a bell with any dish here. There's Nasi Uduk, which is kind of similar with Nasi Lemak or Hainam Rice without ginger. Which area of Indonesia does Nasi Gurih comes from? Raddy (talk)

title: Cookbook talk:Cuisine of Indonesia


text:
User talk:Durova

Welcome, !

Come introduce yourself at the new users page. If you have any questions, you can ask there or contact me personally.

Hello Durova, welcome to Wikibooks! An experienced Wikipedian such as yourself should get acclimatized very quickly. To try and fill in some of the gaps, we've created an FAQ for our wiki-immigrants: Wikibooks for Wikipedians. It's not complete by any standards, but it should help to answer some of the most common questions people have when they first get here.

Anyway, happy editing, have fun, and let us know if you have any questions. --Whiteknight (Page) (Talk) 02:20, 27 February 2008 (UTC)
 * Thanks. :) Durova (talk) 18:20, 29 February 2008 (UTC)

Image restoration/Introduction
They say not to template the regulars.. I'm just checking that this was created on purpose etc. Just remove the template if so :) – Mike.lifeguard  | talk 21:40, 7 June 2008 (UTC)
 * Yes, and I need to do more with it. Sorry for being an infrequent flyer. Durova (talk) 01:22, 20 July 2008 (UTC)

title: User talk:Durova


text:
Metabolomics/Metabolites/Lipids/Steroids

Back to Previous Chapter: Introduction to Metabolomics Next chapter: Hormones Back to Previous Category: Carbohydrates Next Category: Amino Acids Go to first page: Energy Storage Go back to: Membrane Lipids

 * 1) Cholesterol

=Steroids=

Steroid is a chemical name for any substance that has a characteristic chemical structure consisting of multiple rings of connected atoms. Vitamin D, cholesterol, estrogen, and cortisone are some examples of steroids. Various steroids have important roles in the body’s reproductive system and the structure and function of membranes. It has been discovered that steroids can be active in the brain, where they affect the nervous system. Some steroids are used as anesthetics. Douglas Covey of Washington University in St. Louis, Missouri, has uncovered new roles for several of these neurosteroids, which alter electrical activity in the brain. Covey’s research shows that neurosteroids can either activate or tone down receptors that communicate the message of a neurotransmitter called gammaaminobutyrate, or GABA. The main job of this neurotransmitter is to dampen electrical activity throughout the brain. Covey and other scientists have found that steroids that activate the receptors for GABA decrease brain activity even more, making these steroids good candidates for anesthetic medicines. Covey is also investigating the potential of neuroprotective steroids in preventing the nerve-wasting effects of certain neurodegenerative disorders.

Progesterone and Estrogen
The neurotrophic and neuroprotective effects of progesterone and estrogen have been confirmed to support reproductive and cognitive health. These steroids have recently been proven to also regulate metabolic processes, in order to meet specific energetic requirements for cognitive maintenance. Fully comprehending this metabolic control necessitated interpreting signals from a variety of environmental sources that were integrated by receptor-mediated responses that converged upon mitochondrial function. Research involved treating ovariectomized rats with progesterone (P4), 17 -estradiol (E2) or E2+P4, and functionally assessing isolated whole brain mitochondria, in order to determine the effects of P4 and E2 on metabolic control. The brain mitochondria of the hormone treated rats exhibited enhanced functional efficiency and increased metabolic rates. In addition, the same mitochondria displayed an increase in respiratory function that was coupled to an increase in expression, and electron transport chain complex IV activity (cytochrome c oxidase). The enhanced mitochondrial efficiency was a result of this increased respiratory activity that was accompanied by a decreased rate of reactive oxygen leak, and reduced lipid peroxidation.

Exclusive administration of E2 to the mitochondria resulted in a significant increase in complex IV (COX) activity. Specifically, brain mitochondria treated with E2 were prevented from ethanol withdrawal-induced declination of COX activity. In vitro studies exhibited a direct concentration dependent interaction between estrogens and ATPase activity; an increase in estrogen concentration raised ATPase activity, and a decrease in estrogen concentration lowered ATPase activity. By consequence, ATP levels and oxidative stresses were determined to be directly dependent upon the interaction of steroids with oligomycin-sensitivity conferring proteins (OSCP), which act as the binding sites for E2, in the mitochondria. Treatment of the mitochondria with E2 also resulted in lower levels of lipid peroxidation at a constant rate of H2O2 production. This indicated an increase in cellular antioxidant defenses. Furthermore, tightly coordinated regulation of mtDNA and nDNA encoded in mitochondrial genes made it impossible to identify whether or not hormones act at a nuclear site to regulate COXIV in order to increase COXI, II, and III expression, or vice versa, as a result of E2 and P4 acting at both sites. Despite this, all attempts to analyze combined effects of P4 and E2 resulted in a substantial decrease in mitochondrial response. In summation, mitochondrial alterations in the central nervous system that were induced by ovarian hormonal replacements induced efficient and balanced bioenergetics that reduced oxidative stress, and the occurrence of endogenous oxidative damage.

References:

Design Medicines (2006): n. pag. U.S. DEPARTMENT OF HEALTH AND HUMAN SERVICES, National Institutes of Health, National Institute of General Medical Sciences. Web..

http://endo.endojournals.org/cgi/rapidpdf/en.2007-1227v1 Biochemistry Metabolites/Lipids/Steroids

KEGG Pathway: A. Synthesis and degradation of Ketone Bodies http://www.genome.ad.jp/kegg/pathway/map/map00072.html B. Biosynthesis of Steroids: http://www.genome.ad.jp/kegg/pathway/map/map00100.html 1. C12- Steroid Hormone Metabolism: http://www.genome.ad.jp/kegg/pathway/map/map00140.html a. Androgen and Estrogen Metabolism http://www.genome.ad.jp/kegg/pathway/map/map00150.html 2. Bile Acid Biosynthesis: http://www.genome.ad.jp/kegg/pathway/map/map00120.html

MetaCyc Pathway: A. MetaCyc Pathway: sterol biosynthesis http://BioCyc.org/META/NEW-IMAGE?type=PATHWAY&object=PWY-2541 B. MetaCyc Pathway: cholesterol biosynthesis I http://BioCyc.org/META/NEW-IMAGE?type=PATHWAY&object=PWY66-341 C. MetaCyc Pathway: cholesterol biosynthesis II http://BioCyc.org/META/NEW-IMAGE?type=PATHWAY&object=PWY66-4 D. MataCyc Pathway: brassinosteroid biosynthesis I http://BioCyc.org/META/NEW-IMAGE?type=PATHWAY&object=PWY-699 E. MataCyc Pathway: brassinosteroid biosynthesis II http://BioCyc.org/META/NEW-IMAGE?type=PATHWAY&object=PWY-2582 F. MetaCyc Pathway: ginsenoside biosynthesis http://BioCyc.org/META/NEW-IMAGE?type=PATHWAY&object=PWY-5672 G. MetaCyc Pathway: ergosterol biosynthesis http://BioCyc.org/META/NEW-IMAGE?type=PATHWAY&object=ERGOSTEROL-SYN-PWY

General Web Resources: A. Steroids General Information Basic http://en.wikipedia.org/wiki/Steroid B. Anabolic steroid http://en.wikipedia.org/wiki/Anabolic_steroid

Image of Common Steroid Molecules: A. Lanosterol See more information about Lanosterol on wikipedia -> http://en.wikipedia.org/wiki/Lanosterol http://pubchem.ncbi.nlm.nih.gov/summary/summary.cgi?cid=246983

B. Cycloartenol See more information about Cycloartenol on wikipedia-> http://en.wikipedia.org/wiki/Cycloartenol http://pubchem.ncbi.nlm.nih.gov/summary/summary.cgi?cid=92110 C. Sterol http://pubchem.ncbi.nlm.nih.gov/summary/summary.cgi?cid=1107

D. Estrogen (Estriol, Estradiol, and Estrone) See information on wikipedia -> http://en.wikipedia.org/wiki/Estrogen Estriol http://pubchem.ncbi.nlm.nih.gov/summary/summary.cgi?cid=5756

Estradiol http://pubchem.ncbi.nlm.nih.gov/summary/summary.cgi?cid=5757

Estrone http://pubchem.ncbi.nlm.nih.gov/summary/summary.cgi?cid=5870

E. Progesterone http://pubchem.ncbi.nlm.nih.gov/summary/summary.cgi?cid=5994

F. Testosterone http://pubchem.ncbi.nlm.nih.gov/summary/summary.cgi?cid=6013

G. Cholesterol http://pubchem.ncbi.nlm.nih.gov/summary/summary.cgi?cid=5997

Web Resources General Description: A. Steroid Hormone Metabolism http://www.gfmer.ch/Books/Reproductive_health/Steroid_hormone_metabolism.html

Main focus of the resource: A well-defined explanation of steroids and their uses in metabolic systems; includes information on steroid hormones structures, nomenclature and classification, as well as the biosynthesis pathways. In addition, this source demonstrates key ways the steroids are used as metabolites.

New terms: 1. Androgenic- any substance, such as testosterone or androsterone that promotes male characteristics. 2. Aromatase- an enzyme or complex of enzymes that promotes the conversion of an androgen (as testosterone) into estrogens (as estradiol). 3. Adrenal - At, near, or on the kidneys; relating to the adrenal glands or their secretion. 4. Pseudohermaphroditism - an individual having internal reproductive organs of one sex and external sexual characteristics resembling those of the other sex or being ambiguous in nature. 5. Lipophilic - promoting the dissolvability or absorbability of lipids

Connection to Course: Steroids are essential in metabolic processes to elicit biological responses. Steroid metabolism is important in the production of hormones, and for the regulation of their cellular and physiological actions. An important function of the steroid hormones is to coordinate responses for specific biological purposes, such as reproduction and sex differences, which is the main focus of this article. Although we did not focus greatly on steroids and how they impact reproduction and sex differences it is still an important part of their impact on our body. In chapter 10, pg. 359 our course textbook briefly touches on this subject and how steroids are vital in communicating message to other bodily tissues.

Web Resources General Description: B. The Nomenclature of Steroids http://www.chem.qmul.ac.uk/iupac/steroid/3S01.html

Main focus of the resource: This is an excellent recourse that explains the nomenclature of steroids; includes information on stereochemistry, functional groups, configuration, number and ring structure. In addition this source also has history of the nomenclature of steroids. New terms: 1. Addendum- an appendix to a book 2. Gonane- parent tetracyclic hydrocarbon without methyl groups at C-10 and C-13 and without a side chain at C-17 3. Triterpenoids- Terpenoids having a C30 skeleton. 4. Heterocyclic- Of a cyclic compound that contains one or more atoms other than carbon in at least one of its rings. 5. Heteroatoms- any atom in a heterocyclic ring (or other structure normally built of carbon atoms) that is not a carbon atom

Connection to Course: In order to understand how chemical reactions occur in living organisms to maintain life we must begin to understand the chemicals themselves, therefore knowing the structures of steroids is essential to understanding their metabolic processes. In our studies it is vital to understand their structures so we can understand how they interact with other molecules in metabolic pathways, modulate cell function, or regulate metabolism.

Web Resources General Description: C. Steroid Hormones http://www.cs.stedwards.edu/chem/Chemistry/CHEM43/CHEM43/Steroids/Steroids.HTML

Main focus of the resource: Great general overview of steroids and that includes classes of steroids, structures, functions and roles, regulation and control. This is an excellent resource that explains a little bit of everything about steroids allowing the reader to gain a general understanding of steroids. New terms: 1. Sterol- subgroups of steroids with a hydroxyl group in the 3-position of the A-ring. 2. Phytosterols- Sterols of plants 3. Terpenoids- having a C30 skeleton. 4. Glucocorticoids- are a class of steroid hormones characterized by an ability to bind with the glucocorticoid receptor and trigger similar effects. 5. Peripheral- near the surface or outside of; external.

Connection to Course: Steroids regulate many aspect of metabolism by interacting with our immune function, our response to receptors to increase synthesis; they adjust fluidity of the cell membrane, and are altogether vital to how our body functions. This website gives an insight to the breakdown of how these processes work and how steroids play this critical role. In studying steroids we have taken a close look at cholesterol and how it interact with the cell membrane of tissues, this is because it plays such an important role in biochemical possesses.

Additional General Websites: http://www.reactome.org/cgi-bin/eventbrowser?DB=gk_current&ID=192076

Article General Description: A. Regulation of Hepatic 7-Hydroxylase Expression and Response to Dietary Cholesterol in the Rat and Hamster http://www.jbc.org/cgi/content/full/270/10/5381

Main focus of the resource: In this study researchers look at ovarian hormones and their neurotrophic effects on reproductive function and cognitive health. They did this by studying these steroids ability to regulate metabolic functions in rats. From this study they observed brain mitochondria from hormone- treated rats displayed enhanced functional efficiency and increased metabolic rates.

New terms: 1. Myocardium- the muscular substance of the heart.. 2. Ovariectomized- to surgically remove an ovary from 3. Neurotrophic- of, or pertaining to the effect of nerves on the nutritive processes. 4. Cytochrome- any of several carrier molecules in the mitochondria of plant and animal cells, consisting of a protein and an iron-containing porphyrin ring and participating in the stepwise transfer of electrons in oxidation reactions 5. Neuroprotective- serving to protect neurons from injury or degeneration.

Connection to Course: This article demonstrates how vital the mitochondria, which regulates the energy balance of the cell, is to our body and how steroids can impact it. Steroids that impact the mitochondria can in turn impact many specialized physiological functions of the cell. In the study of steroids we have seen in this course how steroid hormones have the ability do so and an example of this would be how progesterone, and ovarian hormone, can provide nerve function and healing by regulating myelin.

Article General Description: B. Progesterone and Estrogen Regulation Oxidative Metabolism in the Brain Mitochondria http://www.jstage.jst.go.jp/article/hypres/30/11/30_1029/_article

Main focus of the resource: In this study researchers are examining the fact that human populations show a strong correlation between dietary cholesterol intake and coronary heart disease due to its effects on plasma low density lipoprotein (LDL) cholesterol. Due to the response to a given intake of cholesterol varying among different species and even in individuals of the same species, this study looks at the mechanisms responsible for differing sensitivity. This was performed by comparing rats, which is able to adapt to fluctuations, with hamsters, who where more sensitive to changes in LDL levels. From this study they observed that the response to dietary cholesterol in these two species spans the range of individual responses observed in humans.

New terms: 1. Aorta- the main trunk of the arterial system, conveying blood from the left ventricle of the heart to all of the body except the lungs. 2. Aliquots- Of, relating to, or denoting an exact divisor or factor of a quantity, especially of an integer. 3. Hepatic- of or pertaining to the liver. 4. Diurnal- of or pertaining to a day or each day; daily.. 5. Isotopic- any of two or more forms of a chemical element, having the same number of protons in the nucleus, or the same atomic number, but having different numbers of neutrons in the nucleus, or different atomic weights.

Connection to Course: This article directly demonstrates what we have been discussing in class; see chapter 21 pg. 825 for detailed diagram of impact of LDL particle. These processes along with dietary uptake of cholesterol and breakdown of how Acetyl-CoA is assembled into cholesterol have all been present to us in lecture.

Article General Description: C. Integration of progesterone receptor action with rapid signaling events in breast cancer models http://www.sciencedirect.com/science?_ob=ArticleURL&_udi=B6T8X-4PP2CR6- 5&_user=47004&_coverDate=02%2F29%2F2008&_alid=696051811&_rdoc=5&_fmt=full&_ori g=search&_cdi=5098&_sort=d&_docanchor=&view=c&_ct=1514&_acct=C000005018&_versio n=1&_urlVersion=0&_userid=47004&md5=836f85277049cb84df9f8cff596cb06f

Main focus of the resource: In looking at breast cancer progression this study examines the underlying molecular mechanisms of uncontrolled cellular growth in breast cancer. They hope to understand how the estrogen and progesterone receptor action contribute to the development and progression of breast cancer.

New terms: 1. Aspartic- pertaining to, or derived, asparagine; as, aspartic acid. 2. Mitogen– any substance or agent that stimulates mitotic cell division 3. Autocrine- Of or relating to self-stimulation through cellular production of a factor and a specific receptor for it. 4. Myometrium- the smooth muscle forming the wall of the uterus 5. Ligand- a molecule, as an antibody, hormone, or drug, that binds to a receptor.

Connection to Course: Steroid hormones and their receptors exert direct effects in the nucleus as transcription factors and function at the membrane and cytosol as mediators in signaling pathways. This process of mediating signaling pathways has been demonstrated throughout this course and more information on this topic can be found in chapter 21 Lipid Biosynthesis of the course textbook. This chapter demonstrates the regulation and balance of dietary uptake.

=Articles and Web Pages for Review and Inclusion=


text:
User:Smoth 007

For my Wikipedia user page, see Smoth 007

title: User:Smoth 007


text:
User talk:Smoth 007

For my Wikipedia user talk page, see Talk

title: User talk:Smoth 007


text: User:Remi/Gallery

title: User:Remi/Gallery


text:
User talk:116.206.5.136

-- Herby talk thyme 08:21, 27 February 2008 (UTC)

title: User talk:116.206.5.136


text:
Khepera III Toolbox/Programming Hints

Writing programs for the Khepera III robot is pretty straightforward. Nevertheless, a good program structure and doing things right the first time will save you time - a lot of time! In this chapter, we therefore discuss a couple of design choices when implementing such programs.

A Simple Program with One State
A simple program will have the following structure:

Most programs consist of a main loop which is executed after an initialization phase. The main loop implements the so-called perception-to-action loop - the loop which reads the sensor values, derives the action to take, and sets the actuators (motors) accordingly. The main loop sometimes also contains a termination condition which quits the program as soon as the goal has been reached.

If you are looking at the code of existing programs (e.g. motion_followline), you will notice that the above structure implemented in different functions. Typically, the structure is broken up into the following functions
 * help: Prints a help text.
 * algorithm_init: Initializes the algorithm.
 * algorithm_run: Executes the main loop.
 * main: Initializes the program and calls the above functions.

In addition, a structure holding the configuration and the state (if necessary) of the algorithm is defined: Even if this looks complicated at first sight, using this nested structure has two advantages. First of all, all algorithm variables are declared in one place. If you want to reuse that algorithm somewhere else, you see at a glance which variables are needed. Second, the classification into configuration variables and state variables will help you implementing the algorithm in a clean way. Configuration variables will only be written during the initialization phase and should only be read in the main loop. State variables, however, are read and written in the main loop.

Programs with Multiple States
Often, programs have more than one state. A robot engaged in a search task, for instance, will maybe have an exploration state in which it walks randomly around, and a gradient following state in which it tries to move towards the target.

The simplest way to implement that is with different main loops, i.e. one main loop per state. A code skeleton for that looks as follows (note that the template program created by the k3-create-program script uses exactly this skeleton):

Do not fear the function pointer (algorithm.state.hook)! Its declaration may look complicated, but it is very easy to use, as you can see in the state functions above. Adding, moving or removing states becomes extremely easy, as you can treat a state as one contiguous block of code. In case the robot does not behave as desired in one particular state, you can modify its code without hurting other states (which is typically the case if you put everything in one main loop with a series of if's).

Moreover, if you draw your algorithm as a state machine on a paper first, you can implement the code right away following exactly the schema on your paper. Each state will correspond to one function, and each arrow to one state change condition.

Stability and Execution Speed
From your control theory course, you probably know that the perception-to-action loop has to run at a certain minimum frequency such that the stability criterion is fulfilled. On the other hand, running that loop at higher speed also consumes more energy.

The speed of the perception-to-action loop shown in the code examples above is determined by three factors:
 * The communication overhead, i.e. the time required to read the sensors and set the actuators.
 * The processing overhead, i.e. the time required to derive the action from the current perception.
 * The waiting time (usleep(algorithm.configuration.wait_us)), which can be adjusted at will.

The communication overhead can only be optimized up to some point. There is a hard limit on the number of bytes you need to transfer between the robot and the Korebot board (processor board) to get a certain piece of information, and the communication channel (I2C bus) has a fixed speed of roughly 10 KB/s. Hence, a call to the khepera3_infrared_proximity function to obtain infrared proximity sensor values will return after about 3.1 ms (if the I2C bus is free), as it has to transfer 31 bytes from and to the microcontroller. The number of bytes transferred by each function can be found in the .h files of the khepera3 module.

Similarly, a certain amount of operations will be necessary for deriving the action given the sensor readings and the current state. Basic mathematical operations are fast as compared to the communication overhead, but making extensive use of log, exp or trigonometric functions will slow down the main loop. In addition, everything that has to be written to, or read from disk will involve substantial overhead as well. Last but not least, the printf can severly slow down your program depending on where the output is redirected.

While the communication overhead can be accurately calculated, the processing overhead needs to be measured in the environment the program is running (e.g. with stdout redirected to where it will be redirected for the real experiments). The waiting time can then be adjusted to achieve the desired perception-to-action loop frequency.

To Thread or Not To Thread
Whether to use threads or not is a huge debate in computer science. The Khepera III Toolbox does not force you to use or not use threads, but it has been written with the idea in mind that most programs won't be multithreaded.

If you are using the code skeleton provided above, you will naturally not use threads (or a single thread, if you want). This makes sense, considering that there is not much to parallelize: the robot can only be in one state at a time, and the inside of a perception-to-action loop has to be executed in a precise order.

Asynchronous IO and the select Syscall
When writing programs that are waiting for some data to arrive on open filehandles, the select syscall will be useful. This syscall takes a list of filehandles, and returns if either data is available on one of them, or a timeout has occurred. The select syscall is the solution to most problems where programmers think they need threads.

As an example for this, have a look at the motion_arrowkeys program, which waits (in an non-blocking fashion) for user input on the standard input and executes the main loop at the same time.

Using Threads anyway
If - for one reason or another - you need go for multiple threads, some care has to be taken when accessing the robot sensors and actuators. Basically, you are not allowed to access the khepera3 module or the i2cal module in a concurrent way, as these modules use statically allocated variables and are therefore not thread-safe. There are two solutions to that:
 * 1) Design your program in such a way that only the main thread (or another dedicated thread) is accessing these modules. This is straightforward in some cases, but can get extremely complicated in other situations.
 * 2) Synchronize all calls to the khepera3 module and all i2cal transactions. They need to be synchronized with the same mutex, as the khepera3 module uses the i2cal module to communicate with the sensors, i.e. a most khepera3 functions are transactions on the I2C bus.

In case you wonder: the current implementation is intentionally not thread-safe, since that would make the function calls more complicated and more error-prone for single-threaded applications. In the future, however, a thread-safe implementation may be added (e.g. as a separate module).

Splitting Up Algorithms into Independent Parts
Just as we break down the implementation of algorithms into functions that implement one state each, we could also split them up into different programs that implement a subset of the states each, and execute them the right order. This works, and is actually a very good technique in many situations!

The Maze Traversal Example
Assume you want to test different algorithms to traverse a maze. The maze entrance is on the left, and the exit on the right side of your arena. Since you want to run the experiment several times, you want your robot to automatically go back to the entrance once it has reached the exit, e.g. by following a line on the ground. You could of course add a new state (state_go_back_to_entrance) to all your algorithms, and switch to that state when the exit has been reached. However, you could also implement this as a separate program (maze_go_back_to_entrance) which you call immediately after any of your maze traversing programs.

Overhead and Speed Considerations
There is some processing overhead in starting and quitting programs, but from an operating system point of view, this overhead is small. You should be careful about your initialization phase, though. For instance, if you have to load big files (e.g. maps, ...) at program start, this may introduce some significant delay. In addition, if you launch your programs remotely over a WLAN connection, there is a small transmission delay (~ 10 ms) to take into account.

Splitting Rules
There is no definite answer on when to split and how much to implement in the same program. However, here are a couple of thoughts:
 * Do split if this helps you testing and debugging individual parts of your algorithm.
 * Do split if this avoids having exactly the same pieces of code in several programs (as in the maze traversal example above).
 * Do split if you think you can reuse at least one part somewhere else.
 * Do split if the two parts have nothing in common.
 * Do not split if the transition is complex (e.g. multiple target states possible)
 * Do not split if the precise timings or low delays are an issue.
 * Do not split if the two parts share state variables or a lot of data.

In addition, it is usually preferred to implement an algorithm to run exactly once, and then quit. If want to test your algorithm in multiple runs, simply launch that program multiple times (with a script, for example) and redirect the output to a different file each time. This approach is much more flexible and robust.

Code Examples
The measure_real_speed example uses a script to run the same program multiple times with different parameters.

title: Khepera III Toolbox/Programming Hints


text: User talk:210.212.108.132

title: User talk:210.212.108.132


text:
Talk:German/Level I/Review 3

Untitled
I'd like to do the recording please contact me!

title: Talk:German/Level I/Review 3


text:
XForms/Output and Links

Motivation
You want to display a repeated set of URLs in a section of your form. Each URL is created by concatenating a base URL and a URL parameter.

Method
The equivalent of the HTML anchor tag () in an XForms application is the  element.

If in a web page, you want your output to appear like this:

in an XForms application each anchor will be xf:load.

Your input instance is like the following:

Discussion
With XForms it is not possible to create dynamic links inside a repeat using a combination of output, value and concat. This would also impact the ability to notify the user that is navigating away from a form.

There are two ways to display a list of links. Both use a trigger with the button appearance turned off. The first uses a load after setting a temporary instance. The second uses a submit/submission combination.

Using load
You can also use the load element as the element.

Link to XForms Application
Load XForms Application

Sample Program
The following program displays a list of links in a horizontal row. Each link has a label and a URL suffix that is extracted from an instance document.

     Displaying Links in an XForms Application         <xf:action ev:event="DOMActivate"> <xf:setvalue ref="instance('URL-container')" value="concat('http://en.wikipedia.org/wiki/', instance('links')/link[index('link-repeat')]/wikipedia-id)" /> <xf:load ref="instance('URL-container')" /> </xf:action> </xf:trigger> </xf:repeat>

Acknowledgment
This solution was posted to the Mozilla XForms development newsgroup by John Clark on February 27th, 2008.

Using Submit and Submission for Links
As an alternative strategy you can replace a form by using the submission statement with a replace="all" attribute. You can then style the submission button using appearance="minimal" and make the button look like a link:

The only disadvantage of this solution over using standard links is that the URL does not display in the status bar. This problem can be mitigated by using the xf:hint element within the label. This text will display when the user hovers over the link.

This method also allows you to interrupt the submission, check for changes in instance data and display warning messages before a form is unloaded.

title: XForms/Output and Links


text:
User:Siebengang/Workbench/Hello, world!

Python
print "Hello, b805eko!"
 * 1) Hello b805eko in Python

Perl
print "Hello World!";
 * 1) Hello World in Perl

PHP

C
/* Hello World in Ansi-C */ int main {    printf("Hello, World!\n"); return 0; }
 * 1) include

C++
// Hello World in C++ int main {    std::cout << "Hello, World!" << std::endl; return 0; }
 * 1) include

C#
// Hello World in Microsoft C# using System; class HelloWorld {    public static int Main(String[] args) {        Console.WriteLine("Hello, World!"); return 0; } }

Fortran 77
C    Hello World in Fortran 77 PROGRAM HELLO PRINT*, 'Hello World!' END

Java
// Hello World in Java class HelloWorld {      public static void main(String args[]) {        System.out.println("Hello World!"); } }

Pascal
{Hello World in Pascal} program HelloWorld(output); begin WriteLn('Hello World!'); end.

Basic
10 REM Hello World in BASIC 20 PRINT "Hello World!"

title: User:Siebengang/Workbench/Hello, world!


text:
User:Josette

 * I have the same user name ...
 * on Wikipedia - Wikipedia:user:Epousesquecido
 * on Commons - commons:user:Epousesquecido
 * on Wikisource - Wikisource:user:Epousesquecido
 * on Meta - meta:user:Epousesquecido

title: User:Josette


text:
Polish/Hard and soft consonants

< Noun cases < ^ Polish ^ > Feminine noun declension >

Before delving into the study of declension patterns in the Polish language, it's beneficial to familiarize yourself with the concept of hard and soft consonants.

Hard and Soft Consonants in Polish
In Polish, consonants can be categorized into two groups: hard and soft. Here's a chart that illustrates this:

Hard consonants in Polish can transform into their soft counterparts according to the above table.

Examples of Hard and Soft Consonants in Use
To illustrate this concept, here are some examples of words in their nominative and locative forms:

 * 'sky' — Nominative: niebo, Locative: w niebie
 * 'brother' — Nominative: brat, Locative: o bracie
 * 'river' — Nominative: rzeka, Locative: o rzece
 * 'leg' — Nominative: noga, Locative: na nodze
 * 'bicycle' — Nominative: rower, Locative: na rowerze
 * 'hell' — Nominative: piekło, Locative: w piekle
 * 'Warsaw' — Nominative: Warszawa, Locative: w Warszawie

title: Polish/Hard and soft consonants


text: User talk:218.248.36.230

title: User talk:218.248.36.230


text: User talk:122.171.10.184

title: User talk:122.171.10.184


text:
Talk:Muggles' Guide to Harry Potter/Books/Philosopher's Stone/Chapter 5

why no reference to quirrel? --87.10.144.175 (talk) 15:18, 27 February 2008 (UTC)
 * You are always welcome to add it if you feel it belongs there. I happen to agree with you, and I was working on this page anyway, so I have added him... Chazz (talk) 20:13, 29 February 2008 (UTC)

Inaccurate analysis
This is what is currently written: "And while Harry's wand heralds his entry into the Wizarding world, its being related to the Dark Lord makes Harry uneasy. Not only does it tie him to his enemy, it may foreshadow his destiny. That it was Voldemort's wand that inflicted Harry's scar and killed his mother and father, further connects him to the Dark Lord and his parents. It also represents the darker, sinister side to what had initially seemed to readers like a magical paradise; the wizard world actually may be far more dangerous than the unhappy Muggle one Harry is leaving behind. And while Ollivander may see the connection between the two wands as an indication that Harry will be a great wizard, Harry is disturbed by sharing even a small similarity to a wizard universally regarded as evil, further evidence of Harry's admirable character."

I think this analysis is inaccurate. I have never edited before and I'm not sure how it is done except to just delete what I think is incorrect and type what I think is correct.

In this case, there are two major inaccuracies: (1) The fact that Harry's wand is related to Voldemort's wand does not make Harry uneasy; (2) Harry is not disturbed by sharing the similarity.

In Philosopher's Stone, Chapter 5, Diagon Alley, Harry feels he may not like Mr. Ollivander very much. He feels Ollivander's eyes are creepy. However, there is nothing that indicates anything about Harry feels about his new wand.

In Goblet of Fire, Chapter 18, The Weighing of the Wands, Harry thinks back to "four summers ago" when he visited Ollivander's shop, bought his wand and found out that his new wand and Voldemort's wand are brothers because they both contain a feather from the same phoenix. This is what Harry feels about his wand: "He was very fond of his wand, and as far as he was concerned its relation to Voldemort's wand was something it couldn't help -- rather as he couldn't help being related to Aunt Petunia."

Also, there are many passages in Deathly Hallows about Harry feeling protected by his wand and the twin cores.

I'm just going to write something different and hope that's the right thing to do.

Starsmark (discuss • contribs) 01:42, 8 July 2014 (UTC)

 * Well, I'm not sure I agree. It is true that the book does not explicitly say anything about Harry's reaction to the wand, but it is only after Ollivander discloses the shared core that Harry "shivers". So I'm going to tweak your write-up a bit to put a little of that back in.

 * As far as editing goes, yes, you can either delete and replace, or simply edit. Chazz (talk) 03:33, 8 July 2014 (UTC)


text:
User talk:Josette

Welcome!
Welcome, !

Come introduce yourself at the new users page. If you have any questions, you can ask there or contact me personally.-- Herby talk thyme 15:19, 27 February 2008 (UTC)

title: User talk:Josette


text:
Trainz/Taking Screenshots

Screenshots in Trainz
This page discusses taking screenshots in Trainz which will have a different result between newer and older versions. Like many improvements, the change in TS2009 which switched over the default image production of screens generated by the software was one asked for by the user community. Trainz versions through TC3 (2008) generated (Targa) files, which are sometimes called 'True Color Graphics files' since they sacrifice compression and compromises for clear high definition imagery and is the Trainz technology preferred underlying image format. Screenshots however are not generally used for asset generation and simulation of a 3D model inside game space, so the newer programs are different in that they automatically generate date and timestamped files familiar to digital camera owners the world over.

Screenshots can be taken in Surveyor mode, Driver mode, Driver mode, Railyard mode by pressing the PrintScreen key, Prt Sc. Trainz does not react to pressing Prt Sc in the same way as most Windows programs: instead of storing a single screen image in the clipboard (the cut and paste buffer), for every press of Prt Sc Trainz creates a TARGA image file (file extension . ) and stores it in Trainz's 'Screenshots' folder (for example  for TRS2004). These files are numbered sequentially like. The normal Windows cut buffer will also receive an image which can be pasted into Microsoft Paint.exe and used to create a .bmp, .jpg, or .png as desired.

Tips for creating screenshots
With either technology to take a screenshot you want to set up the picture.
 * Screenshots in Driver:
 * If you are running in Driver and want a view of the 'action' you might care to hide the controls and just take a snapshot of the scenery. If so, you hide all screen displays in Driver by pressing 5 to remove Trainz's on-screen overlays. To restore the overlays, press 5 again.
 * Press Alt in Surveyor mode to switch to 'look around' mode. This can be useful to get exact positioning of screenshots. All menus and the compass point are removed. Press Esc to exit 'look around' mode.
 * Press Alt in Surveyor mode to switch to 'walk around' mode. This is a great feature for making a close inspection of detail when model building in V-scale, but is quite useful for taking a screenshot. The mouse must be moved very gingerly as it becomes a bit hyperactive. This gives a view from the ground from which the height is not adjustable, but the viewpoint is by using the mouse to rotate the angle of view and the cursor arrow keys to move forward or back, as well as slide/side-step either right or left.
 * Experiment with increasing your screen resolution and then taking the shot. In an image editing program reduce to a suitable size.

Manipulating screenshot images
After closing Trainz, the TARGA files can be opened in an image processing program such as Irfanview or where operations including the following can be performed:
 * Cropping (removing unwanted parts of the image).
 * Adjustment of the brightness/gamma, contrast, or RGB colour balance.
 * Conversion to an image file format such as which will greatly reduce the file size, plus allow viewing the number of software.

For advanced image processing a more sophisticated program such as GIMP or PhotoShop can be used.

title: Trainz/Taking Screenshots


text:
Chess Opening Theory/1. e4/1...Nf6/2. Nc3/2...d5/3. e5/3...Nfd7/4. e6

= Alekhine's Defence: Spielmann Gambit = White gambits a pawn to provoke /4...fxe6/, which weakens Black's kingside structure and shuts off the bishops on c8 and f8.

Theory table
.

'''1. e4 Nf6 2. Nc3 d5 3. e5 Nfd7 4. e6 '''


text:
Muggles' Guide to Harry Potter/Magic/Expulso

Overview
Expulso appears to be one of the many spells, like Confringo, that causes things to explode.

Extended Description
We see the Expulso curse being used only once. Shortly after Harry, Ron, and Hermione leave Bill and Fleur's wedding, they stop in an overnight café on the Tottenham Court Road. There, they are attacked by a pair of Death Eaters. One of the Death Eaters uses this spell to blow up the table behind Harry, who is hidden under his Invisibility Cloak, possibly in an attempt to jinx Harry that misses.

Analysis
While we believe this spell to be a simple explosive, it is uncertain; we have seen in previous battles that curses that miss their target seem to explode when they reach solid objects.


text:
Muggles' Guide to Harry Potter/Magic/Imperturbable Charm

Overview
An Imperturbable Charm, cast on a door or window, prevents approach to the door by anything.

Extended Description
We first hear of this charm when Fred and George are talking about trying to use their Extendable Ears to listen in on meetings of the adult members of the Order. Ginny tells them not to bother, there is an Imperturbable Charm on the door, and that she found this out by tossing Dungbombs at it: none of them had reached the door.

When the family goes to visit Arthur in the hospital for the first time after his injury, the adults there present, Arthur, Molly Weasley, Mad-Eye Moody, and Tonks, send the youngsters out of the ward so they can have a quick discussion. Fred and George again produce Extendable Ears, saying that they hope nobody has thought to put an Imperturbable Charm on the door. It turns out nobody has.

In Harry Potter and the Half-Blood Prince, when Harry, Ron, and Hermione have followed Draco Malfoy to Borgin and Burkes, Ron produces Extendable Ears to allow them to listen in on what Draco is saying, and says that he hopes the store is not protected by an Imperturbable Charm.


text:
Muggles' Guide to Harry Potter/Magic/Quick-Quotes Quill

Overview
A Quick-Quotes Quill is a quill that automatically transcribes what is spoken in its presence.

Extended Description
We first see this when it is produced by Rita Skeeter, when she is interviewing Harry, immediately before the Weighing of the Wands ceremony. Rita's Quill is an acid-green, and she seems to like the flavour of it, as she sucks on the end of it briefly before setting it on the parchment.

We also find that it does not actually record accurately what is being said. This particular Quill seems to generate text that only vaguely resembles what is spoken, slanting it to make it sensational.

Analysis
It is certain that this particular quill and Rita are very attuned, as the Quill seems to produce the sort of story, on its own, that Rita is famous for. One must wonder if the Quill can be tuned, however, as the story that Rita produces with, apparently, the exact same Quill in Harry Potter and the Order of the Phoenix seems to be written straight, when we see it published in The Quibbler


text:
Muggles' Guide to Harry Potter/Magic/Boomslang

Overview
Boomslang skin is one of the components of Polyjuice Potion.

Extended Description
Boomslang skin is used rarely enough that it is not in the student supply cabinet with most other potion ingredients. Hermione determines that in order to make their Polyjuice Potion, she will have to sneak into Professor Snape's office, and arranges a diversion, with Harry's help.

When Boomslang skin turns up missing in Harry Potter and the Goblet of Fire, Snape accuses Harry privately of having stolen it.

A Boomslang is an actual creature, despite the exotic name; it is a venomous snake that is native to parts of Africa. "Boomslang" is Afrikaans for tree- ("boom") snake ("slang"), and refers to Dispholidus typus, a large, venomous snake in the family Colubridae, which is native to sub-Saharan Africa.


text: C++ Programming/Programming Languages/C++/Code/Statements/Variables/Operators/Examples/Quotient and Remainder


text: User talk:168.102.132.2

title: User talk:168.102.132.2