OpenLLM-France/wikimedia huggingface dataset:
# ABC graphs/Rules
### AB graph

A: Arrange atom symbols (Atoms)
B: Connect symbols with lines (Bonding paths)

### ABC graph

A: Arrange atom symbols (Atoms)
B: Connect symbols with lines (σ-Bonds)
C:
* Find the most electronegative atoms evaluate its residual charge.
* Calculate the residual charges for the rest of atoms accounting for the total charge value.

### ABCD graph
#### Rules

    A. Arrange Atoms.
    B. Allocate Bonds.
    C. Assign Charges.
    D. Add Dots.

#### Hints

    A. Hydrogen as well as more electronegative atoms tend to be terminal or (less commonly) bridging.
    B. Few-member cycles are less favorable than linear arrangements.
    C. Residual charge of terminal H/F/Cl/Br/I is 0 (not written), O/S is −, N is =, C is ≡.
       Residual charge of bridging H/F/Cl/Br/I is +, O/S is 0 (not written), N is −.
       Residual charge of the central atom is found using eq ΣC = q (total charge).
    D. Number of dots equals D = A − B − C, where A is the number of the atoms' bonding electrons and B is the number of bonds around that atom.
       A equals to the last digit of the group numbers.

#### Style

    A. Use atom symbols.
    B. Draw bonds with lines.
    C. Write non-zero charges with characters: −, =, ≡, +, ⧺, ᚒ.
    D. Draw dots as pairs or singles.

### ABD graph

A and B steps the same as for ABC graph.
D: For each atom of interest, find the number of bonding electrons (A), evaluate the oxidation number (O), but do not write it, then calculate D as D = A − O. Draw D dots around the atom in pairs of singles (Hund rule applies).

### ABDE and ABCDE graph

A–D steps the same as for ABD or ABCD graphs.
E: For each sp-atom of interest, calculate E as E = 4 − B − D· − D: Draw E hyper-ellipses around the atom.

### Control

Ensure that ΣC = q.
For geometrically similar arrangements prefer one with minimal sum of absolute residual charges Σ|C|. For example, O–O–C vs O–C–O and N–N–O vs N–O–N.
D can not be negative.
# ACE+TAO Opensource Programming Notes/Create a client
## Discussion

So, unlike the server, the client doesn't involve implementing any code generated by the IDL. In the client, we simply instantiate a copy of the factory (using as an address the IOR string we generated with the server) and call its functions. This is all it takes for a basic client.
In the following code, the first argument to the program gets used as the address argument to TAO's orb to find our server. We are using the string generated earlier much like someone would use an IP address/port combination to find a host and application on the internet. While we will discuss it later, this analogy is somewhat apt because, on the internet, we usually prefer to use host names (using DNS) and well known services (ports) to access our services. In CORBA land, the same is true, and we will be discussing that later.
After acquiring the factory object from the orb, we then downcast the generic object to our My_Factory_var object as generated by the IDL. Note that we aren't downcasting it to "My_Factory", but rather "My_Factory_var". TAO, and perhaps CORBA seem to have adopted a standard of using XXX (as defined in your IDL) as the class you use to manipulate the ORB, and XXX_var (as generated by the IDL) as the repository for your object, as generated by XXX.
Now that you have generated your application specific factory object from the generic one received from the ORB, you may proceed to use these two objects as you would any normal C++ object. Just remember to keep in mind the type of data you are getting back from your queries, and or what type of data you are sending. Suffice it to say that inattention to these details will cause memory leaks.
Finally, destroy the ORB. While this is quite a simple application, and technically the destructor isn't needed, its still a good idea to get in the practice as leaving these objects hanging will cause all sorts of problems with distributed programs.
# ABC graphs/Definitions
### Acronym and definitions

| Letter | Words | Concept | Notation | Numerical value |
| A | atom | atom with bonding electrons | symbol | A |
| B | bond | bonding path or σ-binding pair | line | B |
| C | charge | residual charge | characters (−,=,≡,+,⧺,ᚒ) | C |
| D | dot | Non-σ-bonding electrons in pair(s) or as single(s) | dots/dot | D |
| E | ellipse | unoccupied orbital | hyperellipse | E |

### Atoms and number of bonding electrons

Atom symbols are given in the periodic table of elements. Number of bonding electrons equals to the group number for s, sd and sf elements and to the last digit in the group number of sp elements. Let us denote that number as A.
To arrange the atoms one may follow the rules: [comment: to be written].

### Bonding paths and σ-bonds

Any bonds in the ABC-type graphs is drawn with a single line as it corresponds to a bonding path.
[Comment: add the definition of a bonding path and the difference from a σ-bond]
Let us denote the number of σ-bonds formed by a given atom as B.

### Residual charge

