OpenLLM-France/wikimedia huggingface dataset:
# Monetary Economics/What is Money?
## What is Money?

It is useful when defining the entity 'money' to look at what 'money' is used for, at least according to economists. There are 3 generally accepted uses of money:
* As a medium of exchange
* As a unit of account
* As a store of value
We can then approach the question of exactly what 'money' is by taking 'money' to mean that entity which we can use to fulfil the functions of 'money', as defined above. It is then possible to measure money in the real world, making decisions as to what form of monetary balance would meet our criteria of what 'money' is. Moreover, this approach enables us to section the money market along the various lines defined by the different motives to hold money, increasing the flexibility of our analytic model.
This section will look at each function of money in turn, and examine how each function affects the definition of money. We then look at the practical measurement of money in the real world.
# Online OsiriX Documentation/Extract a 3D volume from a series

Extract an area from a series for 3D reconstructions
1) Open your series and select the Closed Polygon tool
2) Activate the Thick Slab feature
3) Draw your ROI on this Thick Slab
4) Propagate your ROI to current Thick Slab by pressing Ctrl-S, or menu ROI : Propagate to current Thick Slab
5) “Jump” to the next Thick Slab, by using Ctrl-Left or Right Arrow keys
6) Continue to create your ROIs, and propagate the selected ROI up to the end of the series
7) Delete pixels that are outside these ROIs
8) For a CT series: select “Outside” and use “-1000” value
9) You can now produce your 3D image
For example, a cardiac-CT without the bones…
# Online OsiriX Documentation/Forwarding a Crash Report to the Developers

One hopes that OsiriX will never crash. However, if it ever does, you can be very helpful to the developers by forwarding a crash report to them.
To do this, go to the Utilities folder which is located in your Applications folder.
There you will find an application named Console. Double-click on this application to run it. You should now see a window that looks something like this:
If you don't see the side pane on the left listing all of the available logs, click on the Logs icon to toggle this list on.
Now click on the little triangle next to ~/Library/Logs. This should toggle a sublist of the logs in this category. Your screen should now look something like this:
Now click on the little triangle next to CrashReporter. This will toggle a sub-sublist of the crash reports from various applications. You may see something like this:
Now scroll down through this list until you see an option titled OsiriX.crash.log. Click on this and you will now see a lot of text appear in the right sided pane of the Console application window, such as shown below.
This, at long last, is your crash log for OsiriX. Drag your cursor over this text and copy it. Then paste it into an e-mail message to one of the OsiriX developers.
An even more sophisticated approach is to use the BugTracker feature of SourceForge.net (where the OsiriX source code base is maintained). You can access it from http://sourceforge.net/projects/osirix/ This process is described in Online OsiriX Documentation/SourceForge BugReporter.
# Online OsiriX Documentation/How to Generate DSA Images

