text:
Reaktor/Wishlists

Reaktor 6 wishlist
You can add features which you think are neccessay or desirable for the next version of Reaktor, just go to edit this page.
 * MP3 playback module just like in Traktor with scrub, beat markers etc..
 * An actual release at some point in time
 * ReWire
 * Thread on Reaktor User Forum
 * FFT desired by all advanced instrument builders
 * Send and receive SYSEX (System Exclusive). This will allow Reaktor to control hardware synths and fx. This will permit a better integration of hardware devices and total recall of hardware settings using reaktor within a daw. +4
 * click-free switches
 * direct sample loading without having to store samples in maps before
 * Sample preview in sample browser window
 * Record samples inside Reaktor//this can already be done//add 24 bit recording in standalone
 * Ability to export sample maps as wavs & more control over maps
 * Ability to connect to a mysql database for patch storage
 * NRPN control assignment
 * Macro Object Inheritance / Ghost Copies (i.e., changes made to one macro are made to all macros of the same type. This saves you the time of having to copy and wire 20 macros when you edited one.)
 * Automatic patching to said Ghost Copies (i.e., patching a signal to an input on one macro patches that signal to all 'ghost' macros)
 * Replacing macros while retaining patches to inputs/outputs that are named the same.
 * More help and in depth descriptions on how to utilize event and audio tables.
 * Reaktor 4 was heavily lacking in quantity of instruments, Reaktor 6 should come with a library as large as Reaktor 3's built in library. Flashy, bloated ensembles are nice, but a wider variety of functional instruments would be more useful than a 50 megabyte 2 oscillator synth.
 * Macros and modules should be allowed back into the main ensemble structure view. With the Reaktor 4 update, this was disabled for the user.
 * Import more audio format (rex, mp3, AAC...)
 * Ability to program own modules with text code, not graphically
 * Scripting Language like Kontakt 2's KSP mainly for advanced midi control
 * Easier Sample Handling - Kontakt Style +1
 * Proper & CPU friendly midi sequencers for live use
 * Proper bandlimiting at Reaktors outputs or downsample module or proper adaptation of oscs to samplerate. (A.k.a Anti-aliasing)
 * Additive resynthesis
 * VST module to insert e.g dedicated efx
 * Save/Compile your ENS as a VST or VSTi
 * New Acoustic Modelling Macro Library - something comparable to Tassman or Harm Visser (Edit: Harm Visser has Reaktor Ensembles available at his website, and Karplus Strong can be easily done in Reaktor already)
 * New Module: Unity Gain Saturation
 * New oscillators that have a fuller, less digital sound (Edit: There are several Anti-Aliased Oscillators built with Core. Check out Multiwave Osc and the ones built into Carbon2)
 * Filter modules which can be compared with other NI products. (Absynth, Kontakt etc)
 * MIDI file player module
 * drawable anti-aliased oscillator (absynth style)
 * drawable oscillator should include all editing methods of absynth oscillators & should include all the same oscillator types, including Morph
 * Absynth style envelopes (Edit: Already exists, or at least an FM8-style one (similar to Absynth): Macros>Building Blocks>Envelopes>Multi BP Env)
 * internal recording higher than 16bit resolution
 * Trim/cut/normalize etc in sample map
 * Remove the distinction between contol resolution and audio resolution so that the control signals can work in real time. This would allow for accurate pitch tracking and other wonderful things +1 (Edit: Core already does this)
 * Option to disable the grid when editing the Panel.
 * large selection of super high quality panel elements - knobs, sliders, buttons, etc, ..
 * less cpu usage
 * Optional wire clean-up
 * View and compare structure using more than one window. Similarly, with the panel/interface view, separating instruments and effects into separate windows.
 * Transparency for every single element (not just for mouse area)
 * Tutorials & How to do Manuals (Edit: ADSR Tutorials has great Reaktor tutorials)
 * Proper in-depth description of components/modules/etc.
 * Support more languages (German / French / Spain / Russian)
 * Front Panel cabling option to build proper modular synths. (Not sure why this wasn't there from the start)
 * A reload option on skins as well as alphabetized listing in the drop down.

title: Reaktor/Wishlists


text:
Reaktor/Hosts

Reaktor as plugin
This page should not include a list of all known VST hosts, but manuals for use of Reaktor with a host, issues and solutions etc.
 * Steinberg Cubase
 * Cakewalk Sonar
 * Emagic Logic
 * Ableton Live
 * Digidesign Pro Tools
 * MOTU Digital Performer
 * Tracktion
 * EnergyXT
 * Plogue Bidule
 * Renoise
 * FL Studio
 * Cakewalk Project5

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

title: Reaktor/Hosts


text:
Reaktor/Varia/NTF file

NTF stands for "Native Table File", which contains values in a format acceptable by Event Table

NTF file structure
The structure of NTF file was not officially published, so below information may be wrong.

title: Reaktor/Varia/NTF file


text:
Reaktor/Varia

This is a section for all stuff, which doesn't fit anywhere else - yet. Feel free to add sections, ideas, as it will grow, we will put it somewhere into the book structure.

 * NTF file structure. It's not officially documented, but Chris List analysed it, and is available here

title: Reaktor/Varia


text:
Ada Programming/Control

condition statement; other statement; ;

condition statement; condition other statement; condition other statement; ...    another statement; ;

;  ; ...  Degrees   Float  -273.15 .. Float'Last; ... Temperature : Degrees; ... Temperature >= 40.0 Put_Line ("Wow!"); Put_Line ("It's extremely hot"); Temperature >= 30.0 Put_Line ("It's hot"); Temperature >= 20.0 Put_Line ("It's warm"); Temperature >= 10.0 Put_Line ("It's cool"); Temperature >= 0.0 Put_Line ("It's cold"); Put_Line ("It's freezing"); ;

In Ada, conditional statements with more than one conditional do not use short-circuit evaluation by default. In order to mimic C/C++'s short-circuit evaluation, use  or   between the conditions.

X     1 Walk_The_Dog; 5       Launch_Nuke; 8 | 10       Sell_All_Stock; Self_Destruct; ;

The subtype of X must be a discrete type, i.e. an enumeration or integer type.

In Ada, one advantage of the case statement is that the compiler will check the coverage of the choices, that is, all the values of the subtype of variable X must be present or a default branch  must specify what to do in the remaining cases.

For procedures:

;

For functions:

Value;

Label; Dont_Do_Something; Label ...

Use_Return Do_Something; Test ;    ;    Do_Something_Else; ; Use_Return;

Use_Goto Do_Something Test Exit_Use_Goto Do_Something_Else Exit_Use_Goto Use_Goto

Use_If Do_Something; Test Do_Something_Else; ;   ;  Use_If;

Endless_Loop : Do_Something; Endless_Loop;

The loop name (in this case, "Endless_Loop") is an optional feature of Ada. Naming loops is nice for readability but not strictly needed. Loop names are useful though if the program should jump out of an inner loop, see below.

While_Loop : X <= 5 X := Calculate_Something; While_Loop;

Until_Loop : X := Calculate_Something; Until_Loop X > 5; Until_Loop;

Exit_Loop : X := Calculate_Something; Exit_Loop X > 5; Do_Something (X); Exit_Loop;

In Ada the exit condition can be combined with any other loop statement as well. You can also have more than one exit statement. You can also exit a named outer loop if you have several loops inside each other.

For_Loop : I Integer  1 .. 10       Do_Something (I) For_Loop;

You don't have to declare both subtype and range as seen in the example. If you leave out the subtype then the compiler will determine it by context; if you leave out the range then the loop will iterate over every value of the subtype given.

As always with Ada: when "determine by context" gives two or more possible options then an error will be displayed and then you have to name the type to be used. Ada will only do "guess-works" when it is safe to do so.

The loop counter I is a constant implicitly declared and ceases to exist after the body of the loop.

Array_Loop : I X'        X (I) := Get_Next_Element; Array_Loop;

With X being an array. Note: This syntax is mostly used on arrays — hence the name — but will also work with other types when a full iteration is needed.

Working example
The following example shows how to iterate over every element of an integer type.

; Range_1 Range_Type  -5 .. 10;    T_IO  ; I_IO    (Range_Type); A Range_Type I_IO.Put (Item => A,                 Width => 3,                 Base  => 10); A < Range_Type'Last T_IO.Put (","); T_IO.New_Line; ;    ;  Range_1;

Wikibook

 * Ada Programming

Ada Reference Manual

|Control Programación en Ada/Sentencias y estructuras de control

title: Ada Programming/Control


text:
Talk:Calculus/Contributing

this is a test phd

Here is a simple line for your links home. I noticed that the link home went to your intro page which was a little annoying.

back to Calculus

you can change the part after the # to reflect the section that you want to link back to on that page.

 * It is now ussually preferable to use Grimm 04:36, 11 Jun 2005 (UTC)

Given that this outline page is now significantly more compelete than the main page isn't it about time to move it over? Grimm

--- Is the "beyond" section a joke? Can it just be removed? Sure Lie theory and postdoc stuff does not belong in a calculus book. and imho nor does a mention of cauchy sequences. -- julius

"Advanced" Topics
I took calculus two and three at Georgia Tech, and then went to Israel for college. Tere is a very simple problem with the book being written; it's fine for an engineer, or a high school student, but by the time a student approaches calculus in college anywhere except in the good ol' US of A, it is taught as real math, with proofs, and formal definitions. I'm just wondering, if this is indeed a high school/American Calculus book, should there also be a "Calculus with analysis," of "Rigorous Calculus" book? I am going to attempt to write a formal introduction to calculus, starting with sets and working upwards, with proofs either provided or suggested, as a set of modules to parallel how this book is organized. I hope this isn't seen as an attempt to take effort from this book, but as far as I can tell, the book is evolving into something I would prefer not to contribute to in any case. -David Manheim, 1:37 EDT, 8/18/05

Adding exercise set for each page
To be clear up front, I'm using book/section/article as the terminology for the hierarchy of the book (e.g. Calculus/Limits/Continuity has book=Calculus, section=Limits and article=Continuity). I'd like to propose adding exercise sets for each article rather than just for each section as it is now. I propose a naming convention of BOOK/SECTION/ARTICLE/Exercises. I'm new to wikibooks, so I don't even know if that's possible. I just think there needs to be exercises at regular intervals to keep the student active in the discussion rather than having the student read tons of info and then overwhelm them with tons of mixed exercises at the end of a section. Is special permission required to create new wikibook articles? I'm currently trying to re-learn calculus, so I'm planning on going through the whole Calculus wikibook, and I figure I may as well make improvements while I'm at it. So I'd like to get good input at the beginning of the process so that I can apply a consistent style and organization throughout the book. --Greenbreen (discuss • contribs) 18:46, 23 March 2011 (UTC)

Navigation links
Something I've noticed as I read through the pages is that the navigation is somewhat inconvenient. The normal flow is to read from the beginning of the page to the end, i.e. top to bottom. However, the link to the next page is at the top of the current page, so the reader has to scroll back up to the top of the page when they are finished with the current one. It seems to me that the positions of the and  templates ought to be reversed. Anyone agree/disagree? Greenbreen (discuss • contribs) 11:09, 27 March 2011 (UTC)
 * I've started adding templates to the bottom of each of the pages.  IMO it makes navigation easier, although maybe it also makes it more cluttered.  Any opinions?  --Greenbreen (discuss • contribs) 18:40, 16 May 2011 (UTC)

Conventions
I've added a conventions section that lists some of the conventions that I've picked up as I've edited the book. I've tried to not only add the convention but also give the reason for it so that contributors can evaluate whether the convention makes sense in their particular circumstance. I hope also that, if someone has a better way of doing something, that they communicate that here. I envision this talk page as a place to discuss best practices for the book and the corresponding article as a place to record the consensus on what the best practices are. --Greenbreen (discuss • contribs) 02:05, 17 July 2011 (UTC)

Non Rigorous
I am starting a new subsection, meant just for people who need to apply calculus, like differentiation and integration in physics, and chemistry. It wont be rigorous, but will have something like "cheat sheet" for reader.

title: Talk:Calculus/Contributing


text:
Reaktor/Comparable Products/Max/MSP

The competition with Max/MSP is an ongoing debate on Reaktor User Forum. Here are some key threads:
 * April 2004
 * November 2003
 * August 2003
 * February 2003
 * January 2003

 * Reaktor 4.x and Max 4.5.x Compared by John Nowak

title: Reaktor/Comparable Products/Max/MSP


text:
Reaktor/Comparable Products/Pure Data

Discussion on User Forum:
 * November 2003

title: Reaktor/Comparable Products/Pure Data


text:
Reaktor/Comparable Products/SuperCollider

Could somebody make a decent comparison between Reaktor and SuperCollider? Some debates on Reaktor User Forum:
 * January 2003


text:
Horn/Repertoire/Orchestral Excerpts

The following is a list of standard excerpts that are regularly asked for in auditions:

Bach, J. S.

 * Brandenburg Concerto No. 1
 * Mass in B minor

Beethoven, L. v.

 * Symphony No. 3
 * Symphony No. 6
 * Symphony No. 7
 * Symphony No. 8
 * Symphony No. 9
 * Fidelio Overture

Brahms, J.

 * Symphony No. 1
 * Symphony No. 2
 * Symphony No. 3
 * Symphony No. 4
 * Academic Festival Overture
 * Concerto for Piano No. 1
 * Concerto for Piano No. 2
 * Variations on a Theme by Haydn
 * Tragic Overture

Bruckner, A.

 * Symphony No. 4

Dvorak, A.

 * Symphony No. 8
 * Symphony No. 9
 * Concerto for Cello

Franck, C.

 * Symphony in D minor

Grieg, E.

 * Grieg Piano Concerto

Haydn, F. J.

 * Symphony No. 31, "Hornsignal"

Holst, G.

 * The Planets

Mahler, G.

 * Symphony No. 1
 * Symphony No. 5
 * Symphony No. 10

Mendelssohn, F.

 * Symphony No. 3
 * Symphony No. 4
 * Nocturne from a Midsummer Night's Dream

Mozart W. A.

 * Symphony No. 40
 * Horn Concerto No. 2 in E-flat
 * Horn Concerto No. 3 in E-flat
 * Horn Concerto No. 4 in E-flat

Mussorgsky, M.

 * Pictures at an Exhibition (orch. Ravel)

Rachmaninov, S.

 * Symphony No. 2
 * Piano Concerto No. 1
 * Piano Concerto No. 2
 * Piano Concerto No. 3

Ravel, M.

 * Concerto for Piano in G major
 * Bolero
 * Pavane pour une Infante Défunte

Schubert, F.

 * Symphony No. 9/7, "The Great"

Schumann, R.

 * Concertstück for 4 horns and orchestra
 * Symphony No. 3, "Rhenish"

Shostakovich, D.

 * Symphony No. 5

Strauss, R.

 * Also Sprach Zarathustra
 * Tod und Verklärung (Death and Transfiguration)
 * Don Juan
 * Don Quixote
 * Ein Heldenleben
 * Till Eulenspiegel

Stravinsky, I.

 * The Firebird Suite
 * The Rite of Spring

Tchaikovsky, P. I.

 * Symphony No. 4
 * Symphony No. 5
 * Capriccio Italien
 * 1812 Overture

Wagner, R.

 * Siegfried's Rhine Journey (the "Short Call")
 * Lohengrin
 * Das Rheingold, Introduction
 * Siegfried (the "Long Call")
 * Die Walküre, Ride of the Valkyries

Weber, C. M. v.

 * Der Freischütz, Overture
 * Overture to Oberon

title: Horn/Repertoire/Orchestral Excerpts


text:
Quechua/WordEnQu

Quechua Wordlists - English to Quechua | Quechua to English -

 * Alphabetically
 * Categorically

Quechua/QuEs

title: Quechua/WordEnQu


text:
Quechua/WordQuEn

Quechua Wordlists - English to Quechua | Quechua to English -

 * Alphabetically
 * Catagorically

title: Quechua/WordQuEn


text:
Quechua/WordEnQu/Cat

Quechua English to Quechua Wordlists - Alphabetical List | Categorical List -

 * Numbers - Yupakuna
 * Colours - Llimpikuna
 * Days - P'unchaykuna
 * Months - Killakuna
 * Seasons - Mit'akuna
 * Verbs - Rimachina

title: Quechua/WordEnQu/Cat


text:
Cookbook:Roasted Meatballs (Kyufteta)

| Cuisine of Bulgaria

Kyufteta are Bulgarian roasted meatballs.

Ingredients

 * ½ lb pork, minced (not too fatty)
 * ¼ lb ground beef
 * 1 onion, finely chopped
 * ½ cup crumbled bread (preferably at least a day old)
 * 1 egg
 * Black pepper, ground
 * White pepper, ground
 * 1½ tsp dried thyme (or as much fresh as you like)
 * 1 tsp grated nutmeg
 * Salt

Procedure

 * 1) Put all the ingredients in a bowl and knead well.
 * 2) Form the mixture into balls approximately 1 inch (2.5 cm) in diameter and flatten them until ½ inch (1.5 cm) thick.
 * 3) Place the balls in a baking pan spread with a bit of oil or cooking spray and roast at medium or high heat 15 minutes or until golden brown.
 * 4) Turn the meatballs over and roast another 5 minutes until golden brown on the other side too.
 * 5) When ready immediately remove from pan and place on kitchen paper to absorb excess fat.
 * 6) Serve hot with salads, or your favourite sauce. Enjoy!