Residual charge on the most electronegative atoms is a charge left after creating 'N' σ-bonds with the corresponding anions, e.g. N3−, O2−, F−.
All other residual charges are calculated using the electroneutrality principle.
Let us denote the residual charge value of a given atom as C.

### Non-σ-bonding electrons

[Comment: there should be a better name. Obviously, these are not the typical lone electrons.]
Let us denote the number of non-σ-bonding electrons as D:
D = A − B − C

### Unoccupied orbitals

Let us denote the number of unoccupied orbitals associated with a given atom as E:
E = N − B − D· − D:
where N is the number of bonding orbitals of the atom (s,p,d,f), D· is a number of singles, D: is a number of pairs.
# ACE+TAO Opensource Programming Notes/Attaching your applications to the core services

Ok, so we now have a client and server along with services... let's wire them up.
If you have an already compiled server from one of the previous examples, you'll want to start that up first and have it advertised on the naming service. To do that, you'll need to tell the server you wrote the IOR of the naming service. TAO allows you two ways to do this. The first is to create an environment variable "NameServiceIOR" which you assign the IOR you used when you started the NamingService. The other method, is to put the IOR on the command line. The IOR from the example below is the string starting with "corbaloc" and continuing to the end of the line. The latter option is my preferred method to get a server started.
The -ORBInitRef option is simply passed to the CORBA::ORB_init function in the opening lines of your application, so you could optionally pass this in directly to the function, thus obviating the need for this long command line. In practice, however, I've always used this long command line form as it makes it easier to move the app around.
To start the client side, using the command line from above is fine.
One final note unrelated to connecting your apps into the framework. The ACE+TAO framework, because it was designed to work on Microsoft's platform, comes with a non-standard way to start up the app. If you want to run your shiny new app as a daemon, you need to add -ORBDaemon to the command line. If you are doing this under linux, don't try the daemon C function call in your source, it'll only serve to confuse things.
# A-level Computing 2009/AQA/Problem Solving, Programming, Data Representation and Practical Exercise/Fundamentals of Data Representation

* From the Specification : Binary number system
* Pure Binary Representation of Denary Integer
* Describe the representation of unsigned denary integers in binary. Perform conversion from denary to binary and vice-versa.
* Binary Arithmetic
* Add two binary numbers and multiply two binary numbers.
* Representation of signed integers by Two’s Complement
* Describe the use of Two’s Complement to perform subtraction. Convert a denary integer into Two’s Complement and vice versa.
* The Concept of Number Bases: Denary, Binary and Hexadecimal
* Describe the conversion of a denary integer to hexadecimal form and vice versa. Describe the use of hexadecimal as shorthand for binary.
* Integers and Numbers with a Fractional Part
* Draw a distinction between integers and numbers with a fractional part in a computer context.Describe how an unsigned denary number with a fractional part is represented in fixed-point form in binary.
* Bit patterns in a computer
* Denary, Binary and Hexadecimal number systems
* Binary arithmetic
* Binary fractions
* Two's complement
* Status register
* From the Specification : Information Coding Schemes
* Describe standard coding systems for coding character data.
* Understand ASCII
* Understand Unicode
* Differentiate between the character code representation of a denary digit and its pure binary representation.
* Error checking and correction
* Parity bits, Hamming code.
* Gray coding
* Describe Gray coding. Explain why and where it is used.
* Information coding schemes
** ASCII
** Unicode
* Error checking and correction
** Parity bits
** Hamming code
* Gray coding
* From the Specification : Representing Images, Sound and other data
* Images
* Describe how bit patterns may represent other forms of data including graphics and sound.
* Bitmapped Graphics
* Bitmaps: resolution, colour depth and simple bitmap file calculations.
* Vector Graphics
* Vector graphics: drawing list – objects and their properties.
* Compare bitmaps to vector graphics; advantages, disadvantages.
* The need for compression and basic techniques for compression.
* Sound files
* The need for compression and basic techniques for compression.
* Sampled Sound and Nyquist-theorem
* Sampling resolution, sampling rate.
* Sound Synthesis
* Describe MIDI and its advantages for storing sound digitally.
* Streaming audio
* Explain what it is and why it is used.
* Analogue and Digital Data. Analogue and Digital Signals
* Differentiate between analogue and digital data and analogue and digital signals.
* Analogue to Digital Converter
* (ADC) Describe the principles of operation of an analogue to digital converter.
* Images
** Bitmaps
** Vectors
** Comparison between vector and bitmaps
* Sounds
** Analogue and digital
** Sampled sound
** Sound compression
** Nyquist-theorem
** Sound synthesis
** Streaming audio
# A-level Computing 2009/AQA/Problem Solving, Programming, Data Representation and Practical Exercise

This exam is worth 60% of your AS grade (30% of the full A-Level). It is examined in June only.

## Definitions

Unit 1 definition list

## The examination

