text:
Talk:Circuit Idea/How to Swap Circuit Inputs and Outputs

In order to provoke discussion about the unique feature of negative feedback to reverse the causality in circuits, I have extracted here a part of correspondence between me and Gordon Deboo (the inventor of Deboo integrator). Circuit-fantasist (talk) 19:54, 25 December 2007 (UTC)

From: Gordon Deboo To: "Cyril"  Sent: Tuesday, October 09, 2007 3:34 PM Subject: Re: Deboo Integrator

... Looking at a problem in a different way can sometimes lead to new ideas. Just to give a simple example (Fig. 1), consider the attenuator (Figure a) and the well-known non-inverting amplifier (Figures b and c) shown in the pdf attachment.

The equation (4-1) for the attenuator shows that the input voltage V1 is attenuated to V2 depending on the values of the two resistors. Equation 4-1 can be solved for V1 as in Equation 4-2, where V1 is great than V2, so that amplification has occurred. Of course this can’t happen with two resistors because it would involve the creation of energy. However, if the required energy is supplied from an external source, such as an operational amplifier (resulting in a  conventional non-inverting amplifier as in Figure b, more usually  drawn as in Figure c) the equation can be satisfied.

I often manipulated circuits in this way, drawing a “box” with the input and output I required and then figuring out what I needed to do to get the desired result. This may seem obvious, but the idea was think about supplying energy to an attenuator to make it an amplifier after rearranging the equation told me what was needed. This type of thinking can enable one to create...

Gordon Deboo California

From: Cyril Mechkov To: Gordon Deboo Sent: Saturday, October 13, 2007 8:32 PM Subject: How to reverse circuit ports by applying negative feedback (Re: Re: Deboo integrator)

Dear Gordon,

Reading your last email, I was deeply struk by your idea of how to transmute a voltage divider into a non-inverting amplifier. Will you believe me that for the first time I consider a valuable circuit idea with someone? Today's people do not like to think about fundamental ideas and principles. Every time when I tried to discuss some basic circuit idea I run upon the rocks...

Surprise. Imagine my amazement when I was reading your excellent explanations (I suppose that the scanned page is from your book) because the same great idea conceived in my mind in the early 1990s! Then I was writing down (regrettably, in Bulgarian) all the ideas arising in my mind on squared sheets of A5 paper. I have scanned especially for you the yellowed record that I made on May 14, 1992 at my home (I was writing the circumstances surrounding the recorded idea on the top of the sheet; now, I continue doing the same).

"Reversed" voltage divider. This is the title of the record, which is eloquent; the drawing too. As you can see, I have drawn (likewise you on Fig. b) the circuit with an unusual shape to show the basic idea in the best way; also, I have colored the added op-amp in a different blue color. The idea is the same: to make the passive voltage divider work conversely we supply it by an additional (properly supplied) op-amp that observes the difference between the divider's output voltage and the actual input voltage. As a result, the op-amp adjusts its output voltage Vout so that an R2/(R1 + R2) part of it to be equal to the input voltage Vin. Thus, the old output voltage VR2 is always equal to the new input voltage Vin; the old divider's input voltage serves as a new output voltage Vout = (R1 + R2)/R2.

Mechanical analogy. On another sheet, I have described a lever analogy of a non-inverting amplifier that exploits the same powerful idea. A man is looking continuously at point A (the output of the "lever divider") and is comparing its height Hin' with the input height Hin. If there is a difference between them, the man moves the end of the lever (the point B) to make Hin' = Hin. As a result, Hout/Hin = (l1 + l2)/l1. By the way, this second-class lever analogy is more truthful than the third-class lever analogy of non-inverting amplifier presented by Tony Kuphald in his Lessons in Electric Circuits.

Human analogies. Thinking about the essence of this phenomenon, I began discerning similar manifestations in many everyday situations (some of them -quite funny:) Secretary > boss. Imagine a male chief that has a beautiful female secretary (or v.v.:); so, he indulges the pretty woman satisfying all her wishes. As a result, the boss thinks that he manages the secretary but, actually, the secretary leads the chief by the nose:) Wife > husband. Similarly, husbands that indulge their wives think that they manage their wives; actually, wives manage their husbands:) Generally speaking, women lead men by the nose in this world:)

Cat > owner. I am also a victim of this phenomenon. I think that I manage my (female) cat Futie; but giving a portion of food to "her" every time when "she" says "miaou" actually, the cat leads me by the nose:(

Generalization. Finally, I made a general conclusion that systems with negative feedback have the unique property to reverse the cause and effect relations between the input and output quantities of the objects. In this way, they can "reverse" the objects. Imagine a block diagram where a converter implementing a function y = f(x) is connected in the feedback loop; as a result, the whole nfb system will implement the reverse function Y = F(X), where Y = x, X = y and F = 1/f.

Applications. For our purposes in electronics, we can use this technique to swap the converter's ports (especially of the one-way devices) by connecting them into the feedback loop. From this viewpoint, an active voltage-to-current converter is actually a reversed passive current-to-voltage converter, an op-amp non-inverting amplifier is a reversed voltage divider (your idea), an op-amp integrator is a reversed differentiator and v.v., an op-amp logarithmic converter is a reversed antilogarithmic converter and v.v., an analog-to-digital converter is a reversed digital-to-analog converter, etc. Another very interesting example is a transdiode that is actually a transistor connected in the op-amp feedback loop; in this odd and never explained circuit configuration, the collector current is the input quantity (?!?) while the base-emitter voltage is the output quantity (?!?) Maybe, the same trick is used in the input part of a current mirror - the active diode, which is actually a transistor with parallel negative feedback (again, although it seems strange, the collector current serves as an input quantity while the base-emitter voltage serves as an output quantity)...

Popularization. Gordon, I am sure you will say "Oh" when you see the picture below (Fig. 5):) Here is the story about it.

In the end of 1990s, I prepared a series of 22 short 1-page articles under the title How to invent circuits. I designed them for Popular electronics (later Poptronics) magazine. Only, Poptronics ceased and I refused all the print undertaking and moved to the web. A few years later I put all the ready stories into a pdf file. As you can see, the story on the page 14 (with a title Compensating by injecting a current) is dedicated to your great integrator. The last story (Let's reverse causality!), which is not completed, is dedicated to the present idea. See the picture on the right - it is exactly as your picture! Is it not amazing that the same idea and the same picture can conceive in different minds? Below the left figure is written in red "a normal divider"; above the right figure is written "a reversed divider".

In the beginning of 2000s I began creating circuit-fantasia.com. Then I included this basic idea in a hierarchical circuit idea classification (time was when I was thinking that this collection was my supreme achievement but others were not thinking as me; so, I did not obtain the recognition that I had expected). Later, I used this technique (likewise you) as a possible way to "invent" the non-inverting amplifier. By the way, another possible way of "inventing" is to "disturb" an op-amp voltage follower by putting an attenuation R2/(R1 + R2) into the feedback loop. As a result, it "reacts" to this intervention by (R1 + R2)/R2 amplification (see Class Exercise 8: Op-amp Amplifiers with Negative Feedback). I have named this great principle "attenuation causes amplification". Actually, it represents the main property of negative feedback systems to compensate disturbances).

Circuit idea. I have reserved a special place for this "reversing causality" phenomenon in the contents of Circuit idea (see the section about negative feedback). I imagine that this part has to contain an introductory "philosophical" story and a series of specific stories dedicated to various circuits based on this idea. I would like to include in some way your materials in these stories. There are a lot of possibilities to do that.

For example, you can develop a story about "inventing" a non-inverting amplifier based on your idea exposed on the scanned text. It may consist of a text based on the image or a few paragraphs and the very scanned image included. If you do not want to do that, I might cite your text and include the original image into the story. Or, I can share with readers in the discussion page how I thought that... but ...

Gordon, believe me, your way of thinking in this material is even more valuable than the same idea. Thinking in this way, young people can invent new circuits. But yet, have you reveal this great idea? Have you written this text (I mean the scan)? Is this published and where? Can I place a link pointing to the source where it is published? It is extremely useful for Circuit idea, if you send me more clever circuit ideas...

Circuit-fantasist (talk) 18:39, 25 December 2007 (UTC)


text: User talk:88.251.203.127

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

title: User talk:88.251.203.127


text: User talk:207.157.65.75

title: User talk:207.157.65.75


text:
Futurebasic/Language/Reference/long fn

Description
In FB,  is a synonym for. Unlike FBII, variables created in a  are local.

title: Futurebasic/Language/Reference/long fn


text:
Futurebasic/Language/Reference/long color

Description
Sets the foreground color or background color for the current output window. Each of the three color components can range from 0 (darkest) to 65535 (lightest), and they combine to make any conceivable shade. If you set  to , or omit the parameter, then   sets the foreground color. If you set  to , then   sets the background color.

Example:

FB Lite behavior: When you use the "FB Lite" runtime,  switches to the Graphics Window before executing; you can't use it to change the color in the Text Window nor on the printer. To change the color of printed output while running FB Lite, use the Toolbox procedure RGBFORECOLOR.

Note: does not immediately change the appearance of the window. If you set the foreground color, the new color will appear the next time you draw text or a QuickDraw shape (it won't affect the color of anything that's already drawn). If you set the background color, the new color will appear the next time you erase all or part of the window (for example, with the  statement).

You can use the Toolbox procedures GetForeColor and GetBackColor to find out the current foreground or background color for the current window.


text:
Talk:Religion in Political Theory

Hi there, my name is Martin M. Elissetche. I'm a PhD student at the University of Maryland and the creator of a social science dictionary located at www.socialsciencedictionry.org. I wanted to know if I could place a copy of your book on my web site or whether you prefer if I just link to it. Please let me know what you think at info@socialsciencedictionary.org. Cheers, m.

title: Talk:Religion in Political Theory


text:
Futurebasic/Language/Reference/log10

Description
Returns the common logarithm of. the common logarithm uses "10" as its base. always returns a double-precision result.

title: Futurebasic/Language/Reference/log10


text:
Futurebasic/Language/Reference/log2

Description
Returns the base-2 logarithm of. always returns a double-precision result.

title: Futurebasic/Language/Reference/log2


