OpenLLM-France/wikimedia huggingface dataset:
# Acoustics/Threshold of Hearing & Pain

The threshold of hearing is the Sound pressure level SPL of 20 µPa (micropascals) = 2 × 10$^{−5}$ pascal (Pa). This low threshold of amplitude (strength or sound pressure level) is frequency dependent. See the frequency curve in Fig. 2 below
The absolute threshold of hearing (ATH) is the minimum amplitude (level or strength) of a pure tone that the average ear with normal hearing can hear in a noiseless environment.
The threshold of pain is the SPL beyond which sound becomes unbearable for a human listener. This threshold varies only slightly with frequency. Prolonged exposure to sound pressure levels in excess of the threshold of pain can cause physical damage, potentially leading to hearing impairment.
Different values for the threshold of pain:
Threshold of pain :
| SPL | sound pressure |
| 120 dBSPL | 20 Pa |
| 130 dBSPL | 63 Pa |
| 134 dBSPL | 100 Pa |
| 137.5 dBSPL | 150 Pa |
| 140 dBSPL | 200 Pa |
The Threshold of hearing is frequency dependent, and typically shows a minimum (indicating the ear's maximum sensitivity) at frequencies between 1 kHz and 5 kHz. A typical ATH curve is pictured in Fig. 1. The absolute threshold of hearing represents the lowest curve amongst the set of equal-loudness contours, with the highest curve representing the threshold of pain.
In psychoacoustic audio compression, the ATH is used, often in combination with masking curves, to calculate which spectral components are inaudible and may thus be ignored in the coding process; any part of an audio spectrum which has an amplitude (level or strength) below the ATH may be removed from an audio signal without any audible change to the signal.
The ATH curve rises with age as the human ear becomes more insensitive to sound, with the greatest changes occurring at frequencies higher than 2 kHz. Curves for subjects of various age groups are illustrated in Fig. 2. The data is from the United States Occupational Health and Environment Control, Standard Number:1910.95 App F
# Acoustics/formulas/Electro acoustic efficiency

This formula is a template, for inclusion into pages about Acoustics. Use the following syntax to include it:
$\eta \approx 1-{\frac {1}{1+k_{eff}^{2}Q_{E}Q_{L}}}-{\frac {1}{1+{\frac {Q_{m0}}{Q_{L}}}}}$
# Acoustics/formulas/Max efficiency

This formula is a template, for inclusion into pages about Acoustics. Use the following syntax to include it:
$\eta _{\max }=1-{\frac {2}{k_{\mathrm {eff} }{\sqrt {Q_{E}Q_{m0}}}}}\qquad \left(k_{\mathrm {eff} }{\sqrt {Q_{E}Q_{m0}}}\ll 1\right)$
# Bartending/Cocktails/B-50 series

The B-50 series is a series of layered shots including:
* B-51
* B-52
* B-52 with Bombay Doors
* B-53
* B-54
* B-57
# Bartending/Cocktails/B-52

The B-52 is a layered shot which the B-50 series is based on.

## Ingredients

* 1 measures Kahlúa
* 1 measures Baileys Irish Cream
* 1 measures Grand Marnier
Garnish
* none

## Glass

* Pousse-café glass

## Procedure

* Make pousse-café

## Variations

* In a shot glass
** Use half measures
* In a double shot glass
** Use teaspoons of Grand Marnier to fill
* In a rocks glass
** Stir
** Strain into ice-filled glass
* Kahlúa may be replaced with another coffee liqueur
* Baileys Irish Cream may be replaced with another Irish Cream
* Grand Marnier may be replaced with another Curaçao

## Related cocktails

* B-50 series
** B-51
** B-52
** B-52 with Bombay Doors
** B-53
** B-54

## References

* Cross, Robert (1996, 2003). The classic 1000 cocktail recipes. Foulsham. ISBN 0-572-02852-0. {{cite book}}: Check date values in: |date= (help); External link in |publisher= (help)
# Bartending/Cocktails/B-51

The B-51 is a layered shot and part of the B-50 series.

## Ingredients

* 1 part Kahlua
* 1 part Irish Cream
* 1 part rum (traditionally a 151 proof, hence B-51)

#### Garnish

* none

## Glass

* Pousse-café glass

## Procedure

* Make pousse-café

## Related cocktails

* B-50 series
** B-51
** B-52
** B-52 with Bombay Doors
** B-53
** B-54
# Bartending/Cocktails/B-53

The B-53 is a layered shot and part of the B-50 series.

## Ingredients

* 1 part Kahlua
* 1 part Sambuca
* 1 part Grand Marnier

#### Garnish

* none

## Glass

* Pousse-café glass

## Procedure

* Make pousse-café

## Variations

* Replacing Grand Marnier with Triple Sec yields a B-57$^{[Needschecking]}$

## Related cocktails

* B-50 series
** B-51
** B-52
** B-52 with Bombay Doors
** B-53
** B-54
# Bartending/Cocktails/Adios Motherfucker

The Adios Motherfucker (often abbreviated AMF and also known as a "Blue Motorcycle") is a strong "multi-liquor" cocktail, similar and comparable to the Long Island Ice Tea.

### Ingredients

* 1/2 oz. vodka
* 1/2 oz. rum
* 1/2 oz. tequila
* 1/2 oz. gin
* 1/2 oz. blue Curaçao
* 2 oz. of sour mix
* 2 oz. 7-Up or ginger ale

### Garnish

cherry

### Glass

pint glass

### Procedure

* Fill glass with ice,and add the vodka, rum, tequila,blue curacao, and gin.
* Fill up with sour mix.
* Add a splash of 7-up soda.
* Garnish with a cherry and stir.
Reference

### Notes

* The AMF is very similar to the Long Island Iced tea, which uses cola and triple sec instead of the clear soda and Curaçao.
* Many bars that cannot serve doubles consider the AMF (and its cousin, the Long Island), off-limits. They are potent and go down smoothly by virtue of their mild flavor.
# Bartending/Cocktails/Alexander

The Alexander is said to be named after Czar Alexander II of Russia.

## Ingredients

* 1/2 shot Gin or Brandy
* 1/2 shot Heavy cream (or half-and-half)
* 1/2 shot White creme de cacao

## Garnishes

* Nutmeg

## Instructions

* Combine ingredients over ice
* Shake and strain into glass
* Sprinkle nutmeg on top

## Notes

* Do not attempt to combine the Gin and Brandy Alexander into a single drink.

## Related Cocktails

* This drink is an ancestor of a popular modern drink: the White Russian.
# Bartending/Cocktails/American Revolution

The American Revolution is a strong lowball cocktail served on the rocks. It contains gin and bourbon and is meant to mellow as its ice melts. Its alcoholic strength depends upon the specific liquors used. "Standard" proof bourbon and gin (40 proof) produces a "2 unit" cocktail (USA units), while combining two higher-proof liquors, such as Bombay Sapphire and Wild Turkey 101 produces the higher (2.44) unit cocktail.

## Ingredients

* Gin, 1.5 oz
* Bourbon, 1.5 oz
* Bitters, 2 dashes
* Orange peel
Garnishes
* Sour cherries, do not use maraschino if you can get sour cherries.

## Glass

* Old Fashioned glass Old Fashioned Glass

## Procedure

* Muddle orange peel in 1 oz of the gin.
* Add the remainder of the gin, the bourbon, the bitters, and ice to the glass.
* Stir 30 seconds (until aromatics of the liquors are awakened).
* Strain into Old Fashioned glass and fill glass with ice.
* Garnish with sour cherries.

## Variations

* Maraschino cherries can substitute for the sour cherries in desperate circumstances.
* Other citrus peels can substitute for orange, for a sharper flavor.

## Related cocktails

* A Loyalist/Tory is made with dark rum instead of bourbon.
# Bartending/Cocktails/B-52 with Bombay Doors

The B-52 with Bombay Doors is a layered shot and part of the B-50 series.

## Ingredients

* 1 part Coffee Liqueur
* 1 part Irish Cream
* 1 part Grand Marnier
* 1 part Bombay Gin

#### Garnish

* none

## Glass

* Pousse-café glass

## Procedure

* Make pousse-café

## Related cocktails

* B-50 series
** B-51
** B-52
** B-52 with Bombay Doors
** B-53
** B-54
# Bartending/Cocktails/B-54

The B-54 is a layered shot and part of the B-50 series.

## Ingredients

* 1 part Kahlua
* 1 part Irish Cream
* 1 part Grand Marnier
* 1 part Green Crème de Menthe

#### Garnish

* none

## Glass

* Shot glass

## Procedure

* Shake with ice.
* Strain into shot glass.

## Related cocktails

* B-50 series
** B-51
** B-52
** B-52 with Bombay Doors
** B-53
** B-54
# Bartending/Cocktails/B-57

The B-57 is a layered shot and part of the B-50 series.

## Ingredients

* 1 part Kahlua
* 1 part Triple Sec
* 1 part Sambuca

#### Garnish

* none

## Glass

* Pousse-café glass

## Procedure

* Make pousse-café

## Related cocktails

* B-50 series
** B-51
** B-52
** B-52 with Bombay Doors
** B-53
** B-54
** B-57
# Ada Programming/Keywords/delta
## Description

This keyword is used in the declaration of fixed point types. Delta represents the absolute error bound of a fixed point type; that is, delta gives a hint to the compiler how to choose the smallest incremental value of the type, called the Small of the type. This Small value is accessible via the attribute T'Small.
For Ordinary fixed point types, it is by default a power of two not greater than the delta; it is specifyable by an attribute clause to be any value not greater than the delta.
For decimal fixed point types, the Small value is equal to the delta, which of course must be a power of ten.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Keywords

### Ada Reference Manual

* 2.9 Reserved Words (Annotated)
* Annex P (informative) Syntax Summary (Annotated)

### Ada Quality and Style Guide

* 3.1.3 Capitalization
# Ada Programming/Keywords/do

This keyword is used in accept statements.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Keywords

### Ada Reference Manual

* 2.9 Reserved Words (Annotated)
* Annex P (informative) Syntax Summary (Annotated)

### Ada Quality and Style Guide

* 3.1.3 Capitalization
# Ada Programming/Keywords/else

This keyword is used in:
* The 'if' statements
* The or else shortcut operator
* Conditional entry calls in tasks.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Keywords

### Ada Reference Manual

* 2.9 Reserved Words (Annotated)
* Annex P (informative) Syntax Summary (Annotated)

### Ada Quality and Style Guide

* 3.1.3 Capitalization
# Ada Programming/Keywords/entry

This keyword is used to define a rendezvous in the context of tasking.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Keywords

### Ada Reference Manual

* 2.9 Reserved Words (Annotated)
* Annex P (informative) Syntax Summary (Annotated)

### Ada Quality and Style Guide

* 3.1.3 Capitalization
# Ada Programming/Keywords/constant

This keyword is used to declare constant objects and named numbers.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Keywords

### Ada Reference Manual

* 2.9 Reserved Words (Annotated)
* Annex P (informative) Syntax Summary (Annotated)

### Ada Quality and Style Guide

* 3.1.3 Capitalization
# Ada Programming/Keywords/declare

This keyword is used to mark beginning of the declarative part of a block.
The Block_Name is optional.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Keywords

### Ada 95 Reference Manual

* 2.9 Reserved Words (Annotated)
* 5.6 Block Statements (Annotated)
* Annex P (informative) Syntax Summary (Annotated)

### Ada 2005 Reference Manual

* 2.9 Reserved Words (Annotated)
* 5.6 Block Statements (Annotated)
* Annex P (informative) Syntax Summary (Annotated)

### Ada Quality and Style Guide

* 3.1.3 Capitalization
# Ada Programming/Keywords/delay
## Delay statements
### Relative delays

The Ravenscar profile forbids the use of the relative delay statement:
This language feature is only available from Ada 2005 on.

### Absolute delays
## Select statements
### Delay alternative

Selective accept:

### Asynchronous transfer of control
## See also
### Wikibook

* Ada Programming
* Ada Programming/Keywords
* Ada Programming/Tasking
* Ada Programming/Pragmas/Restrictions/No Relative Delay

### Ada Reference Manual

* 2.9 Reserved Words (Annotated)
* Annex P (informative) Syntax Summary (Annotated)
* 9.6 Delay Statements, Duration, and Time (Annotated)
* 9.7 Select Statements (Annotated)
* 9.7.1 Selective Accept (Annotated)
* 9.7.2 Timed Entry Calls (Annotated)
* 9.7.4 Asynchronous Transfer of Control (Annotated)

### Ada Quality and Style Guide

* 3.1.3 Capitalization
* 6.1.7 Delay Statements
# Ada Programming/Keywords/elsif

This keyword is used in 'if' statements.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Keywords

### Ada Reference Manual

* 2.9 Reserved Words (Annotated)
* Annex P (informative) Syntax Summary (Annotated)

### Ada Quality and Style Guide

* 3.1.3 Capitalization
# Ada Programming/Keywords/end

This keyword is used to mark the end of the following constructs:
* Control statements
* Subprogram bodies
* Records
* Package specifications and bodies
* Tasks, protected objects, accept statements and select statements
* Blocks

## See also
### Wikibook

* Ada Programming
* Ada Programming/Keywords

### Ada Reference Manual

* 2.9 Reserved Words (Annotated)
* Annex P (informative) Syntax Summary (Annotated)

### Ada Quality and Style Guide

* 3.1.3 Capitalization
# Ada Programming/Keywords/digits

This keyword is used in the declaration of floating point types and fixed point types.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Keywords

### Ada Reference Manual

* 2.9 Reserved Words (Annotated)
* Annex P (informative) Syntax Summary (Annotated)

### Ada Quality and Style Guide

* 3.1.3 Capitalization
# BlitzMax/Language/Variables

Variables are used to store values that change during the execution of your program.
Variables should be declared in your program before use. Declaring a variable means defining a name and type for the variable and, optionally, an initial value.
The general syntax for declaring a variable is:
       Declaration Identifier : Type = Expression
Multiple variables may be declared in one statement using the comma separator.
If the type of a variable is omitted, the variable defaults to being of type Int. If the initial value expression is omitted, the variable is assigned an initial value of Null.
There are 3 kinds of variable, each of which differs by how and where the variable is stored:

## Local Variables

Local variables are used to store temporary values that will eventually be discarded. Local variables are associated with the block of code they are declared in, and are only visible to code within that block. A block of code is represented by one of the following:
      * The body of a function or loop
      * The body of an if/then/else statement
      * The body of a case or default statement
To declare a local variable, use a Local declaration:
Comment: You should prefer the use of local variables, as they are the fastest to use.

## Global Variables

Global variables are variables that exist for the entire lifetime of a program.
To declare a global variable, use a Global declaration:

## Field Variables

Field variables are declared within user-defined types using a Field declaration:
See the user-defined types section for more on field variables.

## Assigning variables

Once declared, a variable's value may be changed using an assignment statement:
       Variable = Expression
You can also perform 'modifying' assignments, which are shorthand for Variable = Variable Operator Expression. The syntax for modifying assignments is:
| Syntax | Operator |
| :+ | Addition |
| :- | Subtraction |
| :* | Multiplication |
| :/ | Division |
| :Mod | Remainder |
| :& | Bitwise and |
| :| | Bitwise or |
| :~ | Bitwise exclusive or |
| :Shl | Bitwise shift left |
| :Shr | Bitwise shift right |
| :Sar | Arithmetic shift right |
For example, the code my_var:+1 can be used in place of my_var=my_var+1.
# BlitzMax/Language/Slices

Slices are sequences of characters or elements within a string or array.
You can extract slices using the general syntax:
       StringOrArray [ StartIndex .. EndIndex ]
The length of the returned slice is always ( EndIndex - StartIndex ) elements long, even if StartIndex is less than 0 or EndIndex is greater than the length of the string or array. 'Missing' elements are initialized to null in the case of arrays, or the space character in the case of strings.
Either index may be omitted. If StartIndex is omitted, it defaults to 0. If EndIndex is omitted, it defaults to the length of the string or array.
This flexibility allows you to use slices to resize or copy arrays. For example:
# BlitzMax/Language/Strings

Strings are used to store sequences of characters.
Strings are actually objects, so can be used where ever an object is expected. Strings provide the following methods:
| Method | Description |
| Find:Int( subString:String,startIndex=0 ) | Finds first occurrence of a sub string. Returns -1 if subString not found. |
| FindLast:Int( subString:String,startIndex=0 ) | Finds last occurrence of a sub string. Returns -1 if subString not found. |
| Trim:String | Removes leading and trailing non-printable characters from a string. |
| Replace:String( subString:String,withString:String ) | Replaces all occurrences of subString with withString. |
| StartsWith:Int( subString:String ) | Returns true if string starts with subString. |
| EndsWith:Int( subString:String ) | Returns true if string ends with subString. |
| Contains:Int( subString:String ) | Returns true if string contains subString. |
| Join:String( bits:String ) | Joins bits together by inserting this string between each bit. |
| Split:String( separator$ ) | Splits this string into bits delimited by separator. |
| ToLower:String | Converts string to lowercase. |
| ToUpper:String | Converts string to uppercase. |
| ToInt:Int | Converts string to an integer. |
| ToLong:Long | Converts string to a long. |
| ToFloat:Float | Converts string to a float. |
| ToDouble:Double | Converts string to a double. |
| ToCString:Byte Ptr | Converts string to a null terminated sequence of 8 bit bytes. The returned memory must eventually be freed with a call to MemFree. |
| ToWString:Short Ptr | Converts string to a null terminated sequence of 16 bit shorts. The returned memory must eventually be freed with a call to MemFree. |
Strings also provide a read-only length field. Here is an example of using string methods:
String also provide the following functions to help with the creation of strings:
| Function | Description |
| FromInt:String( value:Int ) | Creates a string from an integer. |
| FromLong:String( value:Long ) | Creates a string from a long. |
| FromFloat:String( value:Float ) | Creates a string from a float. |
| FromDouble:String( value:Double) | Creates a string from a double. |
| FromCString:String( cString:Byte Ptr ) | Creates a string from a null terminated sequence of 8 bit bytes. |
| FromWString:String( wString:Short Ptr ) | Creates a string from a null terminated sequence of 16 bit shorts. |
| FromBytes:String( bytes:Byte Ptr,length ) | Creates a string from a sequence of length 8 bit bytes. |
| FromShorts:String( shorts:Short Ptr,length ) | Creates a string from a sequence of length 16 bit shorts. |
To call a string function, use: String.Function - for example:
# BlitzMax/Modules/Audio/DirectSound audio

The DirectSound audio module provides DirectSound drivers for use with the audio module.
# BlitzMax/Modules/Audio/Audio samples

The BlitzMax audiosample module contains commands to create and load audio samples for use with the BlitzMax BRL.Audio module.

# Types
## TAudioSample

Audio sample type
* samples
* length
* hertz
* format
* Copy
* Convert
* Create
* CreateStatic

## TAudioSample: Fields

Field samples:Byte Ptr
Description: Byte pointer to sample data
Field length
Description: Length, in samples, of the sample data
Field hertz
Description: Sample rate
Field format
Description: Sample format

## TAudioSample: Methods

Method Copy:TAudioSample
Description: Copy audio sample
Returns: A new audio sample object
Method Convert:TAudioSample( to_format )
Description: Convert audio sample
Returns: A new audio sample object in the specified format

## TAudioSample: Functions

Function Create:TAudioSample( length,hertz,format )
Description: Create an audio sample
Returns: A new audio sample object
Function CreateStatic:TAudioSample( samples:Byte Ptr,length,hertz,format )
Description: Create a static audio sample
Returns: A new audio sample object that references an existing block of memory

## TAudioSampleLoader

Audio sample loader type
To create your own audio sample loaders, you should extend this type and provide a LoadAudioSample method. To add your audio sample loader to the system, simply create an instance of it using New.
* LoadAudioSample

## TAudioSampleLoader: Methods

Method LoadAudioSample:TAudioSample( stream:TStream )
Description: Load an audio sample
Returns: A new audio sample object, or Null if sample could not be loaded
Information: Extending types must implement this method.

# Functions
## CreateAudioSample

Function CreateAudioSample:TAudioSample( length,hertz,format )
Description: Create an audio sample
Returns: An audio sample object
Information: length is the number of samples to allocate for the sample. hertz is the frequency in samples per second (hz) the audio sample will be played. format should be one of:
| Format | Description |
| &SF_MONO8 | Mono unsigned 8 bit |
| &SF_MONO16LE | Mono signed 16 bit little endian |
| &SF_MONO16BE | Mono signed 16 bit big endian |
| &SF_STEREO8 | Stereo unsigned 8 bit |
| &SF_STEREO16LE | Stereo signed 16 bit little endian |
| &SF_STEREO16BE | Stereo signed 16 bit big endian |
Example:

## CreateStaticAudioSample

Function CreateStaticAudioSample:TAudioSample( samples:Byte Ptr,length,hertz,format )
Description: Create an audio sample with existing data
Returns: An audio sample object that references an existing block of memory
Information: The memory referenced by a static audio sample is not released when the audio sample is deleted.
See CreateAudioSample for possile format values.

## LoadAudioSample

Function LoadAudioSample:TAudioSample( url:Object )
Description: Load an audio sample
Returns: An audio sample object
# BlitzMax/Language/Project Management
## Importing source files

The Import statement provides an efficient way to split your project up into multiple files. The syntax for import is:
       Import Filename
Filename must be a quote enclosed string literal with a recognized source file extension such as 'bmx'.
Importing a file makes all the globals, consts, functions and user defined types declared in that file available to the file being currently compiled.
Imported files can be precompiled. This means that if you have a project split into multiple source files, only the files that are actually modified (and files those modifications affect) need to be recompiled. For example, say you have a project split into 2 source files:
If file2.bmx is then modified, both files need to be recompiled because not only has file2.bmx changed, but its changes may also affect file1.bmx.
However, if only file1.bmx is modified there is no need to recompile file2.bmx. BlitzMax's BMK]] utility takes care of all this for you.
One important limitation of Import is that you cannot create 'cycles' of imports.

## Including source files

Include is another way to split a project up into multiple files. The syntax for Include is the same as that for Import, however the included file is simply inserted 'verbatim' into the including file, instead of being separately compiled.
Depending on the platform and project, Include may be faster than Import. It also allows you to get around the 'no cycles' restriction of Import.

## Including binary files

The Incbin statement allows you to include binary files with your programs. The syntax for Incbin is the same as that for Import, however any kind of file may be specified, not just 'bmx' files.
You can access the binary data contained in an incbined file using IncbinPtr (which returns a Byte Ptr) and IncbinLen (which returns an Int). Both IncbinPtr and IncbinLen require a filename parameter. For example: