OpenLLM-France/wikimedia huggingface dataset:
# Breton/Level 1/Lesson 1/Quiz

Enter the Breton words :
1
Good day!
2
Good morning!
3
Good evening!
4
Good bye!
5
Good night!
6
Late
7
I must go now. Red eo din
bremañ
Now, complete with breton words :
Complete with Breton words from the lessons in Brezhoneg Unan.
Demat Yann,
eo ar bed ganit? Mat
, mersi dit. :
# Blender 3D: Noob to Pro/Customization

| previous module: "Animation Notes and FAQ" | • Table of Contents • Glossary | next module: "Mist - Make Objects Opaque" |

## Changing the Theme

Like many other programs with a graphical user interface, Blender allows you to customize or modify many aspects of its appearance. A collection of such customizations is called a theme.
Theme controls are found in the User Preferences window. Click LMB on the "Themes" button to activate a drop-down menu which can be used to select different themes. Below this is an "Add" button that can be used to create new themes. If any themes have been added, a "Delete" button will appear, along with other controls to adjust the current theme.
This book presents screen shots using the default theme. If you are new to Blender, you should continue using the default theme as you progress through the book, to avoid confusion.
| previous module: "Animation Notes and FAQ" | • Table of Contents • Glossary | next module: "Mist - Make Objects Opaque" |
# Blender 3D: Noob to Pro/Every Material Known to Man/Alloy
## Alloy (Blender Render)
### Material
#### Diffuse (Oren-Nayar)

* Color: CCCCCC
* Intensity: 1

#### Specular (Phong)

* Color: FFFFFF
* Intensity: 0.5
* Hardness: 50

#### Mirror

* Reflectivity: 0.5
* Color: FFFFFF
* Fresnel: 0
* Depth: 2
* Maximum Distance: 0
* Gloss
** Amount: 1
(Leave every other sub-tab at its default settings.)
# Blender 3D: Noob to Pro/Every Material Known to Man/Asphalt
## Asphalt (Blender Render)
### Material
#### Diffuse (Lambert)

* Color: 404040
* Intensity: 0.6

#### Specular (CookTorr)

* Color: CCCCCC
* Intensity: 0.22
* Hardness: 5
(Leave every other sub-tab at its default settings.)

### Textures
#### Texture 1 (Musgrave)
##### Musgrave

Type: Multifractal
** Dimension: 0.8
** Lacunarity: 1
** Octaves: 2
** Intensity: 0.4
* Noise Basis: Voronoi F4
** Size: 0.03
** Nabla: 0.025

##### Mapping

* Coordinates: Generated
* Projection: Cube
** Mapping Slot X: X
** Mapping Slot Y: Y
** Mapping Slot Z: Z
* Offset
** X: 0
** Y: 0
** Z: 0
* Size
** X: 1
** Y: 1
** Z: 1

##### Influence

* Geometry
** Normal: 2
* Blend : Mix
* Color: FF00FF
* DVar: 1
* Bump Mapping
** Method: Low Quality
** Space: Object Space
(Leave every other sub-tab at its default settings.)

## Asphalt (Cycles Render)
### Node Setup