text:
Futurebasic/Language/Reference/log

Description
Returns the natural logarithm of. The natural logarithm uses the transcendental number "e" as its base. always returns a double-precision result.

is the inverse of the  function. That is:  equals.

Note: To find the logarithm of  for an arbitrary base , use this formula:

title: Futurebasic/Language/Reference/log


text: User talk:68.238.164.221

title: User talk:68.238.164.221


text:
Futurebasic/Language/Reference/lof

Description
If  is the ID number of an open file,   returns the total number of records in the file. If  equals   or   (and the specified device is open),   returns the total number of records currently in the device's input buffer. If there is a "partial" record at the end of the file (or input buffer), it is included in the count.

The returned record count is based on the record length given in, if it's specified. If this parameter is omitted,  uses the record length that was specified in the   statement when the file or the port was opened. If  is omitted and no record length was specified in the   statement, a default record length of 256 is used.

To determine the total number of bytes in the file or in the serial input buffer, use.

title: Futurebasic/Language/Reference/lof


text:
Futurebasic/Language/Reference/locate

Description
This statement moves the pen position in the current output window to text column  and text row , based on the current font family and font size. The pen's horizontal placement is based on an "average" character width; you can't count on this position to encompass exactly  characters unless you are using a mono-spaced font. places the pen at the upper-leftmost character position in the window.

title: Futurebasic/Language/Reference/locate


text:
Futurebasic/Language/Reference/local fn

Description
This statement marks the beginning of an FB local function. The end of the local function is marked by the  statement. A local function is a named collection of statements which can be accessed and executed as a unit by referring to the function's name (see the  statement). All variables and arrays referenced in a local function (except those explicitly declared as "global") are local to the function, which means they do not have any influence outside of the function; any identically-named variables which appear outside of the function are actually different variables, and occupy a different place in memory, than the function's local variables. (An exception to this rule occurs when an array is listed as one of the function's formal parameters; see more about this below.) When your program "calls" (executes) a local function, you can pass data into the function by means of its parameter list (also called its argument list), and you can receive a value back from the function by means of its return value. Local functions allow you to encapsulate complex programming tasks; they're a fundamental and extremely powerful programming construct.

In addition to marking the beginning of the function, the  statement also declares the function's name, the data type of its return value (if any), and the number and types of its input parameters (if any). A local function can be placed anywhere in the program, except inside another local function; you should also not place a local function inside a "block" structure such as, etc. The statements in   can contain anything except the following:

 A  statement;

An  block;

Another local function.

Adding the  keyword causes all of the function's local variables and arrays (except the parameter variables ,   etc.) to be initialized to zeros, null strings or empty records, each time the function is called. Otherwise, the local variables and arrays will have unpredictable initial values. (You can accomplish the same effect by using the statement with the  keyword; see the  statement for more information.)

The  must be unique; that is, it must be different from the name used in any other ,  ,  ,   or  statement anywhere else in the program. If the function is to return a value, then you should specify the data type of the return value by including an appropriate type-identifier suffix at the end of. For example, a local function which is to return a string value might be declared as follows:

The default data type of a function's return value is "long integer"; if the function is to return a long integer value, you can either include the " " type-identifier suffix or omit it. No type-identifier suffix should be appended to  if the function does not return a value.

In order to execute the statements in, your program must "call" the function using the  statement. The statement can appear anywhere in your program, as long as the function it calls is either defined (using the   statement) or prototyped (using the   statement) somewhere above the   statement. This restriction is required in order to allow your program to compile; however, the actual order of execution of your program's statements is not affected by where you place your 's.

Function Parameters Each of the parameters,   etc. can have any of the following forms:

The parameters in the  statement are called the function's "formal arguments." They must not be global variables. You should not declare the formal argument variables in a  statement; they are implicitly declared by the   statement.

When your program calls the function, the arguments passed to it in the  statement are called the "actual arguments." They must match the function's formal arguments in number, and they must be of "compatible types" (see  for more information). Each time the function is called, values are assigned to its formal arguments as follows:

 If the formal argument is a simpleVar, the value of the actual argument is copied into simpleVar.

If the formal argument is of the form, then the actual argument should be either a record variable or a long-integer expression. In the first case, the record's address is copied into ptrVar; in the second case, the long integer's value is copied into.

If the formal argument is of the form, or  , then the actual argument must either be a variable (possibly a record variable), or a long integer expression preceded by "=". In the first case, the variable's address is copied into  or. In the second case, the value of the long integer expression is copied into  or.

If the formal argument is, then the actual argument must be the base element of an array of the same type, which has the same number of dimensions. The base element is the element in which all subscripts are set to zero. The entire array is then accessible to the local function, and (important!) any changes made to the array's elements within the function will persist after the function exits.

If the local function has no parameters, you should omit the parentheses after

.

Passing an Array of Unknown Size Sometimes it's useful to write a local function which operates on an array passed in its parameter list, without knowing in advance the size of the passed array. For example, suppose you wish to write a function which sorts the elements of a long integer array, and you want it to work regardless of the declared size of the passed array.

When you declare an array as a formal parameter, FB ignores the value of the array's first declared dimension in the  statement. For example, suppose we have a function defined like this:

When we pass a long integer array to, the passed array can have any size as its first declared dimension, as long as it has a second dimension declared as 7. For example:

Within the function, we can safely manipulate elements in the array as long as the subscripts we use don't exceed the declared dimensions of the actual array that was passed. Thus, in, we can set the first subscript in   to values much greater than 1, even though  was "declared" with dimensions (1,7).

Note: you do not have equal freedom with the second, third, etc. dimensions of the parameter array. If the array is multi-dimensional, the second and subsequent dimensions must be declared with the same values in both the "formal" array parameter (in the  statement) and the external   statement that declares the actual passed array.

Returning a Value If you specify an  in the   statement, the function will "return" the value of. This can be any expression which is compatible with the type-identifier suffix (if any) that appears in. When your function "returns" a value, it means that you can reference the function (using ) as part of a string or numeric expression, and the function's return value will be substituted in the expression. For example:

Here, if  returns a value of 7, then the value 42 will be assigned to.

The Lifespan of Local Variables The memory space for a function's local variables is reserved when the function is called. This memory is released after the  statement is executed. Therefore, you should never make reference to a local variable's address after the function has finished executing; in particular, you should never pass a local variable's address back to the routine that called the function. For example:

After the preceding is executed,  points to an area of memory (the old address of  ) which is no longer reserved, and which should not be used.

On the other hand, it is permissible to pass a local variable's address into another local function. This works because the first local function has not yet finished executing when it calls the second local function. Therefore, the memory space holding the first function's local variables is still reserved intact while the second function executes.

Recursive functions You can have several functions executing simultaneously, in the sense that one function can call a second function, which can call a third, and so on. If you design your function calls in such a way that a function can call a function that is already executing, then you have a "recursive function." The most obvious (but not the only) example of a recursive function is any function which calls itself. When that happens, we say that two (or more) "instances" of the function are executing simultaneously.

In FB, every currently executing "instance" of a local function maintains its own private set of local variables, and they don't interfere with the local variables of any other executing instance of that function. Calling a function recursively is very much like calling a "different" function which just happens to contain exactly the same program lines.

Although recursive functions may at first seem like a bizarre concept, they are perfectly acceptable, and often very useful. For example, here is a short program which prints all the permutations of the characters contained in a given input string; note that calls itself. It would be very difficult to write such a program without using recursive functions.

Returning Multiple Values The  statement can return only a single numeric or string expression. But many times, it's useful to have a local function which can return more than one value. The way to accomplish this is through the function's parameter list. If you give the function access to the address of some external variable or array, then the function can alter the contents at that address, effectively modifying the value of that variable or array.

There are three ways to pass an address to your function:  If you pass an entire array (using the ) syntax in the formal parameter list), then your function implicitly has access to the address of the passed array. Any changes you make to the array's elements inside your function are actually made to the external array, so the changes persist after the function exits.

If you use the  syntax in the function's formal parameter list, and specify a variable when you call the function, then the variable's address is copied into var. Your function can then modify the contents at that address.

You can explicitly pass any address into a long integer or  formal parameter.

Example:

title: Futurebasic/Language/Reference/local fn


text:
Futurebasic/Language/Reference/local

Description
This statement is an alternative way to indicate the beginning of the scope of a local function. If used, it must appear somewhere above the  statement. All non-global variables which are declared between the  statement and the   statement have a scope local to the function. Adding the  and/or  keywords has the following additional effects:

 The  keyword causes all of the function's local variables and arrays (except parameter-list variables) to be initialized to zeros, null strings or empty records, each time the function is called. Otherwise, the variables will have unpredictable initial values. You can accomplish the same effect by adding the  keyword to the   statement.

The  keyword prevents the use of global variables within the function. That is, all variables inside the function will be local variables, even those which have the same names as global variables. This is a good practice when you're writing a function that you might wish to use in a number of different projects, because it removes the possibility of the function's local variables being misinterpreted as globals.

Note: is the only kind of statement that you should put between the  statement and the   statement. Executable statements placed between  and   will never be executed.

You cannot declare any of the variables in the function's parameter list using a statement after the   statement.

A compiler preference allows you to fill s with   for debugging. With this item checked, all functions that do not begin with  have every variable filled with this value. It's a great debugging tool.

title: Futurebasic/Language/Reference/local


text:
Futurebasic/Language/Reference/loc

Description
This function returns one of two things, depending on the value of.  If  is the file ID number of an open file, the function returns the current location of the file mark as an offset from the beginning of the current record. For example, if  returns zero, the file mark is located at the beginning of the record. The file mark indicates where in the file the next input or output operation will occur.

if  specifies an open serial port (i.e., if its value is   or  ), then the function indicates the status of the carrier signal. If returns  if the carrier is detected, or   if the carrier is not detected.

Note: You can use  along with   to determine the exact location of the file mark within the file.

title: Futurebasic/Language/Reference/loc


text:
Futurebasic/Language/Reference/line input pound

Description
This statement reads a line of text data from the open file or open serial port specified by, and stores the data into the string variable.

If  equals zero, then   reads data from the keyboard. is identical to.