title: Cookbook:Roasted Meatballs (Kyufteta)


text:
Cookbook:Gyuvetch (Bulgarian Casserole) I

Ingredients

 * 900 g beef, cut in 4–5 cm (2 in) cubes
 * Soy sauce
 * 2 onions, cut in half, then in 5 mm (¼ in) slices
 * 2 carrots, cut in half or quarters lengthwise, then in 5 mm (¼ in) slices
 * 2 packs okra
 * 3 eggplants, cut in 2 cm (1 in) round slices
 * a few tomatoes, each cut in 3
 * 1 kg (2 lbs) potatoes, peeled, quartered and cut in 7 mm (⅓ in) thick slices
 * 12 small sweet red peppers, cut in 5 mm (¼ in) thick rings
 * 2 hot green peppers
 * Salad oil
 * 1 bunch parsley, finely chopped
 * Salt to taste

Procedure

 * 1) Fry beef with salad oil in a skillet until lightly browned. Add enough water to cover the meat and cook until soft. Add soy sauce to taste.
 * 2) Sprinkle eggplants with salt and leave for a while to remove any bitterness. Quarter each slice after wiping off moisture.
 * 3) Sauté carrots, eggplants, potatoes, and okra in a skillet with salad oil. Add tomatoes with liquid. Mix in onions, adding small amount of water, and cook until vegetables become barely tender. Add red pepper and turn off the heat.
 * 4) Mix the meat with pan juice and vegetables and put in an earthenware pot (casserole). Top with hot green peppers, cover, and bake in a 200°C oven for about 20 minutes.
 * 5) Sprinkle with finely-chopped parsley and serve.


text:
C Programming/Procedures and functions/printf

About the printf Function
In C, the   function prints the optional arguments under the control of the template string template to the stream stdout. It returns the number of characters printed, or a negative value if an output error occurred.

int printf (const char *template, ...)

For more information about printf in general, see the Wikipedia article on printf.

Output Conversions
Here is a table summarizing what all the different conversions do in the C implementation of printf:

 * `%d', `%i' : Print an integer as a signed decimal number. `%d' and `%i' are synonymous for output, but are different when used with  function  for input.

 * `%o' : Print an integer as an unsigned octal number.

 * `%u' : Print an integer as an unsigned decimal number.

 * `%x', `%X' : Print an integer as an unsigned hexadecimal number. `%x' uses lower-case letters and `%X' uses upper-case.

 * `%f' : Print a floating-point number in normal (fixed-point) notation.

 * `%e', `%E' : Print a floating-point number in exponential notation. `%e' uses lower-case letters and `%E' uses upper-case.

 * `%g', `%G' : Print a floating-point number in either normal or exponential notation, whichever is more appropriate for its magnitude. `%g' uses lower-case letters and `%G' uses upper-case.

 * `%a', `%A' : Print a floating-point number in a hexadecimal fractional notation which the exponent to base 2 represented in decimal digits. `%a' uses lower-case letters and `%A' uses upper-case.

 * `%c' : Print a single character.

 * `%lc' : Print a single wide character.

 * `%C' : This is an alias for `%lc'. (This is a non-standard Unix-specific extension.)

 * `%s' : Print a string.

 * `%ls' : Print a wide character string.

 * `%S' : This is an alias for `%ls'. (This is a non-standard Unix-specific extension.)

 * `%p' : Print the value of a pointer.

 * `%n' : Get the number of characters printed so far. Note that this conversion specification never produces any output.

 * `%m' : Print the string corresponding to the value of  variable. (This is a non-standard GNU extension.)

 * `%%' : Print a literal `%' character.