There are two ways to generate Digital Subtraction Angiography images with OsiriX (v1.7), once an XA image sequence has been stored in its database (an example sequence can be found at http://homepage.mac.com/kieranmaher/Anonymized.zip):

## 1. Using the Subtraction module

Display the image sequence in the 2D Viewer and activate the subtraction module (use Format | Customize Toolbar... if this module is not displayed in the toolbar of the 2D Viewer).
| Mask Image (1) | Live Image (9) |
The image number used for the mask image is displayed – the first image of the sequence is the default mask. Browse through the sequence and adjust the WL/WW as needed. Click on the ‘current’ button to select another mask image.
| (1) - (9) | (9) - (1) |
Use the up/down arrows to shift the relative position of the mask and live images in single pixel increments in both horizontal (X) and vertical (Y) dimensions, if needed.
Note than finer shifts than whole pixels are a feature yet to be implemented in OsiriX.
Use the Thick Slab module, in the MinIP mode to (effectively) integrate a number of live images so as to generate a vascular trace.
* (1) - (5+6+7+.....+15)
Notes:
Pixel values displayed for subtracted images refer (incorrectly) to unsubtracted images – presumably because the subtracted image is generated in display memory only.
A plug-in is available from http://homepage.mac.com/kieranmaher/LogTransformplugin.zip (for purists) to take the Log Transform of an image sequence prior to running the subtraction process.

## 2. Using the Fusion module

Open an image sequence in the 2D Viewer, and open the same sequence for a second time, so that the image sequence is displayed in two separate windows. Turn off synchronization by selecting 2D Viewer | Stack Syncronize | Off. Drag the icon of one window and drop it onto the image in the second window to call up the fusion functions and click the Subtraction button:
Pixel values displayed for subtracted images refer (correctly) to subtracted images with this option, although pixel shifting is not available. The Thick Slab module can be used to (effectively) integrate both mask images (before subtraction) and live images (before and following subtraction) so as to improve image SNR and to generate a vascular trace.
# Online OsiriX Documentation/Exporting DICOM images

With OsiriX, you can export your DICOM images as TIFF, JPEG, RAW or DICOM images or as a Quicktime sequence. This allows you to capture selected images in a format that will allow you to bring them into, for example, PowerPoint or Keynote presentations or import them into a Microsoft Word document.
To export a single image, you can either press apple-copy (Command-C) to copy it to the clipboard or select Export from the 2D Viewer menu. The Export menu item has a submenu to allow specification of the particular image format (TIFF, JPEG etc.). Using the default preferences, OsiriX will export the image as it appears on the screen -- same size, zoom, rotation, window level, etc. You can find the exact size of the image on the upper left corner of the window:
The same principle applies for images sequence. Select Export to Quicktime from the Export submenu or click on the Quicktime button from the toolbar. With Quicktime export, you have the possibility to export the image fusion dimension of the 4D viewer dimension, if these modes are activated:
You can also change the compression mode and playing rate. We recommend the JPEG compression for best quality.
The preferences can be changed so that when an image is exported, it retains the original image size. This option is found under the Viewers tab in the Preferences... window (OsiriX menu). If this option is enabled, then a 512 by 512 matrix CT will be exported as a 512 by 512 image. In addition, only the image itself is exported, not the alphanumerics such as the patient name. This is often the appropriate choice for capturing images for presentations or papers.
To view and edit the DICOM header before exporting to DICOM, go to OsiriX Format Menu, select Customize Toolbar, drag the Meta-Data button into your toolbar where you want it, select Done on the toolbar customization window. You can save the Metadata as a text file or XML.
OsiriX
# Online OsiriX Documentation/Forward a Crash Report to the Developers

One hopes that OsiriX will never crash. However, if it ever does, you can be very helpful to the developers by forwarding a crash report to them.
To do this, go to the Utilities folder which is located in your Applications folder.
There you will find an application named Console. Double-click on this application to run it. You should now see a window that looks something like this:
If you don't see the side pane on the left listing all of the available logs, click on the Logs icon to toggle this list on.
Now click on the little triangle next to ~/Library/Logs. This should toggle a sublist of the logs in this category. Your screen should now look something like this:
Now click on the little triangle next to CrashReporter. This will toggle a sub-sublist of the crash reports from various applications. You may see something like this:
Now scroll down through this list until you see an option titled OsiriX.crash.log. Click on this and you will now see a lot of text appear in the right sided pane of the Console application window, such as shown below.
This, at long last, is your crash log for OsiriX. Drag your cursor over this text and copy it. Then paste it into an e-mail message to one of the OsiriX developers.
# Online OsiriX Documentation/Help with IT, costs

E2-Are there any Return on Investment studies with Osirix, so that i have better weapons for Windows centric Dept at the hospital.
E3-Training Material for Osirix apart form what I found at Ositix home page.
E4-Additional recommendations for setting a complete solution with Osirix.
E5-Any type of studies Osirix is not good as diagnostic workstation.
E6-Any important equipment or standard not supported on Osirix, which would lead to a need for a commercial solution.
# Online OsiriX Documentation/FAQ

FAQ
1) Which light Windows compatible DICOM Viewer should I burn on DICOM CDs? Try K-PACS, available here: http://www.k-pacs.net/ The easiest way to get all required files is to install K-PACS on a Windows Computer, import a DICOM file into the local database (FILESYSTEM tabulator), select this newly imported study and click "EXPORT". Select "Burn on CD" and then "create CD project". Place all ".dll" ("dicomdll.dll", "iq.dll", "dcmtk.dll") and ".exe" ("K-PACS-Lite.exe") files of the CD project's folder in the root directory of your OSIRIX patient CD.
2) Why I cannot open a 2,000 images series with my 8-GB MacPro? The base version of OsiriX is a 32-bit application that can address only 4-GB. Buy the 64-bit extension and you will be able to use all the ram you want.O
3) I can Query a DICOM node, but I cannot Retrieve. Why? To Query a DICOM node, you have to add his parameters in the Locations View of the Preferences. But to Query & Retrieve a DICOM node, you also have to add the parameters of your OsiriX DICOM workstation on the DICOM nodes list of the PACS (AETitle, IP Address and Port Number). Contact the PACS IT manager to add these parameters. These parameters can be found in the Listener View of the Preferences. Warning: port 104 requires root access on MacOS: you cannot receive communications on this port. You should prefer port 11112 (ftp://medical.nema.org/medical/dicom/final/cp603_ft.pdf). Be sure that you didn't activate the Firewall on your Mac: go to System Preferences / Sharing / Firewall, and Stop it if it was activated. Each AETitle should be unique, if not, Query & Retrieve can fail (C-Move SCU/SCP).
4) I'm searching an open-source PACS Server software that runs on Mac hardware. What do you recommend?Try DCM4CHEE (http://www.dcm4che.org/). For a step-by-step installation, visit: http://www.osirix-viewer.com/PACS.html
5) I cannot retrieve Images via VPN 2Mbit SDSL. The errormessage is "MoveFailed: RefusedOutOfResourcesSubOerations". Firewalls are turned off. Parameters in preferences are correct. What is wrong? Check that you are not using a port below 4000. Recommend 4444, 4096 or 11112. Check that your computer (AETitle, address and port) is correctly saved in the PACS server. It requires a FIXED IP.
6) When I insert a DICOM CD, I can see the images, but when I eject the CD the images disappear. How can I put and save the images in the database? You can automatically copy the images in the database when inserting a DICOM CD. Go to the Preferences - Database, and select 'Copy files to OsiriX Data if', and select 'Ask the user'.
7) How to repair a corrupted Database.sql file? Open the Terminal application and enter 'sqlite3 Database.sql .dump | sqlite3 DatabaseRepaired.sql'. And replace the corrupted database with the new file.
# OpenGL Programming/Mini-Portal Recursive

