OpenLLM-France/wikimedia huggingface dataset:
# A-level Physics/Forces, Fields and Energy/Work and energy

Doing Work:
Work is done whenever a force moves something over a distance. The force moves through a distance, and we say that it does work. The amount of work done tells us the amount of energy that has been transferred by the force. Thus:
work done (J) = energy transferred (J)
To calculate the amount of work done W, we need to know two quantities:
- The magnitude of the force F. - The distance, d, moved by the force, in the direction of the force/parallel to the force.
So Work done $W$ = force $F$ × distance moved in the direction of the force $x$.
    $W=Fx$
or, where $\Theta$ is the angle between the direction of the force and the distance,
    $W=Fxcos\Theta$
Force is measured in $newtons$ and distance travelled parallel to the force in $metres$. Thus, Work done is described in newton metres or $Nm$. This is the SI unit, joule, $J$. work done by tension &= T \times D\\ work done against friction &= -F \times D\\ work done by gravity &= -mg \times h\\ \end{alignat} </math>
Energy:
James Joule is the man, where the term 'the joule' comes from. His principle of conservation of energy states that:
While energy may be converted from one form to another, the total amount of energy in a closed system is always constant.
There are two main different types of energy; kinetic and potential. Kinetic energy (E$_K$) is moving energy and potential energy (E$_P$)is the energy that could be transferred to moving energy. The formula for these are:
Kinetic Energy: $E_{K}={\frac {1}{2}}mv^{2}$
Potential Energy: $E_{P}=mg\Delta h$
The relationship between work done and energy is:
Work done = Energy transferred
# A-level Physics/Forces and Motion/Deformation of solids
## Hooke's law

$F={k\;x}$
This applies to an object's deformation only before the elastic limit; from then on it deforms plastically and no longer follows this law. it states that, extension is directly proportional to the applied force.

## Spring Constant

$k={\frac {1}{gradient}}$
$k={\frac {F}{x}}$
The gradient refers to the gradient of a Tension-Extension graph. The standard units of k are N m$^{−1}$

## Strain

$Strain={\frac {Extension}{Original\;length}}$
Because this is a division of two measurements of length, Strain has no units and remains a ratio.
It can also be represented as $Strain={\frac {Changeinlength}{Original\;length}}$

## Stress

$Stress={\frac {Force}{CrossSectional\;Area}}$
The units for Stress are N m$^{−2}$, otherwise known as Pascals (Pa)

## The Young's modulus

$Young\;modulus={\frac {Stress}{Strain}}$

## Strain energy

$Strain\;energy={\frac {1}{2}}Fx$
However, due to Hooke's Law, it can be calculated in another form, y=mx+c;
$Strain\;energy={\frac {1}{2}}2jx={\frac {1}{2}}kx^{2}$

## Elastic limit

the maximum extent to which a solid may be stretched without permanent alteration of size or shape.

## Plastic limit

When the stress is sufficient to permanently deform the metal, it is called plastic deformation.
# A-level Physics/Health Physics
## Contents

* Introduction to Health Physics
* Biomedical Physics
** Body Mechanics
** The Eye and Sight
** The Ear and Hearing
* Transport Phenomena
* Medical Imaging
* Medical Treatment
* Natural Radiation
* Radiation Dosimetry
* Radiological Health
* Radiological Engineering
* Medical Health Physics
* Radiation Biology
* Radiation Protection
* Radioecology
# A Little C Primer/C Math Library

This chapter discusses some useful standard C libraries:
* math library
* standard utility library
* the "sprintf" function
* string function library
* character class test library
And the following minor topics:
* command-line arguments
* dynamic memory allocation
* pointers to functions
* PC memory model and other declarations
* troubleshooting hints
The math library requires the declaration:
The math functions consist of:
All values are "doubles", and trig values are expressed in radians.
# A Little C Primer/C Quick Reference