If the syntax of a conversion specification is invalid, unpredictable things will happen, so don't do this. If there aren't enough function arguments provided to supply values for all the conversion specifications in the template string, or if the arguments are not of the correct types, the results are unpredictable. If you supply more arguments than conversion specifications, the extra argument values are simply ignored; this is sometimes useful.


text: Quechua/WordEnQu/Cat/Numbers

title: Quechua/WordEnQu/Cat/Numbers


text:
Cookbook:Cabbage Rolls in Yogurt Sauce (Sarmi)

Sarmi is a Bulgarian dish of stuffed cabbage leaves, which shows significant Greek influences. For a gathering you may wish to consider presenting these somewhat 'white' rolls side-by-side with a dish of cabbage rolls in tomato sauce (see Cabbage Rolls in Tomato Sauce (Holubtsi)).

Ingredients

 * 500 g (about 1 ⅛ lb) minced (ground) veal or beef
 * 300 g (about ¾ lb) minced (ground) pork
 * 1 bunch of spring onions
 * ½ cup uncooked rice
 * 1 cup yogurt
 * Parsley
 * Mint
 * Paprika (optional)
 * Pepper
 * 30–40 grape or cabbage leaves (depending on the size, a substantially smaller number of leaves may be needed)
 * 100 g butter or ½ cup sunflower oil
 * Salt

Procedure

 * 1) Boil the vine or cabbage leaves in salted water until they look cooked and are just bendable enough to roll. Drain and allow to cool during the following steps.
 * 2) Lightly fry the finely chopped onions in a small amount of oil, and stir in a teaspoon or more of paprika.
 * 3) Add the meat, rice, pepper, mint, and finely chopped parsley, then cook until the meat looks almost done.
 * 4) Add ¾ cup of water, bring to a boil, then immediately cover and reduce heat to a bare minimum for 10 minutes, until the water is absorbed by the rice. Uncover and fluff as needed with a small spatula or spoon. Allow to cool to handling temperature.
 * 5) Put 1 teaspoon of the meat mixture on each leaf and make into a rolled, fully enclosed, package, similar to a small egg roll. A bit more filling can be used if you are using large cabbage leaves, but try to make all the rolls somewhat uniform in size.
 * 6) Arrange the rolls in a saucepan, add 1½ cups of warm water, cover, and simmer gently over low heat.
 * 7) In the meantime, mix the yogurt with a bit of paprika for color (or omit if you wish to keep the dish somewhat white in color), and other spices as you desire.
 * 8) When rolls are done, allow to cool a bit, gently transfer to a dish, and add the yogurt mixture to coat.
 * 9) Serve with vegetables of your choice. Enjoy!


text:
Cookbook:Baklava

| Desserts

Pastry

 * 1 lb phyllo dough
 * 4–5 cup walnuts, chopped coarsely
 * ½ cup white granulated sugar
 * ¼ tsp ground cloves
 * 1 tsp cinnamon
 * ¾ pound sweet butter

Syrup

 * 2 ½ cups of water
 * 3 cups white granulated sugar
 * 3 tsp lemon juice
 * 1 tsp vanilla extract

Pastry

 * 1) Combine nuts, cinnamon, cloves, and sugar. Melt butter in a saucepan.
 * 2) Use a pastry brush to brush inside of a 14 x 10.5-inch (36 x 27 cm) pan with melted butter.
 * 3) Line bottom of pan with one piece of Phyllo dough. Fold under excess Phyllo.
 * 4) Alternate sides with each piece of Phyllo, brushing the top of each layer with melted butter.
 * 5) Repeat 5 times, making 5 layers.
 * 6) On the 6th sheet, sprinkle evenly with nut mixture.
 * 7) Continue until all nut mixture is used and last 6 buttered sheets of Phyllo form top crust.
 * 8) Use a sharp knife to cut into diamond shapes.
 * 9) Bake at 300 °F (150 °C) for about 1 ½ hours or until lightly brown.

Syrup

 * 1) Combine syrup ingredients. Boil syrup for about 10 minutes and then allow to cool.
 * 2) Pour cooled syrup over hot pastry. Enjoy!

title: Cookbook:Baklava


text:
Talk:Quechua

Untitled
possible image to be added -

The correct name for "Quechua" subject page
I want to change the title of the name of the subject "Quechua", because it does not represent all the quechua speakers. It should call Ayacucho Quechua, because it is. This name offends to Quechua speakers from other parts of the Andes mountains that speak other different languages name also Quechua. Jhon ar qu (discuss • contribs) 19:28, 2 August 2022 (UTC)

title: Talk:Quechua


text:
Cookbook:Tripe Soup (Shkembe Chorba)

| Cuisine of Bulgaria

Shkembe chorba is a popular meat dish in Bulgarian cuisine.

Ingredients

 * 1 tbsp butter
 * 3½ cup beef stock
 * 1 ea. onion, chopped fine
 * 1 tsp salt
 * 1 ea. bell pepper, cut into thin-strips
 * ½ tsp dried marjoram
 * 1 ea. bay leaf
 * 2 tbsp flour
 * 2 tbsp parsley, chopped fine
 * 1 can (6 oz / 180 g) tomato paste
 * 1 ea. garlic clove, crushed
 * 1½ lb (675 g) tripe, cooked
 * ⅔ cup grated Kashkaval cheese

Procedure

 * 1) Combine onion, red pepper, butter in large saucepan.
 * 2) Sprinkle flour over onion mixture, then stir in the tomato paste.
 * 3) Cut tripe into thin strips.
 * 4) Add tripe pieces, stock, salt, marjoram and bay leaf to onion mixture.
 * 5) Partially cover the pot and simmer 30 minutes.
 * 6) Remove and discard bay leaf.
 * 7) Pour soup into a tureen or serve in individual bowls.
 * 8) In a small bowl, combine parsley, garlic and cheese. Sprinkle over hot soup and serve immediately.

title: Cookbook:Tripe Soup (Shkembe Chorba)


text:
Cookbook:Kashkaval Pane (Bulgarian Fried Cheese)

Kashkaval pane (or Cașcaval pane) is a Bulgarian dish of fried Kashkaval, a type of cheese.

Ingredients

 * 12 oz yellow kashkaval cheese
 * Oil for deep frying
 * 2 eggs
 * Flour seasoned with salt and freshly ground black pepper
 * Bread crumbs
 * Flat-leaf parsley to garnish

Procedure

 * 1) Cut the yellow cheese into slices about ½ inch thick. Wet in water. Gently pat off any excess moisture with paper towels.
 * 2) Heat the oil in a pot until a small piece of bread sizzles as soon as it is dropped in.
 * 3) Beat the eggs in a shallow bowl, while the oil is heating.
 * 4) Spread some seasoned flour on a plate and some bread crumbs on another plate.
 * 5) Press the yellow cheese slices into the flour, coating them evenly with a thin layer of flour, shaking off any excess flour. Dip them into the egg, then into the bread crumbs, then once more into the egg, then again into the bread crumbs, covering the whole slice.
 * 6) Fry immediately in the hot oil until golden brown.
 * 7) Drain on paper towels and serve hot, garnished with parsley. Enjoy!


text:
Bulgarian

Bulgarian is an Indo-European language, a member of the Southern branch of the Slavic languages. Bulgarian is spoken by approximately 10 million people in 70 countries around the world. The Bulgarian language is the official language of the Republic of Bulgaria. Bulgarian became an official language of the European Union in 2007 when Bulgaria joined the EU. The code for the Bulgarian language and Bulgaria is BG. This book is an attempt to provide some useful words, expressions and other information from different fields to facilitate the learning of the Bulgarian language. Please see also the Bulgarian language article in Wikipedia that provides a lot of additional useful information such as the alphabet, grammar, tenses, genders, cases, and so forth. Take a peek at the Bulgarian Wikipedia for advanced level information.

Basics

 * /Numbers/
 * /Colors/
 * /Time/
 * /Expressions/
 * /Questions/
 * /Verbs/

Lessons

 * /Lesson One/

Vocabulary

 * /Emergencies/
 * /Restaurants/
 * /Market/
 * /Post Office/
 * /Transportation/
 * /Tourism/
 * /Places/
 * /Directions/

Other sister projects

 * Bulgarian language article in Wikipedia
 * Bulgarian Wikipedia
 * Bulgarian phrasebook on Wikivoyage
 * Bulgarian Wiktionary - multilingual dictionary
 * Bulgarian Wikiquote - quotes in Bulgarian
 * Bulgarian Wikinews - news in Bulgarian
 * Bulgarian Wikimedia Commons

title: Bulgarian


text:
Reaktor/Modules/Sawtooth

Module description
Oscillator for sawtooth signal, with logaritmic pitch control (P) and linear amplitude modulation (A).
 * P - Input for control of the pitch (=logaritmic control of the frequency). Scale: 1 semitone per unit. 69 = a3 = 44 Hz, 0 = c-2 = 8.18 Hz. Typ: Range (0...127)
 * A - Input for linear amplitude control. The waveform at (Out) swings between -(A) and (A). Can also be used for ring modulation. Typ: Range: (0...1)

Sawtooth in general

 * Sawtooth wave on Wikipedia

title: Reaktor/Modules/Sawtooth


text:
Koine Greek/8

8. The Stem of a word is that part of it which remains substantially unchanged through varieties of inflection. Nouns, Adjectives and Pronouns are 'declined'; Verbs are 'conjugated' by the help of prefixes or terminations added to the stem, which may itself be variously modified, but can always be traced, and contains the main idea of the word. To know this Stem, therefore, is an essential preliminary to the study of the inflections.

The stems of words shall in this section be distinguished by dark letters, and in general by an appended hyphen, as the stem in itself is incomplete, requiring some kind of addition before it becomes a word.

title: Koine Greek/8


text:
Koine Greek/9

9. The Noun
Nouns in Greek are inflected. Inflection means that a suffix which is appended to the stem is modified. In Greek the suffix is modified according to gender, case, and number.

There are three genders: Three Genders: Masculine (m.), Feminine (f.) and Neuter (n.). Substantives have grammatical gender, where gender is an inalienable property and often not correlated to physical sex. Pronouns and Adjectives modify their gender to match the gender of the substantive described.

In Greek, there are three numbers: singular, denoting a quantity of one; dual, denoting a pair; plural, denoting more than two.

In Greek there are five cases; the cases and their primary uses are tabulated below:

The Nominative Case singular is the form given in all vocabularies and dictionaries. The method of its formation from the Stem is therefore a matter of prime importance.

title: Koine Greek/9


text:
Koine Greek/10

10. The Definite Article is employed in combination with nouns, and is declined in gender, number, and case, to correspond with them.

