OpenLLM-France/wikimedia huggingface dataset:
# Radiation Oncology/RTOG Trials/8319

* Front Page: Radiation Oncology | RTOG Trials | Randomized Trials
RTOG 83-19 (LIVER)
* Title: Phase III Randomized Comparison of ADR/5-FU plus I131-Antiferritin IgG vs ADR/5-FU Alone Following ADR/5-FU plus External Beam Radiotherapy in Nonmetastatic Nonresectable Primary Hepatoma
* Objective:
** I. Determine the therapeutic efficacy of cyclic I131-antiferritin IgG plus adriamycin/5-fluorouracil vs. adriamycin/5-fluorouracil alone following induction with external beam irradiation plus adriamycin/5-fluorouracil in patients with nonmetastatic, nonresectable primary hepatoma.
** II. Determine both survival and the incidence of tumor volumetric reduction of at least 30 percent in the two treatment arms.
** III. Study the relationship between duration of remission and AFP negativity.
* Protocol:
** Induction RT (21.0 Gy at 3.0 Gy/Fx) + low-dose CT (5-FU/adriamycin) followed 1 month later by:
** Arm 1: adriamycin/5-FU + 131-I-antiferritin
** Arm 2: adriamycin/5-FU
* Eligibility: Histologically proven primary hepatoma that is nonresectable and from which there are no known extrahepatic metastases. Patients with positive AFP titers are
excluded.
* Enrolled:
* Conclusion:
** PMID 1850722 -- A randomized prospective trial comparing full dose chemotherapy to 131I antiferritin: an RTOG study. (1991 Order S, Int J Radiat Oncol Biol Phys. 1991 May;20(5):953-63.) Conclusion: "Overall, radiolabeled antibody administration and full dose chemotherapy led to equivalent partial remission rates (22-30% vs 23-25%) and survival rates compared to chemotherapy (6 month median; AFP+ 5 months; AFP- 10 months)."
* Publications:
** PMID 9612600 -- Survival results among patients with alpha-fetoprotein-positive, unresectable hepatocellular carcinoma: analysis of three sequential treatments of the RTOG and Johns Hopkins Oncology Center. (Abrams RA, Cancer J Sci Am. 1998 May-Jun;4(3):178-84.) Conclusion: "Intravenous 131I-polyclonal antiferritin did not improve survival when added to either post-induction regimen but dramatically increased hematologic toxicities."
# RTEMS for Embedded Software Developers

RTEMS (Real-Time Executive for Multiprocessor Systems) is a real-time operating system (RTOS) designed for embedded systems.
The long term goal of this book is to instruct the reader in:
* Getting Started (Getting to "Hello World") ( March 2015 )
** Getting the cross-toolset
** Building RTEMS
** Running RTEMS
* Contributing While Learning ( March 2015 )
* The RTEMS Git Repository ( March 2015 )
** list RTEMS applications here
* RTEMS Addon packages ( March 2015 )
** Using the existing RTEMS Addon Packages
** Adding to the RTEMS Addon Packages
* Device Drivers ( March 2015 )
** Existing device drivers
** Modifying device drivers
* RTEMS Managers
** To be listed
* Modifying the RTEMS source code
** CPU kit
** Board Support Packages

## Why RTEMS?

* RTEMS is an open source RTOS.
* RTEMS is an abstraction layer that makes it possible to write an application for one embedded system, and run that application on over 10 chip families and 100 board support packages.
* RTEMS started in 1989, and still has an active development community.
* RTEMS is designed to be a POSIX compliant RTOS, there is less difficulty associated with porting software designed to run on BSD or Linux.
* RTEMS includes a TCP/IP stack
* RTEMS includes support for a variety of filesystems including the NFS and the FAT filesystem.
* RTEMS supports thread-aware debug over ethernet

## References

* ↑ RTEMS wiki
* ↑ "RTEMS POSIX 1003.1 Compliance Guide". p. 1. quote: "RTEMS supports a single process, multithreaded POSIX 1003.1b environment. ... providing routines like getpid and making them work in a sensible fashion for an embedded environment ... makes it significantly easier to port code from a UNIX environment without modifying it."
* ↑ "RTEMS On-Line Library".
* ↑ "About RTEMS".
# RTEMS for Embedded Software Developers/Device Drivers