If  specifies a file, then   reads a line of text from the file, beginning at the current "file mark" position (which is usually at the beginning of the line), and ending when a carriage-return character is encountered, or the end of the file is encountered, or 255 characters have been read, whichever occurs first. then assigns the entire string of characters to. the file mark is then advanced to a position just past the last character read.

If  specifies a serial port (i.e., if its value is   or  ), then   behaves in a similar way, except that the concepts of "file mark" and "end of file" generally don't apply.

Note that  is similar to , except that special characters such as commas, quotes and leading spaces are not interpreted as data item delimiters, but instead are copied directly into.

Note: If the file mark is already at the end of the file when you execute, FB generates an "Input past end of file" error. To prevent this situation, check the value of  before executing.


text:
Futurebasic/Language/Reference/line input

Description
This statement behaves similarly to the  statement, except that the entire line of text entered by the user (including any commas, quotes and leading spaces) is stored into the single variable. See the  statement for a description of the parameters that precede.

Note: and  are considered rather "old-fashioned" ways to interact with the user. Programs with good user-interface design usually utilize Edit Fields instead.


text:
Futurebasic/Language/Reference/line

Description
This function looks for the indicated  in your program, and returns the memory address of the first program instruction that follows the label. The returned address can be used with the  statement (in cpu68K compiles). If you want to use  in this way, the label should indicate the beginning of an   procedure.

Note: To get an entry point address for an  procedure which is to be used as a "callback procedure" for a MacOS Toolbox routine, use the   function instead.

title: Futurebasic/Language/Reference/line


text:
Futurebasic/Language/Reference/library

Description
Libraries are routines that are stored either in the Extensions folder of the System Folder or in the folder with the compiled application. Libraries are accessed through FB's standard toolbox assignment mechanism. Libraries may be dragged into the project window and included in the compiled application.

The first syntax:  tells FB to begin using toolbox calls from. Only one library at a time is ever accessible. When the toolbox statements have been set up using  and , the second syntax is used to return to the default library.

The  command is a mechanism that establishes links to a precompiled library. It doesn't matter who created the library (Apple's libraries are most common) or what language it was written in. It's just a file full of subroutines. The creator of the library will usually provide a set of function calls that may be used after the library is opened. Each of these is made available to your FB application with a  or  command.

Example:

The following example is already part of the FB headers and does not need to be entered. It is offered here as an example only.

Checking For Available Library Commands After executing a  statement, you may wish to determine if a particular routine is available. The following example shows how that can be accomplished. A source code example for a library written in C is included on your CD. Our simple shared library creates a toolbox call named

title: Futurebasic/Language/Reference/library


text:
Futurebasic/Language/Reference/let

Syntax
1. 2.

Description
The  statement assigns a value to the variable , replacing whatever value  had before. Note that the  keyword is optional.  If you use Syntax 1, the value of  is assigned to  :

If  is a numeric variable, then   can be any numeric expression; if   is outside the range or precision that can be stored in , then the expression will be appropriately converted.

If  is a POINTER variable, then   can be _nil (zero), or another POINTER variable of the same type, or any valid address expression.

If  is a HANDLE variable, then   can be _nil (zero), or another HANDLE variable of the same type, or any valid address expression whose value is a handle.

If  is a string variable, then   can be any string expression. You should make sure that the length of  does not exceed the maximum string size that will fit into.

If  is a "pseudo" record (declared using  ), then   must be a record variable declared with the same length as.

If  is a "true" record (declared using  ), then   must be a record variable of the same type as.

If you use Syntax 2, then  bytes are copied into , from the memory location starting at. The  parameter must be a static integer expression (i.e., it cannot contain any variables). Note that FB does not check whether actually equals the size of. If  is too small, an incomplete value will be copied into  ; if   is too big, data will be copied into addresses beyond  's location in memory (this can be dangerous).

title: Futurebasic/Language/Reference/let


text:
Futurebasic/Language/Reference/len

Revised (2.0)
May 30, 2000 (Release 3)

Description
This function returns the number of characters contained in  or. In the case of an empty string, zero is returned.

Note: To determine the maximum number of characters that can be put into a string variable, use:

The maximum number of characters allowed in a container is theoretically 2 gigabytes, but is normally limited by available memory.

title: Futurebasic/Language/Reference/len


text:
Futurebasic/Language/Reference/leftstring

Revised
May 30, 2000 (Release 3)

Description
This function returns a substring or subcontainer consisting of the leftmost characters of   or. If  is greater than the length of   or , then   returns the entire string or container. If  is zero, then   returns an empty (zero-length) string.

Note: You may not use complex expressions that include containers on the right side of the equal sign. Instead of using:

Use:


text:
Futurebasic/Language/Reference/maxwindow

Description
Sets a limit on how large the user can make a window by dragging its "grow box." After  is executed, the user will not be able to drag the window's size wider than  pixels nor taller than   pixels (these dimensions refer to the window's "content region"; they don't include the "structure region" (frame) of the window). The statement applies to all currently open windows and all subsequently opened windows, until another   statement is executed.

does not apply to windows which don't have a grow box. Also, it does not limit the dimensions of a window which is resized by clicking its "zoom box" (see the  statement to learn how to do this).

If there is any currently open window (with a grow box) whose dimension(s) exceed and/or ,   will not shrink it immediately. The window will shrink the next time the user clicks on its grow box.

Note: If you need to apply different size limits to each of several open windows, then you will need to execute each time such a window becomes active. In your dialog-event handling function, watch for the  event, then execute   with the appropriate parameters depending on which window has become active. See the  function for more information.


text: User talk:202.61.173.20

title: User talk:202.61.173.20


text:
Futurebasic/Language/Reference/machlg

Description
Instructions the compiler to insert MC680x0 machine language instructions into the compiled code at the current location; these instructions are executed when the program is run.

Each constant is treated as a 2-byte instruction, and is inserted directly into the code stream. Typically, you will express a  as a 4-digit hexadecimal number. Each  is translated into an instruction which loads the variable's address into register A0.

The  statement is valid only for a "cpu68K" compile, and you should use only MC680x0 machine language instructions in the argument list (not PPC instructions). FB generates an error if you attempt to use  in a program compiled with the "cpuPPC" or "cpuFAT" options. To get around this problem, you can put the  statement inside a " " block; in that case, the   instruction will be ignored in a PPC compile.

Note: It's recommended that you use FutureBasic's "Inline Assembler" syntax rather than the  statement when you need to insert machine language instructions. Not only does this make your code easier to read, but it also allows you to insert PPC instructions as well as MC680x0 instructions.

See Also:

BEGINASSEM...ENDASSEM

title: Futurebasic/Language/Reference/machlg


text:
User talk:24.168.141.32

NASA did not delist Pluto as a planet - that was done by the International Astronomical Union. Please check your facts before adding them to Wikibooks. --Jomegat (talk) 00:28, 29 April 2008 (UTC)

title: User talk:24.168.141.32


text:
Futurebasic/Language/Reference/maybe

Description
This function is a special random number generator that returns either  (-1) or   (0), with equal probability. Before your program calls  for the first time, you should execute the   statement to "seed" the random number generator.

title: Futurebasic/Language/Reference/maybe


text:
Futurebasic/Language/Reference/mem

Description
Returns information about available heap memory or about an  string array. In addition, if you specify the value  in , the   function will force all purgeable resources to be removed from memory.

Specify one of the following values in  to get information about the application's heap memory:

Specify one of the following values in  to get information about an   string array. In this table,  represents the ID number (0 through 9) of the array you're interested in. If the specified  array has not yet been initialized (using the   statement),   returns zero for all of the items in this table.

title: Futurebasic/Language/Reference/mem


text:
Futurebasic/Language/Reference/mod

Description
The  operator subtracts from   the largest multiple of  ) which is less than or equal to , and returns the result as remainder. If  is negative, then a negative result is returned in remainder.

Note that if  and modulus are both integers, the result of   is just the remainder of the integer division operation.

title: Futurebasic/Language/Reference/mod


text:
Futurebasic/Language/Reference/mkistr

Description
("MaKe Integer string") returns a string which has the same internal bit pattern as ; each character in the returned string will represent 8 bits from. The returned string will have a length of 1, 2 or 4 characters, depending on which of,   or   is currently in effect. If  is in effect, you should make sure that   is within the range of numbers that can be expressed in a single byte; similarly, if   is in effect, you should make sure that   is within the range of numbers that can be expressed in a "word"-length (2-byte) integer.

is useful for translating the 4-letter file types, creator codes, resource types, etc. that are frequently used in MacOS Toolbox routines. These codes are typically transmitted in the form of long-integer values; by using the  function you can translate these long integers into strings for display purposes (be sure to set   before doing this).

If  is in effect,   returns the same thing as the   function.

Note: When  is in effect and 4-character strings and long-integers are being converted,   is essentially the inverse of the   function. Note, however, that the behavior of does not depend on the current setting of.

title: Futurebasic/Language/Reference/mkistr


text:
Futurebasic/Language/Reference/minwindow

Description
Sets a limit on how small the user can make a window by dragging its "grow box." After  is executed, the user will not be able to drag the window's size narrower than   pixels horizontally nor shorter than   pixels vertically (these dimensions refer to the window's "content region"; they don't include the "structure region" (frame) of the window). The  statement applies to all currently open windows and all subsequently opened windows, until another   statement is executed.

does not apply to windows which don't have a grow box. Also, it does not limit the dimensions of a window which is resized by clicking its "zoom box" (see the  statement to learn how to do this).

If there is any currently open window (with a grow box) whose dimension(s) are smaller than  and/or ,   will not expand it immediately. The window will expand the next time the user clicks on its grow box.

Note: If you need to apply different size limits to each of several open windows, then you will need to execute each time such a window becomes active. In your dialog-event handling function, watch for the  event, then execute   with the appropriate parameters depending on which window has become active. See the  function for more information.


text:
Futurebasic/Language/Reference/menu preferences

Revised
Feb 2002 (Release 6)