The Following forms, which should be carefully committed to memory, afford a general type of the inflections of nouns, adjective, and pronouns, and will therefore be useful in their acquisition.

11. The Definite Article, the. It has first and second declension endings. Note that the nominative masculine and feminine forms of the definite article start with a vowel and not τ, and also note that there are no accents on the vowel. By contrast, the relative pronoun who (ὅς, ἥ, ὅ) has accents on the vowels, but is otherwise spelled the same.

12. Indefinite Pronoun: any, a certain, a

13. In the two forms now given there are three particular patterns applicable to all nouns, adjectives and pronouns.

1) Neuters are alike in the nominative and accusative of number. Neuters plural, nominative and accusative all end in α. 2) The dative singular always ends in i; although to the vowel the iota is subscript (please note, this needs to be added) 3) The genitive plural always ends in ων.

Useful External Links
WikiChristian - Koine Greek: Definite Article

title: Koine Greek/10


text:
Gujarati/Family relations

In Gujarati culture:

These are the "titles" for family members. With the exception of Father, Mother, Grandparents, and others who are marked with a star (who are called by the title only), all of these titles are added after the name of the person.

 * Father: Pappa, Papa, Bawa or Bapuji*
 * Mother: Ba, Mummy, Mumma or Maamajee*

 * Brother (also male cousins): Bhai (e.g. Haresh Bhai)
 * Brother's Wife: Bhabhi (e.g. Komal Bhabhi)

 * Sister (also female cousins): Bahen/Ben (e.g. Mayuri Ben)
 * Older Sister: Didi/Ben (e.g. Mayuri Didi)
 * Younger Brother: Bhaio*
 * Sister's Husband: Banevi or Jijaji or Kumaar (from in-laws) (e.g. Kunal Jijaji)

 * Father's Younger Brother or Father's Younger Cousins (1st, 2nd, 3rd, etc): Kaka or Chacha (e.g. Rajesh Kaka)
 * Father's Younger Brother's Wife: Kaki or Chachi (e.g. Komal Kaki)
 * Father's Older Brother:Bapa or Mhota Pappa or Mhota Bawa or Ji Dada
 * Father's Oldest Brother: Mota kaka or Mhota Papa or Mhota Bawa
 * Father's Oldest Brother's Wife: Mhoti or Mhoti Mummy or Mhoti Ma or Mhoti Ba or Bhabu

 * Father's Sister: Fai, Foi, Fui, Fia, Faiba, Foiba (e.g. Komal Fai)
 * Father's Sister's Husband: Fua, Fuji (e.g. Akshay Fua)

 * Mother's Brother and Mother's Male Cousins (1st, 2nd, etc): Mama (e.g. Ketul Mama)
 * Mother's Brother's Wife: Mami (e.g. Kanta Mami)

 * Mother's Sister: Masi (e.g. Sneha Masi) or Mahee
 * Mother's Sister's Husband: Masa (e.g. Gopal Masa) or Mahaji

 * Paternal Grandfather: Dada or Dada Bawa or Bapuji*
 * Paternal Grandmother: Dadi or Dadi Ma or or Ba*

 * Maternal Grandfather: Nanabapa or Nana Bawa or Nana or Dada*
 * Maternal Grandmother: Nanima or Ba or Nani*
 * Maternal Grandfather's Brother: Nana or Nana Bawa
 * Maternal Grandmother's Sister: Nani

 * Wife's father:Sasra or hahara
 * Wife's mother:Sasu or hahu
 * Wife's Younger Sister: Saali
 * Wife's Younger Brother: Saalo
 * Wife’s Elder Sister: Patla Sasu or Patla Hahu
 * Wife's Sister’s husband: Sadhu Bhai
 * Wife's Brothers wife: Saadhotri or Sadaveli (e.g. Bhumika Saadhotri)

 * Husband’s Elder Brother: Jeth
 * Husband’s Elder Brother’s Wife: Jethani
 * Husband’s Younger Brother: De-ar
 * Husband’s Younger Brother’s wife: Derani
 * Husband’s Sister: Nanand
 * Husband’s Sister’s Husband: Nandoi

 * Brother’s Son: Bhatrijo, Bhatrijao (plural)
 * Brother’s Daughter: Bhatriji, Bhatrijio (plural)
 * Sister’s Son: Bhanej, Bhanjo, Bhaniyo, Bhaniyao (plural)
 * Sister’s Daughter: Bhanej, Bhanji, Bhani, Bhanio (plural)

 * Cousins are considered to be "brother" or "sister". Elder cousins' name followed by Bhai or Ben

 * Son: Babo, Chokro, Dikro, Lalo
 * Daughter: Baby, Chokri, Dikri, Lali

If an uncle or aunt is a generation above usual (a "great uncle" or "great aunt"), a "mhota/mota" (big) is usually added to the title, and the name is dropped. So Maternal Grandmother's Brother is "Mhota Mama" (Elder Uncle).

Names are usually followed by titles, as they have listed above. This is different from the English, where we would say "Uncle John".

It is not unusual for this to vary from family to family, but these are the generally accepted titles.

title: Gujarati/Family relations


text:
Cookbook:Tabbouleh III

| Mediterranean | Middle Eastern cuisines

Ingredients

 * ½ cup bulghur wheat (fine grind is best, medium grind acceptable)
 * 2 bunches parsley (flat leaf or curly Italian)
 * 1 bunch green onion
 * At least 2 cups chopped tomatoes
 * 5–6 stalks fresh mint
 * 2–3 lemons, or to taste
 * Olive oil
 * Salt
 * Cucumbers (optional)
 * Romaine lettuce leaves (garnish and scoopers, optional)
 * Fresh grape leaves (optional)

Procedure

 * 1) Soak the bulghur wheat in at least three times its volume of cold water. Fine grind only needs a half hour of soaking. Medium grind needs longer. Bulghur wheat has already been parboiled before cracking or grinding, so it doesn’t need further cooking to be edible in tabbouli.
 * 2) Drain bulghur.
 * 3) Chop the parsley leaves, green onions, mint, tomatoes and cucumbers.
 * 4) Chop the parsley quite fine, using a knife, not food processor.
 * 5) Mix veggies and bulghur together. Douse with strained lemon juice. If you are not ready to serve immediately, then cover and hold in a cool place. Do NOT add salt and olive oil until immediately before serving.

Notes, tips, and variations

 * You may garnish with more diced tomatoes and/or diced cucumber, and insert lettuce or fresh grape leaves around the sides of the bowl. Use green leaves to scoop up the salad, popping leaf and salad into mouth.

title: Cookbook:Tabbouleh III


text:
Robotics/Components/Actuation Devices/Motors

There are several different types of motors. Each motor type has several advantages as well as disadvantages depending on a particular robots design. See this Wikipedia article for basic information about the different electro motors.

AC-motors
There are several different types of AC-motors, but their use is limited to high power stationary industrial robots. They are harder to use than DC-motors.

DC-motors
DC-motors are very easy to use, but like most other motors their usefulness for robotics is very dependent on the gearing available. DC-motors are made much more effective if they have an efficient gear ratio for a particular task. If your priority is to have a fast spinning motor and torque is of little concern a low gearing or even no gearing may be what you need; however, most motors used in robots need torque over top speed so a motor with a high gear ratio could be more useful.

The control of a DC motor can be split into two parts: speed and direction.

Direction
Changing direction in which a DC-motor turns is very easy: simply reverse the polarity.

Both pairs of switches ( (S1A,S1B) and (S2A, S2B) )-see the picture on the right- will always switch together. This circuit is called an H-bridge. In a real design the switches can be several different components (Relays, transistors, FETs) or the whole circuit (without the motor) could be an IC (integrated circuit). use sugarcan relays

Speed
Speed is a little bit more complicated. Many beginners would try to slow down a motor by reducing its voltage with a variable resistor or other ways. This does not work well, because it will not only reduce the motor's speed, it will also reduce a motor's strength, while also consuming a lot of electricity as large amounts of heat are generated by the resistor.

A far better way is to use a PWM (Pulse-width modulation) device.

Servo
What is a servo?

Servos are used in robotics for different purposes: e.g. to move a sensor around or to move the legs of a robot. Some users modify the servo so that they can use it as a DC-motor with a gearbox.

Controlling a servo is done with Pulse-width modulation. The length of the pulse is relative to the position the servo will turn to. The length of this pulses is usually between 1ms and 2ms, if so 1.5ms would be the center position. This pulse needs to be repeated with small intervals (otherwise the servo might turn to a "save" position or it might simply stay at its current position. This depends on the type of servo used).

Stepper motor
We cover stepper motors in more detail in the next chapter, Robotics/Stepper Motors.

(The category-box overlaps some of the text here. This line added to keep the real content on the screen)


text:
User:Rama

Please use my page at en.wikipedia.org. Thank you.

title: User:Rama


text:
Talk:Puzzles/Riddles

Format
The format effecively treats the whole set of riddles as a single puzzle. People should be able to check their guesses, or even add new riddles, without accidentally seeing the answers to the ones they haven't yet thought about or are still thinking about. I therefore suggest that we split up the answers into one page per riddle. -- Smjg 14:57, 29 Nov 2004 (UTC)

 * Sounds great. It would also handle the problems of the huge ToC and the oversized page. - SamE 05:16, 4 Dec 2004 (UTC)

 * Logic puzzles has a good format for this. -160.36.157.78 05:47, 4 Dec 2004 (UTC)

Does it seem navigable now that I've put the solutions on individual pages? It might be good to split the riddles themselves into groups of 10, so that the table of contents will fit within the page. (e.g. riddles 1-10 on Riddles, 11-20 on Riddles 2, etc.) -Tormod 06:40, 4 Dec 2004 (UTC)
 * The only objection I have is that we have many incredibly small pages; then again, that's the only way to do it (that I know of). One other way I found in a riddle book was to title each and every riddle and organize them alphabetically for the answers and by difficulty for the riddles. I do like your plan for splitting up the riddles; see Chip's Challenge for a way I did this. - SamE 02:06, 8 Dec 2004 (UTC)
 * Does it take up a lot more memory to have many little pages than one big one? I think hyperlinking is easier for the reader than looking through an index like the book of riddles you mention.  Chip's Challenge looks good. -Tormod 19:08, 9 Dec 2004 (UTC)
 * I ran into the many-little-pages problem with SMW: Yoshi's Island 1. I tried to explain the walkthrough using what would have ended up becoming about 100 pages. I wanted to make it completely comprehensive, but that took so long to copy-paste, rewrite and test, that I gave up on it and put the 30 or so pages I had written on VfD. I don't know if it takes more memory or what, but it sure takes a lot of time and energy to make them all work. This especially applies when you want to make a change to all of them at once and you don't have a bot. So I would go with the strategy I used on Chip's Challenge. - SamE 03:44, 10 Dec 2004 (UTC)
 * I actually really like the format now - as a user, it's super-convenient to click on the link to see the solution. If there was a hints/discussion page for each one, that'd be perfect!  -PK

