OpenLLM-France/wikimedia huggingface dataset:
# Bartending/Cocktails/Jarabacoa Cocktail

A Jarabacoa is a cocktail made with spiced rum, honey, lime juice, vanilla, cinnamon, and cola. Jarabacoas are usually served in a cocktail glass or lowball.

## Recipe

* Mix 6 parts rum, 1 part honey, and 1 part lime juice; heat until honey dissolves.
* Allow mix to cool.
* Pour 1 part mix and 1 part cola and a few drops of vanilla extract over ice into martini shaker, shake very gently.
* Pour into cocktail glass and garnish with a bit of cinnamon.

## History

The history of the Jarabacoa cocktail is unknown, it is named after a municipality in the Dominican Republic. It is speculated that the term was coined by a traveller upon returning from a stay in Jarabacoa.
# Bartending/Cocktails/Glossary/Q

This page lists the cocktail recipes beginning with the letter "Q" contained within the Wikibooks Bartending Guide. Since this is a manually edited list, you also might want to check the automated category listing for new entries not yet added to this list.

### QF

* Kahlúa
* Irish Cream
* Midori

### Queen Mary

* glass of beer
* grenadine (to taste)
* garnished with maraschino cherries
Notes:
* Named after Queen Mary of Teck, Queen Consort to King George V of the United Kingdom and the British Dominions.
* A popular alternative to a Shandy, this beer cocktail finds its origin in Calgary, Canada.
# Bartending/Cocktails/Godfather

Godfather is a cocktail made in tiki glass, very fashionable and a little bit sweet but strong to blow your mind.
Ingredients:
* 5cl rum
* 5cl tequila
* 5cl pineapple juice
* 2.5cl lemon juice
* 2.5cl melon vert
Procedure:
* Pour all cocktail in a shaker and shake with ice.
* Serve in a tiki glass
* Garnish with pineapple
# Bartending/Cocktails/Greyhound

The Greyhound is a Highball drink made with Vodka and Grapefruit Juice. The "traditional" method for making a highball is;
Fill the highball glass completely with ice. Then add;
1 oz. Vodka
2 oz. Grapefruit Juice
Add a sip stick. No garnishment is needed.
# Bartending/Cocktails/Haterade

Hater-ade
* 1 oz vodka
* 1 oz SoBe energy drink
* 3 oz Gatorade
Place ice cubes in glass, pour liquor over ice cubes, combine with SoBe energy drink and Gatorade in any order. Drink cold.
# Bartending/Cocktails/Lady Killer

Recipe for a Lady Killer.
* 3/10 Pineapple juice
* 3/10 Passion fruit juice
* 1/10 Apricot brandy
* 1/10 Cointreau
* 2/10 Gin Burnett
* Garnish with green Mirabeau, sprig of mint and orange peel.
# Biblical Studies/Christianity/Protestant churches/Lutheran

Lutheran teaching can be summarized with the three Reformation solas. Salvation is by God's grace alone (sola gratia) through faith alone (sola fide) for the sake of Jesus Christ's atoning death and without any merit on the part of those who are redeemed. The Bible alone (sola Scriptura) is the sole norm and basis of all Christian doctrine and anything which is contrary to what Scripture teaches is not in accordance with God's Will
Historically, Lutherans trace themselves to Martin Luther, who was the founder of the Protestant Reformation. In order to preserve the legacy and teaching of the Reformation, a group of pastors and theologians in Germany (where Luther lived) gathered together the three ecumenical creeds as well as the key works of Martin Luther and Philip Melanchthon into the Lutheran Confessions (also known as the Book of Concord). The Book of Concord is recognized as a faithful and true interpretation of the Bible and it is the symbol and body of doctrine for the Lutheran faith. Contained in the Book of Concord are the Nicene Creed, Apostles Creed, Athanasian Creed, the unaltered Augsburg Confession, the Apology to the Augsburg Confession, the Smalcald Articles, the Treatise on the Power and Primacy of the Pope, Luther's Small Catechism, w:Luther's Large Catechism and the Formula of Concord, all of which describe the doctrine and faith of the Lutheran Church.

## External references

* Book of Concord e-text
* Project Wittenberg, a repository of Public Domain and freely available Lutheranism related works
# Biblical Studies/Christianity/Roman Catholicism
#### Introduction and Statistics