* Node 1 (Value)
** Value: 150
* Node 2 (Math)
** Divide
** Value: (Node 1)
** Value: 5
* Node 3 (Math)
** Multiply
** Value: (Node 1)
** Value: 2
* Node 4 (Voronoi Texture)
** Coloring: Intensity
** Vector: Default
** Scale: (Node 1)
* Node 5 (Noise Texture)
** Vector: Default
** Scale: (Node 1)
** Detail: (Node 3)
** Distortion: 0
* Node 6 (Noise Texture)
** Vector: Default
** Scale: (Node 1)
** Detail: (Node 2)
** Distortion: 0
* Node 7 (Color Ramp)
** Color mode: RGB
** Interpolation: Linear
** Points
*** 0 (Position: 0) > 000000 (Alpha: 1)
*** 1 (Position: 1) > BABABA (Alpha: 1)
** Factor: (Node 4 (Color))
* Node 8 (Color Ramp)
** Color mode: RGB
** Interpolation: Linear
** Points
*** 0 (Position: 0) > 000000 (Alpha: 1)
*** 1 (Position: 1) > BABABA (Alpha: 1)
** Factor: (Node 5 (Color))
* Node 9 (Color Ramp)
** Color mode: RGB
** Interpolation: Linear
** Points
*** 0 (Position: 0) > 1A1AFF (Alpha: 1)
*** 1 (Position: 1) > 800080 (Alpha: 1)
** Factor: (Node 6 (Color))
* Node 10 (Diffuse BSDF)
** Color: (Node 8 (Color))
** Roughness: 0
** Normal: Default
* Node 11 (Glossy BSDF)
** Shader Model: GGX
** Color: CCCCCC
** Roughness: 0.2
** Normal: Default
* Node 12 (Normal Map)
** Object Space
** Strength: 5
** Color: (Node 9 (Color))
* Node 13 (Mix Shader)
** Factor: (Node 7 (Color))
** Shader: (Node 10)
** Shader: (Node 11)
* Node 14 (Material Output)
** Surface: (Node 13)
** Volume: Default
** Displacement: (Node 12)
# Celestia/Celx Scripting/Q&A/Assigning Custom Key Functions with CELX

With CELX it's easy to create custom key functions, and assign them to different keys on your keyboard. Here's how:
First, you create a Lua function using CELX to implement your custom function. In this example, we'll create a new key function which zooms the active view so that the currently selected object fills the view:
Next, you create a table which maps a selected key to your new function. In this example, we'll use the "z" key:
Then, you create a key handling function to call your new Lua function when the desired key is pressed, and assign it as the Celestia keyboard callback:
Note that when there's a custom key definition for the input key, the callback returns true to indicate to Celestia that no further processing of the key is needed. Otherwise it returns false, and Celesta will handle the key according to the built-in key function assignments.
Finally, you tell Celestia that you want the callback to be called when a key is pressed, and then you wait for input:
Note that the script has an infinite loop, so you'll need to use the escape key to terminate it.
Once you've got the basic script, you can assign other new key functions simply by defining the Lua functions to implement them, and adding them to the key map.
Give it a try!

## Download the script

Below you can find the whole script (without comments) in a single text block. Copy everything in the grey box and paste it into a text file in your favourite text editor, and save that file in your scripts directory as zoomtofit.celx. Then open it (File/Open Script) from within Celestia to see the script in action.
</syntaxhighlight>

### Distinguishing upper from lower case

Unfortunately, the example above does not distinguish between the typing of upper case (capital) letters and lower case letters.
When Celestia calls the function celestia_keyboard_callback, the function's argument ("key" in this example) contains the letter that was typed. A simple string of IF statements can distinguish among them:
This form of the callback calls the function zoomToFit if an upper-case F is typed, but lets Celestia handle all other letters, including lower-case f.
# Celestia/Celx Scripting/Q&A/Angles

Finding the angles between two objects is a handy thing to be able to do in a script. It would mostly be useful for finding angular separations and phase angles (illustrated below) which can be used for a variety of other purposes.
The angular separation between two objects seen is a measure of how far apart they are in the sky as seen by the observer.
The phase angle is usually described for non-emissive objects orbiting stars (e.g. planets, asteroids, comets, moons, etc.) and is the angle of illumination of the object seen by an observer. It is the angle between the Star-Target line and the Target-Observer line. Using the image as an example, a phase angle of 0 degrees means that the observer is directly between the star and the planet - thus, the star is behind the observer, and the planet would appear "Full" to the viewer. A phase angle of 90 or 270 degrees means that the observer is over the terminator of the planet (the line dividing day and night), so he would see a 'Half-Full" planet. A phase angle of 180 degrees means that the planet is directly between the observer and the star, so the observer is in the planet's shadow and would see a "New" planet. At intermediate phase angles the observer would see a crescent or gibbous planet.