* 2016 Exam Resit
* 2016 Exam
* 2015 Exam
* 2014 Exam
* 2013 Exam
* 2012 Exam
* 2011 Exam
# C++ Language/Std/FilesystemAccess/RedirectingStdout

The _dup function is useful for redirecting stdout to a file written on the disk.
Additional information about redirecting stdout
# C++ Language/Std/FilesystemAccess/StreamedIo

An IOStreams stream can target a file.
Additional information about streaming to a file
# C++ Language/Std/Iostreams

A "stream" uses operator << to stream from general-purpose-data into a character sequence. A stream uses operator >> to stream the other direction.
* Stringstream
* Streaming Custom Types
# C++ Language/Std/Iostreams/StreamingCustomTypes

To enable std::cout << oVar; where oVar has a custom type, you would need to implement an overload of the stream-operator operator<<.
Additional information about streaming custom types
# C++ Language/Std/Iostreams/Stringstream

One possible place where the character sequence could go is into a std::stringstream object, which captures the character sequence as a C++ variable. That variable can then be accessed as a read-only string.
Alternatively, a character sequence can be output to the Console by streaming to std::cout.
Alternatively, a character sequence can be streamed out to a file in the filesystem.
Additional information about stringstream (includes interactive examples)
# C++ Language/Std/Multithreading/AtomicValues

If the only content of a critical section is the manipulation of one variable, then the easiest synchronization approach would be to use std::atomic<> and its associated arithmetic functions.
Additional information about atomic values
# C++ Language/Std/Multithreading/CriticalSection

A "critical section" is a code fragment that should be treated as atomic because of how it uses shared variables or resources. Extra code (inserted before and after a critical section) should enforce the mutually exclusive execution property (a.k.a. "mutex" property) within this critical section without causing "deadlock" nor "starvation".
Additional information about critical sections
# C++ Language/Std/Multithreading/Events

An "event" is a signal communicated from one thread to another thread.
Additional information about events (includes interactive examples)
# C++ Language/Std/FilesystemAccess/SizeOfFile

There are two ways of measuring a file's size. Either call _filelength, or access the st_size data member of an object returned by _fstat.
Additional information about measuring the size of a file
# C++ Language/Std/Multithreading

Traditionally, we think of the flow of execution through a program as being in one place at a time, flowing from one statement to the next. But it is possible for a C++ program to have multiple "threads" of execution. Each thread would act like a traditional flow of execution. Having multiple threads causes the computation of different parts of your software at essentially the same time. Each thread maintains its own local state for things like its stack of function calls.
* Thread Creation
* Critical Section
* Atomic Values
* Locks
* Events
* Return Value
* Semaphores
* Monitors and Channels
# A-level Computing 2009/Authors

* (AQA) Peter EJ Kemp (editor) - London
* (CIE) Peter Astbury - Alexandria, Egypt

## Contributors and proof readers

* Students from Christ the King Sixth Form College
* Students from Loxford School
* Students from Wreake Valley Academy
* Peter L Higginson - Reading
Thanks for helping out!
# A-level Computing 2009/CIE

This is a book about A-Level Computing. It aims to fit in with the Cambridge International AS and A Level Computing syllabus but is not endorsed by Cambridge International. It should be useful as a revision guide or to find alternative explanations to the ones in your textbook. If you haven't heard of an A-Level then this book probably won't be of much interest to you but you can find out about them at Wikipedia.
If any part of this book is unclear or even wrong then please post a comment on the discussion page or simply fix it yourself! In particular, please say if the book assumes any knowledge or skills which not all A-Level Computing students have.

## How to read the book

You will meet several coloured boxes, here are their meanings:
* Specification link
* What the specification says you must learn for each chapter
* Examples
* Example questions and how to solve them
* Questions
* Questions to test yourself, click below
* Answer:
* to check if you were right
* Extension
* Topics that aren't examined but you might be interested in
There will be a lot of concepts that you need to be familiar with, definitions are highlighted like so:

## Course Structure

* To be awarded an AS (Advanced Subsidiary) Level qualification in Computing, a student must take the 2 AS sections.
* To be awarded an A (Advanced) Level qualification in Computing, a student must take all 4 sections.
The book is split into the four sections. Each section is split into chapters with each chapter covering the topics for that section.

## AS sections

* Theory Fundamentals
* Fundamental Problem-solving and Programming skills

## A2 sections

* Operating Systems
* Computing project
# A-level Computing 2009/CIE/Computer systems, communications and software
## Theory

* Components of a computer system and modes of use
* System software
* Data: its representation, structure and management
* Hardware
* Data transmission and networking
* System life cycle
* Choosing appropriate applications software
* Handling of data in information systems
* Designing the user interface
* Logic gates

## The Examination