Drawing portals-within-portals introduces a new set of corner cases.

# Recursive portals

Here's the algorithm overview:

# Clipping the portal scene

The stencil buffer will be created incrementally:
* draw a portal shape
* draw its intersection with the sub-portal shape to get a new portal clip shape
* repeat
To get the intersection is not straightforward:
* draw the outer portal using GL_INCR
* draw the sub-portal using GL_INCR
* re-draw the outer portal using GL_DECR
* pixels >= 1 represent the intersection between the outer portal and the sub-portal
Technically we could save and restore the buffer at each level of recursion (instead of re-drawing all the portal shapes from scratch), but this would be slow, and retrieving the stencil buffer data is not possible with OpenGL ES 2.
The outer portal and sub-portal are exactly the same object, only the View matrix changes. So we pass a stack of view to the function, and push a new View matrix with each new level of recursion.
Note that the stencil drawing must support volumetric portals, which means it may be written to more than once (so you cannot achieve intersection using just GL_INVERT).
Think about the fill_screen trick if you need to debug and see what your shape looks like.
- Recent stats
< OpenGL Programming
# OpenGL Programming/Migrating from 1.x to 2.x

OpenGL ES 2.0 has most of OpenGL 1.x just not available, and OpenGL 3.x and OpenGL 4.x deprecate it (the features are still available in the "compatibility profile", but you can expect the features to disappear soon enough).
However, little is said about how these features are replaced in the new versions. Here's how:

# Matrix stack

Deprecated functions: glIdentity, glRotate, glOrtho, gluOrtho...
Matrix maths can be done:
* in the shaders, using build-in operators
* in the C source code using additional libraries such as:
** GLM - http://glm.g-truc.net/
*** cglm = Highly Optimized Graphics Math (glm) for C
** Kazmath - https://code.launchpad.net/~kazmath-developers/kazmath/trunk
** libSIMDx86 - http://simdx86.sourceforge.net/
GLM provides glm::ortho to replace glOrtho and gluOrtho for orthographic perspectives (and 2D programming).
Examples:
* Tutorial 05: cube rotation

# Vertex and texture

Deprecated functions: glVertex, glTexCoord...
These data are now sent in batch mode, as C arrays. You can use:
* directly a C array : data is resent a each frame
* glBufferData : send the C data once to the graphic card, then refer to the buffer
You use glVertexAttribPointer, once for each vertex attribute (position, color, texture coordinate...), passing it the C array or OpenGL buffer.
Examples:
* Tutorial 01: introduction (C arrays, no buffer)
* Tutorial 04: cube (elements)
Then you use glDrawArrays or glDrawElements to start drawing.