Description
In OS X, preferences are no longer accessible from the bottom item of the Edit menu. They are traditionally moved to the application menu. This means that you would have to do a large amount of coding to insure that your program followed the proper guidelines for both System 9 and OS X. Instead, you may use the  statement. If you are operating in System 9, this command does nothing. If your application is being run in OS X, the preference menu is moved to the application menu. Further, if the user selects the preference item, the menu choice is converted to the specified  and   so that your program can react without special coding.

A full example of using the new PREFERENCE commands can be found on on the  help page.

Note: This will not work properly if the  is anything other than the last item of the edit menu. FB must delete the old preference item and this would change menu IDs in your program if other selections followed it.


text:
Futurebasic/Language/Reference/MID function

Revised
June 15, 2000 (Release 3)

Description
This function returns a substring or subcontainer of or , consisting of characters which begin at position   within  or. If you specify, then a maximum of   characters are returned; otherwise, all the characters from   to the end of  or  are returned. If  is less than 1, then it's treated as 1. If  is greater than the length of  or , then a null (zero-length) string is returned.

Note: You may not use complex expressions that include containers on the right side of the equal sign. Instead of using:

Use:

Example:

program output:


text:
Futurebasic/Language/Reference/compile shutdown

= COMPILE SHUTDOWN statement =

Statement
✔ Appearance ✔ Standard ✔ Console

Syntax
COMPILE SHUTDOWN "Optional Quoted Remark"

Description
You may have some code that is specifically designed for one platform or another. For instance, 68K assembly cannot be compiled into a PPC application. In such cases,  would abort the compile process with an error and show the offending line complete with the optional quoted remark.


text:
Futurebasic/Language/Reference/compileflags

= COMPILEFLAGS function =

Description
Compile statements are directives to the compiler to change the way it evaluates and compiles code. (See  for a complete list of compiler directives.) Compile flags do not literally exist as accessible variables in the application but are used to set internal flags during compilation.

You can use this function to check specific flags which may be required by your application or to provide notes to another programmer about how to improve or streamline their code.

In addition to all of the standard compiler flags, this function can return additional information.


text:
Futurebasic/Language/Reference/compilerversion

= COMPILERVERSION function =

Function
✔ Appearance ✔ Standard ✔ Console

Description
This function returns the current version of the compiler. The number is internally set before each compiler is shipped. The purpose of this function is to determine whether or not a specific functionality is present before a particular command is executed.

If, for example, you wanted to invoke a routine that was not added to the compiler until version 3 release 2, you would check the version as follows:

The  function always returns a long word which is formatted as follows:

Byte 1 = Version number Byte 2 = Release number Byte 3 = Revision Number Byte 4 = Fix


text:
Futurebasic/Language/Reference/compound

= COMPOUND function =

Description
Returns the compounding factor for the given interest rate and number of periods. The interest rate should be expressed as a fraction of 1; for example, 5.2 percent should be expressed as 0.052.

Note
uses the following formula:

(1 + )

title: Futurebasic/Language/Reference/compound


text:
Futurebasic/Language/Reference/compress dynamic

= COMPRESS DYNAMIC statement =

Statement
✔ Appearance ✔ Standard ✔ Console

Syntax
Revised: May, 2001 (Release 5)

Description
When space is required for a dynamic array, it is allocated in chunks. The size of these chunks is determined by the global variable. If  is set to 1000 and you use a single element, 1000 elements are allocated. No additional elements are allocated unless and until you pass the 1000 mark. If you needed to access the 1001st element, an additional 1000 elements would be allocated.

The preallocation of space in large chunks can make dynamic arrays operate at a much faster pace because the handle used to accommodate the information is not resized as often.

When you want to regain RAM set aside for a dynamic array that has not yet been addressed, use. The size of the handle used to hold information is reduced. Internal counters that track the maximum number of elements available before resizing are also corrected.


text:
Futurebasic/Language/Reference/constant declaration

= Constant declaration statement =

Statement
✔ Appearance ✔ Standard ✔ Console

Description
This is a non-executable statement which assigns the value of  to the symbolic constant indicated by. The  must indicate a name which was not defined anywhere previously in the program, and which is different from all pre-defined FB symbolic constant names. The name must be preceded by an underscore character. The  must be a "static integer expression"; it cannot contain any variables nor function references.

The constant declaration statement is one of several ways to assign values to symbolic constant names. Other ways include using the  statement and using the   statement.


text:
Futurebasic/Language/Reference/coordinate window

= COORDINATE WINDOW statement =

Statement
✔ Appearance ✔ Standard ✔ Console

Description
This statement does nothing, but is retained for backwards-compatibility with older versions of FutureBasic.


text:
Futurebasic/Language/Reference/cos

= COS function =

Function
✔ Appearance ✔ Standard ✔ Console

Description
Returns the cosine of, where   is given in radians. The returned value will be in the range -1 to +1. always returns a double-precision result.

Note: To find the cosine of an angle  which is given in degrees, use the following:

where  equals 3.14159265359

title: Futurebasic/Language/Reference/cos


text:
Futurebasic/Language/Reference/cosh

= COSH function =

Function
✔ Appearance ✔ Standard ✔ Console

Description
Returns the hyperbolic cosine of. always returns a double-precision result.

Note:

is defined as:  2

title: Futurebasic/Language/Reference/cosh


text:
Futurebasic/Language/Reference/cursor

= CURSOR statement =

Statement
✔ χ Appearance ✔ χ Standard ✔ χ Console

Syntax (Standard BASIC):

Syntax (Appearance Runtime)
Revised: February, 2002 (Release 6)

Description
If  is positive, it's interpreted as the resource ID of a ' ' (first choice) or a ' ' resource (alternative choice), and this statement changes the current cursor to the indicated cursor. The following cursor resources are found in the System file, and are always available:

For Appearance Manager calls,  must be   or

Standard BASIC:

Appearance manager Cursors Items marked with an asterisk (*) may be animated.

Error Messages (Appearance Manager)  If you attempt to use an illegal value in the cursor statement, you will see the following dialog:

This type of dialog will only appear when you select Run from the Command menu. It will not show up if you use an illegal value in the program after selecting Build. This prevents the error message from appearing on your end user's screen, but still makes it available during the coding process.