* Jun 2010 Exam
* Nov 2010 Exam
* Jun 2011 Exam
* Nov 2011 Exam
# C++ Language/Std/Stl/CollectionClasses/SortedCollections/Map/SortClass

The ordering of items does not matter in a map-literal. What does matter is the "sort-class" template-parameter (the default is std::less<> if omitted). The sort-class determines the actual item-ordering within STL's internal representation (by ordering their keys). When iterators use ++ and --, they follow that sort-class order (not the map-literal's apparent order).
Additional information about specifying a sort-class (includes interactive examples)
# C++ Language/Std/Stl/CollectionClasses/SortedCollections/Map/InsertingItems

The distinction between a map's insert and emplace functions is the same as it was for vectors. With a map, you could also use C-array-indexing syntax, which will insert a new item if the map didn't already contain one with that key.
Additional information about inserting items into a map (includes interactive examples)
# C++ Language/Std/Stl/CollectionClasses/SortedCollections/Multiset

A "multiset" (an instance of class set::multiset<>) is the same as a set, except that the same item can occur multiple times.
Additional information about multiset (includes interactive examples)
# C++ Language/Std/Stl/CollectionClasses/SortedCollections/PairAsOneItem

A "pair" is an object whose type encapsulates two other types.
A pair has a literal form, using braces: std::pair<char,int> ciVar = {'a',11};. Access each component as ciVar.first or ciVar.second.
Pair assignment (= operator) copies-by-value the two elements from source to destination. Usually, assignment's destination is another pair. However, pair-assignment could also use std::tie to decompose into two scalar variables.
Additional information about std::pair (includes interactive examples)
# C++ Language/Std/Stl/CollectionClasses/SortedCollections/Set

A "set" (an instance of class std::set<>) is the same as a map, except that each item contains only the key (there is no value).
Additional information about sets (includes interactive examples)
# C++ Language/Std/Stl/Iterators

Various kinds of "iterators" collectively act as a common interface (designed to resemble the API of a C pointer) between multiple kinds of collection classes and multiple algorithms.
* Basic Iterators
* Ranges
* Insert-Iterators
* Reverse-Iterators
* Stream-Iterators
* Custom Iterators
# C++ Language/Std/Stl/CollectionClasses/SortedCollections/Tuple

A "tuple" is like a pair, except that a tuple can have more than two elements: std::tuple<char,int,float> cifVar('a', 11, 1.1F);. Access each component as std::get<0>(cifVar) or std::get<1>(cifVar) or std::get<2>(cifVar).
Additional information about tuple (includes interactive examples)
# C++ Language/Std/Stl/CollectionClasses/SortedCollections/Map/RemovingItems

The erase function removes an item from a map. You can give erase either an iterator, or the key of the item that you want removed.
Additional information about removing items from a map (includes interactive examples)
# C++ Language/Std/Stl/CollectionClasses/SortedCollections/Map/Size

The size function reports how many items are in the map. The count('i') function reports how many items are in the map having that particular key (0 or 1 of them).
Additional information about map size (includes interactive examples)
# C++ Language/Std/Stl/CollectionClasses/SortedCollections/Multimap

A "multimap" (an instance of class std::multimap<>) is the same as a map, except that multiple items are allowed to have the same key.
Additional information about multimap (includes interactive examples)
# A Quick Introduction to Unix/Directory Structure

* Components
* Shells and subshells
* Directory Structure
* Changing Directories
* Listing Files and Directories
* Pathnames
* Files and Processes
* Wildcards
* Exercises 1
* Creating Directories
* Creating Files
* Special Directories
* Exercises 2
* Copying Files
* Moving Files
* Deleting Files
* Exercises 3
* Redirection
* Searching Text Files
* More grep examples
* Permissions on Files and Directories
* Editing Text
* Exercises 4
* My First Shell Script
* Job Control
* Links
* Environment Variables
All Unix files are integrated in a single directory structure. The file-system is arranged in a structure like an inverted tree. The top of this tree is the root and is written as a slash ‘/’.
In the diagram on the left, we see that the home directory of the user ccaajim contains two sub-directories (stats and pictures) and a file called train.doc.
The full path to the file train.doc is /nfs/fs-i/UM0098/ccaajim/train.doc
This is rather different from the view you get of a Windows file structure. Unix integrates all the files into one directory structure rather than listing different physical storage devices each with its own root. The filestructure is logical rather than physical. If the computer had a CD ROM drive then it might appear as a folder under, say, nfs, called cd.
You will find some directories on all (or almost all) Unix systems and it may help to have an idea what they contain, even if most users will never go near some of them.
| Directory name | Typical contents |
| /bin | commands and programs used by all the users of the system |
| /boot | files required by the boot loader |
| /dev | CD/DVD-ROM, floppy drives, USB devices, etc. |
| /etc | System configuration files |
| /home | User data files |