This section is primarily designed to show the reader how to modify drivers.
Perhaps this could be presented as a case study of porting a new board for a supported chip as an example.
Some drivers that could be explored are:
* clock
* console
* shmsupp
* startup
* timer
Another approach could be exploring modifying libbsp drivers.
reference: http://git.rtems.org/rtems/tree/c/src/lib/libbsp/no_cpu/no_bsp
# RPG Maker 2003/Database

The database holds all important information for creating your perfect RPG. The database is where you can edit the names and looks of your heroes, give them the skills necessary for survival, make items and weapons for them, make monsters to give them a challenge, the attributes that could help or hinder them, as well as many of the crucial layouts of the battle scenes, the animations of their attacks, and what the menus could look like. Without the database, your game might look like everyone elses, and who wants that?
Make sure to read this section so you can get a handle on everything that you need to create the backbone to a successful game.
# RTEMS for Embedded Software Developers/Device drivers

This chapter will cover using and developing RTEMS Device Drivers
* Existing device drivers
* Modifying device drivers
# Linear Algebra/Topic: Linear Recurrences/Solutions
## Solutions
### Problem 1

Solve each homogeneous linear recurrence relations.
* $f(n+1)=5f(n)-6f(n-1)$
* $f(n+1)=4f(n)$
* $f(n+1)=6f(n)+7f(n-1)+6f(n-2)$

### Answer

* We express the relation in matrix form. The characteristic equation of the matrix has roots of $2$ and $3$. Any function of the form $f(n)=c_{1}2^{n}+c_{2}3^{n}$ satisfies the recurrence.
    ${\begin{pmatrix}5&-6\\1&0\end{pmatrix}}{\begin{pmatrix}f(n)\\f(n-1)\end{pmatrix}}={\begin{pmatrix}f(n+1)\\f(n)\end{pmatrix}}$
    ${\begin{vmatrix}5-\lambda &-6\\1&-\lambda \end{vmatrix}}=\lambda ^{2}-5\lambda +6$
* This is like the prior part, but simpler. The matrix expression of the relation is and the characteristic equation of the matrix has the single root $4$. Any function of the form $f(n)=c4^{n}$ satisfies this recurrence.
    ${\begin{pmatrix}4\end{pmatrix}}{\begin{pmatrix}f(n)\end{pmatrix}}={\begin{pmatrix}f(n+1)\end{pmatrix}}$
    ${\begin{vmatrix}4-\lambda \end{vmatrix}}=4-\lambda$
* In matrix form the relation gives this characteristic equation.
    ${\begin{pmatrix}6&7&6\\1&0&0\\0&1&0\end{pmatrix}}{\begin{pmatrix}f(n)\\f(n-1)\\f(n-2)\end{pmatrix}}={\begin{pmatrix}f(n+1)\\f(n)\\f(n-1)\end{pmatrix}}$
    ${\begin{vmatrix}6-\lambda &7&6\\1&-\lambda &0\\0&1&-\lambda \end{vmatrix}}=-\lambda ^{3}+6\lambda ^{2}+7\lambda +6$

### Problem 2

Give a formula for the relations of the prior exercise, with these initial conditions.
* $f(0)=1$, $f(1)=1$
* $f(0)=0$, $f(1)=1$
* $f(0)=1$, $f(1)=1$, $f(2)=3$.

### Problem 3

Check that the isomorphism given between $S$ and $\mathbb {R} ^{k}$ is a linear map. It is argued above that this map is one-to-one. What is its inverse?

### Problem 4

Show that the characteristic equation of the matrix is as stated, that is, is the polynomial associated with the relation. (Hint: expanding down the final column, and using induction will work.)

### Problem 5

Given a homogeneous linear recurrence relation $f(n+1)=a_{n}f(n)+\dots +a_{n-k}f(n-k)$, let $r_{1}$, ..., $r_{k}$ be the roots of the associated polynomial.
* Prove that each function $f_{r_{i}}(n)=r_{k}^{n}$ satisfies the recurrence (without initial conditions).
* Prove that no $r_{i}$ is $0$.
* Prove that the set $\{f_{r_{1}},\dots ,f_{r_{k}}\}$ is linearly independent.

### Problem 6

(This refers to the value $T(64)=18,446,744,073,709,551,615$ given in the computer code below.) Transferring one disk per second, how many years would it take the priests at the Tower of Hanoi to finish the job?
# Reaktor/Tutorials/Reaktor as effects processor/Acknowledgements...
## Acknowledgements... and a reminder