## Theory

Celestia stores the positions of objects as a table consisting of an x-coordinate, y-coordinate, and z-coordinate. The line connecting two points is known as a vector, so basically we're finding the angle between two vectors. First we have to calculate each of the vectors. To do this we find the positions of the objects at either end of the line, and then simply subtract one from the other. So in order to calculate a Phase Angle, the vector of the Star-Planet line is (position of the planet - position of the star), and the vector of the Observer-Planet line is (position of the planet - position of the observer).
Once we have these vectors, we need to use a special mathematical function used for vectors called the Dot Product. This is reproduced below:
    $\mathbf {a} \cdot \mathbf {b} =a\,b\cos \theta \;$
We'd refer to this as "a dot b", where a and b are the vectors involved. The ab on the right-hand-side of the equation are the lengths of the two vectors multiplied together, and the angle theta is the angle between the two vectors. In this case, Celestia already knows what the vectors are (and how long they are and what the angle is between them) and so can calculate the dot product - we just need to extract the information we want in a script. We can also normalise the vectors so that the lengths equal 1 - this makes the calculation a little simpler (and conveniently enough there's a 'normalize' script command that does this). This reduces the equation we need in the script to:
    $\theta =\arccos(\mathbf {a} \cdot \mathbf {b} )\;$
The script below illustrates how to perform this calculation in Celx.

## Download the script

This is a complete script that you can run as-is to display the phase angle to a target in the solar system. The target must already be selected before the script is run.
# Basic Physics of Digital Radiography/The Quiz

A quiz on X-ray production & their interactions with matter is available below for those who wish to test their knowledge and understanding of these topics.
Additional quizzes are also available on:
      * Radiation Biology & Dosimetry
      * Technology of Radiographic Imaging
# Basic Physics of Nuclear Medicine

Nuclear Medicine is a fascinating application of nuclear physics. The first ten chapters of this wikibook are intended to support a basic introductory course in an early semester of an undergraduate program. They assume that students have completed decent high school programs in maths and physics and are concurrently taking subjects in the medical sciences. Additional chapters cover more advanced topics in this field. Our focus in this wikibook is the diagnostic application of Nuclear Medicine. Therapeutic applications are considered in a separate wikibook, "Radiation Oncology".
Note that this WikiBooks is well past its use-by date. Some of the basic physics might still be of relevance, but the technologies and applications chapters need substantial updating.
A companion wikibook on the Basic Physics of Digital Radiography is also available.

## Contents

      * Atomic & Nuclear Structure
      * Radioactive Decay
      * The Radioactive Decay Law
      * Units of Radiation Measurement
      * Interaction of Radiation with Matter
      * Attenuation of Gamma-Rays
      * Gas-Filled Radiation Detectors
      * Scintillation Detectors
      * Nuclear Medicine Imaging Systems
      * Computers in Nuclear Medicine
      * Fourier Methods
      * X-Ray CT in Nuclear Medicine
      * PACS and Advanced Image Processing
      * Three-Dimensional Visualization Techniques
      * Patient Dosimetry
      * Production of Radioisotopes
      * Chapter Review
      * Dynamic Studies in Nuclear Medicine
      * Deconvolution Analysis
      * Sonography & Nuclear Medicine
      * MRI & Nuclear Medicine
      * Dual-Energy Absorptiometry
The principal author of this text is grateful for the expert editorial assistance of Dirk Hünniger during his German translation of the text and his contribution to the section on the Operation of a 99m-Tc Generator.

## Bibliography