Forcing a Cursor Event:  If  is negative(for example: then the cursor is changed to the one whose ID is , and a cursor event is generated, which can be trapped by checking for events of type   with the  function. You cannot generate a   when switching to the   (since its resource ID number has no negative!)

Note: If you've designed a  or a   resource of your own which you want to make available to your program, do the following:

Assign a positive resource ID number to the resource (don't use any of the numbers in the above table. You should use an ID number of 128 or higher.)

Copy the resource to the resources file which you reference in your program's  statement.

You can then use the  statement to activate your cursor within the program.

title: Futurebasic/Language/Reference/cursor


text:
User:Polluks

Aros/User/Networking

Aros/Developer/ABIv1

Aros/Developer/ZuneFurther

Aros/Developer/Zune/Classes

Aros/Developer/Docs/Libraries/LowLevel

Aros/Platforms/x86 Network support

Aros/Platforms/68k_support/Developer/Compiler

Aros/Platforms/AROS_USB_support

de:Benutzer:Polluks

title: User:Polluks


text:
Introduction to Indonesian Philosophy/Leluhur as Our First Philosophers

Indonesians have a generic term for calling their forefathers in the past, leluhur (literally, ‘the virtuous ones’) or nenek-moyang (literally, ‘the clever grandmothers ‘). In fact, they are really clever and virtuous. Our first kind of Homo sapiens who lived in 6000 centuries BC, Homo Wajakensis, had thought of abstract thing such as ‘death’. It is said that the Indonesian word mati or mate (death) had been a well-known word to the Old World of Middle East that the Koran of Islam—the Arabic literary classic of 7 century AD—mentioned it as mawt, Arabic pronunciation of the Old-Polynesian mate or mati, besides the word kapur (English, camphor) which was mentioned in the Koran as kâfûr when describing joys in Paradise. We inherit many mythologies of origin, which tell the first thought of the origin of death.

In the Mesolithic age, our leluhur had understood reality as unity. They did not separate yet ‘the signifier’ (the concept we make) and ‘the signified’ (reality outside us)—using the terms of Saussure. Reality is one. Having understood this way, our leluhur made painting of a pig in the cave of Pattakere (South Sulawesi). They drew in the cave a pig with an arrow breaking its heart, hoping that what they drew would be real: they would succeed in hunting the pig with their arrows later or the next day. They thought what they drew would be real. The drawing, in their mind, is reality, because ‘the signifier’ is always ‘the signified’.[12] In the same way they decorated their bodies with red color, thinking that red color meant blood and blood meant source of life. If they colored bodies with red, they believed that they would have life energy more and more added.[13]

In the Neolithic era (3500–2500 BC), our leluhur had more developed. They had understood the spirituality of universe. They created smoothly-grinded stone axes, used for their religious rites and for talisman, since they believed that the axes had got spirit or ‘soul inside’. In Java, souls were believed to reside in stone ornaments.[14] In the Mentawai Islands (West Sumatra), our leluhur believe that everything possesses a soul—not only living beings such as men and animals, but also objects such as stones, trees, rivers, caves, the stars, the moon, the sun, rain, the rainbow, the wind. The soul is a brother, a shadow, a counterpart of everything existing in the world. The soul is an independent entity, quite capable of detaching itself from its physical brother or counterpart. The souls of different entities can meet with each other, and influence each other. When a man’s soul leaves his body, it sees many things, meets with other souls, talks to them, and listens to them, and when it comes back to the body, it may tell the man of its experiences. These are then the dreams men dream. The soul may even go wandering and traveling while the man is awake. The Mentawaian would understand when a man or a woman is moody—his or her soul is experiencing something unpleasant in its wanderings. The Batak calls the soul his tondi; the Minangkabau calls sumange; the Torajan calls tanoana, while The Nias has his noso. [15]

In the Bronze-Iron age, our leluhur had reached the knowledge of ‘two worlds’: ‘the world of dead men’ and ‘the world of living beings’. It is known from the paintings on their bronze kettledrums. They painted on kettledrums a ship, but not for sailing oceans. The ship, it is believed, is for carrying the soul of a dead man from this world of living beings to the world of dead men.[16] The motif of the boat is not only on their kettledrums, but also is to be found in the architecture of houses. In Savu Island, a house has a bow and aft, and the motif of the ship of the dead or the ship of the souls (men on a boat) is found among the Dayak (especially in the tiwah festive day) and the Lampong, while the Torajan call their coffin a prau (boat).[17]

Almost at the same age came the Megalithic age, when our leluhur began worshipping their ancestors. They felt the need to choose leader of community, since their social organization had been well established. They selected as the leader the strongest man in his body and soul, the richest of all inhabitants, the most attentive to his people. When a man was chosen to be leader of community, he had a right to build a monument to commemorate his existence, a menhir. Through this menhir, when he was dead, a generation after can commemorate his merits and deeds to his community. The menhir used for commemorational aim later changed into its use for worshipping. His people believed that the leader would always watch over them and protect the community from any danger. They then began worshipping the leaders. They also developed more the belief of the residence of soul. They believed that the leaders’ souls (which became their ancestors) resided in the highest mountain ever. That’s why their menhir is always shaped like multi-leveled structure (Indonesian, punden berundak-undak), that is, to symbolize the height of the residence of souls. Under the punden, our leluhur always buried the bodies of ancestors, so as to easily worship them.[18] The shape of punden is verily Indonesian original. The Borobudur Temple, having been wrongly believed as an Indian-style building, had been build instead on the scheme of punden berundak-undak. In the burial located under the menhir, our leluhur also put glass beads, iron and bronze tools in the same grave, since they believed those to be things to wear and to use in ‘the world of the dead’.[19]

So far as our leluhur is concerned, we can conclude that our leluhur of the past time had reached instinctively and intuitively by their budi some high level of spirituality, which later would be of very much use in their encounter with the foreign philosophies of India and of Persia.

Chinese immigrants came to Indonesia in 1122-222 BC, but they wholeheartedly assimilated to Indonesian way of life. They became part of our leluhur too. Meanwhile, Indian foreigners came to Indonesia in 320 BC and they began to attract our leluhur with their sophisticated system of philosophy. I can understand how our leluhur were very attracted by this Indian philosophy. I have been studying Hinduism and Buddhism recently and I cannot help admiring at these philosophies so much. Only at a short glance of reading these Indian authoritative texts, I believe, anyone can get verily attracted. So did our leluhur in the past.

Our leluhur had known already that the universe was full of spirits. Ancestors, when being dead, were also spirits. They also believed that the spirits or the souls had special residences. And, they reached the understanding of the ‘two worlds`. All these beliefs were more developed by the adoption of the Indian philosophy. Indian Hindus, actually, in many parts gave them new ‘names` for the things our leluhur had known or they materialized what our leluhur had spiritualized. Leluhur called spirits or souls with many names; Hindus materialized and personified them and called them deva (god) or devi (goddess), manifestations of Brahman. Leluhur had belief in punden berundak-undak as the highest residence of spirits; Hindus called it anew as Mahameru Mountain. Leluhur had known ‘the world of the dead` and ‘the world of the living`; Hindus called them as Shiva (manifestation of the Infinite Transcendental Spirit) and Kali (the finite world of Nature). What our leluhur verily lacked was the concept of Supreme Spirit, which was also the One. Hindus mentioned Him as Brahman.

Our leluhur owed Indians too in devaraja cult. Some kings like Sanjaya of Hindu-Mataram, Airlangga (1007-1049) and his descendants from Kameshvara I to Kertajaya, asked some Brahmins to consecrate them through complex Hindu rituals and to insert ‘divine essence` to their bodies, in order that they could incarnate Shiva (the god of destruction, the god of reproduction, the god of asceticism, the god of meditation, the god of dancing art, the god of salvation, manifestation of Brahman) and Vishnu (the god of preservation, the god of sustainment, manifestation of Brahman).[20]

The utmost spiritual achievement that our leluhur had gained in 8 century AD is the concept of the unity of truth of religions. Hinduism and Buddhism—two different philosophies of the same Indian origin—were considered by our leluhur as containing the same truth. King Vishnu (775-782), who was a devout Buddhist, did not feel ashamed to name himself with a Hindu god`s name. Sambhara Suryavarana, a Buddhist writer who lived in the Kingdom of Hindu Mataram, overtly praised a Hindu King Sindok in his Buddhist sacred literature Sang Hyang Kamahayanikan. Mpu Prapãnca (1335-1380) wrote Negarakertagama, in which he blended Shaivism and Buddhism, while Mpu Tantular, a writer who lived in the era of Hayam Wuruk (1350-1389), wrote Kakawin Sutasoma, who also intentionally blended Shaivism and Buddhism.[21] Mpu Tantular said in his Kakawin Sutasoma:

Rwâneka dhâtu winuwus Buddha Wiswa,

Bhinnêki rakwa ring apan kena parwanosen,

Mangka ng Jinatwa kalawan Siwatatwa tunggal,

Bhinnêka tunggal ika tan hana dharma mangrwa.[22]

(It is said that the well known Buddha and Shiva are two different substances,

They are indeed different, yet how is it possible to recognize their difference in a glance,

since the truth of Jina (Buddha) and the truth of Shiva is one,

they are indeed different, but they are of the same kind, as there is no duality in Truth.)

Our leluhur of Java learned and mastered the Indian esthetics (kavya) very fast. They applied their learning by founding clubs of ‘poet laureate’. The royal poets are called kawi-kawi or mpu, and their poetry called kakawin. The poets are so called, because they used in their poetry-writing Bahasa Kawi—esthetic Old Javanese language created and utilized amongst kawi-kawi clubs. These kawi-kawi believed in the divine inspiration, by which they were ‘guided’ to make very esthetic poems. They believed that deva or devi would fall down to earth, bless them, manifest within and ‘reside’ in their kakawin as well, like residing in temples. They prayed Indian devas like Vishnu, Shiva, Kama, Ratih or sometimes Sarasvati before writing kakawin on the firm belief that by doing so those devas would happily help them compose very artistic poems. No wonder then that their kakawins have godly quality.[23] Mpu Panuluh, a kawi who wrote a very wonderful kakawin, explained how he wrote his Kakawin Hariwangsa:

To far, faraway mountain peaks I always wander to do my worship, longing for communication with the world of gods. My heart is focused on worshipping god Vishnu, hoping that He would willingly come down to my heart as He would to a lotus. My worship of Vishnu through this Samadhi (meditation) only has one purpose, that is, I hope I can manage in writing a kalangö (an esthetic work) and I hope He willingly helps me through His power write a poem, by which I can establish my stand amongst those who deserve to be called kawi (esthetic poet).[24]

For 7 centuries our leluhur had learned many things from the Indian civilization and culture. They were fast and creative learners. Called creative in the sense that, after receiving many Indian elements, our leluhur developed them more, but even formulated new stream of thought which would verily accord to the indigenous thought. It is undeniable truth, however, that we had learned many things of India and we cannot easily escape from its attracting spell. Therefore, when a wave of Islamic thought began to band in fifteenth-century Indonesia, only its Sufism was very well welcomed by our leluhur, since it resembled the Indian spirituality in very many aspects of it. Wali Songo or ‘The Nine Muslim Saints’, who left Persia and India for Indonesia in 15th century, were best welcomed by our leluhur, for they taught the same monism like the Indian one, although with different terminology and idioms. This is beautifully expressed in the words of Ki Ageng Pengging, one of our leluhurs who eagerly learned Sufistic monism from Syekh Siti Jenar of India:

Kyageng Pengging tan riringa

Angengkoki jati ning Mahasukci

Allah kana kéné suwung

Jatine among asma

Ya asmané manungsa ingkang linuhung

Mengku sipat kalih dasa

Agama Buda Islami

Karonina nora béda

Warna roro asmané mung sawiji.[25]

(Without hesitation Ki Ageng Pengging said

that he is the All-Holy.

“God is not found here or there.

In fact, ‘God’ is only a name,

that is, a name for Great Man

who has twenty attributes.

Buddha and Islam

are never different.

The forms are two, but the names are one”)

Our leluhur learned the Islamic heritage as eagerly as they learned the Indian one. But, as they did so to Indian, they only accepted the Islamic civilization if it fitted the indigenous thought well. I don’t want to repeat what P.J. Zoetmulder has genuinely revealed in his book Pantheïsme en Monisme in de Javaansche Soeloek-Litteratuur (recently translated into English), in which he showed that our leluhur had invented complex philosophical concepts of emanation through seven levels of divine manifestation (martabat tujuh) and radical monism. I humbly ask readers to read and recite this genial work.

Our leluhur continued to be the fountain of spiritual knowledge by their inner faculty of budi, until they were stopped to be considered as ‘the virtuous ones’ and had been object of mockery. This happened when Adat (the compilation of leluhur’s traditional wisdom) has been subject to criticism by Muslim reformers inspired by Wahhabite ideals emerged in West Sumatra in the decade of 1800s. By their poisonous teaching of eradicating the indigenous civilization, later generations of Indonesia were inspired to be rebellious children who sacrificed their own civilization to get ‘the false Arabian Paradise’.


text: User talk:80.34.142.220

title: User talk:80.34.142.220


text: User talk:59.101.236.115

title: User talk:59.101.236.115


text:
The Science of Programming/Terrifying Concepts

Probably the two most terrifying concepts in the freshman world are Calculus and Programming. They certainly were for me. I was a C student when it came to Calculus and a B student when it came to programming. Let me assure you that both concepts are quite simple, notwithstanding my grades as a freshman. In fact, both calculus and programming are so simple, my freshman grades are most embarrassing.

Let's start with calculus. I don't know how or why I got it into my head that calculus was a difficult subject. As pointed out by Sylvanus P. Thompson (herein SPT) in the analogous chapter of Calculus Made Easy (herein CME), you simply have to understand the two symbols you will encounter over and over again when discussing Calculus. They are $$\int$$ and $$d$$. The first symbol, $$\int$$ (the integral symbol), simply means 'to sum up'. The second symbol, $$d$$ (the differentiation symbol), means simply 'a tiny piece of'. Placed together, as in

$$\int x^2\,dx$$

they simply means to sum up all the tiny pieces of the curve $$x^2$$

Let me add that the purpose of differentiation is just to find the slope of a curve and that the purpose of integration is to find the area under a curve. That's all.

With regards to programming, it also is rather simple. To write a program, one simply calls functions to do the work you need to do. Sometimes the function you need to call already exists. Sometimes it doesn't and you have to build it. But guess what? You are going to build the function from other functions, some of which already exist and some that do not. Simple, right?

I've used the word simple and its variants an awful lot, but I do so because it really is all so simple.


text:
The Science of Programming/How Low Can You Go?

Recall from the last chapter that the symbol d with respect to Calculus means 'to take tiny pieces of'. Let's practice taking small pieces of a number and, at the same time, learn some programming. And, because you must, as future Computer Scientists, you must learn to let go and be wild, we will take a small piece of a small piece, and a small piece of that very small piece, and so on and so on, ad infinitum.

At this point, you should install Sway on your system.

Using the Sway Interpreter
We begin by starting the Sway interpreter, Sway being the Programming Language you will learn. Once started, the interpreter rewards you with a prompt:

sway>

This prompt signals to you to enter some code. When you do so, the interpreter will tell you the result of running (or evaluating or executing) that code.

sway> 3; INTEGER: 3

To exit the interpreter, type  or a . These key strokes are generated by holding the Control key down while at the same type tapping the 'd' or 'c' key at the same time. Here, we have entered a 3 followed by a semicolon (the semicolon tells the interpreter that we are done entering code). Sway (actually the Sway interpreter) responds by saying 3 is an integer with a value of 3. Of course, we already knew all that, so the interpreter doesn't seem to be all that useful. But did you know that 43 times 112 is 4816?

sway> 43 * 112; INTEGER: 4816

Sway does! Let's use the fact that the interpreter is pretty good at math to figure out what a small part of a big number is. Let's assume that a small part is $$\frac{1}{16}$$ of the whole. First, let's figure out what $$\frac{1}{16}$$ is as a decimal number, or real number, since that will be easier to type in:

sway> 1/16; SOURCE CODE ERROR file stdin,line 1 an expression was expected, found token of type BAD_NUMBER error occurred prior to: 16;[END OF LINE]

Uh oh. Sway did not like the '1' followed so closely by the '/'. In fact, Sway requires spaces around things like division signs in most instances. Let's try again:

sway> 1 / 16; INTEGER: 0

Better, at least we got an answer instead of an error. However, it doesn't seem that the interpreter is that good at math after all. If we put on our Sherlock Holmes cap and ponder, we see that the interpreter said the result of dividing 1 by 16 is an integer, but we know it should be a real number. It turns out that the Sway language, like most programming languages, uses a rule that combining two things of the same type yields a result of the same type. In this case, zero happens to be the largest integer that is less than the desired result. In other words, the interpreter truncated the fractional part of the real number and gave us the integer that was left. Let's experiment and see if this is so:

sway> 7 / 2; INTEGER: 3

Seems to be. So getting back to our original problem, how do we find out what is 1 divided by 16 as a real number? Let's enter the numbers as real numbers instead of integers:

sway> 1.0 / 16.0; REAL_NUMBER: 0.0625000000

That's much better!

Now let's figure out what a small part of a million is (using our assumption of what is small):

sway> 1000000 * 0.0625; REAL_NUMBER: 62500.0000000000

Sixty-two and a half thousand. Still big in an absolute sense, but much smaller that a million. Being wild and crazy, let's take a small part of a small part:

sway> 1000000 * .0625 * .0625; REAL_NUMBER: 3906.2500000000

About 4000. Much smaller.

You should familiarize yourself with Sway primitives and combinations, including Sway's precedence and associativity rules, at this point.

Using Variables
Shall we continue taking ever smaller parts?

Before we do, I must admit that I am, at heart, a lazy person, as are most Computer Scientists. Typing in all those numbers is just too much work! I am going to use two short symbols to represent both the million and the fraction:

sway> var x = 1000000; INTEGER: 1000000 sway> var f = .0625; REAL_NUMBER: 0.0625000000

What I've done is created a variable to stand in for the million and a variable to stand in for the fraction, x and f respectively. Now I can use those variables instead of the numbers. Let's check to see if I did things right:

sway> x * f * f;   REAL_NUMBER: 3906.2500000000

Looks like I did. Let's go a step further:

sway> x * f * f * f;   REAL_NUMBER: 244.1406250000

It seems variables are a nice way to reduce the amount of typing needed. The only drawback is remembering what a variable stands for. This is why it is so important to name your variables in such a way as to make it easy for you to recall their meanings. Generally, single letter variable names are 'not a good idea (although there are exceptions to this rule).

To learn more, see Sway variables.

Using functions
We could go further with this, but you have yet to understand the depths of my laziness. Even typing in * f repeatedly is too much for my sensibilities. I am going to define (or write) a function to do the work for me (you can cut and paste this function into the interpreter if you are lazy like me and don't want to type it in yourself):

function smaller(amount,fraction) {       inspect(amount * fraction); }

Whether you paste it in or type it in, you should get the following response from the interpreter:

sway>    function smaller(amount,fraction) more>        { more>        inspect(amount * fraction); more>        } FUNCTION:

The more> prompt indicates that the Sway interpreter is expecting some more code.

There are two things you must do when dealing with functions, (1) define them and (2) call them. Here, we have just defined a function; now we need to call it. We will call it by typing the name of the function followed by a parenthesized list of arguments. Sometimes we say this is "passing the arguments to the function".

When calling the function smaller , the values of the arguments will be bound to the variables amount and fraction, which are found after the function name in its definition. These variables are known as the formal parameters of the function. This passing and binding, in essence, defines those variables for us. Note that the arguments and formal parameters do need to be separated by whitespace; the comma serves as a separator.

After these implicit variable definitions, the code between the curly braces {} will be evaluated as if you had typed them in directly to the interpreter. This is why I said in the previous chapter that a function does the work for you. If we look at the code (or body) of the function we just defined, we see that a function named inspect is being called. Since we haven't defined inspect, we can assume that this function already exists within the interpreter. By its name, we can guess that it will tell us something about what happens when we multiply amount by fraction:

sway> smaller(x,f); amount * fraction is 62500.000000 REAL_NUMBER: 62500.000000

There is a whole lot going on here that needs explanation. The first is that the value of x (1000000) was bound to the formal parameter amount of the function smaller. Likewise, the value of f (0.0625) was bound to the formal parameter fraction. Then the body of the function smaller was evaluated, triggering a call to the inspect function. What inspect does is print out its literal argument, followed by the string " is ", followed by the value of its argument. Since the call to inspect is that last thing smaller does, whatever inspect returns is returned by smaller. This return value appears to be the evaluated argument.

Note that interpreter reported two things. The first is the string produced by inspect. The second is the report of the return value as we have seen before. We call an action that has an effect outside the called function (in this case, the printing by inspect) a side effect.

To learn more, see Sway Functions.

Recursion
Now, at this point, you are probably thinking that, not only am I lazy, I must be a rather dim bulb as well, because I spent a lot more effort writing the smaller function and calling it than I would have simply typing:

sway> x * f;   REAL_NUMBER: 62500.000000

If that was all I was going to do, you would be quite right in your assessment. But I am not finished yet. Now I am going to make smaller much, much more powerful:

function smaller(amount,fraction) {       inspect(amount * fraction); smaller(amount * fraction,fraction); }

Notice that I have added a call to the smaller function after the call to the inspect function. When a function calls itself, it is said to be a recursive function, that it exhibits the property of recursion and that at the point of the recursive call, the function recurs. Notice further that the first argument to smaller in that internal call will send a (hopefully) smaller number to the smaller function. In that call, smaller will be called again with yet an even smaller number, and so on. Let's try it:

sway> smaller(1000000,.0625); amount * fraction is 62500.0000000000 amount * fraction is 3906.2500000000 amount * fraction is 244.1406250000 amount * fraction is 15.2587890625 amount * fraction is 0.9536743164 amount * fraction is 0.0596046448 amount * fraction is 0.0037252903 amount * fraction is 0.0002328306 amount * fraction is 1.4551915228e-05 amount * fraction is 9.0949470177e-07 ...   amount * fraction is 0.0000000000e+00 amount * fraction is 0.0000000000e+00 amount * fraction is 0.0000000000e+00 amount * fraction is 0.0000000000e+00 amount * fraction is 0.0000000000e+00 amount * fraction is 0.0000000000e+00 amount * fraction is 0.0000000000e+00 amount * fraction is 0.0000000000e+00 encountered a fatal error...   stack overflow.

Wow! Unless you have very quick eyes, all you saw is the bottom part of this output. What happened? What we did was to define a function that fell into an infinite loop when we called it. An infinite loop occurs because we never told our function when to stop calling itself. Thus, it tried to call itself ad infinitum. Of course, a computer has a limited amount of memory, so in this particular case, the calls could not go on forever. Let's redefine our function so that it pauses after every inspection so we can slow down the output:

function smaller(amount,fraction) {       inspect(amount * fraction); pause; smaller(amount * fraction,fraction); }

You can start up the Sway interpreter again and paste in our revised function definition.

Now when we call our function we see this output (assuming you repeatedly hit the enter key on your keyboard):

sway> smaller(1000000,.0625); amount * fraction is 62500.0000000000 amount * fraction is 3906.2500000000 amount * fraction is 244.1406250000 amount * fraction is 15.2587890625 amount * fraction is 0.9536743164 amount * fraction is 0.0596046448 amount * fraction is 0.0037252903 amount * fraction is 0.0002328306

You can stop the interpreter by typing in a -c which is entered from your keyboard by holding the Control key down while tapping the 'c' once.

We can see that amount * fraction gets very small very quickly. If you start again and keep going, you will see that amount * fraction eventually reaches zero. Theoretically, it doesn't, but at some point the quantity gets smaller that can be represented by Sway, so Sway reports zero.

You should read more about recursion and learn about if expressions before continuing.

Let's try a new version of the function, this one calls itself a given number of times before stopping:

function smaller(x,f,n) {       if (n == 0) {           :done; }       else {           inspect(x); smaller(x * f,f,n - 1); }       }

This time, we have a new formal parameter n, which represents the number of times to the function recursively calls itself again. We've also changed the call to inspect to print out the value of x. Note that the recursive call not only makes x smaller, it makes n smaller as well. When n gets small enough, the function returns the symbol done.

We must remember to add an extra argument to the call. Let's send in 8 as the number of times to recursively call:

sway> smaller(1000000,.0625,8); x is 1000000 x is 62500.000000 x is 3906.2500000 x is 244.14062500 x is 15.258789062 x is 0.9536743164 x is 0.0596046448 x is 0.0037252903 SYMBOL: :done

Yay! Our program stopped recuring infinitely. Formally, the if inside the function has two cases: the base case, which does not contain a recursive call and a recursive case, which does. Infinite recursive loops occur when the base case is never reached, usually due to some misstatement of the base case condition or a misunderstanding of the range of values taken on by the formal parameter being tested in the base case condition.

Back to Calculus
What did this exercise with finding ever smaller numbers have to do with calculus? Well, the $$d$$ symbol means 'take a tiny piece of'. How tiny? Infinitesimally small, or in other words, the value computed by an infinite number of recursive calls to smaller. Of course, this is smaller than we can fathom, but that is not a big deal. We can't fathom how our brains work, but we get along OK, or at least most of us do.

Questions
All formulas are written using Grammar School Precedence.

1. What happens when you combine an integer and a real number?

2. This question and subsequent questions refer to the last version of smaller. Why did the call to smaller return a real number?

3. Redefine smaller so that it prints out nine inspections rather than eight, for the same initial value of 8.

4. What happens when zero is passed as the count to smaller?

5. What happens when -1 is passed as the count to smaller? Why?

6. What happens if the recursive call in smaller is replaced by smaller(x *f,f,n)? Why?

7. Write a Sway function to represent $$ y = 2 x ^ a $$, and evaluate it for $$ x = 1, 2, 3 $$, and $$ a = 2, 4, 6 $$.

8. Using the Sway function for $$ y $$ in the previous problem, write a new Sway function $$ z = a y $$, and evaluate as before.

9. A series is a sequence of terms that are added together. If as more and more terms are added together, the sum of the terms get closer and closer to a number k, then, k is said to be the limit of that series. The book explains this with Zeno's paradox. Let's say you start a distance 1 away from a wall and with each step, you travel half the remaining distance to the wall (why is this a paradox?). Using recursion and Sway, define a function zeno(n) that demonstrates this process. The argument to zeno is the number of steps taken and the return value should be the total distance travelled. What is the limit of the zeno series?

10. Let $$g(x) = x^2$$ and $$h(x) = (g(1+x) - g(1-x))/(3 x)$$. Calculate $$h(1)$$, $$h(2)$$, $$h(3)$$, and $$h(0.5)$$. Express $$h(x)$$ in terms of $$x$$. Draw a graph of h in the range $$-2 \leq x \leq 2$$.

11. The formula for the chance of an NPC (Non-Player Character) landing a crushing blow in the World of Warcraft (a popular Massively Multiplayer Online Role-Playing Game or MMORPG), is $$(\mathit{NPCLevel} * 5 - \mathit{PlayerDefense}) * 2\% - 15\%$$. For a level 70 NPC, express this as a function of $$PlayerDefense(x)$$ and give the value of defense that makes the chance 0.

12. The amount of experience to level a character is $$ h(x) = g(x) * (1344 - ((69 - x) * ((69 - x) * 4 + 3))) + 155 $$ where x is the character level and where $$g(x) = 5x + 45$$ is the basic amount of experience earned for dispatching a mob of level equal to the character. Calculate $$h(61)$$, $$h(69)$$, $$h(0.5)$$, and $$h(1)$$. Express $$h(x)$$ in terms of x. Plot a graph of h for $$61 \leq x \leq 69$$.


text:
Cookbook:Simple Spaghetti

| Cuisine of Italy | Italian-American cuisine

Ingredients
For 4 servings:
 * 2.25 L (10 cups) water
 * 8 oz (224 g) spaghetti
 * 2.5 cups (24 oz) pasta sauce (optional but recommended)
 * Salt (optional but recommended)
 * Vegetable oil (optional but recommended)

Procedure

 * 1) On a stovetop, bring the water to a boil on high heat after adding salt and vegetable oil (see tips below).
 * 2) Reduce heat to medium and add the pasta.
 * 3) While the spaghetti is cooking, pour desired amount of sauce into pan and set stove to medium.
 * 4) Set a timer for 7 minutes. When the timer goes off, fish out a strand of spaghetti and bite into it.  What you're going for here is al dente, meaning that the pasta is just soft enough to eat: no longer crunchy in the middle, and not mushy and over-done. A more traditional (but messy) way to see if the spaghetti is done is to throw some strands onto a wall.  If they stick to the wall, then the pasta is ready to eat.
 * 5) When the sauce begins to bubble, reduce the heat to its lowest setting and cover.
 * 6) Once the pasta is ready, carefully drain it through a colander into a sink.
 * 7) Serve sauce over pasta in bowls.