Many thanks, once again, to all those generous and creative souls who contributed to this tutorial effort, and to the many I haven't named who continue to help me see Reaktor's power and possibilities via the several Reaktor on-line forums (there are some good ones at Yahoo and K-V-R, as well as the ones at the NI site). Reaktor users have created an amazing community, and I urge all readers to join in.
Finally, please remember that because Reaktor is such a flexible, open-ended environment, there are certainly many alternative ways to do anything described in this tutorial, and many additional options I haven't even dreamed of. I've simply included here what I thought were the easiest ideas to implement, based on what I could imagine.
So, go boldly forth and invent new stuff... and I hope you'll share your discoveries with the rest of us!
# Reaktor/Tutorials/Reaktor as effects processor/Ensembles
## Ensembles

Ensembles (R documents with suffix .ens) are at the top level of R and have the Reaktor icon in the Browser. Only one can be open at a time; you can't link them together. When you open an Ensemble, you'll see that it contains one or more instruments, plus the Audio In and Audio Out modules, which are only visible in the Ensemble - Structure view... and any ensemble that's currently open will close.
Ensembles can ONLY contain Instruments! All other objects must be inside instruments. To insert other object types into an ensemble, first open the structure of one of the instruments within it, then insert.
next page
# Reaktor/Tutorials/Reaktor as effects processor/LFOs — use waveforms to move parameters
## LFOs—Use waveforms to move parameters

A Low Frequency Oscillator is simply a wave-form generator whose waves are moving so slowly that they can be used as a modulation source, instead of so fast that they make a sound (and would be more useful as a sound source for a synth).
You can connect the output of any LFO available in Reaktor, either from the Macro or Module Libraries, or swiped from other instruments and ensembles, via MIDI, to any knob, slider, or other panel control and watch the control move, following the LFO's wave form, which can be one of several common types, including sine, triangle, pulse, random, and others.
The trick is to focus the movement exactly where you want it using the LFO's control settings, its properties and other modules which can change the values and shapes of the waves. Most LFOs are “bi-polar;” that is, their wave-forms travel equally far both above and below zero, creating both positive and negative values. Many knobs, etc., on the other hand, only go from zero to maximum. So, the first thing I set out to build was a Positive-only LFO.
Of course, I didn't have to build this from scratch; I just asked about it in the Reaktor forums, and many ideas and suggestions appeared over night (special thanks to Chris List and John Nowak). And, I later discovered that several LFOs with positive-only settings already exist for the taking... there's one in the Green Matrix synth, for example, which I've used here and included in the downloads; it's hooked up to the Position Slider in the InScanner instrument just described. Let's take a closer look.
next page
# Reaktor/Tutorials/Reaktor as effects processor/Instrument hierarchy
## Instrument hierarchy

To save the settings of multiple instruments with a single snap, you need to create a snapshot master. This can be either an instrument that contains the instruments you want it to be the master for, or it can be the ensemble itself... or both.
In the ensemble shown below, neither instrument can be the master for the ensemble, because they're both at the same level; one is not contained within the other, they're both simply contained within the ensemble. The ensemble can be the master, but not as it's configured here, simply because there is currently no ensemble header to provide a snapshot selector.
To create an ensemble header, simply open Properties (F4), go to the Appearance page, and focus it on the ensemble by clicking on the ensemble panel background. Hi-lite the “Visible in Main Panel” button, and the header will pop into view.
To make the ensemble the snapshot master for the instruments in the ensemble, focus the Properties on the header by selecting it, then switch to the Functions page, and hi-lite the “Snapshot Master for Plugin” button. Next, focus the same page on each instrument whose snaps you want to control with the Master, and turn on the “Store by Parent” and “Recall by Parent” buttons for each one.
Now you can see ensemble-level snapshots for our example ensemble, and that they are master snaps, both saving a new snap to each instrument snapshot bank when created, and recalling all those snaps when selected.
Interestingly, you can create nested instrument hierarchies with multiple snapshot masters within a single ensemble, as shown below. Each instrument at the ensemble level here is simply a container, holding two processing instruments within it. Only the Ensemble in this case has been designated as “Snapshot Master for Plugin” in its Properties. All the instruments are simply set up to store and recall “by Parent,” as just described, but selecting a snap in either “sub-master” container instrument will recall the same snap in each “child” instrument inside it. This demo ensemble is included in the tutorial downloads, so you can experiment with this snap-storing process.
Note that master snaps are inserted in “child” instrument banks in the same numbered slot as they have in the parent bank, bumping all existing snaps up a slot each time a new master snap is created.
next page
# Reaktor/Tutorials/Reaktor as effects processor/Macros
## Macros