The name "Roman Catholicism" denotes the beliefs of those Christians who are in communion with the Pope who, as the successor of St Peter as Bishop of Rome, has primacy among all the bishops. Such Christians may be termed "Roman Catholics" or simply "Catholics". Historically speaking, the word "Catholic" has always been applied to the Church (it means "universal") and "Roman" goes before it to emphasise both the primacy of the Pope and continuity with the teachings of Jesus Christ and his apostles.
According to the 2006 Annuario Pontificio, the official yearbook of the Vatican, the membership of the Catholic Church was approximately 1,098,000,000 in 2004. There were 405,891 priests, 32,324 permanent deacons, and 113,044 seminarians when the data was compiled .
Include statistics of cardinals, bishops, episcopal sees, religious, parishes.
Hierarchy of the Catholic Church
Doctrines
Sacraments
Moral Teachings and Requirements
Prayers and Sacramentals
Liturgies of the Church, the Mass, and articles appropriate to the Mass
History of the Catholic Church and Biographies of the Saints
Other Topics
# Biblical Studies/Christianity/Protestant churches
## Historical Background

* The Reformation

## Representative Protestant Denominations

* Anabaptist and Baptist
* Anglican/Episcopalian
* Calvinist/Reformed and Presbyterian
* Ethiopian–Eritrean Evangelicalism
* Lutheran
* Methodist/Wesleyan and the Holiness movement
* Pentecostal and Charismatic
* Quakers
* Restoration movement/Church of Christ
* Salvation Army
* Seventh-day Adventist
* United/Uniting
* Other Denominations
* Non-Denominational
# A-level Mathematics/OCR/C2/Integration/Problems
## Example problems

1. Evaluate these indefinite integrals:
(a) $\int 2x^{5}\,dx$
(b)$\int 7x^{6}+2x^{3}-x^{2}\,dx$
2. Find the equation of the curve in each of the following cases:
(a) Given ${\frac {dy}{dx}}=x+5$ and that the point $(0,3)$ lies on the curve.
(b) Given ${\frac {dy}{dx}}=3x^{2}+7x+0.1$ and that the point $(2,2)$ lies on the curve.
3. Evaluate these definite integrals
(a)$\int _{0}^{2}x+1\,dx$
(b)$\int _{-3}^{4.7}{\frac {1}{7}}x^{\frac {1}{3}}+1\,dx$
4. Find the area between the curve of $y=-x^{4}-{\frac {1}{2}}x^{3}+3x^{2}$ and the x-axis from $x=-2$ to $x=0$.
Worked solutions can be found here: Integration problem solutions
# A-level Mathematics/OCR/C2/Integration/Solutions
## Worked Solutions

1a)
    $\int 2x^{5}\,dx$
    Using our rule: That $\int {\frac {dy}{dx}}=x^{n}dx$ is equal to $y={\frac {x^{(n+1)}}{(n+1)}}+C$
    We get:
    $y={\frac {2x^{6}}{6}}+C$
b)
    $\int 7x^{6}+2x^{3}-x^{2}\,dx$
    Again using our rule, we would get:
    $y=x^{7}+{\frac {x^{4}}{2}}-{\frac {x^{3}}{3}}+C$
2a)
    $\int x+5\,dx$ given that the point $(0,3)$ lies on the curve.
    Using our rule, the integral becomes
    $y={\frac {x^{2}}{2}}+5x+C$
    Now we can sub in our points $(0,3)$, So that:
    $3={\frac {0^{2}}{2}}+5(0)+C$
    Therefore C = 3
b)
    $\int 3x^{2}+7x+0.1\,dx$
    Evaulating this we get: $x^{3}+{\frac {7x^{2}}{2}}+0.1x+C$
    Given (2,2), subing these points in:
    $2=2^{3}+{\frac {7(2^{2})}{2}}+0.2+C$
    $2=8+14+0.2+C$
    $C=-20.2$
3a)
    $\int _{0}^{2}x+1\,dx$
    Evaluating this we get:
    ${\Bigg \lfloor }{\frac {x^{2}}{2}}+x{\Bigg \rceil }_{0}^{2}$
    Substituting in values we get:
    ${\Bigg \lfloor }\left({\frac {2^{2}}{2}}+2\right)-\left({\frac {0^{2}}{2}}+0\right){\Bigg \rceil }$
    $=4$