Notes, tips, and variations

 * Adding salt to the cooking water enhances the pasta flavor and to allows the water to boil more quickly. Adding vegetable oil to the cooking water helps prevent the spaghetti from sticking together.
 * Try adding herbs or fruit (such as pineapple tidbits) to the water before it boils to keep with the pasta after straining for extra flavor and texture.
 * Before cooking the sauce, consider sautéing some finely minced onions, garlic, ground beef (or pork/sausage/veal/etc.), cheese (parmesan/mozzarella/etc.), mushrooms, or anything else that catches your fancy. Then add the sauce.
 * In a pinch, you can make plain spaghetti and add ketchup if you do not have any pasta sauce available.
 * The following foods go well with spaghetti and can be served together:
 * Broccoli (or other vegetables).
 * Garlic Bread
 * Meatballs
 * Pineapple (or other fruits) tidbits (boiled, grilled, or fried)
 * Shredded and/or grated cheese
 * Tomato, alfredo, or other sauces (can choose one, the other, or mixed together)
 * Cooking is about experimentation—never be afraid to try anything once!

title: Cookbook:Simple Spaghetti


text:
Talk:Geometry/Inductive and Deductive Reasoning

''NOT: If a statement is preceded by "NOT," then it is evaluating the opposite truth value of that statement. The symbol for "NOT" is For example, if the statement p is "Elvis is dead," then ¬p would be "Elvis is not dead." The concept of "NOT" can cause some confusion when it relates to statements which contain the word "all." For example, if r is "¬". "All men have hair," then ¬r would be "All men do not have hair" or "No men have hair." Do not confuse this with "Not all men have hair" or "Some men have hair." The "NOT" should apply to the verb in the statement: in this case, "have."''