I came to this page to have a look and was totally put off. No one wants to see "Riddle 1, Riddle 2" all the way down to 40. No one, equally, wants those riddles just listed off underneath. Furthermore, some of the riddles are pathetically easy (eg the first) and some are really quite hard. If someone's looking for a hard riddle, how are they going to find it? They can't read every one.

I suggest that the riddles be split up by difficulty: Very-Easy, Easy, Average, Hard, Very-Hard. Aesthetically, it would also be nice to give each riddle a title rather than a number. A hints/discussion page for each one would also be extremely nice. However those are extraneous. The splitting into difficulty categories is essential. --212.135.1.84 18:49, 27 Jun 2005 (UTC)

Hints?
why are you giving hints before giving people the chance to figure things out? put the hints in a link. —Preceding unsigned comment added by 24.241.16.59 (discuss • contribs) 02:50, 10 September 2005

Hiding the answer in a template instead
In an attempt to help fix some of the problems with the solutions being deleted by over zealous administrators seeking to delete very small pages, I've tried to put the answers into a special template called Template:Riddle.

I've also gone and deleted the first two solution pages, and it would be useful to transfer the talk pages that may have been started for each answer to be here instead as well. I'm not going to go any further at the moment, but instead I'm looking for general input in this matter before I add this template to all of the rest of the answers. --Rob Horning 15:56, 20 March 2006 (UTC)

 * Since there hasn't been any arguments either for or against this proposal, I'm going to go ahead and make the changes and delete the various Riddles sub-modules that are mostly one or two words anyway. --Rob Horning 16:57, 31 March 2006 (UTC)

The title stays as one line regardless of line breaks in firefox. --Hagindaz 04:45, 14 April 2006 (UTC)

Riddle 2
This riddle could mean anything black on white, eg text, an oven, washing machine, etc...

scholar
The word scholar suggests that the answer is supposed to be book. huhahua

Riddle 9
Thats a sick riddle.

Really? I think is pretty cool.

Riddle 12
How does a shadows footsteps talk?

Riddle 14
My best guess is: bokrage
 * Bok is Afrikaans for antelope. The springbok is the best known.
 * Okra is a pepper-like vegetable.
 * Rag is a bit of a stretch for a utensil, but it's the best I can do.
 * While by some definitions a person's age does change from year to year, it can also mean forever, which shouldn't change. (Ago could also fit here, but I don't think it works any better.)

Brilliant work, but I don't think it answers the question - 1234567 was supposed to be a 7 letter word, too, and as far as I can tell, it's not.

I have also seen this riddle saying "changes every year" instead of being the same every year. Age would fit very well there. The answer is Cabbage - Sudhish

Other suggestions that I've seen: PROPEND
 * PRO = professional sports teams get named after animals (lions, bears, ducks) -- doesn't really work
 * ROPE = slang for licorice
 * PEN = a writing utensil
 * END = December 31st

GARBAGE
 * GAR = A fish
 * ARBA = American Rabbit Breeders Association (ARBA) -- doesn't really work
 * BAG = A Bag is a utensil
 * AGE = Age itself does not change just the ###'s that represent our age or Age of our waste is unproved.

Has anyone worked this one out?

Riddle 15
This can also be the wind.

I agree most with wind. Mostly because of the breathing and how dying down doesnt really mean ending with wind.

''I disagree. The wind doesn't breathe, because it IS breath, actually. Though it may breeze. In order to breathe, you need another substance to breathe. The wind is made up of air, so it can't also breathe air. Fire, however, is kept alive by the oxygen in the air, so it breathes.''Balthus 07:40, 4 April 2006 (UTC)
 * I believe something is wrong with the format as I can't see anything on firefox or internet explorer Aznph8playa 04:43, 22 May 2006 (UTC)

Riddle 16
and

other suggestions:

death -Jahrl Eriksen

the later A

air

Riddle 17
A Window

Other suggestions:

Smith's Patented SpectroGasmic, Cold Fusion Powered, X-ray Goggles (the oldest, functional pair were uncovered in an Egyptian tomb in Thebes c. 1942)

Riddle 18
Lighthouse

--Frontier 12:30, 8 Feb 2005 (UTC)

Other suggestions: the Sun

"[B]lue fields" can be interpretted as either a body or water or the sky. problem: the sun burns.

The North star or big dipper

A compass needle "never moves" applies to the needle, while the compas moves, the needle, when working properly and without too much interference from local magnetic sources, does not move or turn. It only appears to turn when you move the compass.

---The Day.---

Guides travelers... Rises East, Sets West

never moves... As opposed to day being in the nighttime.

Always turning... Time of day

never looks... Just to confuse the issue, from the phrase "turn & look"

Always shining... The Sun

never burns... It never burns out.

Looks on blue fields with each of its turns... The Sky is Blue. Each of it's turns just means the day.

---Dylan Campbell---

I vouch for the North Star.

Guides travelers, never moves. - It is stationary in the sky. Always turning, never looks. - It is (from our perspective) revolving 360 degrees per day because of the rotation of the planet, though we can't really tell because it's a sphere. Always shining, never burns. - It is always shining, and doesn't burn anything on the Earth, unlike, say, the sun. Obviously it is burning because it's a star, but... You could apply this to lighthouses too. Stand directly in front of the light and tell me it doesn't burn. Looks on blue fields with each of its turns. - Referring to blue sky during the day.

--70.127.189.112 06:42, 15 April 2006 (UTC)

Riddle 19
Bowling

 * Ok, then, what's the 3 black eyes?
 * The holes in the bowling ball, of course! -star882

Riddle 20
It's a dictionary, or you're holding the book upside down.

You could be in east asia, they format their books to be read back to front, relative to our norm. -Jahrl Eriksen

Riddle 21
I am confused. Lungs? —Preceding unsigned comment added by 160.94.120.197 (discuss • contribs) 9 November 2005

"I feast on your body, your soul, and your mind," This doesnt make any sense for a shadow, or am I missing something?

um i think because little kids, (and even adults) play games with shadows and avoid them or whatever. also, the later in the day it gets, the farther up your body a shadow would be if someone walked past you. ;)

Deletion and undeletion
Three times, users created this page and wrote "shadow" or "a shadow". Twice, sysops deleted the page, but missed it the third time. I decided that this page was okay, so I undeleted the older versions. See deletion log.

Generally, a page containing only "a shadow" is nonsense, and eligible for speedy deletions. What those sysops did not know is that this page, Riddles: 21, is linked from Puzzles:Riddles. "A shadow" is the answer to riddle 21.

However, visitors to Riddles: 21, unless they come from Puzzles:Riddles, have no idea what this page is about. There is no link back to Puzzles:Riddles or anywhere, and the module title does not show that module is part of the Puzzles book. This is another reason to support the requirement for slash convention in Naming policy. --Kernigh 05:16, 14 February 2006 (UTC)

Riddle 22
Pearl white connotates lustre, an egg shell has no lustre, its is dull. I'm just bitter because my best guess was a tooth with a gold crown. -Jahrl Eriksen

Riddle 33
I don't understand, "But many have the strength to lift a man", having to do with a human hair.

Perhaps if you made a rope out of the hair. Or Perhaps the hair of a woman could "lift" the man if you catch my drift -Jahrl Eriksen

Riddle 39
Ridonculous -Jahrl Eriksen

Riddle 41
I don't get it. Elton John? I was expecting something else. --Rob Horning 04:33, 14 April 2006 (UTC)

major formatting errors
using latest firefox.

Template:Riddle doesnt appear to work. and its not exactly printworthy.

but "not work" i mean all the text on this page is being bunched together and overlapping. in short its totally gone wrong. suggest this:

 * I as well am having errors with this template while using firefoxAznph8playa 03:41, 22 May 2006 (UTC)
 * I'm using Internet Explorer and also having these problems.

Riddle 6
Both Dreams and Stars come at night without summons and flee the world in the morning, so I added dreams to the answer Aznph8playa 03:52, 22 May 2006 (UTC)

We are tall, straight and upright. Who are we?
Discussion: We are tall straight and upright. What are we? GiftyOxox (discuss • contribs) 16:22, 16 March 2017 (UTC)

Completely clean up
Hi guys, I think, I might re-do a complete makeover to the riddles. Encik Tekateki (discuss • contribs) 02:03, 25 May 2019 (UTC)

title: Talk:Puzzles/Riddles


text:
Ada Programming/Type System

Ada's type system allows the programmer to construct powerful abstractions that represent the real world, and to provide valuable information to the compiler, so that the compiler can find many logic or design errors before they become bugs. It is at the heart of the language, and good Ada programmers learn to use it to great advantage. Four principles govern the type system:

 * Type: a way to categorize data. characters are types 'a' through 'z'. Integers are types that include 0,1,2....
 * Strong typing: types are incompatible with one another, so it is not possible to mix apples and oranges. The compiler will not guess that your apple is an orange. You must explicitly say my_fruit = fruit(my_apple). Strong typing reduces the amount of errors. This is because developers can really easily write a float into an integer variable without knowing. Now data you needed for your program to succeed has been lost in the conversion when the complier switched types. Ada gets mad and rejects the developer's dumb mistake by refusing to do the conversion unless explicitly told.
 * Static typing: type checked while compiling, this allows type errors to be found earlier.
 * Abstraction: types represent the real world or the problem at hand; not how the computer represents the data internally. There are ways to specify exactly how a type must be represented at the bit level, but we will defer that discussion to another chapter. An example of an abstraction is your car. You don't really know how it works you just know that bumbling hunk of metal moves. Nearly every technology you work with is abstracted layer to simplify the complex circuits that make it up - the same goes for software. You want abstraction because code in a class makes a lot more sense than a hundred if statements with no explanation when debugging
 * Name equivalence: as opposed to structural equivalence used in most other languages. Two types are compatible if and only if they have the same name; not if they just happen to have the same size or bit representation.  You can thus declare two integer types with the same ranges that are totally incompatible, or two record types with exactly the same components, but which are incompatible.

Types are incompatible with one another. However, each type can have any number of subtypes, which are compatible with their base type and may be compatible with one another. See below for examples of subtypes which are incompatible with one another.

Predefined types
There are several predefined types, but most programmers prefer to define their own, application-specific types. Nevertheless, these predefined types are very useful as interfaces between libraries developed independently. The predefined library, obviously, uses these types too.