b)
    $\int _{-3}^{4.7}{\frac {1}{7}}x^{\frac {1}{3}}+1\,dx$
    Evaluating this we get:
    ${\Bigg \lfloor }{\frac {3x^{\frac {4}{3}}}{28}}+x{\Bigg \rceil }_{-3}^{4.7}$
    ${\Bigg \lfloor }\left({\frac {3(4.7)^{\frac {4}{3}}}{28}}+4.7\right)-\left({\frac {3(-3)^{\frac {4}{3}}}{28}}-3\right){\Bigg \rceil }$
    $\approx 8.08$
4)
    The question is simply to evaluate this definite integral:
    ${\begin{aligned}\int _{-2}^{0}{\biggy=-x^{4}-{\frac {1}{2}}x^{3}+3x^{2}{\bigg )}\,dx&={\Bigg \lfloor }\left({\frac {-1}{5}}x^{5}-{\frac {1}{8}}x^{4}+x^{3}\right){\Bigg \rceil }_{-2}^{0}\\&=-{\bigg{\frac {-1}{5}}*-2^{5}-{\frac {1}{8}}*-2^{4}-2^{3}{\bigg )}\\&=3.6\end{aligned}}$
# A-level Mathematics/OCR/C3

This is the Core Mathematics 3 module of the A-level Mathematics book. This module assumes that you are familiar with the C1 and C2 modules. Please post all questions to A-level Mathematics/Discussion.

## Contents

* Algebraic Functions
* Special Functions and Transformations
* More Trigonometric Functions and Identities
* Differentiation
* Integration
* Numerical Methods
* Appendix A: Formulae
# BlitzMax/Language/Modules

A module is a precompiled collection of constants, globals, functions and user defined types, that may be used by applications or other modules.

## Creating modules

Modules live in the 'mod' directory within the main BlitzMax directory. To create your own module, you must add a new subdirectory to 'mod' with the following format:
Modscope should be a unique name (for example, the name of your organization or company) and is used to group together modules provided by a common source. Both modscope and modname should be valid identifiers. Also, to prevent issues with case sensitive filesystems such as Linux's, it is recommended that modscope and modname be lowercase.
You will also need to create a main module source file inside the module directory. This file must have the same name as ModuleName:
Finally, your source file must include a Module statement at the top:
Once your module is setup, BMK can be used to build it:
Or, to build all modules in the same scope:

## Using modules within modules

To use a module within another module, you simply import it with the Import command:
This will import both the specified module and any modules imported by that module. In other words, Import is recursive.

## Using modules within applications

By default, BlitzMax imports every module it finds in the 'brl' and 'pub' module scopes when compiling applications. However, this can result in bulky executables. You can override this default behaviour by using the Framework command:
       Framework modscope.modname
Framework should appear at the top of your main application source file.
Specifying an application framework prevents BlitzMax from importing every module under the sun. Only the framework module and any explicitly imported modules are imported into your application.
For example, to create a 'stripped down' BASIC application, you can use the BRL.Basic framework:
When a building a multifile application, the framework (if any) found in the main source file is automatically passed to all 'child' files in the application. However, if you change this 'default' framework, you will need to 'rebuild all' for the change to affect other files.
# BlitzMax/Language/Interfacing with C

You can use the Import command to add certain non-BlitzMax source files to your projects, and the Extern command to make the functions in those files available to BlitzMax applications.
The currently supported non-BlitzMax source file types are: .c (C); .cpp (C++); .cxx (C++); .m (ObjectiveC); and .s (Assembler).
BlitzMax will use the GNU compiler tools to compile C, C++ and ObjectiveC files, and either the 'fasm' assembler for x86 assembly or GNU assembler for PowerPC assembly.
Here is a simple example of importing C source code into your project and accessing a C function:
You can also use Import to add a C compiler 'include' directory. To do this, use an import path that ends in "*.h", for example:
Extern can also be used to work with C++ style objects from within BlitzMax. To do this, simply place a user-defined type declaration within an extern block. For example:
Note that there are several limits on the use of extern types:
      * Methods declared in an extern type must be declared virtual in the C++ class.
      * Objects of extern type cannot be created with New. Instead, such objects must be created by an extern function.
      * Extern types can extend other extern types, but can not extend standard BlitzMax types. Similarly, BlitzMax types can not extend extern types.
      * Objects of extern type cannot be cast to 'Object'.