_____________

I suggest that someone review this definition of NOT.

The truth-tables at the bottom of the Wiki page indicate that the negation of a true statement is a false statement, and vice versa. This is consistent with notions of classical deductive logic. Yet the above-quoted definition of NOT seems to contradict it.

The definition states that the negation of the proposition p "All men have hair" is "All men do not have hair." Assume that some, but that all, men have hair. In this case, both the proposition p and its negation are false. This contradicts the truth tables.

In contrast, if "All men have hair" is false, then it seems intuitive to conclude that "NOT all men have hair" (or "Some men do NOT have hair") is true. That is, the NOT should apply to a proposition as a whole, not to the verb of the proposition in particular.


text:
Talk:19th Century Literature/Frankenstein

I liked the comparisons you made between the monster and upper class society, I also feel that the story was a look at humanism and the eternal desire to have companionship. Victor created the monster and then turned his back on him leaving him to fend for himself and to be excluded from the world around him. He never knew a kind or gental touch and went to great lengths to try to acquire it. He even tracked Victor down and demanded a femal counter part to share in his diformaty and solitude. The monster struggled with loneliness and solitude, he ultimitaly became evil to gain attention from his master. Everything leads back to human emotion and desire for companionship.


text:
User talk:169.244.100.45

Join Us!
--Whiteknight (Page) (Talk) 16:11, 29 April 2008 (UTC)

title: User talk:169.244.100.45


text:
User talk:Scrapper333

Welcome!
Welcome, Scrapper333!

Come introduce yourself at the new users page. If you have any questions, you can ask there or contact me personally.--Whiteknight (Page) (Talk) 17:22, 29 April 2008 (UTC)

title: User talk:Scrapper333


text: Template:NUMBEROFBOOKS

title: Template:NUMBEROFBOOKS


text:
Talk:Adventist Youth Honors Answer Book/Outreach/Christian Citizenship