Macros (documents with suffix .mdl) have an icon with three modules linked together, and are self-contained structures that hold other patched-together objects (including instruments, other macros, and modules), just like instruments.
The difference is that macros don't have their own snapshots or panels. They're designed to organize various parts of a complex instrument or ensemble into sub-devices, all of which will be controlled by a single snapshot taken by the containing instrument. An outline around a portion of the controls on a R panel tells you you're looking at a macro that's inside the structure of that instrument, if the panel designer chose to make the macro outline visible, using the Properties window described later in this tutorial.
Modules are R documents at the lowest level. They're the basic building blocks of all the other objects. Each module has its own unique icon, if there's room for an icon on it. Modules can't be opened and they don't have structure windows; they are configured using the properties window (Mac/PC: F4), as you'll see in the Properties portion of this tutorial. Reconfigured modules can only be saved by saving an object that contains them, not on their own, but once reconfigured, they can be copied and pasted.
All other R components can be opened and altered in a new structure window by double-clicking on them.
next page
# Reaktor/Tutorials/Reaktor as effects processor/An addendum on tables
## An addendum on tables

Here are a few table-related tips, plus a description of a new table-drawing instrument I've added to the pedal-driven tables ensemble; it allows you to create table curves using math modules, and it's sized to simplify copying and pasting from it into the pedal-driven tables.
The tips: A table has three modes: D (draw), S (select), and C (control). Change modes by clicking in the mode indicator box in the upper left hand of the table window, or by hitting the TAB key when the table is selected. D lets you draw in the table, S lets you select all or part by dragging in the table, and C locks the table so it can't be altered. To copy or paste from one table to another, or from one part of a table to another, both the source and the destination table or part must be selected. You can shift a selection vertically (scale it) by clicking and dragging up and down with the mouse when pressing Command (Mac) or Ctrl (PC), and shift horizontally (rotate it) by clicking and dragging right or left when pressing the Shift key.
next page
# Reaktor/Tutorials/Reaktor as effects processor/Extracting instruments from ensembles
## Extracting instruments from ensembles

Most library effects are available as both ensembles and instruments in the library, which makes it easy to assemble your own choice of effects instruments into new multi-effect ensembles. But occasionally you'll come across an ensemble, perhaps in the User Library, that includes one or more new effects instruments that you'd like to borrow. Any instrument within any ensemble can be saved as a standalone instrument by opening its contextual menu, choosing “Save Instrument As... ”, giving it a new name and storing it in a new location, from which you can insert it into any open ensemble, using the browser or the ensemble's contextual menu.
I always add the .ism suffix when I save an instrument this way, and keep .ism's in their own folder within my FX-favorites folder. This isn't strictly necessary; only instruments will show up when you scan a folder of ensembles and instruments in order to insert an instrument into an ensemble structure window. But the Browser is easier to use when huge folders are organized into subfolders.
next page
# Reaktor/Tutorials/Reaktor as effects processor/Hightlights of the properties window
## Hightlights of the Properties window

Every Reaktor object has numerous properties, allowing you many different ways to configure the behaviour and appearance of everything you build or use. The following overview and few examples show several interesting properties from an effects-processing and parameter-control perspective. As you read further on in the other parts of this tutorial, you'll see how I've used all of these examples myself when creating the ensemble examples described and included. You may find it most useful to come back to this section for close reading after exploring them. Hit F4 (Mac/PC) to open the Properties window. When open, the Properties window is always on top, and its focus and contents change depending on what object is hi-lited in any panel or structure window (instrument, module, macro, panel control, table, etc.) It has 4 pages:
next page
# Reaktor/Tutorials/Reaktor as effects processor/Instruments
## Instruments