* Applied Imaging Technology, 4th Ed., JCP Heggie, NA Liddell & KP Maher (St Vincent's Hospital Melbourne, 2001)
* Basic Science of Nuclear Medicine, 2nd Ed., RP Parker, PHS Smith, DM Taylor (Churchill Livingstone, 1984)
* Computed Tomography: Fundamentals, System Technology, Image Quality, Applications, 3rd Ed., WA Kalender (Wiley, 2000)
* Introduction to Nuclear Physics, H Enge (Addison-Wesley, 1966)
* Magnetic Resonance in Medicine, 4th Ed., PA Rinck (Blackwell, 2001)
* Nuclear Medicine in Urology & Nephrology, 2nd Ed., HJ Testa, PH O'Reilly & RA Shields (Butterworth-Heinemann, 1986)
* Physics in Nuclear Medicine, JA Sorenson and ME Phelps (Grune & Stratton, 1980)
* Radioisotope Techniques in Clinical Research and Diagnosis, N Veall and H Vetter (Butterworths, 1958)
* Radionuclide Techniques in Medicine, JM McAlister (Cambridge University Press, 1979).
# Bikol/Animals

| Bikol | English |
| gamgam, bayong | bird |
| kanding | goat |
| ayam | dog |
| ikos | cat |
| damulag, karabaw | carabao, buffalo |
| sira | fish |
| kabayo | horse |
| agila | eagle |
| pating | shark |
| ulod | worm |
| kalibangbang | butterfly |
| halas | snake |
# Bikol/External Links

Bikol ᜊᜒᜃᜓᜎ᜔
* the regional language of Bicolandia
* Differences between Bikol and Tagalog
* Translate Bikol
* Learn Philippine Languages
* Wikijunior:Languages/Bikol — version for children.
# Bikol/Authors

This Bikol Wikibook wouldn't be here today if it wasn't for its authors. This book was started by the username Jay Bolero, contributors have constantly improved upon it and have brought the Wikibook into good shape.
This book already has all of the most basic information allowing you to construct a simple sentence, and say a few things in Bikol. However, do try to help by adding some more information on other topics that are not here. As you write, remember that people reading this book can be totally new to the language. Do not write as if you are writing for another Bikol speaker, but keep in mind to explain things in great detail to enable learners to use this book easily.
Please remember that this is a wiki textbook. Feel free to edit it, update it, correct it, and do anything to boost its capabilities to teach those who read this textbook, and/or otherwise increase its teaching potential.
This Bikol Wikibook has received contributions from the following users (please insert your full name if possible):
Initiator
Other Contributors
* Me Lendroz
* Crystal East
# Bikol/Contents

Welcome to the course dedicated to teaching you the regional language of the Philippines spoken in Bicolandia. If you haven't already done so, please, spend a few minutes to first read the book's introduction and reading guide. Once that's done, you're ready to begin your very first Bicolano lesson! Good luck!
If you have made contributions to this Wikibook and would like to have formal credit for being an author, please add your name to this list: Authors and Contributors.
# Bikol/Days of the Week

The days of the week were all imported from Spanish.
| Lunes | Monday |
| Martes | Tuesday |
| Myerkoles | Wednesday |
| Huwebes | Thursday |
| Byernes | Friday |
| Sabado | Saturday |
| Domingo | Sunday |
These should be easy to remember if you have studied Spanish.
First of all, learn the whole list of days by heart. Make sure you can recite them to yourself, without looking at this page.
Here are a few sentences using the days in Bikol. You can see how the article or the plural is used, depending on the context.
* Lunes na sa aga.
* Mapasiring kami sa Manila sa Sabado.
* Myerkoles kasuhapon.
Plurals are not appropriate for days ...
Quiz: Translate the following English sentences in Bikol.
# Bikol/Common phrases

Bikol is a regional language spoken in Bicol Region, Philippines. It is a member of the Austronesian language family and is one of the most spoken among indigenous languages in the Philippines.
| English | Bikol | Pseudo pronunciation |
| hello | kumusta | koo-mooss-TAH |
| how are you? | kumusta ka? | koo-mooss-TAH kah? |
| thank you | Dios mabalos | JAWSS MAH-bah-lawss |
| you're welcome | daing ano man | dah-EENG ah-NAW mahn |
| yes | iyo | ee-YAW |
| no | dai | dah-EE |
| I am fine | marhay man ako | mahr-HIGH mahn ah-KAW |
| what is your name? | ano an pangaran mo? | ah-NAW ahn pah-NGAH-rahn maw? |
| my name is ... | ako si... | ah-KAW see |
| nice to know you | Kaugmahan ko na mamidbidan ka | kah-oog-MAH-hahn kaw nah mah-meed-BEE-dahn kah |
| nice to know you too | Kaugmahan ko man na mamidbidan ka | kah-oog-MAH-hahn kaw mahn nah mah-meed-BEE-dahn kah |
| How much does this cost? | manggurano ini? | mahng-goo-RAH'-naw ee-NEE? |
| Do you speak English? | Tatao ka mag-Ingles? | tah-tah-AW kah mahg-eeng-GLEHSS |
# C++ Language/Std/Strings/AvoidingBufferOverrun

Some of the original C-Runtime functions were succeptible to a buffer-overrun-hack. For example, strnlen(NULL, 16) would cause a runtime-error.
A safer alternative is available in Win32; strnlen_s(NULL, 16) simply returns 0 without trying to overrun the buffer.
Additional information about avoiding buffer-overrun
# C++ Language/Std/Strings/CStringManipulation

A traditional C "string" is simply an array of char, where the end of the string data is terminated by a '\0' character. That terminating character is relied upon (but not counted) when strlen("abcde") measures that string's length to be 5.
The lexicographical ordering of two C-strings is compared by strcmp.
To copy C-string data to some other char-array buffer, use strcpy (or strcat, which will concatenate by starting at the end of existing data).
Additional information about C-string manipulation functions (includes interactive examples)
# C++ Language/Std/Stl/Iterators/InsertIterators

Algorithm std::copy has already been written by STL to call operators = and ++ on both source and destination iterators (overwriting destination items with data copied from source items). As such, that algorithm assumes the destination collection must already have at least as many items as the source collection.
A std::back_insert_iterator<> "insert-iterator" is intermediary code which allows that same implementation of std::copy to be used with an empty destination collection. That insert-iterator achieves this by re-defining the effect of operators = and ++. Operator = now has the effect of veciDesti.push_back, and operator ++ now does nothing.
Additional information about insert-iterators (includes interactive examples)
# C++ Language/Std/Stl/Iterators/ReverseIterators

Similar to an insert-iterator, a "reverse-iterator" allows you to use STL's existing std::copy algorithm, but changes the effect that it has because of intermediary code that re-defines the iterator's operators. In this case, the result is a "reverse-copy effect".
Additional information about reverse-iterators
# C++ Language/Std/Stl/Iterators/StreamIterators

Like insert-iterators and reverse-iterators, using a "stream-iterator" changes the effect of STL's existing algorithms. In this case, the iterator's = operator gets re-defined to have the effect of std::cout << source << " ";.
Additional information about stream-iterators (includes interactive examples)
# C++ Language/Std/Stl/Iterators/BasicIterators

An iterator is an object that reprsents a position within some collection class: void OutputVector(std::vector<int>& x) { std::vector<int>::iterator piIter; for (piIter = x.begin; piIter != x.end; ++piIter) { int iVar = *piIter; std::cout << iVar; } }
Additional information about basic iterators (includes interactive examples)
# C++ Language/Std/Stl/Iterators/CustomIterators

It is possible to define your own custom iterator, by deriving from std::iterator<>.
Additional information about custom iterators
# C++ Language/Std/Stl/Iterators/Ranges

Often, a client uses parameters to specify a range of items to a STL algorithm. The convention is that the range's beginning is always inclusive, and its ending is always exclusive. To specify a range that involves all items, program as find(veciVar.begin, veciVar.end, 11);
Additional information about ranges of iterators
# C++ Language/Std/Strings

A "string" is a sequence of characters, used to represent text in a C++ program.
* Unicode
* Avoiding Buffer-Overrun
* Character Categories
* C-String Manipulation
* String Class
* Casting Numeric Values
* AliasedStrings
* Regular Expressions
* Locale
# C++ Language/Std/Strings/AliasedStrings

The newer std::string_view class is like std::string, except that its copy-construction does aliasing instead of copying character data.
Additional information about aliased strings
# Cocoa Programming/Status items
## What is a status item?

A status item is an icon that's installed in the menu bar, near the clock and other MacOS common icons, such as Volume, Spotlight, etc. These icons provide a place to keep, for example, important shortcuts for your application, or just an icon that identify the current application status; often they are associated with menus. In this document I'll explain how to build a status item, rather than explain all the class reference which is included with your Xcode, and available on the ADC site.

## Building a status item application

The code
First of all you have to remember that your status item it's a separate application: when you close the application, the status item is deallocated. Generally status items are used to control and monitor a process that the end user doesn't see, or are theirself a controller of something (see "QuickTunes").
We create a new class called "myStatusItem". The status item class is NSStatusItem, you have to instantiate it in your header, together with all you need:
How can you see we have introduced two images which are the main and the alternate icons for our status item, these images are 18x18.
The next step is that of writing the true program, the ".m" file: we have to tell MacOS that we want to install a status item. This is made by this line of code
Next we can allocate the two images with
Then the last lines, customize our status item:
It'd be nice to write also another method, the dealloc method, after the - (void) awakeFromNib, which is the main method called after the application has started. With the dealloc we help the memory management by release some things that we don't need, in fact when this happens, our app has already terminated. With this code we want to release the images that make the icon:
The interface
When we created our application, using the "cocoa application" template, Xcode made also a NIB file, that consist in our program's UI and resources. Double click the NIB for adding the interface. Since we've already written our code and specified some outlets and our classes, we can refresh the NIB standard contents by moving in the Classes view (in the main window of Interface builder) and select "Read files..." from the classes menu; we select our ".h". The myStatusItem class will be selected, right click it and Instantiate. Next drop in the instance view a NSMenu item and name it like you did in the code, in this case "myMenu". You can add NSMenuItem (s) under your menu and add actions to them.
Connecting code and interface
Cocoa uses the outlets to connect code and interface. If you remember we defined an outlet, NSMenu: let's connect it! go to the Instances view and select the "blue box", your app's instance. Open the Inspector and go to the Connections panel. As you can see there's listed "myMenu". Control-drag from the app instance to the NSMenu icon "myMenu" and then hit the "Connect" button. That's all. Now if you press the build and go button you'll see a NSStatusItem in your status bar. (You have to add the two images to your active target in your project).
# Cocos Malay travel phrasebook/Bikol

* EN: Below is a Cocos Malay phrasebook for Bikol speakers.
* BCL: Sa ibaba iyo an Cocos Malay phrasebook para sa mga parataram nin Bikol.
| Bahasa Melayu Cocos | Bikol |
| Hai | Kumusta |
| Selamat datang | Maugmang pag-abot |
| Selamat pagi | Marhay na aga |
| Selamat tenggah hari | Marhay na udto |
| Selamat malam | Marhay na banggi |
| Apa kabar? | Kumusta? |
| Terima kasih | Dios mabalos |
| Jumpa lagi | Sagkod sa giraray |
# Cocoa Programming/Multithreading

Multithreading in Cocoa is just like multithreading in any other *nix application, but there are a couple things you should know.

## Not All Cocoa Objects are Thread-Safe

Mutable objects are pretty much not thread-safe, and you should attempt to avoid them and find an immutable alternative. If none exists, you can use locks to synchronize the access mutable objects across threads.