This section contains a sample program to give syntax examples for fundamental C statements, followed by a list of library routines. This list is very terse and simply provides reminders. If more details are needed, please refer to the previous chapters.
Console I/O -- #include <stdio.h>:
PC console routines -- #include <conio.h>:
Format codes:
File-I/O -- #include <stdio.h>:
File modes:
Offset values:
Math library -- #include <math.h>:
Standard utility library -- #include <stdlib.h>:
Time & date library -- #include <time.h>:
String function library -- #include <string.h>:
Character class test library -- #include <ctype.h>:
Dynamic memory allocation -- #include <malloc.h>:
# A Little C Primer/C Standard Utility Library & Time Library

The utility functions library features a grab-bag of functions. It requires the declaration:
Useful functions include:
The functions "atof", "atoi", and "atol" will return 0 if they can't convert the string given them into a value.
The time and date library includes a wide variety of functions, some of them obscure and nonstandard. This library requires the declaration:
The most essential function is "time", which returns the number of seconds since midnight proleptic Coordinated Universal Time (UTC) of January 1, 1970, not counting leap seconds. It returns a value as "time_t" (a "long") as defined in the header file.
The following function uses "time" to implement a program delay with resolution in seconds:
The "ctime" function converts the time value returned by "time" into a time-and-date string. The following little program prints the current time and date:
This program prints a string of the form:

## Further reading

* C Programming/Standard libraries
* C Programming/C Reference
* C++ Programming/Code/Standard C Library
# A Little C Primer/C Dynamic Memory Allocation & Deallocation

For simple programs, it is OK to just declare an array of a given size:
In more sophisticated programs, this leads to trouble. There may be no way of knowing how big an array needs to be for the specific task the program is performing, and so allocating an array in a fixed size will either result in wasted memory or in not having enough to do the job.
The answer to this problem is to have the program allocate the memory at runtime, and that's what the "malloc" library function does. For example, let's use "malloc" to allocate an array of "char":
The header file "stdlib.h" must be included, and a pointer to the memory block to be allocated must be declared. The "malloc" function sets the pointer to the allocated memory block with:
The count is in bytes and it is "cast" to the type of "size_t", which is defined in "stdio.h". The pointer returned by "malloc" is assigned to the variable "p", which is of type "char *". In ANSI C, "malloc" returns a pointer of type "void *", which can be assigned to any other pointer type without a cast.
If the "malloc" fails because it can't allocate the memory, it returns the value NULL (as defined in "stdio.h").
It is simple to allocate other data types:
The "sizeof" function is used to determine the number of bytes in the "int" data type.
When the programs finished using the memory block, it get rids of it using the "free" function:
C also contains two other memory-allocation functions closely related to "malloc": the "calloc" function, which performs the same function as "malloc" but allows the block allocated to be specified in terms of number of elements:
—and the "realloc" function, which reallocates the size of an array
that's already been allocated:
# A Little C Primer/C Preprocessor Directives

We've already seen the "#include" and "#define" preprocessor directives. The C preprocessor supports several other directives as well. All such directives start with a "#" to allow them to be distinguished from C language commands.
As explained in the first chapter, the "#include" directive allows the contents of other files to be included in C source code:
Notice that the standard header file "stdio.h" is specified in angle brackets. This tells the C preprocessor that the file can be found in the standard directories designated by the C compiler for header files. To include a file from a nonstandard directory, use double quotes:
Include files can be nested. They can call other include files.
Also as explained in the first chapter, the "#define" directive can be used to specify symbols to be substituted for specific strings of text:
In this case, the preprocessor does a simple text substitution on PI throughout the source listing. The C compiler proper not only does not know what PI is, it never even sees it.
The "#define" directive can be used to create function-like macros that allow parameter substitution. For example:
This macro could then be used in an expression as follows:
Beware that such function-like macros don't behave exactly like true functions. For example, suppose "x++" is as an argument for the macro above:
This would result in "x" being incremented twice because "x++" is substituted in the expression twice:
Along with the "#define" directive, there is also an "#undef" directive that undefines a constant that has been previously defined:
Another feature supported by the C preprocessor is conditional compilation, using the following directives:
These directives can test the values of defined constants to define which blocks of code are passed on to the C compiler proper:
These directives can be nested if needed. The "#if" and "#elif" can also test to see if a constant has been defined at all, using the "defined" operator:
—or test to see if a constant has not been defined:
Finally, there is a "#pragma" directive, which by definition is a catch-all used to implement machine-unique commands that are not part of the C language. Pragmas vary from compiler to compiler, since they are by definition nonstandard.
# A Little C Primer/C Operators