Instruments (R documents with suffix .ism) are the next level below ensembles, and have a keyboard Icon, both in the structure window and in the Browser. Multiple instruments can be open and linked together within an single ensemble. Instruments can be dragged from the Browser or opened from menus to insert them into the open structure window of any type of object that has a window, which includes Ensembles, other Instruments, and Macros.
Only Instruments and ensembles have snapshots, or presets, and every instrument within an ensemble has its own snapshot selector in the Panel view.
No matter where they are inserted, instruments always have their own panel in the panel view. The two instruments above are collapsed, and will expand to reveal their panel controls when either the View A or B button is selected. Once opened, you can unlock each panel to rearrange its controls as you prefer, and each view can hold a different arrangement of, and different selection of, all available controls. You can also open each instrument panel in its own window, in addition to the ensemble window.
next page
# Rebol Programming/violet

VIOLET is a tuple of value: 72.0.90
# DESCRIPTION:

Prints a list of globally-defined functions.
WHAT is a function value.
# DESCRIPTION

Prints the active directory path
WHAT-DIR is a function value.
# Rebol Programming/view?

It's set by rebol to true if you are using Rebol/View; otherwise it is set to false.
For more information: http://www.rebol.com/download-view.html
# DESCRIPTION:

Returns TRUE if face is displayed.
VIEWED? is a function value.

# ARGUMENTS

* face -- (Type: object)
# Rebol Programming/water

WATER is a tuple of value: 80.108.142
# DESCRIPTION:

Display the REBOL viewtop
VIEWTOP is a function value.

# ARGUMENTS

* url -- (Type: url file any-type)

# REFINEMENTS

* /only -- Only if prefs/desktop option says so
# DESCRIPTION:

Waits for a duration, port, or both.
WAIT is a native value.

# ARGUMENTS

* value -- (Type: number time port block none)

# REFINEMENTS

* /all -- Returns all events in a block
# DESCRIPTION:

While a condition block is TRUE, evaluates another block.
WHILE is a native value.

# ARGUMENTS

* cond-block -- (Type: block)
* body-block -- (Type: block)
# Rebol Programming/wheat

WHEAT is a tuple of value: 245.222.129
# Reconstruction

This book will function as a guide to the reconstruction of homes, specifically those damaged by hurricanes. The book will be a series of tutorials logically organized. This book will be geared towards use by volunteer groups, semi-skilled labor, and home owners.

## Table of Contents
### Section I: Deconstruction

* Safety (Jul 31, 2006)
* Evaluation (Jul 31, 2006)
* Prep
* Debris Removal
* Trim, Frame, and Cabinet Removal
* Wall Removal
* De-nailing and De-wiring

### Section II: Mold Treatment

* Safety
* Prep
* Mold Treatment
** Scrub and Spray (Jul 31, 2006)
** Grind and Scrub
** Bleach and Baking Soda
* Mold Test

### Section III: Reconstruction

* Safety
* Evaluation
* Permits and Licenses
* Roofing
* Electrical
* Plumbing
* Insulation (Jul 31, 2006)
* Walls
** Drywall (Jul 31, 2006)
** Wood Panels
* Door Installation
* Trim Work
* Cabinet Installation
* Painting
* Flooring
# Function poisoning
### Intent

Hide or prohibit the usage of certain functions, favoring better alternatives.

### Motivation

Often, when interacting with libraries that have a C or pre-C++11 interface, since modern C++ is more expressive, it would be very convenient to hide (from people that are working on a project), all (or just many) functions that allocate memory and return a raw pointer (like a T*), and replace them with something more RAII-friendly (like a unique_ptr).

### Solution and Sample Code

Guideline for banning a function:
A function g is a strict replacement of a function f of a library L if:
* g provides clear benefits over f (like putting the deleter in a destructor instead of manual call)
* g can act as a drop-in replacement for f, which means:
** it can interact with the library L without writing more than one line of glue code that has no particular drawbacks
** updating f to g in the codebase is a trivial operation (use Change All Occurences or a simple find-and-replace)
** the cost of removing f is not too high
* g does not have any drawback compared to f, which means:
** it does not add any measurable runtime overhead compared to f
** it does not add any new dependency
** it cannot be less type-safe, exception-safe or thread-safe
** it cannot introduce new kinds of programming errors
* g does not reduce readability or hides intent compared to f, which means:
** there is no need to document what g does since it should do the same of f, only the benefits if those are not clear to everyone
Therefore, if g is a strict replacement of f, one can ban f in a codebase.

### Known Uses

Replace a function which cannot be removed (for example if it is part of an external library) with a function with improved functionality.

### Related Idioms

* Interface Class