# BlitzMax/Language/Literals

Literals are simple numeric or string values.

## Integer literals

Integer literals may be in either decimal, hexadecimal or binary format. To specify a hexadecimal literal, prepend it with the @$ character. To specify a binary literal, prepend it with the % character. Here are some examples of integer literals:

## Floating point literals

Floating point literals are numeric values with a fractional part. The fractional part is specified using a decimal point. Floating point literals may also be extended using 'e notation'. For example:

## String literals

A string literal is a sequence of characters enclosed in quotation marks. For example:
String literals can also contain escape sequences. An escape sequence is a special sequence of characters used to represent another character. This is useful for including 'untypable' characters and quotation marks in strings. Escape sequences always start with the ~ character. The following escape sequences are supported:
| Escape sequence | Equivalent character |
| ~0 | Null character (ascii code 0) |
| ~t | Tab character (ascii code 9) |
| ~r | Return character (ascii code 13) |
| ~n | Newline character (ascii code 10) |
| ~q | Quote character (ascii code 34) |
| ~~ | Tilde character (ascii code 126) |
For example:
The type of a literal may also be modified by appending @:TypeName to the literal. For example:
# BlitzMax/Language/Exceptions

BlitzMax provides a mechanism for handling runtime errors known as exception handling
An exception is actually just an object. You can throw and catch exceptions using the Throw command and a Try / Catch block. Here is a simple example:
Throwing an exception causes the program to jump to the most recent Catch block. You can provide multiple catch blocks for catching exceptions of different types. If there is no appropriate Catch block for the exception, then the program jumps to the next most recent Catch block. If no catch block can be found to deal with the exception, the program will end.
BlitzMax has several built-in exception types, all of which extend type TBlitzException. These are:
| Exception | Cause |
| TNullMethodException | Thrown when a program attempts to call an abstract method. |
| TNullFunctionException | Thrown when a program attempts to call a null function. |
| TNullObjectException | Thrown when a program attempts to access a null object (only thrown in debug mode). |
| TArrayBoundsException | Thrown when a program attempts to access an array element outside of an array's bounds (only thrown in debug mode). |
| TRuntimeException | Thrown by the RuntimeError or Assert commands. |
# BlitzMax/Language/Memory Management

BlitzMax currently uses an optimized form of reference counting to implement memory management.
However, there is one situation where you need to be a bit careful about memory management and that is when you are dealing with cyclic data structures.
A cyclic data structure is a data structure (in BlitzMax, a user defined type) that can potentially 'point to itself'. The most extreme example of a cyclic data structure is something like:
If you run this program, you will notice that memory is slowly leaking. This is happening because the reference count for each TCyclic object never reaches 0, thanks to the objects 'cyclic' field.
It is therefore necessary to ensure such cyclic data structures are cleanly handled. This can be achieved by adding a method to 'unlink' any such cycles. For example:
In real-world use this problem seldom arises, and when it does it's typically when designing container types.
If you are at all worried about this, you can easily track memory usage with the GCMemAlloced function from the BlitzMax runtime library.
# BlitzMax/Language/Pointers

BlitzMax supports 'C' style pointers for use by code that must perform low level interaction with the operating system and/or speed sensitive code.
Pointers are not recommended for general use, as misuse of pointers can easily result in memory corruption causing all sorts of bugs and headaches!
Pointers may be declared by appending Ptr to the type of a variable or function declaration. For example:
Note the pointers are only supported for the primitive numeric types: Byte, Short, Int, Long, Float and Double.
The Varptr operator allows you to find the address of a variable, yielding a pointer. For example:
Array style indexing is used to dereference pointers:
BlitzMax will automatically convert any pointer type to a byte pointer for you. In addition, objects and arrays may be assigned to byte pointers. In the case of objects, the pointer will contain the address of the first field of the object. In the case of arrays, the pointer will contain the address of the first element of the array.
Be very careful when assigning objects to pointers, as there is a danger that the garbage collector will 'reclaim' the object before you have finished with the pointer! It is recommended that you use GCSuspend and GCResume around code that converts objects to pointers.
You may also explicitly cast pointers to and from other pointers, and to and from Int. For example:
Comment: BlitzMax also supports pointer arithmetic, using the standard + and - operators.
# BlitzMax/Language/Identifiers