C supports the following arithmetic operators:
It also supports the following useful (if cryptic) "increment" and "decrement" operators:
These operators can also be expressed as "a++" and "a--". If the only thing that's needed is an increment or decrement, the distinction between the two forms is irrelevant. However, if a variable is being incremented or decremented as a component of some expression, then "++a" means "increment the variable first, then get its value", while "a++" means "get the value of the variable first, then increment it". Failing to remember this distinction can lead to subtle programming errors.
Finally, C supports a set of bitwise operations:
C allows math operations to be performed in a shortcut fashion:
The C relational operations were discussed in the previous chapter and are repeated here for completeness:
These are actually math operations that yield 1 if true and 0 if false. The following operation actually makes syntactic sense:
This would give "a" the value "b" if "b" is less than 2, and the value "10" otherwise. This is cute, but not recommended. It's cryptic; may make porting to other languages more difficult; and in this case, it can be done much more effectively with the conditional operator discussed in the previous chapter:
This conditional operator is also known as the "triadic" operator.
There are similar logical operators:
Remember that these are logical operations, not bitwise operations—don't confuse "&&" and "||" with "&" and "|". The distinction is that while the bitwise operators perform the operations on a bit-by-bit basis, the logical operations simply assess the values of their operands to be either 0 or 1 (any nonzero operand value evaluates to 1 in such comparisons) and return either a 0 or a 1:
Finally, there is a "sizeof" operand that returns the size of a particular operand in bytes:
This comes in handy for some mass storage operations. The "sizeof" function can be given a data type name or the name of a variable, and the variable can be an array, in which case "sizeof" gives the size of the entire array.
The precedence of these operators in math functions—that is, which ones are evaluated before others—are defined as follows, reading from the highest precedence to the lowest:
Of course, parentheses can be used to control precedence. If in doubt about the order of evaluation of an expression, add more parentheses. They won't cause any trouble and might save some pain.
Advanced math operations are available as library functions. These will be discussed in a later chapter.
# Ada Programming/Attributes/'Address
## Attribute Definition Clause

X'Address is an Ada attribute where X is any object, program unit, or label, RM 13.3(10/1). [A program unit is either a package, a task unit, a protected unit, a protected entry, a generic unit, or an explicitly declared subprogram other than an enumeration literal, RM 10.1(1).]
'Address may be used to return the address of the first element allocated to X. 'Address may also be used to set the address of X for stand-alone objects and program units, RM 13.3(12).
It's not recommended to use Integer_32 in this case.

## Aspect Specification

The address may also be specified directly when declaring the variable using an aspect declaration:

## See also
### Wikibook

* Ada Programming
* Ada Programming/Attributes
* Ada Programming/Attributes/'Alignment

### Ada Reference Manual

* 13.3 Operational and Representation Attributes (Annotated)
* Annex K Language-Defined Attributes (Annotated)
# Ada Programming/Attributes/'Aft

S'Aft is an Ada attribute where S is a fixed point subtype.
S'Aft returns the number digits needed after the decimal point to accommodate the precision of the subtype S, unless the delta of the subtype S is larger than 0.1, in which case the attribute returns a value of 1.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Attributes

### Ada Reference Manual

* Annex K Language-Defined Attributes (Annotated)
# Ada Programming/Attributes/'Alignment
## Description

X'Alignment is an Ada attribute where X is any memory-allocated object or type. This attribute controls the address values used for objects. The alignment must be non-negative. A value of zero means that the object need not be allocated at the boundary of a storage units. Otherwise the address is a multiple of X's alignment.
The alignment of an object may be set.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Attributes
* Ada Programming/Attributes/'Address

### Ada Reference Manual

* 13.3 Operational and Representation Attributes (Annotated)
* Annex K Language-Defined Attributes (Annotated)
# Ada Programming/Aspects/No Return
## Description