There are a lot of flag images available in SVG at [Open Clipart http://openclipart.org] GG (talk) 17:57, 29 April 2008 (UTC)


text:
User:Scrolls~enwikibooks

Hello there!

You've reached the profile page of scrolls, a technical writer from somewhere in Canada.

Since I write software manuals by day, I figured this would be a good place to practice my trade on other topics as well. Although considering how much writing I do during the day, I'm not sure I'll do much writing here, but nevertheless, I thought signing up for an account was a good thing to do just in case.

Cheers!

title: User:Scrolls~enwikibooks


text: User talk:216.234.204.6

title: User talk:216.234.204.6


text:
Editing Wikitext/Class and Style Notes

'''This short piece is intended to communicate a few of the more basic points about styles for authors starting out with Wikibooks. The system's style-sheets are not accessible for edit by authors but a considerable amount of CSS styling is still possible by the addition of HTML and Wikitext tags to the page.'''

Basics

 * Styles: These are sometimes called CSS style rules.  They are delivered to the browser along with the Wikibooks' web-pages. They are sent in text files called style-sheets, though fortunately they can be typed directly onto the Wikibooks edit area as well.
 * User style-sheets form an exception.  Those who are familiar with this use of their browsers could modify the local display of a wiki web-page, but not the stored version that can be viewed by others.
 * HTML tags and Wikitext tags can be added to the edit area of the work.  Authors can use either Wikitext or HTML tags in their work; in fact many of the HTML tags that are in general use could be used.   Wikibooks uses the Wikitext mark-up most of the time, but it is translated to HTML before it is sent to the browser for use.
 * Wikibooks authors are limited to in-line styles.  Authors do not have access to the style-sheets for the Wikibooks system.   They must write their styles into Wikitext tags or HTML tags that they add to the edit area of their pages.   If however, they know of classes of styles that already exist they can declare them in tags for use too.
 * Templates can contain styles too. Templates are named blocks of prepared text, with or without styles, that can be inserted into an authors work with a special format.  Complex tasks involving in-line styles, especially those that are to be used frequently can benefit from their use.   Templates made by others are available to all.
 * In-line styles have a fairly high priority.  In fact, for those familiar with the subject, each in-line style declaration has a specificity that is one-thousand times that of a simple tag-selector, one-hundred times that of declarations within a class block, and ten times that of declarations within an id block.   That is to say, they override other author styles unless those other styles have an !important marking.
 * HTML attributes are styles too. Before the use of CSS styles HTML attributes were the main way to style web-pages.   Many of these attributes are no longer available in HTML5, but a few still are.   Because their future is uncertain, Wikibooks  prefers the use of CSS styles.
 * Use a CSS styles reference.  To find the styles to apply in your work, the best way by far is to refer to a reference list.   A comprehensive list and tutorial for CSS styles can be found both within wikibooks itself and at the World Wide Web Consortium CSS Reference.

In-line CSS Styles
All in-line styles, whether written in HTML tags or Wikitext makes use of the Style attribute. There should be only one style declaration in an element if confusion is not to result.

The following code is typical of an in-line style declaration for text to which paragraph tags have been added. It is used here to set the font name and its spacing. The main points to note about the style declaration are these: Some structures written in wikitext, such as tables, use a slightly different format but the style-part is the same. Those with an interest in such formats should refer to the page Tables, and for a reference list and tutorial on CSS styles, refer to the site World Wide Web Consortium CSS Reference.
 * The style-block is always equated to the attribute style .
 * The entire style-block is set in parenthesis.
 * There is a colon between each property and its value.
 * Individual declarations are separated by semi-colons.
 * Values that contain spaces must themselves be set in quotation marks.
 * A space can exist after a semi-colon.
 * The last semi-colon is optional.
 * Any number of properties can be listed.

Common Styling Tasks
This section describes the basics of the more common styling tasks encountered by the new Wikibooks writer. Writers are encouraged to add to this section with their useful findings. Thus. in a healthy writing environment it should increase with time.

Styling Paragraph Text
The most common task by far in Wikibooks styling involves changing the appearance of text. There are two main methods available to the writer, the addition of paragraph tags that are then styled, or the similar use of span tags. Both methods use a style expression of the type previously described and the layout of each is shown below. The span technique is usually reserved for short strings of text whereas styled paragraphs have more general use. Paragraphs are examples of block elements, so they can have widths, margins, and other dimensions set for them. The span tag is an example of an in-line element, without block styles.

If there are several paragraphs to style, rather that styling each, it is best to add a set of div tags around the work and to style that. Then, provided that it is possible to do so, the styles will be inherited from the division tag. The inheritance of styles is beyond the scope of this section but is covered elsewhere in The CSS Cascade - Inheritance of Styles.

Styling the 'Pre' Tags
The Pre tags can be added to text when we need to preserve its exact layout. That is to say, where the browser must be discouraged from doing formatting of its own. Examples include the writing of verse, lyrics, code listings, and various other purposes. This kind of text is referred to as pre-formatted text to distinguish it from un-formatted text, the usual thing, where the browser wraps text at the end of lines. These tags also have the effect of deactivating functional code like tables, and all other tags. The basic code is just:

The pre tags can be CSS-styled to produce different fonts, borders, and backgrounds, in addition to the full set of width, padding, margins and alignment that is common for all block elements. See the example below, where a few styles have been added. The white-space property makes sure that long lines are wrapped, instead of forcing the page width to widen.

More methods for pre-formatted text can be found at Preformatted Text.

Shifting the TOC
One of the most useful things that styles can do is to shift the Table of Contents (TOC) to some precise point on the page. This becomes essential when lists appear at the top of a page. In order to avoid the inevitable distortion of bullet-points the TOC can be simply moved to the right hand side of the page, as opposed to its habitual position on the left.

The usual method to do this is to place the Table of Contents in a table cell, and to then move the table to any place on the page that suits. A table is chosen rather than a division because a table can change in size easily, to accommodate a changing TOC width. Templates have been made that exploit this idea, including Template:Tocright. Using HTML tags, the general form is just: Notice that the TOC inclusion is in capitals and has four underscores, two on each side.

For positioning on the right of a page the table could be styled as follows:

The float property places the table on the right of its container, the page, and allows text to wrap around it. The text will start to wrap, starting with the line of text that follows the code block. The margin property sets the spacing between the table container and the wrapped text.

Further information can found on the TOC at  Headings.

Dividing the Page
Pages can be divided into partitions. This is useful when applying styles to large sections, and for making smaller box-like shapes.

The size of the enclosed section is not important. For example, the author's section of the page itself could be divided into two parts as follows. Here, one part has been given a different background color from the remainder. The existing text and structures will be indented within these new colored containers by 10 pixels, about one tenth of an inch or so depending upon the resolution of screens.

Useful CSS Classes
Sadly, there are few if any useful classes that can add interest to an author's work. There is a real need for a set of table classes; the condescension of the Wikitable class is really not sufficient. It is a matter for web-masters to improve the availability of classes, since others have no access to the modification of style-sheets. However, would it appear from the long standing of the basic table style that they think that they are just fine as they are?

See Also
 * CSS Reference  :   A useful external CSS reference list
 * Sandbox  :   The WikiBooks sandbox
 * Templates  :   WikiBooks template making A101
 * Style Presentation Modes in Opera 12.16  :   A description of the Opera browsers style modes.
 * The CSS Cascade  :   A basic explanation of the CSS cascade.

title: Editing Wikitext/Class and Style Notes


text:
User talk:Keeper76

Welcome
I am Keeper, an admin on English Wikipedia. Just branching out my name for a global account. I don't expect to branch out much further than en.wikipedia at this point (but you never know!) For now, if you need to leave me a message, or make a comment, please do so on my en.wiki talkpage by clicking here. Thanks, happy editing, Keeper76 (talk) 19:47, 29 April 2008 (UTC)

title: User talk:Keeper76


text:
Template:Java Web Application Development With Click Framework/Page

 Java Web Application Development With Click Framework


text: Template:Outdated

title: Template:Outdated


text:
Wings 3D/User Manual/Geometry Graph

6.2 Geometry graph The geometry graph only list the objects, including lights in the workspace. Here you can lock, hide, duplicate and rename objects. The graph becomes more important as the number of objects in your scene increases.

The geometry graph window contains a vertical listing of all the objects currently in the geometry window. (If there are no objects at all, this window will be empty.) Adjacent and to the right of each object listed are three icons. One for object selection, one for object visibility, and one for wireframe mode. Left clicking the icon toggles its status. Right clicking the icon toggles the status of all other icons.

Considering the convienience and usefulness of this particular window, it is recommended by most users that you keep it open and to the left or right of the geometry window workspace. This way you have a fast alternate method to select, see whats selected, or hide things without having to go through many actions or menus.

title: Wings 3D/User Manual/Geometry Graph


text:
Wings 3D/User Manual/Plugins

Plugins expand the functionality of Wings3D with capabilities not found in the basic Wings3D installation. They can do things such as adding new tools, import/export capabilities, or other features that may be considered too unusual or experimental for inclusion into a regular Wings3D release. Typically, they consist of an Erlang .beam file, but may include supporting files. They are installed by either directly copying the file to the Wings3D plugin directory or by using the dialog available through the Edit|Plug-in preferences menu.

Mesh Creation
Plugins in this section add primitives to the Primitives pop-up menu.

Slide Plug-in

 * Developer: clacos
 * Description: Moves a vertex back and forth along a connected edge.
 * Installation: Place in the wings3d\lib\wings-1.0.1\plugins\commands directory.
 * Usage: Pick a vertex to slide and then choose an edge to slide it along.
 * Link: http://membres.lycos.fr/dong3d/plugsdone/wpc_slide_097_01.beam

(Plug-in Name)

 * Developer:
 * Description:
 * Installation:
 * Usage:
 * Link: http://

Modeling
Plugins in this section add functionality to Wings3D's modeling capabilities.

(Plug-in Name)

 * Developer:
 * Description:
 * Installation:
 * Usage:
 * Link: http://

(Plug-in Name)

 * Developer:
 * Description:
 * Installation:
 * Usage:
 * Link: http://

File Format Importers & Exporters
Plugins in this section import and export non-native 3D model formats.

(Plug-in Name)

 * Developer:
 * Description:
 * Installation:
 * Usage:
 * Link: http://

(Plug-in Name)

 * Developer:
 * Description:
 * Installation:
 * Usage:
 * Link: http://

Render Exporters
Plugins in this section send Wings3D scenes to external rendering applications.

(Plug-in Name)

 * Developer:
 * Description:
 * Installation:
 * Usage:
 * Link: http://

(Plug-in Name)

 * Developer:
 * Description:
 * Installation:
 * Usage:
 * Link: http://

Miscellaneous
Plugins in this section... do other stuff.

title: Wings 3D/User Manual/Plugins


text:
User:Whiteknight/Template Cheatsheet

This is going to be a list of all message templates and what they mean. Click on the name of a template to view its text and determine if it is the correct one to use.

title: User:Whiteknight/Template Cheatsheet


text:
Talk:Wings 3D/User Manual/A Quick Start Guide/Finger exercises to get you started

On the ending part (or least it was when I just visited) about the nature of normals, you might consider pointing out that a normal could be pointing one of two ways in regards to faces. Wings3D hides normal backfaces by default, so you'd observe some clipping or no surfaces at all (inverted cube is a good example.) But to remove all uncertainty, there's also an option to view the normals. And I also believe that there are normals in regards to the selection types. An edge's normal can be a different vector than that of a face or vertex. Only thing is, would mentioning that in the exercise be more confusing to new users? --Pauljs75 (talk) 21:37, 29 April 2008 (UTC)