Identifiers are used to name constants, variables, functions and user defined types.
Identifiers start with a letter or underscore and can be followed by any combination of letters, digits or underscores. For example, the following are all valid identifiers:
Identifiers in BlitzMax are case-insensitive. This means that the identifiers hello, Hello and HELLO are all treated as the same identifier.
The following identifiers are reserved for use by the BlitzMax language, and can not be used as general purpose identifiers:
# BlitzMax/Language/Functions

A function is a self contained block of code that can be called from multiple points in your program.
Functions are declared using the syntax:
       Function Identifier : ReturnType ( Parameters )
       Function statements...
       End Function
If ReturnType is omitted, the function defaults to returning an Int.
Parameters is a comma separated list of parameters for the function. The syntax of each parameter is similar to a variable declaration: Identifier : Type. Function parameters may be used inside a function in the same way as local variables.
The Return statement is used to return a value from a function.
Here is an example of a simple function that adds 2 integers and returns their sum:
This function can then be called by other code:
Function parameters can be assigned constant 'default values' using syntax similar to initializing a variable: Identifier : Type = ConstantExpression.
Default parameters can then be optionally omitted when the function is called:
# C++ Language/Templates/Traits/BinaryPredicateTraits

Predicate trait std::is_same<int,__int32>::value tests those two types for equality (__int32 is a platform-specific type on Win32 that is the same as int).
Additional information about binary predicate traits
# C++ Language/Templates/Traits/BinaryTransformTraits

Transform trait std::common_type<TLHS,TRHS>::type provides the coercion-result of a mixed-type-operation.
Additional information about binary transform traits
# C++ Language/Templates/Traits/SfinaeConditionalCompilation

Modern C++ compilers follow the "Substitution Failure is not an Error" (S.F.I.N.A.E.) principle, whereby the compiler silently eliminates a failed specialization from consideration, without that generating a compilation-error.
Additional information about the S.F.I.N.A.E. principle (includes interactive examples)
# C++ Language/Templates/TemplatedFunctions

A templated-function looks like any ordinary function, but with "template-parameter" placeholders for some types: template<typename T> T ComputeMin(T x, T y) { return (x < y) ? x : y; }. No compilation happens here where this templated-function is being defined; instead, this ComputeMin<> will get compiled (with "specialization" T=int applied) during the first occurrence of that usage, as in int iResult = ComputeMin<int>(3,4);. In this case, you could have simply written int iResult = ComputeMin(3,4);, since the compiler could infer T=int from those parameter types.
Additional information about templated-functions (includes interactive examples)
# C++ Language/Templates/TemplatedVariables

Modern C++ can also use template syntax with any global variable (defined outside all functions). Each template-specialization will behave like a separate variable.
Additional information about templated-variables (includes interactive examples)
# C++ Language/Templates/Traits

A "trait" is information about some type, which is available to the compiler at compile-time (because it is expressed either as a static-data-member or as a type alias). Traits are often used to guide the decision-making within template-metaprogramming.
* Unary Predicate Traits
* Binary Predicate Traits
* Array Traits
* Unary Transform Traits
* Binary Transform Traits
* S.F.I.N.A.E. Conditional-Compilation
# C++ Language/Templates/TemplateParameters/DefaultTemplateParameters

A template-parameter may have a default. That default may be defined in terms of a previous template-parameter: template<typename T0, typename T1 = CRA<T0> > class CRB {...};.
Additional information about default template-parameters
# C++ Language/Templates/TemplateParameters/VariableNumberOfTemplateParameters

A "variadic template" has been programmed to specialize a variable number of template-parameters: template<typename T0, typename... TN>.
Additional information about variadic templates (includes interactive examples)
# C++ Language/Templates/Traits/ArrayTraits

At compile-time, std::rank<int[8][8]>::value resolves to 3, and std::extent<int[3][4], 1>::value resolves to 4.
Additional information about array traits (includes interactive examples)
# C++ Language/Templates/TemplatedClasses

If a class is written as a template, then all of its members share that common abstraction, and are collectively specialized together.
Additional information about templated-classes
# Ada Programming/Attributes/'Relative Deadline
## Description

Relative deadline of P.
Denotes a non-aliased component of the protected object P. This component is of type Ada.Real_Time.Time_Span and its value is the relative deadline of P. P'Relative_Deadline denotes a variable if and only if P denotes a variable. A reference to this attribute shall appear only within the body of P.