Specifying the aspect No_Return indicates that a procedure cannot return normally; it may raise an exception, loop forever, or terminate the program.
A non-returning procedure may not contain any return statements. If a non-returning procedure implicitly returns (by reaching the end of its statement sequence), Program_Error will be raised at the point of call.
On the call site, this enables detection of dead code and suppression of warnings about missing return statements or missing assignment to variables.

## Portability

The aspect No_Return was introduced in Ada 2012. It is the replacement for pragma No_Return which was introduced in Ada 2005.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Aspects
* Ada Programming/Subprograms

### Ada Reference Manual

* 6.5.1: "Non Returning Procedures"

## References

* ↑ AI05-0229
* ↑ AI95-00329
# Ada Programming/Attributes/'Adjacent
## Description

S'Adjacent(X, T) is an Ada attribute where X is any floating point type.
'Adjacent returns the adjacent floating point number to X in the direction of T.

## Example

The output with GNAT 4.6 on the x86-64 architecture is:

## See also
### Wikibook

* Ada Programming
* Ada Programming/Attributes

### Ada Reference Manual

* 5.3 Attributes of Floating Point Types (Annotated)
* Annex K Language-Defined Attributes (Annotated)
# Ada Programming/Attributes/'Address Size
## Description

Is a static constant giving the number of bits in an Address. It is the same value as System.Address’Size, but has the advantage of being static, while a direct reference to System.Address’Size is nonstatic because Address is a private type.

## Example

Standard'Address_Size (Standard is the only allowed prefix)
# Ada Programming/Attributes/'Abort Signal
## Description

Provides the entity for the special exception used to signal task abort or asynchronous transfer of control. Normally this attribute should only be used in the tasking runtime (it is highly peculiar, and completely outside the normal semantics of Ada, for a user program to intercept the abort exception).

## Example

Standard'Abort_Signal (Standard is the only allowed prefix).
# Ada Programming/Attributes/'Access
## Description

X'Access is an Ada attribute where X is any object or subprogram.
'Access may be used to return an access value designating the object or subprogram.

## See also
### Wikibook

* Ada Programming
* Ada Programming/Attributes
* Ada Programming/Types/access

### Ada Reference Manual

* 3.10 Access Types (Annotated)
* Annex K Language-Defined Attributes (Annotated)
# Arabic/XofYand

