OpenLLM-France/wikimedia huggingface dataset:
# Ada Programming/Attributes/'Enabled
## Description

The Enabled attribute allows an application program to check at compile time to see if the designated check is currently enabled. The prefix is a simple identifier, referencing any predefined check name (other than All_Checks) or a check name introduced by pragma Check_Name. If no argument is given for the attribute, the check is for the general state of the check, if an argument is given, then it is an entity name, and the check indicates whether an Suppress or Unsuppress has been given naming the entity (if not, then the argument is ignored).
Note that instantiations inherit the check status at the point of the instantiation, so a useful idiom is to have a library package that introduces a check name with pragma Check_Name, and then contains generic packages or subprograms which use the Enabled attribute to see if the check is enabled. A user of this package can then issue a pragma Suppress or pragma Unsuppress before instantiating the package or subprogram, controlling whether the check will be present.
# Ada Programming/Attributes/'Extended Base
## Description

For a type T returns the base type of T. This attribute is allowed only as the prefix of the name of another attribute. (This is the old Ada83 'BASE attribute.)
# Ada Programming/Attributes/'Enum Val

This language feature has been introduced in Ada 2022.

## Description

Return the enumeration literal represented by a given number.
For every enumeration subtype S, S'Enum_Val denotes a function with the following spec:
The function returns the enumeration value whose representation matches the argument, or raises Constraint_Error if no enumeration literal of the type has the matching value. This will be equal to the value of the Val attribute in the absence of an enumeration representation clause. This is a static attribute (i.e., the result is static if the argument is static).

## See also
### Wikibook

* Ada Programming
* Ada Programming/Attributes
* Ada Programming/Attributes/'Enum_Rep

### Ada Reference Manual

* 13.4: Enumeration Representation Clauses
* Annex K: Language-Defined Attributes

### Ada 2022 Overview

* 7.13 Getting the representation of an enumeration value

### External links

GNAT Reference Manual > Implementation Defined Attributes > Enum_Val
# Ada Programming/Attributes/'Exponent
## Description

Returns normalized exponent of the floating point argument.
For every subtype S of a floating point type T:
S'Exponent denotes a function with the following specification:
The function yields the normalized exponent of X.
# Ada Programming/Attributes/'Enum Rep
## Description

This language feature has been introduced in Ada 2022. User_Enum_Type'Enum_Rep(Instance); where User_Enum_Type is an enumeration type and Instance is an instance of that type will return the underlying representation for that instance of the enumeration. The default representation of an enumeration is based on its position (starting at zero). However, Ada does provide language facilities for specifying the representation independently of the position. The Enum_Rep allows you to retrieve that representation. Generally in Ada, enumerations are their own type and the representation is not important. However, in the interests of cross language compatibility and for possible use in embedded programming the representation can be manipulated. While the core language allows you to change the representation, it doesn't provide a convenient attribute for retrieving it. This extended attribute addresses that need. Using it does require that you know the underlying type used to support the enumeration, since Enum_Rep returns that type. Typically, the standard type Integer is sufficient.
Note that this attribute is now standard in Ada 2022. In earlier Ada versions, it is available in GNAT as an implementation defined attribute, but the standard and portable way to get the internal representation was using an instantiation of Unchecked_Conversion.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Attributes
* Ada Programming/Attributes/'Enum_Val

### Ada Reference Manual

* 13.4: Enumeration Representation Clauses
* Annex K: Language-Defined Attributes

### Ada 2022 Overview

* 7.13 Getting the representation of an enumeration value

### External links

GNAT Reference Manual > Implementation Defined Attributes > Enum_Rep
# Ada Programming/Attributes/'Extended Aft
## Description

Returns the minimum number of characters required for the fractional part of the representation of the fixed point subtype T. All parameters are optional. They are:

### Base : Number_Base := 10

    the base in which the digits will be represented.

### Based : Boolean := FALSE

    if TRUE, compute the width of the based format (e.g.,10#99.0#).
# Ada Programming/Attributes/'Elab Subp Body
## Description

This attribute can only be applied to a library level subprogram name and is only allowed in CodePeer mode. It returns the entity for the corresponding elaboration procedure for elaborating the body of the referenced subprogram unit. This is used in the main generated elaboration procedure by the binder in CodePeer mode only and is unrecognized otherwise.
# Ada Programming/Attributes/'Emax
## Description

The Emax attribute is provided for compatibility with Ada 83. See the Ada 83 reference manual for an exact description of the semantics of this attribute.
# A-level Mathematics/OCR/C4

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

## Contents

* Algebra and Graphs
* Advanced Differentiation
* Advanced Integration
* First Order Differential Equations
* Introduction to Vectors
* Formulae
# A-level Mathematics/OCR/C4/Advanced Integration
## Integration Involving Linear Substitution

Integrating a function with a linear substitution is the same as performing the chain rule in reverse. In Core four we formalize the knowledge that we learned in core three. Yet the procedure that we learn in core three is the same in core 4. In order to integrate the function $\int f^{'}[g(x)].g^{'}(x)\,dx=f[g(x)]+c$.

### Example

Integrate 12cos(12x + 9).
* g(x) = 12x + 9 and ${\frac {dg(x)}{dx}}=12$
* sin(12x+9) + C

## Integration by Parts

Integration by parts does not actually solve the problem as the method of substitution does, instead it changes the function into something that is (hopefully) easier to integrate, either by substitution or otherwise.
Consider the product rule:
${\frac {dy}{dx}}=v{\frac {du}{dx}}+u{\frac {dv}{dx}}$
Integrating this rule gives:
$\int {\frac {dy}{dx}}\,dx=\int v{\frac {du}{dx}}\,dx+\int u{\frac {dv}{dx}}\,dx$
$\Rightarrow \int {\frac {dy}{dx}}\,dx-\int v{\frac {du}{dx}}\,dx=\int u{\frac {dv}{dx}}\,dx$
$\Rightarrow \int u{\frac {dv}{dx}}\,dx=uv-\int v{\frac {du}{dx}}\,dx$
The function we need to integrate has now changed from $u{\tfrac {dv}{dx}}$ to $v{\tfrac {du}{dx}}$

### Examples

Integrate $xe^{x}$ with respect to $x$
* $u=x\Rightarrow {\tfrac {du}{dx}}=1$
* ${\tfrac {dv}{dx}}=e^{x}\Rightarrow v=e^{x}$
* $\int xe^{x}\,dx=xe^{x}-\int 1\cdot e^{x}\,dx$
* $=xe^{x}-e^{x}+c\,\!$
* $=(x-1)e^{x}+c\,\!$
Another more complex example:
Integrate $x^{2}e^{x}$ with respect to $x$
* $u=x^{2}\Rightarrow {\frac {du}{dx}}=2x$
* ${\frac {dv}{dx}}=e^{x}\Rightarrow v=e^{x}$
* $\int x^{2}e^{x}\,dx=x^{2}e^{x}-\int 2x\cdot e^{x}\,dx$
* Now we can use integration by parts again on $\int 2x\cdot e^{x}\,dx$:
* $u=2x\Rightarrow {\frac {du}{dx}}=2$
* ${\frac {dv}{dx}}=e^{x}\Rightarrow v=e^{x}$
* $x^{2}e^{x}-\int 2x\cdot e^{x}\,dx=x^{2}e^{x}-(2xe^{x}-\int 2e^{x}\,dx)$
* $=x^{2}e^{x}-2xe^{x}+2e^{x}+c\,\!$
* $=e^{x}(x^{2}-2x+2)+c\,\!$
# A-level Mathematics/OCR/D1

Please post all questions to A-level Mathematics/Discussion.

## Contents

* Algorithms
* Node Graphs
* Linear Programming
# A-level Mathematics/OCR/C4/Introduction to Vectors
## Vectors as directions

Vectors symbolise directions in a space. In a coordinate system with an x and y axis, the direction from a point (x1,y1) to (x2,y2)can be represented as a vector, eg V.
In other words, to move from point from (x1,y1) to (x2,y2) would be to move in the direction of vector V
Vectors are written as column brackets, where the top row is the number of units to move in the x direction, and the bottom row is the number of units to move in the y direction. This leads to their use in describing translations, direction, movements etc, which is where many people first meet vectors.

## Position Vectors of Points

The direction from the origin (0,0) to a point (x1,y1) can be expressed as a vector, e.g., W. This is called the position vector of the point.
If a point lies on the line from (0,0) to (x1,y1) its position vector is equal to some scalar multiple of the vector. If it were halfway from the origin to (x1,y1) its position vector would be 1/2W

## Finding directions between points using their position vectors

This is best illustrated with an example: Point A has coordinates (xa,ya). We can say it has position vector a. Point B has coordinates (xb,yb). We can say it has position vector b.
Beginning at A, how can we find a journey using only a and b that goes between A and B?
Recall that a represents the direction from A to the origin. Similarly with b. So we could go the 'long way around' - journeying from A to B via the origin. The net result would be the same - we'd start at A and end at B.
    If A is in the direction a from (0,0), the (0,0) is the opposition direction from A - i.e. -a.
So we journey backwards along a to the origin, then forwards along b to our destination B.
    Our result is -a + b or b-a
To add or subtract vectors add their components line by line.
This is true for all pairs of points and is pretty useful when we start to solve problems with vectors. Of course, a diagram is often helpful to visualise things!

## In Three Dimensions & beyond

Of course, most of the world around us is 3D. But all the arguments of above remain true - we just define a z axis, give points a z coordinate, and include a z component in our vectors. Similarly for higher dimensional spaces - more axis, more ordinates, more components in our vectors. But in UK A Level courses you'll only have to worry about 3 dimensions.
# A-level Mathematics/OCR/C4/Formulae
## Formulae

By the end of this module you will be expected to have learnt the following formulae:

### Differentiation

    If $y=\sin kx,\,$ then ${\frac {dy}{dx}}=k\cos kx$.
    If $y=\cos kx,\,$ then ${\frac {dy}{dx}}=-k\sin kx$.

### Integration

    $\int \cos kx\,dx={\frac {1}{k}}\sin kx+c$
    $\int \sin kx\,dx=-{\frac {1}{k}}\cos kx+c$
    $\int f^{'}[g(x)].g^{'}(x)\,dx=f[g(x)]+c$

### Vectors

    $\left|x\mathbf {i} +y\mathbf {j} +z\mathbf {k} \right|={\sqrt {x^{2}+y^{2}+z^{2}}}$
    $(a\mathbf {i} +b\mathbf {j} +c\mathbf {k} )\cdot (x\mathbf {i} +y\mathbf {j} +z\mathbf {k} )=ax+by+cz$
    $\mathbf {a} \cdot \mathbf {b} =\left|\mathbf {a} \right|\left|\mathbf {b} \right|\cos \theta$
    The vector equation of a line through point $\mathbf {a}$ with direction $\mathbf {b}$ is $\mathbf {r} =\mathbf {a} +t\mathbf {b}$
# An Introduction to Python For Undergraduate Engineers
## Authors

Matthew Johnson
Dut Andrew Kulang

## Getting Started

* What Is This Wikibook About?
* Installing Python
* Running Python
* Getting Started

## Lessons

* Python as a Calculator
* Numeric Data Types
* Getting Inputs
* Reading/Writing to Files

## Conditional Programming

* If/Else
* For Loops
* While Loops
* Boolean Logic

## Functions

* Functions

## Mathematics In Python

There are two main additional modules that enable us to use Python as a very sophisticated environment for dealing with algebra and numerical problems, these are the built in 'math' module and an additional module 'sympy', which can be downloaded from the internet (see the 'Getting Additional Modules' section at the end).
Remember that to use a module we must first import it using the import command, for example:
* Symbolic Algebra
* Differentiation
* Integration
* Matrices

## Getting Additional Modules

EasyGui Sympy

## Recommended Reading
### Wikibooks

* Non-Programmer's Tutorial for Python 2.6
* Non-Programmer's Tutorial for Python 3

### Textbooks

Computer Science: The Python Programming Language, Miller & Ranum, Jones & Bartlett Publishers, ISBN 0-7637-4316-X
This is a good, quick way to get into the basics, but won't really give you much more detail than this wiki.
Python Programming: An Introduction to Computer Science, John Zelle, Franklin Beedle & Associates, ISBN 1-887902-99-6
This is a more thorough book that covers more detail, however it is written as a way of learning computer science using Python as a starting language and so may not directly relate to programming in engineering. Nevertheless if software design is closer to your interests/needs then this might be the book for you.

## References

The following references have helped the author(s) to learn python and are recommended for study if you wish to pursue python further. This wikibook is intended only as a short course to get you started with python. There is much more you can learn and a great deal more that you can do with it! Good luck!
http://www.python.org/
# An Introduction to Python For Undergraduate Engineers/For Loops

For loops give you a way to repeatedly do something. This can be either a set number of times, or to repeat a part of your program several times, but each time with a different value of a variable each time.
This will continually loop around, printing the value of i each time. This is a good time to quickly introduce you to two things, list and the range command. As you have seen in the example, we can produce a list by using square brackets containing the values of our list, each one separated by a comma. For example, we can produce a variable and assign a list of values to it as follows:
This variable is now of type 'list' and contains multiple entries. We can save ourselves the effort of writing out a long list just to count simply by using the range(startvalue,endvalue) command;
Note that the end value is 10, and not 11 as you might expect. This is because the range does not include the end value. We can use this in our 'for' loop, as a quick way to repeat some part of our program with a list of values in a set range, for example:
This will tell you the value of i squared, starting with i=1, up to i=19. Note that we have had to use the str command to get Python to print out the message and the value of 'answer'. This converts the integer value of 'answer' to a string, so that it can be added to the message (which itself is a string!). Give it a go and try playing around with different values and different calculations.
# An Introduction to Python For Undergraduate Engineers/Getting Inputs

If you want your program to get an input from the user (for example to enter some parameters for your program to use), we use the input("Message here") command, as follows:
When the program is run, this will show the user the message Enter your name: and will then save whatever the user inputs as the variable username. This can be very useful when writing a program to solve engineering type problems, as your program could ask the user to enter some parameters (such as mass, volume etc.) for your program to use.
# An Introduction to Python For Undergraduate Engineers/Getting Started

Python can be run in two modes, the first is called interactive mode. This is where every command you type in is immediately interpreted by python and the result outputted onto your screen. For example type:
This will immediately print 'Hello and welcome to python!' on your screen.
Alternatively you can use python in non-interactive (standard) mode. Write your lines of code into a file, save it and then run that file. This is convenient if your program starts to become large - otherwise you would have to type all the lines of your program every time you started using python.
When you first load IDLE, it is running in interactive mode. To write a program script (to save and run later), click on 'File; New Window'. Here you can write your program and save it. To run it you can either click on 'Run; Run Module' or press F5. Alternatively, you can run a python script by typing the following in a DOS Prompt (or in the Terminal on a Linux machine).
python myfilename.py
# An Introduction to Python For Undergraduate Engineers/If/Else

Now that you have a few of the basic components under your belt, it is now the time to make some extra tools available to you. The most important part of a program is often the ability to get your program to do something if something is true (or false). For example if an inputted value is above a set value. For example:
This little program will ask the user to input their age and then test whether it is greater than or equal to 18. If the user is old enough, a message saying continue is printed on screen, otherwise the user is told to go away!
The if statement will run a logical test and then run the commands after it if the test result is true. If the result is false, it will run the commands after the else: statement. If there is no else statement and the result is false, the program will do nothing.
You can add further tests before the else commands are run using the elif statement (stands for else if). It will act like another if statement after the first one until if all if test are false, then and only then will the else commands be run. For example:
If you are not quite sure what's going on try putting this into a script and running it in IDLE. See what message you get!
# An Introduction to Python For Undergraduate Engineers/Installing Python

Python can be downloaded from the official Python website:
http://www.python.org/
If you are running Microsoft™ Windows™ then you can download a simple installation file from the downloads section of the official Python website and run that. If you are using a Linux distribution (such as Ubuntu, Debian, Red Hat etc.) you will most probably already have python installed.
# An Introduction to Python For Undergraduate Engineers/Boolean Logic

You can use simple Boolean expressions in logical statements such as those that we used in the while loop. The available expressions are:
| Expression | Example | Description of example |
| and | while done==False and x<10: | keep looping whilst both done equals false and x is less than 10 |
| or | if count==10 or value==5: | do something if variable count=10 or the variable value=5 |
| not | while not done: | keep looping while the done variable is not 'True' |
# An Introduction to Python For Undergraduate Engineers/Matrices

Matrices can be created in the following way:
In this example, [1,2] produces the first line of the matrix and [2,3] creates the second.

## Quick Standard Matrices

The following built in functions can be used to quickly create some standard matrices of specified size.
| Command | Description | Example |
| eye | Identity Matrix | eye(4) creates a 4x4 identity matrix |
| zeros | Empty Matrix | zeros(2,3) creates a 2x3 matrix of zeros |
| ones | Matrix of 1s | ones(2) creates a 2x2 matrix of ones |

## Getting the Size of a Matrix

You can find out the size of a matrix using the .shape command, for example:
| Command | Description |
| .shape[0] | Gives number of rows |
| .shape[1] | Gives number of columns |
# An Introduction to Python For Undergraduate Engineers/Functions

Functions are declared with the def keyword, followed by the function’s prototype, a colon, and the body of the function which is indented. For instance
# Annotations to James Joyce's Ulysses/Eumaeus/582
## Annotations

bona fides (Latin) good faith. In English, bona fides means sincerity or trustworthiness, particularly in relation to a person's stated identity.
# Annotations to James Joyce's Ulysses/Eumaeus/585
## Annotations

minutiae minor details; trifles. Like alias on the previous page, minutiae is a late borrowing from Latin, which has become a naturalized English expression and is not generally italicized; but the narrator of this episode (Bloom?) italicizes every word that has been borrowed from a foreign language, whether naturalized or not.

## References

* ↑ Online Etymology Dictionary.
# Annotations to James Joyce's Ulysses/Eumaeus/580
## Annotations

post mortem child Post mortem is Latin for after death. Bloom is using the phrase attributively to describe a child born after the death of its father; in this case, of course, it is an inappropriate description, as Murphy is still alive.
# Annotations to James Joyce's Ulysses/Eumaeus/583
## Annotations

coup d'oeil French: 'Glance'.
in the spring when young men's fancy after Tennyson's 'Locksley Hall' (1842), L.20: "In the spring a young man's fancy lightly turns to thoughts of love"

## References

* ↑ Johnson, J. ed., 1993. Ulysses:[the 1922 text]. Oxford University Press, p. 948.
* ↑ Johnson, J. ed., 1993. Ulysses:[the 1922 text]. Oxford University Press, p. 949.
# Annotations to James Joyce's Ulysses/Eumaeus/584
## Annotations

alias otherwise known as. Although the phrase has been borrowed from Latin, it has become a naturalized English expression and is not generally italicized; but the narrator of this episode (Bloom?) italicizes most words that have been borrowed from foreign languages, whether they have been naturalized or not. See also 308.27.

## References

* ↑ Online Etymology Dictionary.
# ABC graphs/ABCD
## 1st Example

Compounds: H, O, H2, O2, OH, OH−, H2O, H3O+, H2O2.
Topic: combustion of H2 in O2
Media: explosion!

## 2nd Example

Compounds: Ca2C, Ca3N2, CaO, CaF2 -> CH4, NH3, H2O, HF
Topic: hydrolysis
Media: reaction of some oxide producing a basic solution visualised with phenolphthalein

## 3rd Example

Compounds: CO2, NO2, SO2 -> CO32-, NO3-, SO32- & SO3
Topic: atmospheric gases, redox
Media: acid rain from volcano and cars

## 4th Example

Compounds: PF5, -> H3PO4, Al3+ -> Al(OH)4-
Topic: hydrolysis again
Media: dissolution of aluminium foil in a strong vase
# ACE+TAO Opensource Programming Notes/Configuring your app to work with an Implementation Repository

CORBA allows for the service of persistent objects, i.e., objects not residing in RAM, or cached memory in a runnable state. The IMR is the infrastructure which provides this functionality. The thing is, with modern servers, this really isn't a concern as the ACE+TAO executables are quite small. For a smaller chunk of hardware, like a PC or laptop, this still holds true as the executables are really quite small. The point being, that if you need to use the IMR, your app is likely quite beefy and needs to run in a multi server environment, thus, you can afford the $200 USD for the manual from OCI to figure out how to use it effectively. That being said, it isn't too bad as most of the functionality is baked into the command line of your service app. You can also look at the TAO documentation, which as usual, gets you 80% there. TAO IMR
# ACE+TAO Opensource Programming Notes/Advertise your service on a naming service
## Discussion

So the previous client/server pair were a bit clunky. What they lacked in elegance, they gained in brevity. This client/server example will show how to edit the previous examples so that they use the naming service and nolonger rely on the clunky manual IOR method of addressing. As a side note, these IOR strings are only good for the length of time the server is running. Since each new process generates a unique IOR string, storing them in a file for client reuse just isn't feasible, therefore, we use the naming service, which acts like a DNS for our services.
So, to make this work, we need to get a reference to a naming service, create a name with which to bind our service under, and register that name with the naming service. The following lines of code are what we will need:
Placing this code above the "orb->run" line of the previous server will get it on the naming server. For the full source code, see the following listing

## main.cpp

So, as you can see, the main difference here is the addition of a new include for the naming service and the code snipit mentioned above. The other portions of the server remain exactly the same.