These types are predefined in the package:
 * Integer: This type covers at least the range $$-2^{15}+1$$ .. $$+2^{15}-1$$ (RM ). The Standard also defines  and   subtypes of this type.

 * Float: There is only a very weak implementation requirement on this type (RM ); most of the time you would define your own floating-point types, and specify your precision and range requirements.
 * Duration: A fixed point type used for timing. It represents a period of time in seconds (RM ).
 * Character : A special form of Enumerations. There are three predefined kinds of character types: 8-bit characters (called ), 16-bit characters (called  ), and 32-bit characters .   has been present since the first version of the language (Ada 83),   was added in Ada 95, while the type   is available with Ada 2005.
 * String: Three indefinite array types, of,  , and   respectively.  The standard library contains packages for handling strings in three variants: fixed length , with varying length below a certain upper bound , and unbounded length .  Each of these packages has a   and a   variant.
 * Boolean : A  in Ada is an Enumeration of   and   with special semantics.

Packages  and   predefine some types which are primarily useful for low-level programming and interfacing to hardware.

 * System.Address : An address in memory.
 * System.Storage_Elements.Storage_Offset : An offset, which can be added to an address to obtain a new address. You can also subtract one address from another to get the offset between them.  Together, ,   and their associated subprograms provide for address arithmetic.
 * System.Storage_Elements.Storage_Count : A subtype of  which cannot be negative, and represents the memory size of a data structure (similar to C's  ).
 * System.Storage_Elements.Storage_Element : In most computers, this is a byte. Formally, it is the smallest unit of memory that has an address.
 * System.Storage_Elements.Storage_Array : An array of s without any meaning, useful when doing raw memory access.

The Type Hierarchy
Types are organized hierarchically. A type inherits properties from types above it in the hierarchy. For example, all scalar types (integer, enumeration, modular, fixed-point and floating-point types) have operators "", "" and arithmetic operators defined for them, and all discrete types can serve as array indexes.

Here is a broad overview of each category of types; please follow the links for detailed explanations. Inside parenthesis there are equivalences in C and Pascal for readers familiar with those languages.

 * Signed Integers (int, INTEGER) : Signed Integers are defined via the range of values needed.
 * Unsigned Integers (unsigned, CARDINAL) : Unsigned Integers are called Modular Types. Apart from being unsigned they also have wrap-around functionality.
 * Enumerations (enum, char, bool, BOOLEAN) : Ada Enumeration types are a separate type family.
 * Floating point (float, double, REAL) : Floating point types are defined by the digits needed, the relative error bound.
 * Ordinary and Decimal Fixed Point (DECIMAL) : Fixed point types are defined by their delta, the absolute error bound.
 * Arrays ( [ ], ARRAY [ ] OF, STRING ) : Arrays with both compile-time and run-time determined size are supported.
 * Record (struct, class, RECORD OF) : A record is a composite type that groups one or more fields.
 * Access (*, ^, POINTER TO) : Ada's Access types may be more than just a simple memory address.
 * Task & Protected (similar to multithreading in C++) : Task and Protected types allow the control of concurrency
 * Interfaces (similar to virtual methods in C++) : New in Ada 2005, these types are similar to the Java interfaces.

Classification of Types
Ada's types can be classified as follows.

Specific vs. Class-wide

T ...     T'

and  are the same.

Primitive operations with parameters of specific types are non-dispatching, those with parameters of class-wide types are dispatching.

New types can be declared by deriving from specific types; primitive operations are inherited by derivation. You cannot derive from class-wide types.

Constrained vs. Unconstrained

I  1 .. 10;            AC   (1 .. 10)  ...

AU  (I  <>)  ...            R (X: Discriminant [:= Default])  ...

By giving a constraint to an unconstrained subtype, a subtype or object becomes constrained:

RC R (Value); OC: R (Value); OU: R;

Declaring an unconstrained object is only possible if a default value is given in the type declaration above. The language does not specify how such objects are allocated. GNAT allocates the maximum size, so that size changes that might occur with discriminant changes present no problem. Another possibility is implicit dynamic allocation on the heap and re-allocation followed by a deallocation when the size changes.

 Definite vs. Indefinite

I  1 .. 10;                      RD (X: Discriminant := Default)  ...

T (<>) ...                      AU   (I  <>)  ...    RI (X: Discriminant)  ...

Definite subtypes allow the declaration of objects without initial value, since objects of definite subtypes have constraints that are known at creation-time. Object declarations of indefinite subtypes need an initial value to supply a constraint; they are then constrained by the constraint delivered by the initial value.

OT: T := Expr; OA: AU := (3 => 10, 5 => 2, 4 => 4); OR: RI := Expr;

Unconstrained vs. Indefinite

Note that unconstrained subtypes are not necessarily indefinite as can be seen above with RD: it is a definite unconstrained subtype.

Concurrency Types
The Ada language uses types for one more purpose in addition to classifying data + operations. The type system integrates concurrency (threading, parallelism). Programmers will use types for expressing the concurrent threads of control of their programs.

The core pieces of this part of the type system, the task types and the protected types are explained in greater depth in a section on tasking.

Limited Types
Limiting a type means disallowing assignment. The “concurrency types” described above are always limited. Programmers can define their own types to be limited, too, like this:

T  …;

(The ellipsis stands for, or for a definition, see the corresponding subsection on this page.) A limited type also doesn't have an equality operator unless the programmer defines one.

You can learn more in the limited types chapter.

Defining new types and subtypes
You can define a new type with the following syntax:

T ...

followed by the description of the type, as explained in detail in each category of type.

Formally, the above declaration creates a type and its first subtype named. The type itself, correctly called the "type of T", is anonymous; the RM refers to it as  (in italics), but often speaks sloppily about the type T. But this is an academic consideration; for most purposes, it is sufficient to think of   as a type. For scalar types, there is also a base type called, which encompasses all values of T.

For signed integer types, the type of T comprises the (complete) set of mathematical integers. The base type is a certain hardware type, symmetric around zero (except for possibly one extra negative value), encompassing all values of T.

As explained above, all types are incompatible; thus:

Integer_1  1 .. 10; Integer_2   1 .. 10; A : Integer_1 := 8; B : Integer_2 := A;

is illegal, because  and   are different and incompatible types. It is this feature which allows the compiler to detect logic errors at compile time, such as adding a file descriptor to a number of bytes, or a length to a weight. The fact that the two types have the same range does not make them compatible: this is name equivalence in action, as opposed to structural equivalence. (Below, we will see how you can convert between incompatible types; there are strict rules for this.)

Creating subtypes
You can also create new subtypes of a given type, which will be compatible with each other, like this:

Integer_1  1 .. 10; Integer_2  Integer_1       7 .. 11;   Integer_3  Integer_1'Base  7 .. 11;  A : Integer_1 := 8; B : Integer_3 := A;

The declaration of  is bad because the constraint   is not compatible with  ; it raises   at subtype elaboration time.

and  are compatible because they are both subtypes of the same type, namely.

It is not necessary that the subtype ranges overlap, or be included in one another. The compiler inserts a run-time range check when you assign A to B; if the value of A, at that point, happens to be outside the range of, the program raises.

There are a few predefined subtypes which are very useful:

Natural  Integer  0 .. Integer'Last; Positive Integer  1 .. Integer'Last;

Derived types
A derived type is a new, full-blown type created from an existing one. Like any other type, it is incompatible with its parent; however, it inherits the primitive operations defined for the parent type.

Integer_1  1 .. 10; Integer_2   Integer_1  2 .. 8; A : Integer_1 := 8; B : Integer_2 := A;

Here both types are discrete; it is mandatory that the range of the derived type be included in the range of its parent. Contrast this with subtypes. The reason is that the derived type inherits the primitive operations defined for its parent, and these operations assume the range of the parent type. Here is an illustration of this feature:

Derived_Types Pak Integer_1  1 .. 10;       P (I:  Integer_1); Integer_2  Integer_1  8 .. 10;     Pak; Pak Pak; Pak; A: Integer_1 := 4; B: Integer_2 := 9; P (B); Derived_Types;

When we call, the parameter B is converted to  ; this conversion of course passes since the set of acceptable values for the derived type (here, 8 .. 10) must be included in that of the parent type (1 .. 10). Then P is called with the converted parameter.

Consider however a variant of the example above:

Derived_Types Pak Integer_1  1 .. 10;     P (I:  Integer_1; J:  Integer_1); Integer_2  Integer_1  8 .. 10;   Pak; Pak P (I: Integer_1; J:  Integer_1) J := I - 1; P;   Pak; Pak; A: Integer_1 := 4; X: Integer_1; B: Integer_2 := 8; Y: Integer_2; P (A, X); P (B, Y); Derived_Types;

When  is called, both parameters are converted to. Thus the range check on J (7) in the body of P will pass. However on return parameter Y is converted back to  and the range check on Y will of course fail.

With the above in mind, you will see why in the following program Constraint_Error will be called at run time, before  is even called.

Derived_Types Pak Integer_1  1 .. 10;     P (I:  Integer_1; J:  Integer_1); Integer_2  Integer_1'Base  8 .. 12;   Pak; Pak P (I: Integer_1; J:  Integer_1) J := I - 1; P;   Pak; Pak; B: Integer_2 := 11; Y: Integer_2; P (B, Y); Derived_Types;

Subtype categories
Ada supports various categories of subtypes which have different abilities. Here is an overview in alphabetical order.

Anonymous subtype
A subtype which does not have a name assigned to it. Such a subtype is created with a variable declaration:

X : String (1 .. 10) := ( => ' ');

Here, (1 .. 10) is the constraint. This variable declaration is equivalent to:

Anonymous_String_Type String (1 .. 10); X : Anonymous_String_Type := ( => ' ');

Base type
In Ada, all types are anonymous and only subtypes may be named. For scalar types, there is a special subtype of the anonymous type, called the base type, which is nameable with  notation. This  (read "name tick attribute") is the special notation used in Ada for what is called an attribute, i.e. a characteristic of a type, a variable, or some other program entity, that is defined by the compiler and can be queried. In this case, the base type comprises all values of the first subtype. Some examples:

Int  0 .. 100;

The base type  is a hardware type selected by the compiler that comprises the values of. Thus, it may have the range -27 .. 27-1 or -215 .. 215-1 or any other such type.

Enum  (A, B, C, D); Short  Enum  A .. C;

is the same as, but   also holds the literal.

Constrained subtype
A subtype of an indefinite subtype that adds constraints. The following example defines a 10 character string sub-type.

String_10 String (1 .. 10);

You cannot partially constrain an unconstrained subtype:

My_Array  (Integer  <>, Integer  <>)  Some_Type; Constr My_Array (1 .. 10, -100 .. 200);

Constraints for all indices must be given, the result is necessarily a definite subtype.

Definite subtype
A definite subtype is a subtype whose size is known at compile-time. All subtypes which are not indefinite subtypes are, by definition, definite subtypes.

Objects of definite subtypes may be declared without additional constraints.

Indefinite subtype
An indefinite subtype is a subtype whose size is not known at compile-time but is dynamically calculated at run-time. An indefinite subtype does not by itself provide enough information to create an object; an additional constraint or explicit initialization expression is necessary in order to calculate the actual size and therefore create the object.

X : String := "This is a string";

is an object of the indefinite (sub)type. Its constraint is derived implicitly from its initial value. may change its value, but not its bounds.

It should be noted that it is not necessary to initialize the object from a literal. You can also use a function. For example:

X : String := Ada.Command_Line.Argument (1);

This statement reads the first command-line argument and assigns it to.

A subtype of an indefinite subtype that does not add a constraint only introduces a new name for the original subtype (a kind of renaming under a different notion).

My_String String;

My_String and String are interchangeable.

Named subtype
A subtype which has a name assigned to it. “First subtypes” are created with the keyword  (remember that types are always anonymous, the name in a type declaration is the name of the first subtype), others with the keyword. For example:

Count_To_Ten  1 .. 10;

is the first subtype of a suitable integer base type. However, if you would like to use this as an index constraint on, the following declaration is illegal:

Ten_Characters String (Count_to_Ten);

This is because  has   as its index, which is a subtype of   (these declarations are taken from package  ):

Positive Integer  1 .. Integer'Last; String (Positive  <>)  Character;

So you have to use the following declarations:

Count_To_Ten Integer  1 .. 10; Ten_Characters  String (Count_to_Ten);

Now  is the name of that subtype of   which is constrained to. You see that posing constraints on types versus subtypes has very different effects.

Unconstrained subtype
Any indefinite type is also an unconstrained subtype. However, unconstrainedness and indefiniteness are not the same.

My_Enum (A, B, C); My_Record (Discriminant: My_Enum) ...; My_Object_A: My_Record (A);

This type is unconstrained and indefinite because you need to give an actual discriminant for object declarations; the object is constrained to this discriminant which may not change.

When however a default is provided for the discriminant, the type is definite yet unconstrained; it allows to define both, constrained and unconstrained objects:

My_Enum (A, B, C); My_Record (Discriminant: My_Enum := A) ...; My_Object_U: My_Record; My_Object_B: My_Record (B);

Here, My_Object_U is unconstrained; upon declaration, it has the discriminant A (the default) which however may change.

Incompatible subtypes
My_Integer  -10 .. + 10;  My_Positive  My_Integer  + 1 .. + 10;  My_Negative  My_Integer  -10 .. - 1;

These subtypes are of course incompatible.

Another example are subtypes of a discriminated record:

My_Enum (A, B, C); My_Record (Discriminant: My_Enum) ...; My_A_Record My_Record (A); My_C_Record My_Record (C);

Also these subtypes are incompatible.

Qualified expressions
In most cases, the compiler is able to infer the type of an expression; for example:

Enum (A, B, C); E : Enum := A;

Here the compiler knows that  is a value of the type. But consider:

Bad Enum_1 (A, B, C); P (E : Enum_1) ...      Enum_2  (A, X, Y, Z); P (E : Enum_2) ...     P (A); Bad;

The compiler cannot choose between the two versions of ; both would be equally valid. To remove the ambiguity, you use a qualified expression:

P (Enum_1'(A));

As seen in the following example, this syntax is often used when creating new objects. If you try to compile the example, it will fail with a compilation error since the compiler will determine that 256 is not in range of.

; Convert_Evaluate_As Byte      2**8; Byte_Ptr  Byte; T_IO ; M_IO   (Byte); A : Byte_Ptr :=  Byte'(256); T_IO.Put ("A = "); M_IO.Put (Item => A.all,              Width =>  5,              Base  => 10); Convert_Evaluate_As;

You should use qualified expression when getting a string literal's length.

Type conversions
Data do not always come in the format you need them. You must, then, face the task of converting them. As a true multi-purpose language with a special emphasis on "mission critical", "system programming" and "safety", Ada has several conversion techniques. The most difficult part is choosing the right one, so the following list is sorted in order of utility. You should try the first one first; the last technique is a last resort, to be used if all others fail. There are also a few related techniques that you might choose instead of actually converting the data.

Since the most important aspect is not the result of a successful conversion, but how the system will react to an invalid conversion, all examples also demonstrate faulty conversions.

Explicit type conversion
An explicit type conversion looks much like a function call; it does not use the tick (apostrophe, ') like the qualified expression does.

Type_Name (Expression)

The compiler first checks that the conversion is legal, and if it is, it inserts a run-time check at the point of the conversion; hence the name checked conversion. If the conversion fails, the program raises Constraint_Error. Most compilers are very smart and optimise away the constraint checks; so, you need not worry about any performance penalty. Some compilers can also warn that a constraint check will always fail (and optimise the check with an unconditional raise).

Explicit type conversions are legal:
 * between any two numeric types
 * between any two subtypes of the same type
 * between any two types derived from the same type (note special rules for tagged types)
 * between array types under certain conditions (see RM 4.6(24.2/2..24.7/2))
 * and nowhere else

(The rules become more complex with class-wide and anonymous access types.)

I: Integer := Integer (10); J: Integer := 10; K: Integer := Integer'(10);

This example illustrates explicit type conversions:

; Convert_Checked Short  -128 .. +127;    Byte    256; T_IO ; I_IO   (Short); M_IO   (Byte); A : Short := -1; B : Byte; B := Byte (A); T_IO.Put ("A = "); I_IO.Put (Item =>  A,              Width =>  5,              Base  => 10); T_IO.Put (", B = "); M_IO.Put (Item =>  B,              Width =>  5,              Base  => 10); Convert_Checked;

Explicit conversions are possible between any two numeric types: integers, fixed-point and floating-point types. If one of the types involved is a fixed-point or floating-point type, the compiler not only checks for the range constraints (thus the code above will raise Constraint_Error), but also performs any loss of precision necessary.

Example 1: the loss of precision causes the procedure to only ever print "0" or "1", since  is an integer and is always zero or one.

Ada.Text_IO; Naive_Explicit_Conversion Proportion  4  0.0 .. 1.0;    Percentage   0 .. 100;    To_Proportion (P :  Percentage)  Proportion Proportion (P / 100); To_Proportion; Ada.Text_IO.Put_Line (Proportion'Image (To_Proportion (27))); Naive_Explicit_Conversion;

Example 2: we use an intermediate floating-point type to guarantee the precision.

Ada.Text_IO; Explicit_Conversion Proportion  4  0.0 .. 1.0;    Percentage   0 .. 100;    To_Proportion (P :  Percentage)  Proportion Prop  4  0.0 .. 100.0;       Proportion (Prop (P) / 100.0); To_Proportion; Ada.Text_IO.Put_Line (Proportion'Image (To_Proportion (27))); Explicit_Conversion;

You might ask why you should convert between two subtypes of the same type. An example will illustrate this.

String_10 String (1 .. 10); X: String := "A line long enough to make the example valid"; Slice: String := String_10 (X (11 .. 20));

Here,  has bounds 1 and 10, whereas   has bounds 11 and 20.

Change of Representation
Type conversions can be used for packing and unpacking of records or arrays.

Unpacked ; Packed   Unpacked; Packed ;

P: Packed; U: Unpacked; P := Packed (U); U := Unpacked (P);

Checked conversion for non-numeric types
The examples above all revolved around conversions between numeric types; it is possible to convert between any two numeric types in this way. But what happens between non-numeric types, e.g. between array types or record types? The answer is two-fold:

 * you can convert explicitly between a type and types derived from it, or between types derived from the same type,
 * and that's all. No other conversions are possible.

Why would you want to derive a record type from another record type? Because of representation clauses. Here we enter the realm of low-level systems programming, which is not for the faint of heart, nor is it useful for desktop applications. So hold on tight, and let's dive in.

Suppose you have a record type which uses the default, efficient representation. Now you want to write this record to a device, which uses a special record format. This special representation is more compact (uses fewer bits), but is grossly inefficient. You want to have a layered programming interface: the upper layer, intended for applications, uses the efficient representation. The lower layer is a device driver that accesses the hardware directly and uses the inefficient representation.

Device_Driver Size_Type  0 .. 64;    Register A, B : Boolean; Size : Size_Type; ;    Read (R :  Register); Write (R : Register); Device_Driver;

The compiler chooses a default, efficient representation for. For example, on a 32-bit machine, it would probably use three 32-bit words, one for A, one for B and one for Size. This efficient representation is good for applications, but at one point we want to convert the entire record to just 8 bits, because that's what our hardware requires.

Device_Driver Hardware_Register  Register; Hardware_Register A 0  0 .. 0;      B  0  1 .. 1;      Size  0  2 .. 7;    ;     Get  Hardware_Register; Put (H : Hardware_Register); Read (R : Register) H : Hardware_Register := Get; R := Register (H); Read; Write (R : Register) Put (Hardware_Register (R)); Write; Device_Driver;

In the above example, the package body declares a derived type with the inefficient, but compact representation, and converts to and from it.

This illustrates that type conversions can result in a change of representation.

View conversion, in object-oriented programming
Within object-oriented programming you have to distinguish between specific types and class-wide types.

With specific types, only conversions in the direction to the root are possible, which of course cannot fail. There are no conversions in the opposite direction (where would you get the further components from?) ; extension aggregates have to be used instead.

With the conversion itself, no components of the source object that are not present in the target object are lost, they are just hidden from visibility. Therefore, this kind of conversion is called a view conversion since it provides a view of the source object as an object of the target type (especially it does not change the object's tag).

It is a common idiom in object oriented programming to rename the result of a view conversion. (A renaming declaration does not create a new object; it only gives a new name to something that already exists.)

Parent_Type ; ;  Child_Type   Parent_Type ; ; Child_Instance : Child_Type; Parent_View   : Parent_Type  Parent_Type (Child_Instance); Parent_Part   : Parent_Type := Parent_Type (Child_Instance);

is not a new object, but another name for  viewed as the parent, i.e. only the parent components are visible, the child-specific components are hidden. , however, is an object of the parent type, which of course has no storage for the child-specific components, so they are lost with the assignment.

All types derived from a tagged type  form a tree rooted at. The class-wide type  can hold any object within this tree. With class-wide types, conversions in any direction are possible; there is a run-time tag check that raises  if the check fails. These conversions are also view conversions, no data is created or lost.

Object_1 : Parent_Type' := Parent_Type' (Child_Instance); Object_2 : Parent_Type' Parent_Type' (Child_Instance);

is a new object, a copy;  is just a new name. Both objects are of the class-wide type. Conversions to any type within the given class are legal, but are tag-checked.

Success : Child_Type := Child_Type (Parent_Type' (Parent_View)); Failure : Child_Type := Child_Type (Parent_Type' (Parent_Part));

The first conversion passes the tag check and both objects  and   are equal. The second conversion fails the tag check. (Conversion assignments of this kind will rarely be used; dispatching will do this automatically, see object oriented programming.)

You can perform these checks yourself with membership tests:

Parent_View Child_Type  ...  Parent_View  Child_Type'  ...

There is also the package.

Address conversion
Ada's access type is not just a memory location (a thin pointer). Depending on implementation and the access type used, the access might keep additional information (a fat pointer). For example GNAT keeps two memory addresses for each access to an indefinite object — one for the data and one for the constraint informations (', ', ').

If you want to convert an access to a simple memory location you can use the package. Note however that an address and a fat pointer cannot be converted reversibly into one another.

The address of an array object is the address of its first component. Thus, the bounds get lost in such a conversion.

My_Array  (Positive  <>)  Something; A: My_Array (50 .. 100); A' = A(A')'

Unchecked conversion
One of the great criticisms of Pascal was "there is no escape". The reason was that sometimes you have to convert the incompatible. For this purpose, Ada has the generic function Unchecked_Conversion:

Source (<>)  ; Target (<>)  ; (S : Source) Target;

will bit-copy the source data and reinterpret them under the target type without any checks. It is your chore to make sure that the requirements on unchecked conversion as stated in RM are fulfilled; if not, the result is implementation dependent and may even lead to abnormal data. Use the 'Valid attribute after the conversion to check the validity of the data in problematic cases.

A function call to (an instance of)  will copy the source to the destination. The compiler may also do a conversion in place (every instance has the convention Intrinsic).

To use  you need to instantiate the generic.

In the example below, you can see how this is done. When run, the example will output. No error will be reported, but is this the result you expect?

; ;  Convert_Unchecked Short  -128 .. +127;    Byte    256; T_IO ; I_IO   (Short); M_IO   (Byte); Convert   (Source => Short,                                                      Target => Byte); A : Short := -1; B : Byte; B := Convert (A); T_IO.Put ("A = "); I_IO.Put (Item =>  A,              Width =>  5,              Base  => 10); T_IO.Put (", B = "); M_IO.Put (Item =>  B,              Width =>  5,              Base  => 10); Convert_Unchecked;

There is of course a range check in the assignment. Thus if  were defined as ,   would be raised.

Overlays
If the copying of the result of  is too much waste in terms of performance, then you can try overlays, i.e. address mappings. By using overlays, both objects share the same memory location. If you assign a value to one, the other changes as well. The syntax is:

Target' expression; (Ada, Target);

where expression defines the address of the source object.

While overlays might look more elegant than, you should be aware that they are even more dangerous and have even greater potential for doing something very wrong. For example if  and you assign a value to Target, you might inadvertently write into memory allocated to a different object.

You have to take care also of implicit initializations of objects of the target type, since they would overwrite the actual value of the source object. The Import pragma with convention Ada can be used to prevent this, since it avoids the implicit initialization, RM.

The example below does the same as the example from "Unchecked Conversion".

; Convert_Address_Mapping Short  -128 .. +127;    Byte    256; T_IO ; I_IO   (Short); M_IO   (Byte); A : Short; B : Byte; B' A'; (Ada, B); A := -1; T_IO.Put ("A = "); I_IO.Put (Item =>  A,              Width =>  5,              Base  => 10); T_IO.Put (", B = "); M_IO.Put (Item =>  B,              Width =>  5,              Base  => 10); Convert_Address_Mapping;

Export / Import
Just for the record: There is still another method using the and  pragmas. However, since this method completely undermines Ada's visibility and type concepts even more than overlays, it has no place here in this language introduction and is left to experts.

Elaborated Discussion of Types for Signed Integer Types
As explained before, a type declaration

T  1 .. 10;

declares an anonymous type  and its first subtype   (please note the italicization). encompasses the complete set of mathematical integers. Static expressions and named numbers make use of this fact.

All numeric integer literals are of type. They are converted to the appropriate specific type where needed. itself has no operators.

Some examples with static named numbers:

S1: := Integer' + Integer'; S2: := Long_Integer' + 1; S3: := S1 + S2; S4: := Integer' + Long_Integer';

Static expressions are evaluated at compile-time on the appropriate types with no overflow checks, i.e. mathematically exact (only limited by computer store). The result is then implicitly converted to.

The literal 1 in  is of type   and implicitly converted to.

implicitly converts the summands to, performs the calculation and converts back to.

is illegal because it mixes two different types. You can however write this as

S5: := Integer'Pos (Integer') + Long_Integer'Pos (Long_Integer');

where the Pos attributes convert the values to, which are then further implicitly converted to  , added and the result converted back to.

is the anonymous greatest integer type representable by the hardware. It has the range. All integer types are rooted at, i.e. derived from it. can be viewed as.

During run-time, computations of course are performed with range checks and overflow checks on the appropriate subtype. Intermediate results may however exceed the range limits. Thus with  of the subtype   above, the following code will return the correct result:

I := 10; J := 8; K := (I + J) - 12;

Real literals are of type, and similar rules as the ones above apply accordingly.

Relations between types
Types can be made from other types. Array types, for example, are made from two types, one for the arrays' index and one for the arrays' components. An array, then, expresses an association, namely that between one value of the index type and a value of the component type.

Color (Red, Green, Blue); Intensity  0 .. 255;  Colored_Point   (Color)  Intensity;

The type Color is the index type and the type Intensity is the component type of the array type Colored_Point. See array.

Wikibook

 * Ada Programming

Ada Reference Manual

|Type System Programación en Ada/Tipos

title: Ada Programming/Type System


text:
Reaktor/Modules/Snap Value

Comments

 * Snap Value saves its value on shut-down / start-up

title: Reaktor/Modules/Snap Value


text:
Reaktor/Modules/Snapshot

Comments

 * Snapshot Recall and Store ports won't always fire on switch pressing. They only fire when they should (ie when a snap is recalled or stored respectively)

title: Reaktor/Modules/Snapshot


text:
Reaktor/Modules/Multi Picture

Comments

 * MultiPicture module works in incremental mode. MX and MY ports do not fire anything on ensemble start up, or on switch pressing, as that usually conflicts with a Snap Value. They only fire as you move the mouse.

title: Reaktor/Modules/Multi Picture


text:
Reaktor/Modules/System Info

Comments

 * The CR output fires constantly at the control rate (typically 400hz). So, if the CR output is connected to a complex event structure, you will have a lot of events being processed that will eat more CPU.

title: Reaktor/Modules/System Info


text:
Reaktor/Modules/Selector/Scanner

Comments

 * The difference between the Selector and Router is that when you change the Selector to a new position, it sends whatever value was last received there (even if it's not currently being received) - while changing the position on the Router only "opens that pathway" to allow something new to pass though (nothing is sent until new values arrive at that input).
 * Selector module can be used to scale values from 0..1 range to any other range, defined by two input values, e.g. -10..40. See thread on User Forum

title: Reaktor/Modules/Selector/Scanner


text:
Reaktor/Modules/Router M to 1

Comments

 * The difference between the Selector and Router is that when you change the Selector to a new position, it sends whatever value was last received there (even if it's not currently being received) - while changing the position on the Router only "opens that pathway" to allow something new to pass though (nothing is sent until new values arrive at that input).

title: Reaktor/Modules/Router M to 1


text:
Talk:HyperText Markup Language/Layers

Hi, i'm Mahi,

I have a html tabbed table.in that i have 6 tabs all are having the same alignment.but some tabs are not fitting with window. means some tabs displaying content with full width and some are not. in table tag i have given the widht="100%" for all tabs (each tab is different table.) can any one help me please.

thanks in advance.

regds, Mahi

title: Talk:HyperText Markup Language/Layers


text:
Talk:JLPT Guide/JLPT N5 Vocabulary

Untitled
This is a must! I worked on something very similar on my own, but abandoned the work after incidentally finding this. Thanks a lot, guys. Filip Hráček

Needs moving
The test has been rescaled, and the old level 4 (that this page name references) has become level N5. The new name should be something like "JLPT Guide/JLPT N5 Vocabulary". Anyone opposed? --Astrochicken (talk) 06:56, 30 November 2010 (UTC)
 * Page was moved, thanks! --211.120.119.94 (talk) 23:17, 30 November 2010 (UTC)

title: Talk:JLPT Guide/JLPT N5 Vocabulary


text:
XML - Managing Data Exchange/RDF/Answers

Question
 * 1)  Create an RDF/XML document that describes an article of your choice (e.g. from magazines like CIO.com or ZDNet.com). Use the Dublin Core element set and the Dublin Core terms as a framework for your description. After completing the document please validate your work with the W3C RDF Validator.

Answer


text:
User talk:Desertfox 59

†åøß†

Restoring contributer signature
Do we acutally need the signature of everyone who has contributed to a page? I'd rather see a move toward editing the pages to make them more cohesive, like a book or article, rather than a chat session. For example, if we could convince people to create wiki accounts and add themselves to the "Contributers" page so you can easily look up their contributions. Canscorch 00:13, 6 Mar 2005 (UTC)

Apparent Vandalism: changing signatures
Have you noticed someone changing the signatures on many AA pages? At first I thought it was just that you had changed usernames, since it was only yours that I noticed being changed at first. I see now that many others are being modified.

title: User talk:Desertfox 59


text:
File talk:75%.png

Why don't we use the gray background? If it looks too like, we can lighten the gray a bit. It seems out of place with the other grayed-in completion images. - SamE 00:46, 30 Nov 2004 (UTC)

too small
i like the concept, but these are practically invisible on a 120 dpi screen. consider making them bigger and thicker. - Omegatron 03:56, 12 Dec 2004 (UTC)

those three edits
I inadvertently clicked on the "rev" link. I re-reverted it, and that re-revision got logged twice. MShonle 05:46, 24 Dec 2004 (UTC)

Reverting
Can it be reverted to last version by Karl Warwick? As in svg file. —Preceding unsigned comment added by Soeb (discuss • contribs) 2008-03-20T19:07:31

title: File talk:75%.png