We are going to learn about X and Y structures, and we will learn about the Arabic word for "and".
This seems simple enough. There is one thing to remember though. و (wa) always is included in the word that follows it. It is not considered a separate word in Arabic.
Correct: والولد
Incorrect: و الولد
Both mean "and the boy", but due to an Arabic spelling rule, that says one letter words must connect to following words what is 3 words in English, "and the boy" ,is one word in Arabic, "andtheboy".
Here are examples of X of Y structures so you understand what you will learn.
The cat of the neighbour. OR The neighbor's cat. The dog of the man. OR The man's dog.
Did you notice that the first sentence uses "the X of Y" format, while the second uses apostrophe (an apostrophe is this sign: ' )and then an "s". In Arabic There is no " apostrophe s" type of structure. Whenever you translate The neighbor's cat, the word "cat" will come first in Arabic and "the neighbour" will come right after it.
Remember how Arabic doesn't use a word for "is" in sentences like "The boy is big". Arabic also doesn't use a word for "of" in sentences like "the cat of the neighbour".
So now, you might be asking how do you say "the cat of the neighbour" if there is no word for "of". It has to do with sentence structure.
In English it looks like this. the ____1____ of ______2_____
= In Arabic it will look like this ــــــ1ــــــــ ال ــــــ2ـــــِ
Note: "1" stands for the first word. "2" stands for the second word.
For example: the boy of the city. ولد الـمدينة (wa-la-dul<_ma-dii-na-ti) مدينة (ma-dii-na) means "city".
Note that the last letter of "Template:Font size="+3""is a تاء مربوطة (taa'--mar-buu-Ta) meaning closed ت (taa). This variant of ت (taa) looks like a ه (haa) with two dots on top. It is pronounced as "h" when you stop at that word (although the "h" sound is very faint) and at all other times it is pronounced as the normal "t" sound, as in "talk".
The structure "the boy of the city" can be translated as one of the following. Each one means the same thing. The only difference is that each one has a different function in the sentence. walad+u al-madiinati=(wa-la-dul_ma-dii-na-ti) walad+a al-madiinati=(wa-la-dal_ma-dii-na-ti) walad+i al-madiinati=(wa-la-dil_ma-dii-na-ti)
I'll write out an "X" where the three sentences differ. (wa-la-dXl<_ma-dii-na)
The difference is a vowel that attaches to the word for "boy": (wa-lad). This vowel indicates something called grammatical case. This will be explained later, And we will use the "u" ending for all the following examples, because that is the default case.
The man's dog/ the dog of the man. كـَلـْبُ الرَّجُلِ
kalb + u + al + rajul = (kal-bur<_ra-jul)
The woman's dog/ the dog of the woman.
كـَلـْبُ المَرْأةِ
kalb + u + al + mar'a (kal-bul<_mar-a)
Now let's use و (wa)." و (wa)" means "and" in Arabic.
كـَلـْبُ الرَّجُلِ وَكـَلـْبُ المَرْأةِ
kalb+u +al+rajul+i+ wa+kalb+u+al+mar'at (kal-bur<-ra-ju-li—wa_kal-bul<-mar-a) The man's dog, and the woman's dog.
# Exercise 1

* اَلْمَدْرَسَةُ كَبِيْرَةٌ.‏
* اَلْجَاْمِعَةُ قَدِيْمَةٌ.‏
* اَلْشُّقَّةُ صَغِيْرَةٌ.‏
* اَلْمَحَّاْيَةُ جَدِيْدَةٌ.‏
* اَلْقَلَمُ رَخِيْصٌ.‏
* اَلْمَدْرَسَةُ جَدِيْدَةٌ.‏
* اَلْمَطَاْرُ كَبِيْرٌ.‏
* اَلْحَاْسُوْبُ غَاْلٍ.‏
* اَلْمَطْعَمُ غَاْلٍ.‏
* اَلْجَاْمِعَةُ غَاْلِيَةٌ.‏
* اَلْمَحَّاْيَةُ غَاْلِيَةٌ.‏
* اَلْشُّقَّةُ جَدِيْدَةٌ.‏

# Key

1. The school is large. 2. The university is old. 3. The apartment is small. 4. The eraser is new. 5. The pen is cheap. 6. The school is new. 7. The airport is big. 8. The computer is expensive. 9. The restaurant is expensive. 10. University is expensive. 11. The eraser is expensive. 12. The apartment is new.
# Arabic/XisYandPronouns
## X is Y + pronouns

We learned in the previous lesson how to say sentences such as the following in Arabic. The boy is small. The man is big. But what if you want to say where something is. You need a preposition. Take this talk between two people for example: Where is the hammer? It is under the table.
In the second sentence a preposition was used. Whenever you are telling where something is you are using a preposition. Here are some examples of prepositions in English.
under, over, around, through, beside, on, from, inside, behind, etc.
So what if we wanted to say the boy is with the man. We know the following: ولد (wa-lad) =boy رجل (ra-jul) =man
Remember we have to prefix "ال" (al) to those words in order to make "the man" and "the boy". But there is one word we haven't covered yet. We haven't covered the preposition "with". That's all we need, there is no need to have a word for "is" in an Arabic sentence. "is" is understood when the first word has "ال" (al) and the second doesn't. مع (ma-`a) with
Now try to construct the sentence.
Here's how it should look. الولد مع الرجل
(al_wa-lad—ma-`al-ra-jul) WordForWord Translation: the-boy with the-man The boy is with the man.
But what if we wanted to say "The boy is with a man".
الولد مع رجل
(al_wa-lad—ma-`a-ra-jul) All we had to do was take away "ال" (al) (which means "the") from "رجل" (ra-jul) (which means "a man"). There is no word for "a" in Arabic.
Here are some prepositions we will use:
under = (tiH-ta) تـحت on top of= (`a-la) على in= (fii)في over= (faw-qa) فوق from= (min) من