# Normals

Deprecated functions: glNormal, glNormalPointer
Normals need to be passed to the shaders (namely for shading computations), like vector coordinates (glVertexAttribPointer). To compute the normal of 3 vertices a, b and c in counter-clockwise order, GLM provides:
Examples:
* Tutorial 08: load .obj, computing normals on the fly

# Evaluators - Bezier curves and surfaces

Deprecated functions: glMap1, glMap2, glEvalCoord, glEvalPoint...
* GLU ES - http://code.google.com/p/glues/ - this is for OpenGL 1.x, so it may not work in a 2.x environment, but provides replacement code
* Manual code (not that hard)
Examples:
* Tutorial 07: teapot (Bézier surfaces)

# Lighting

Deprecated functions: glLight (glLightfv3, etc.), glShadeModel...
The bad news is that you have to reimplement everything in the shaders. The good news is that it's not so hard, plus you have copy/pasteable code in the examples below :)
You also need to make the light parameters available to your shaders, and it's best to store them as a shader struct.
Examples:
* Diffuse Reflection
* Other parts of the lighting tutorials
- Recent stats
< OpenGL Programming
# Optimization - the scissors

We saw that the scissors were not suited for clipping portals, because scissors can only clip a rectangle. However, scissor clipping is much faster than stencil buffer clipping (it's just a coordinates comparison, rather than a complete screen buffer access).
We can use the scissors to optimize the performances, by doing a first rough clipping, before using the stencil buffer. This will also allow us to detect when a sub-portal is completely hidden and break from the recursive loop.
- Recent stats
< OpenGL Programming
# Nim Programming

Nim Programming

## Table of contents
### Introduction

    Why Learn Nim
    How to Install Nim

### Basics

    First steps, hello world!
    Variables
    Conditionals
    If Then Else...
    Blocks
    Loops

### Starter

    Starting
    Typing types

### Definition

    What's a compiled language?
# Nimrod Programming/Basic type
## Typing types

So now let's introduce a new concept, types. Types are categories of data, indeed we have already used some of them, string, Boolean and int. Using them is easy, we just need to change how we declare variables. Up until know we have been doin something like this:
var myVar = "This is a string"
But we can also do this:
var myVar:string myVar = "This is a string"
Or even this:
var myVar:string = "This is a string"
As you may know, Nim needs to know what kind (type) of variable it is before making the executable (because the resulting program is faster that way) and it can't be changed the type after that. Now we have all sort of technical names for those attributes, but this is generally called static typing, and we say Nim it's a statically typed language (one in which the types of variables won't change). This may sound very confusing, types? static typing? What?? But let it be a moment and it may start to make sense (if not don't worry it will end up doing that).
Well we know what a type is, though, how we do know what types are available to us, in order to play with them? Well, we are going to list them, however for now we are going to introduce only the most basic ones (which are pretty much the same for every language):

### Numbers

In order to have an efficient way of representing numbers there are several kinds of numbers:
# Nikola Tesla/Sources

* Tesla, Nikola, "My Inventions (An Autobiography)", Electrical Experimenter magazine, Feb, June, and Oct, 1919.
* O'Neill, John J., "Prodigal Genius: The Life of Nikola", 1944. ISBN 0913022403
* W.C. Wysock, J.F. Corum, J.M. Hardesty and K.L. Corum, Who Was The Real Dr. Nikola Tesla ? (A Look At His Professional Credentials)". Antenna Measurement Techniques Association, posterpaper, October 22-25, 2001 (PDF)
# Nikola Tesla

Nikola Tesla :
| Introduction Early years Middle years Later years References Sources | Harnessing Nature's Wheelwork |
# Introspector/GccCpp/tree.h
## Tree.h header

Here is the header file :
# Introspector/Interfaces/GUI

The introspector GUI will ideally be a c# windows application.
The ["Abstract GUI Client"] is a proposed API that will isolate you, the user from a particular GUI toolkit.
It is based on the ["MVC Concept"] which splits things into Model ["MVC/Model"], View ["MVC/View"] and Controller ["MVC/Controller"].
The user looks at the view, and enters data into the controller.
The ["GUI User"] provides events to the ["MVC/Controller Elements"].
The controller is basically a producer of events that are sent to the model. A stream of updates are sent from the controller to to model, and that updates all the views that are watching a particular object.
The ["GUI Application Server"] serves ["MVC/View"] to the ["GUI Client Application"]. The ["GUI Client Application"] displays ["MVC/View"] to the ["GUI User"], and it offers multiple ["MVC/Controller"].
The ["GUI Application Server"] uses ["MVC/Model"] to store ["Application Data"].
The ["Application Data"] is able to be processed by any backend module.
The ["MVC/Model"] can be a ["DotGNU/RDF Model"].
The ["DotGNU/RDF Model"] can be composed of ["DotGNU/RDF Graphs"].
The ["DotGNU/RDF Graph"] can be managed on ["DotGNU/RDF Storage Server"].

## TaskProposal DotGNU RDF Gui

Implement a ["DotGNU"] ["RDF"] ["Gui"] using ["Abstract GUI Client"].
Status : Proposal
# Introspector/Introspection

The definition of introspection :
the Introspector is a ModeofMind, a StateOfAwareness. the IntrospectorModeOfMind has a LearningAndInteractiveNature.
The Introspective mind is a read only mode at first, it allows you to see into yourself.
The issues of OntologicalStructure and SymbolicDefinition come ito play when you are Introspecting.
To introspect means literaly to look inside. To spect is to spy, to watch. To externalized your internal ideas into *more* internal forms, but for you mind to see.
This is the ExpansionPredicate, you expand on a symbol, and visualize it.
To project images inside the mind.
It is a result of adding one InfQuant to an InternalMentalEvent in the VisualSphere.
an InfQuant is a Quantity of Information
The InternalMentalSymbols, the SymbolDecls, the IconDecls, the GraphDecls that are visualized to the outside world are at first meaningless to a third party.
First via the assignment to a Meaning does a Symbol become valuable. First when they are assigned a meaning via semantics can the value of them be understood.
This process is a stepwise process that involves an human partner that takes part in the introspector use case. Via interfacing with a human, we are able, to extract "meaning" from them.
This meaning is into sentences, an human encoding, an understandable textual form. Sentences allow easy understanding, via direct expression of subject, predicate and object we can indicate the meaning.
Let us look to quotes
http://www.peirce.org/writings/p119.html
Here is an interesting api that I found into the introspector,it externalizes an model, allowing it to be inspected. http://jade.cselt.it/doc/api/jade/content/onto/Introspector.html#method_detail http://jade.cselt.it/doc/api/jade/content/schema/ObjectSchema.html
Quote from : http://www.quebecoislibre.org/030510-9.htm
Quote from http://www.gazettenet.com/04222003/entertai/5279.htm
Quote from http://www.globeandmail.com/servlet/ArticleNews/TPStory/LAC/20030507/CASUCC/TPBusiness/General
From : http://electroniciraq.net/news/737.shtml
Quote from http://ontology.buffalo.edu/smith//articles/mach/mach.html
See also PrinciplesOfVirtualWork PrinciplesOfContinuity
Quote from http://www.acooke.org/andrew/writing/lang.html
from : http://www.singinst.org/LOGI/seedAI.html
More to come.....
# Introspector/LanguageTools/SilverScheme

SilverScheme is a Scheme like OO language that uses introspection heavily. The rather unedited doc is here: Introspector/LanguageTools/SilverScheme/Doc. The ontology used is here: Introspector/LanguageTools/SilverScheme/Ontology.
In Silverscheme the class system is implemented on top of the prototype system. The prototype system is pretty easy: every object is a (changed) copy of another object. The object that it's a copy of is it's prototype.
A few important concepts:
SilverScheme will have a built-in KnowledgeInterchangeFormat reasoner for logic programming.
Knowledge Interchange Format (KIF) is a way of representing knowledge in computers. It's also a quite simple logic language that's useful for reasoning about knowledge. At the moment KIF resources are rather spread across the web, here are a few links:
Introspector/KifTutorial
Ideas for libraries and tools go at Introspector/LanguageTools/SilverScheme/Projects.
A list of projects that will be needed to support SilverScheme and/or make it more fun.
Needed:
Fun:
Usually languages have small examples that aren't really fun. SilverScheme has a big fun example however, a full blown board/card game named Sourcery. Sourcery will be a good example of the logic capabilities of SilverScheme since it will use KIF to determine what is allowed and what not in a dynamic way.