Mumps/MDH Toolkit
Experiments in Information Storage and Retrieval Using Mumps
5th Edition
Kevin C. O'Kane, Ph.D.
Computer Science Department
University of Northern Iowa
Cedar Falls, IA 50614
okane@cs.uni.edu
http://www.cs.uni.edu/~okane
May 4, 2008
|
Copyright (c) 2007, 2008 Kevin C. O'Kane, Ph.D.
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the Invariant Sections being: Page 1, with the Front-Cover Texts being: Page 1, and with the Back-Cover Texts being: no Back-Cover Texts. |
The purpose of this text is to illustrate several basic information storage and retrieval techniques through real world data experiments. Information retrieval is the art of identifying similarities between queries and objects in a database. In nearly all cases, the objects found as a result of the query will not be identical to the query but will resemble it in some fashion.
For example, if your query is "give me articles about aviation," the results might include articles about early pioneers in the field, technical reports on aircraft design, flight schedules on airlines, information on airports and so on. For example, the term "aviation" when typed into Google results in about 111,000,000 hits all of which have something to do with aviation.
Information retrieval isn't restricted to text retrieval. So, if you have a cut of a musical piece such as this (from the Beethoven 9th Symphony) and you want to find other music similar to it such as this (from the Beethoven Choral Fantasy), you need a retrieval engine that can detect the similarities.
Similar examples exist in many other areas. In Bioinformatics, researchers often identify DNA or protein sequences and search massive databases for similar (and sometimes only distantly related) sequences. For example, the DNA sequence:
>gi|2695846|emb|Y13255.1|ABY13255 Acipenser baeri mRNA for immunoglobulin heavy chain, clone ScH 3.3 TGGTTACAACACTTTCTTCTTTCAATAACCACAATACTGCAGTACAATGGGGATTTTAACAGCTCTCTGTATAATAATGA CAGCTCTATCAAGTGTCCGGTCTGATGTAGTGTTGACTGAGTCCGGACCAGCAGTTATAAAGCCTGGAGAGTCCCATAAA CTGTCCTGTAAAGCCTCTGGATTCACATTCAGCAGCGCCTACATGAGCTGGGTTCGACAAGCTCCTGGAAAGGGTCTGGA ATGGGTGGCTTATATTTACTCAGGTGGTAGTAGTACATACTATGCCCAGTCTGTCCAGGGAAGATTCGCCATCTCCAGAG ACGATTCCAACAGCATGCTGTATTTACAAATGAACAGCCTGAAGACTGAAGACACTGCCGTGTATTACTGTGCTCGGGGC GGGCTGGGGTGGTCCCTTGACTACTGGGGGAAAGGCACAATGATCACCGTAACTTCTGCTACGCCATCACCACCGACAGT GTTTCCGCTTATGGAGTCATGTTGTTTGAGCGATATCTCGGGTCCTGTTGCTACGGGCTGCTTAGCAACCGGATTCTGCC TACCCCCGCGACCTTCTCGTGGACTGATCAATCTGGAAAAGCTTTT |
Where the first line identifies the name and library accession numbers of the sequence and the subsequent lines are the DNA nucleotide codes (the letters A, C, G, and T represent Adenine, Cytosine, Guanine, and Thymine, respectively). A program known as BLAST (Basic Local Alignment Sequencing Tool) can be used to find similar sequences in the online databases of known sequences. If you submit the above to NCBI BLAST (National Center for Biotechnology Information), they will conduct a search of their nr database of 6,284,619 nucleotide sequences, presently more than 22,427,755,047 bytes in length. The result is a ranked list of hits of sequences in the data base based on their similarity to the query sequence. Sequences found whose similarity score exceeds a threshold are displayed. One of these is:
>gb|U17058.1|LOU17058 Lepisosteus osseus Ig heavy chain V region mRNA, partial cds
Length=159
Score = 151 bits (76), Expect = 4e-33
Identities = 133/152 (87%), Gaps = 0/152 (0%)
Strand=Plus/Plus
Query 242 TGGGTGGCTTATATTTACTCAGGTGGTAGTAGTACATACTATGCCCAGTCTGTCCAGGGA 301
|||||||| ||||||||| | | ||| || | |||||||||| |||||||||||||||||
Sbjct 4 TGGGTGGCGTATATTTACACCGATGGGAGCAATACATACTATTCCCAGTCTGTCCAGGGA 63
Query 302 AGATTCGCCATCTCCAGAGACGATTCCAACAGCATGCTGTATTTACAAATGAACAGCCTG 361
|||||| |||||||||||||| ||||||| | |||||| ||||| |||| |||||||
Sbjct 64 AGATTCACCATCTCCAGAGACAATTCCAAGAATCAGCTGTACTTACAGATGAGCAGCCTG 123
Query 362 AAGACTGAAGACACTGCCGTGTATTACTGTGC 393
||||||||||||||||| ||||||||||||||
Sbjct 124 AAGACTGAAGACACTGCTGTGTATTACTGTGC 155
|
In the display from BLAST seen above, the sections of the query that match the sequence in the database are shown. The numbers at the neginning and ends of the lines are the sarting and ending points of the subsequence (relative to one, the start of all sequences). Where there are vertical lines between the query and the subject, there is an exact match. Where there are blanks, there was a mismatch.
It should be clear that, even though the subject is different than the query in many places, the two have a high degreee of similarity.
Also, consider the search for similar images. Again, this involves searching for similarities, not identity. For example, a human observer would clearly see the two following pictures as dealing with the same subject, despite the differences:
An obvious question would be, how can you write a computer program to see the similarity?
Mumps
In this book we will mainly deal with text retrieval.
The main software tool will be an interpreter for the Mumps language.
As noted below, the Mumps language was originally developed to
handle hierarchical medical record data. It did this through
a facility known as "global arrays". Global arrays are large (64 bit
file addressed), multi-dimensional,
string indexed, disk based data structures used to store text and numbers.
In their simplest form, they are text indexed vectors. At their most
complex, they are text indexed trees storing both code and information.
The examples in this text are written in the dialect of Mumps accepted
by the Mumps Compiler and related Mumps Interpreter. These are open
source (GPL/LGPL licensed) free software packages. While mainly
designed to run under Linux and Cygwin, there are versions available for Windows XP.
Greatest efficiency and interoperability with other software
is achieved by compiling Mumps programs to C++ and then to
executables. However, for both Linux and Windows XP there
are stand-alone interpreters for Mumps.
While interpreters increase program run time
(generally not too great as most of the examples shown
here are predominantly I/O bound jobs), they are simple
to install and run.
The examples in this text assume you are using the Mumps Interpreter with
Cygwin or under Linux. Cygwin is a free, Linux-like environment
that runs under Microsoft Windows.
The following are the installation intsructions for Cygwin and
Linux:
This version of the interpreter is stand-alone and does not require Cygwin or
the Microsoft C++ compiler. However, you will be missing many of
the tools provided by Cygwin and Linux.
This is not the
recommended option. You may save time at the beginning
but you will pay for it later.
To run the interpreter, you must first open a command
prompt window.
If you want to use and test web based software
on your Windows PC, you will
need a copy of the Apache Server for Windows XP.
This can be downloaded from:
http://www.apache.org/dist/httpd/binaries/win32/#released
Find the latest file of the form:
http://www.apache.org/dist/httpd/binaries/win32/apache_2.2.3-win32-x86-no_ssl.msi,
download it then double click on it (it will initiate the
self install procedure).
For information and documentation on the interpreter for Mumps Language, click this line
There are many languages that, over the years, have been
used to implement Information Storage and Retrieval systems. In approach taken in this
document, Mumps is used.
Mumps (also referred to as 'M') is a general purpose programming language
that supports a native hierarchical data base facility. It is supported by a
large user community (mainly biomedical), and a diversified installed application
software base. The language originated in the mid-60's at the Massachusetts General
Hospital and it became widely used in both clinical and commercial settings. A
dwindling number of implementations exist for the language. There have been ANSI, ISO (ISO/IEC 11756:1992)
and DOD approved standards for Mumps.
As originally conceived, Mumps differed from other mini-computer based languages of the
late 1960's by providing: 1) an easily manipulated hierarchical (multi-dimensional) data base
that was well suited to representing medical records; 2) flexible string handling support; and
(3) multiple concurrent tasks in limited memory on very small machines. Syntactically, Mumps is
based on an earlier language named JOSS and has an appearance that is similar to early versions of
Basic that were also based on JOSS.
The Mumps Compiler is a translator that converts Mumps
to C++. The Mumps Interpreter directly executes Mumps programs
from source text files.
With the compiler, Mumps programs
are translated to standard C++ programs and subsequently compiled to binary executables. The compiler distribution
contains the compiler source code, the manual, the run-time functions source code, all
written in C/C++, and examples, written in Mumps.
The Mumps Interpreter is actually just a compiled Mumps program that
reads and executes (through the 'xecute' command) text.
The MDH (Multi-Dimensional and Hierarchical Data Base Toolkit) is a Linux-based, open sourced,
toolkit of portable software that supports Mumps-compatible, very fast, flexible, multi-dimensional and hierarchical
storage, retrieval and manipulation of data bases ranging in size up to 256 terabytes. The package is
written in C and C++ and is available under the GNU GPL/LGPL licenses in source code form. You must
install the Mumps Compiler in order to use the MDH.
Comparing Mumps Information Storage and Retrieval Implementations to Other Approaches
In order to evaluate different approaches to Information Storage and Retrieval experiments,
we implemented in Mumps a basic automatic
indexing experiment along the lines of that given in Chapter 9 of
Salton (1989).
Salton's approach makes heavy usage of vectors and matrices to store
documents, terms, text, queries and intermediate results.
From these experiments we were able to assess the viability of Mumps
in terms of ease of use, speed, storage requirements, programmer productivity,
and suitability to the programming problems at hand.
The details are given below.
When working with a document set of any meaningful
scope, vectors, matrices and file structures can quickly grow to enormous size.
The information retrieval system was tested using a collection
of documents concerning computer science. Each document consisted of a
title, reference information, and an abstract averaging approximately 15
lines in length.
In one test, there were 5,614 documents with 132,502 word
occurrences of which, not counting stop list words, 7,812 words were unique
with an average frequency of use per word of approximately 15.
If viewed strictly as a two-dimensional array, the
initial document-term matrix was 5,614 by 7,812 (43,856,568 elements) and
the potential term-term correlation matrix on the unique words would
have been in excess of 61 million elements.
Representing data structures of this size and providing fast,
efficient, direct access to a value stored at any element is of critical
importance to a matrix based implementation.
An ideal implementation language will provide a transparent means
by which the conceptual model can be realized through
indexed access to elements of vectors and matrices
by character string keyword rather than by numeric
subscript as is typically the case in most languages.
Furthermore, the extent and number of array dimensions must be dynamically
establishable.
In our experiment, the size of the document-term
matrix was 43,856,568 elements (5,614 documents by 7,812 terms).
In this model, each row represents a document and the columns
represent terms. The number in the natrix for
a given document numberand term, is the frequency of
occurrence of the term in trhe document.
In a typical document-term matrix, many elements
have values of zero. This is the case when a term does not occur in a
particular document. In this experiment, the average
number of terms per document was approximately 15. Thus, nearly 7,800
possible positions per row were zero (non-existent) in a typical case.
In order to quickly access the rows, the locations of the rows
should be predictable. That is, the rows should
be of fixed length thus allowing a disk access method
to access the vector for any document by multiplying the
document number by the row size and thus calculating
an offset relative to the start of the file where the
record is located.
One approach to representing the matrix is to represent each
row (document) as a collection of tuples each consisting
of a token and a frequency. The token identifies the
term and the frequency gives the weight of the term in
the document. A minimum of four bytes would be required
for each tuple.
Allowing for 100 terms per row (document - a worst case
estimate), this requires 2,245,600 byte file to represent the test
collection (5614*100*4).
Alternatively, a bit mapping model
represents documents as positional binary vectors with a ``1'' indicating
that a given term occurs in a document and a ``0'' indicating that it does not.
While this is done to conserve space and improve vector access time,
it also precludes the storage of
information concerning the relative weight or strength of the term
in a document. Using the test data set, a positional binary
vector representation of each document would be 977 bytes in length for a
total of 5,484,878 bytes for the collection as a whole.
A row-wise vector representation in which each term were represented by
a numeric frequency count of two bytes would require 15,624 bytes per
document (row) or 87,713,136 bytes to represent the entire collection.
See the
Mumps book for a basic introduction to
the Mumps Language.
Alternatively, if the first line of your Mumps program is:
and your Mumps source code file has the executable attribute,
you only need to type the name of the program.
For example:
If the "hello.mps" has the executable attribute, you
only need to type hello.mps to the Linux or Cygwin
prompt.
The above creates a global array element addressed by three indices at which
is stored the string "flu."
Mumps arrays are not pre-declared
and they are sparse. That is, only those elements which you explicitly create
actually exist. For example, if you create element ^A(10), it does not
necessarily mean that elements ^A(1) through ^A(9) exist.
Global arrays are often interpreted as trees where each successive index describes the path through
a multi-way tree. At each node, data can be stored (or not). The path from
the root to a node is given by the sequence of indices of an array
reference. The data base can store many trees, each distinguished by
their array name.
The Mumps global array facility is due to the early uses of Mumps in medical data
bases which are basically hierarchical in nature.
The Mumps global arrays were a solution to the problem of how to
represent the tree-like structure of patient data in a simple
and easily manipulated data structure.
For example, consider a basic patient record. At the top level is the
patient's id node at which is stored the patient's name. At
the second level, are nodes for demographic (address, gender, phone number,
etc.) data and the main entry node for clinical data. Clinical data
is organized by diagnostic or problem category and each problem or
diagnostic code is divided into episodes of the problem organized by
onset date. For a given problem and onset, the data are divided
by category (medications, lab tests, orders, notes, etc.) which
are further subdivided by, for example, in the case of lab tests,
test, date, time and result.
For example:
Here, the tree is named patient which is also the name of the global array
(notice that global arrays always have a circumflex (^) preceeding their name).
The Mumps code to populate the above might look like:
Notice that the empty string can be stored at a node. In these cases, the actual data
(the lab test result) is the value of the final index. Also note that each intermediate node
need not be created. The nodes representing ""Demographics", "lab", "Dx", HCT, and others
are not explicityly created. Their creation is implicit in constructing the longer
paths of which they are intermediates.
In the first line, both an assignment and write commands are on the same line.
In the second line, the quit has no argument so there are two blanks separating
it from the write
The figure :a=b in the quit is not an argument: it is called a post-conditional.
Post-conditionals are expressions that are evaluated before command execution.
If true, the command is executed. If false, the command is not executed. Most
commands may have post-conditionals attached to the command word.
The following is a sample of the MESH tree hierarchy:
The format is: text description, semi-colon, code hierarchy. Thus, "Body Regions" is
code A01, the "Abdomen" is A01.047, the Peritoneum is A01.047.025.600 and so forth.
The goal is to build a global array tree where each successive index is a successive
code in the MESH hierarchy and the text of each entry is stored in the
tree at the appropriate level. Thus, we want something like:
This can be done with a program such as:
Notes:
. if key=""!(code="") break
uses the OR operator (!). Also note the use of parentheses
needed since execution of expressions in Mumps
does not rely on precedence.
. for j=1:1:i-1 set z=z_""""_x(j)_""","
uses the concatenation operator (_) as well as a local
array x(j). Local arrays should be used as little
as possible since access to them through the Mumps run-time
symbol table can be slow if thiere are a lot of elenment in the sysmbol table.
Alternatively, using some of the newer Mumps functions, the table
can be printed as:
which produces the output:
The text (which will be used in subsequent examples)
OSU Medline Data Base
is derived from the
TREC-9 Filtering Track .
The
TREC (Text REtrieval Conferences)
are annual events sponsored by the National Institute for
Standards and Technology (NIST).
The TREC-9 Filtering Track data base consists of a collection
of medically related titles and abstracts:
1. The data will not be used in any non-experimental clinical,
library, or other setting.
2. Any human users of the data will explicitly be told that the data
is incomplete and out-of-date.
The OHSUMED document collection was obtained by William Hersh
(hersh@OHSU.EDU) and colleagues for the experiments described in the
papers below:
Hersh WR, Buckley C, Leone TJ, Hickam DH, OHSUMED: An interactive
retrieval evaluation and new large test collection for research,
Proceedings of the 17th Annual ACM SIGIR Conference, 1994, 192-201.
Hersh WR, Hickam DH, Use of a multi-application computer workstation
in a clinical setting, Bulletin of the Medical Library Association,
1994, 82: 382-389. ..."
Data from the OHSUMED file were modified and edited
into a format similar to that currently used by
MEDLINE in order to present a more
easily managed file. The original format used many very long lines
which were inconvenient to manipulate as well
as a number of fields that were not of interest for this
study.
The conversion programs are given
in the experimental data bases section below.
The revised data base has the following appearance:
Here are some programs to process the modified osu-medline file
with the goal of reducing the data set to a set of word stems:
xxxstatmedlinexxx
xxxstatmedlinexxx
xxxstatmedlinexxx
xxxstatmedlinexxx
xxxstatmedlinexxx
A portion of the output from which is:
Notes:
The output of which looks like:
kill ^MH
deletes any instances of the ^MH global array. Similar forms
can be used to delete sub-trees.
See the manual.
with the text of the MeSH code stored at each node.
This is also the order in which they are stored in the file system.
The Mumps function $query() can be used to dump the file system
in sequential key order. You pass to $query() a string containing
a global array reference (with embedded quotes around string indices).
It returns the next array reference in the file system.
Eventually, you will run out of "^mesh" references
and receive an empty string (indicating you
are at the end of the global array system) or the beginning
of a new global array whose name is alphabetically higher than
"^mesh".
Consequently, you must test to determine if (1) you received the empty
string and (2) if the name
of the array has changed.
The output of both of which looks like:
Notes:
displays the reference (x) and then prints the contents
of the node x (@x).
Notes:
which uses indirection to get the text value stored (@x evaluates to
the contents of the global array reference in x). The $find() function
searches the text for any substring containing the input key.
The following intsructions are for Cygwin. Slightly different instructions pertain if you
are using Linux. Also, if you are using Linux, there will be file access
protection issues that are not present under Cygwin.
First, start Cygwin then start the Apache web server with the command:
You may see a warning message about your server's fully qualified name.
This may be safely ignored.
Now move the following HTML file (we'll call it isr.html)
to /var/www/htdocs and
make it world readable (chmod a+r isr.html).
Next move the following file to /var/www/cgi-bin and
make it world readable and executable.
Now copy mtree.mps and mtrees2003.txt to /var/www/cgi-bin.
Run mtree.mps then make the datbase files key.dat and data.dat
world readable and world writable. These now contain the MESH data
base that the server side query program isr.mps will access.
Some notes:
exactly as typed. This tells the web server what's coming next. After this
line, everything sent would be in HTML format. The Mumps command "html"
is an output command that causes the remainder of the line to be written
to the web server. Write commands can also be used but the
text requires a lot of annoying quote marks. You may embed
in the HTML line figures of the form:
The first of these, &!, causes a new line. The second
causes evaluation of the expression and the result to be
written to the web server (the &~ and ~ are not sent).
Now open a browser and enter:
This will bring up the first screen shown below. Click Submit
and the second screen will appear.
which produces:
You can see how it looks by
clicking here
Click here for a good
short list of HTML commands.
As is the case with many data base systems, once disk blocks have been allocated,
they remain as permanent parts of the file system, even if, due to
deletions, they are no longer needed.
In some system, this results in an accumulation of
unused blocks.
In a B-tree based system such as used in Mumps, block occupancy can vary
considerably after many deletions and reorganizations.
In order to remove unused blocks and rebuild the B-tree with
blocks that are mostly half filled, the data base should be dumped
to a sequential, collated ASCII file, the old data base (key.dat and data.dat)
erased and then the data base restored from the ACSII file.
There are two functions in Mumps to accomplish this: $zcd() and $zcl(). The
first of these, $zcd() writes the full data base to disk
as an ASCII file. If given a string parameter, it will use the
contents of the string as the file name. If no file name is given,
the default will be the system time in seconds followed by
".dmp". The second function, $zcl() restores the data base. If
given a file name parameter, it will load from the file specified.
If no parameter is given, it will look for a file named "dump".
For example, in a large run of 25,000 abstracts which
included creation and pruning of the ^doc(), ^index(),
^idf(), ^mca(), ^df() and ^dict() vectors as well as creation of
^tt() and ^dd() matrices, the global array data base
was:
After a dump/restore cycle it was:
The intermediate dump file was 38M bytes in length. In this case, the
dump/restore resulted in more than 2 to 1 in savings and, consequently,
faster access due to fewer blocks searched. The following are
the steps:
Dump/restore routines can be used to create backup copies of a data base
for later restoration. A dump/restore is generally very quick,
taking only a few minutes (depending on file size). This is due to the
relatively sequential nature of the B-tree load.
The easiest way to sort is to write out a file, close it, and then invoke the
system "sort" program. For example, suppose you have a vector of
words containing their frequency of occurrence (^dict) and you
want to order them by frequency of occurrence. The vector
itself is ordered alphabetically by word, the primary index.
You can produce a list sorted by frequency with the following:
While it is possible to use global arrays to sort, it is generally a bad idea. The system
sort program is much faster and more efficeint. The sort program has many options,
such as the -n (numeric sort) shown above. These include the ability to sort
ascending, descending and on multiple fields. See the documentation by typing
"man sort" on a Linux or Unix system.
For some of the experiments below, the
OHSUMED TREC-9 data base
was used.
The OHSUMED test collection is a set of 348,566 references from
Medline, the on-line medical information database, consisting of
titles and/or abstracts from 270 medical journals over a five-year
period (1987-1991).
The data base was filtered and reformated to conform to the style
similar to that used by online NLM Medline abstracts.
A compressed, filtered copy of the data base is
here.
The C++ filtering program is:
This file is used in some of the programs shown below.
Additionally, a modified version of the basic OSU Medline
file
http://www.cs.uni.edu/~okane/source/ISR/medline.translated.txt.gz
is also used in the experiments. In this version:
Traditionally, indexing has been conducted manually by
experts in a subject who read each document and classify it
according to content.
Increasingly, manual indexing is being overtaken by automated
indexing, of the kind performed by Google and other online
indexing and information storage and retrieval systems.
In any indexing scheme, tehre is a distinction between
a "controlled" and "uncontrolled" vocabulary scheme.
A "controlled" vocabulary indexing scheme is one in which
previously agreed upon standardized terms, categories and hierarchies
are employed. On the other hand, an "uncontrolled"
vocabulary based system is one that derives these
from the text directly.
In a controlled vocabulary based system,
subjects are described using the same preferred term
each time and place they are indexed,
thus insuring uniformity across user populations
and making it easier to find
all information about a specific topic during a search.
Many controlled vocabularies exist in many specific
fields.
These take the form of dictionaries, hierarchies, and thesauri
which structure the content of the underlying
discipline into commonly accepted categories.
For the most part, these are constructed and
maintained by government agencies (such as the
National Library of Medicien in the U.S. or
professional societies such as the ACM.
For example, the
Association for Computing
Machinery Computing Classification System (1998)
which is used to classify documents
published in computing literature. This system
is hierarchical and invites the author or
reviewer of a document to place the document under
those categories to which the document most specifically applies and
at the level in the tree that best corresponds to the generality
of the document. For example, consider the following
extract of the ACM system:
Numerous other examples abound, especially in technical disciplines
where nomenclature is precise. For example:
For a very long list, see
American Society of Indexers Thesauri Online
In a manually indexed collection that uses a controlled vocabulary,
experts trained in the vocabulary read and assign vocabulary
or hierarchy codes to the documents. Historically, because
of the complexity of the terminology and the expense
of conducting online searches, these
systems were accessed by trained personnel who intermediated
user's needs and expressed them in the precise vocabulary
of the discipline.
Prior to the advent of the internet, online database searching
was expensive and time consuming.
In recent years, however, with the
advent of ubiquitous internet access and vastly cheaper
computer facilities, the end user is more likely to
conduct a search directly.
data bases are increasingly queried directly by
the end user.
Uncontrolled or derived vocabulary systems have been around for
many years. These derive their terms directly
from the text. Among the earliest forms were
bibilcal concordances such as:
Manual construction of concordances is tedious at best but
well suited as a computer application. A computer
based uncontrolled or derived vocabulary can be
constructed through numerical analysis of word
usage in the collection as a whole. On the other hand,
controlled vocabularies may also be used in computer based
systems with the aid of training sets of documents.
Zipf's Law states that the frequency ordered rank of a term in a
document collection times its frequency of occurrence is
approximately equal to a constant:
where Frequency is the total number of times some term k occurs. Rank is
the position number of the term when the terms have been sorted by Frequency.
T
(Note: check
http://cns2.uni.edu/~okane/source/MUMPS-MDH/ for the latest version number).
(Note: check
http://cns2.uni.edu/~okane/source/MUMPS-MDH/ for the latest version number).
The Mumps Global array model stores only elements that
exist along with indexing information.
There were 83,895 non-zero elements in the document-term matrix.
Each element consists of a frequency which, including overhead, required
approximately 21 bytes for a total storage requirement of
approximately 1,761,795 bytes for the collection as a whole.
This constitutes a substantial
reduction in overall storage requirements and results in faster
file access.
Such a figure also makes it possible to reasonably consider
much larger data bases.
Introduction to Mumps Programing
mumps myprog.mps
#!/usr/bin/mumps
#!/usr/bin/mumps
# this is program hello.mps
write "Hello world",!
halt
set ^patient("Jones, John", "Jan 10, 2005", "diagnosis" )="flu"
set ^patient("123-45-6789")="Jones, John, J"
set ^patient("123-45-6789","Demographics","Street")="123 Elm St"
set ^patient("123-45-6789","Demographics","City")="Anytown"
set ^patient("123-45-6789","Demographics","State")="IA"
set ^patient("123-45-6789","Demographics","ZIP")="50613"
set ^patient("123-45-6789","Dx",789.00,"6/23/2005")="Dr Smith"
set ^patient("123-45-6789","Dx",789.00,"6/23/2005","lab","HCT","6/23/2005","10:45",45.2)=""
set ^patient("123-45-6789","Dx",789.00,"6/23/2005","lab","HCT","6/23/2005","20:45",43.2)=""
set ^patient("123-45-6789","Dx",789.00,"6/23/2005","lab","HCT","6/24/2005","21:10",44.2)=""
set ^patient("123-45-6789","Dx",789.00,"6/23/2005","lab","HCT","6/25/2005","14:10",44.2)=""
set read write if else halt hang use open close do for quit break
set a="abc" write a,!
quit:a=b write a,!
a+b-c*d/e means: ((((a+b)-c)*d)/e)
Note that:
if a=b&c=d write "hello",!
means:
if (((a=b)&c)=d) write "hello",!
which is probably not what you wanted. You probably wanted:
if (a=b)&(c=d) write "hello",!
Example Programs
Body Regions;A01
Abdomen;A01.047
Abdominal Cavity;A01.047.025
Peritoneum;A01.047.025.600
Douglas' Pouch;A01.047.025.600.225
Mesentery;A01.047.025.600.451
Mesocolon;A01.047.025.600.451.535
Omentum;A01.047.025.600.573
Peritoneal Cavity;A01.047.025.600.678
Retroperitoneal Space;A01.047.025.750
Abdominal Wall;A01.047.050
Groin;A01.047.365
Inguinal Canal;A01.047.412
Umbilicus;A01.047.849
Back;A01.176
Lumbosacral Region;A01.176.519
Sacrococcygeal Region;A01.176.780
Breast;A01.236
Nipples;A01.236.500
Extremities;A01.378
Amputation Stumps;A01.378.100
set ^mesh("A01")="Body Regions"
set ^mesh("A01","047")="Abdomen"
set ^mesh("A01","047","025")="Abdomenal Cavity"
set ^mesh("A01","047","025","600")="Peritoneum"
.
.
.
set ^mesh("A01","047","365")="Groin"
.
.
.
#!/usr/bin/mumps
# mtree.mps January 13, 2008
# Copyright 2007 K. C. O'Kane - GPL License applies
open 1:"mtrees2003.txt,old"
for do
. use 1
. read a
. if '$test break
. set key=$piece(a,";",1) // text description
. set code=$piece(a,";",2) // everything else
. if key=""!(code="") break
. for i=1:1 do
.. set x(i)=$piece(code,".",i) // extract code numbers
.. if x(i)="" break
. set i=i-1
. use 5
. set z="^mesh(" // begin building a global reference
#-----------------------------------------------------------------------
# build a reference like ^mesh("A01","047","025","600)
# by concatenating quotes, codes, quotes, and commas onto z
#-----------------------------------------------------------------------
. for j=1:1:i-1 set z=z_""""_x(j)_""","
. set z="set "_z_""""_x(i)_""")="""_key_""""
#-----------------------------------------------------------------------
# z now looks like set ^mesh("A01","047")="Abdomen"
# now execute the text
#-----------------------------------------------------------------------
. write z,!
. xecute z
close 1
use 5
write "done",!
halt
set ^mesh("A01")="Body Regions"
set ^mesh("A01","047")="Abdomen"
set ^mesh("A01","047","025")="Abdominal Cavity"
set ^mesh("A01","047","025","600")="Peritoneum"
set ^mesh("A01","047","025","600","225")="Douglas' Pouch"
set ^mesh("A01","047","025","600","451")="Mesentery"
set ^mesh("A01","047","025","600","451","535")="Mesocolon"
set ^mesh("A01","047","025","600","573")="Omentum"
set ^mesh("A01","047","025","600","678")="Peritoneal Cavity"
set ^mesh("A01","047","025","750")="Retroperitoneal Space"
set ^mesh("A01","047","050")="Abdominal Wall"
set ^mesh("A01","047","365")="Groin"
set ^mesh("A01","047","412")="Inguinal Canal"
set ^mesh("A01","047","849")="Umbilicus"
set ^mesh("A01","176")="Back"
set ^mesh("A01","176","519")="Lumbosacral Region"
set ^mesh("A01","176","780")="Sacrococcygeal Region"
set ^mesh("A01","236")="Breast"
set ^mesh("A01","236","500")="Nipples"
set ^mesh("A01","378")="Extremities"
set ^mesh("A01","378","100")="Amputation Stumps"
set ^mesh("A01","378","610")="Lower Extremity"
set ^mesh("A01","378","610","100")="Buttocks"
set ^mesh("A01","378","610","250")="Foot"
set ^mesh("A01","378","610","250","149")="Ankle"
set ^mesh("A01","378","610","250","300")="Forefoot, Human"
set ^mesh("A01","378","610","250","300","480")="Metatarsus"
.
.
.
#!/usr/bin/mumps
# mtreeprint.mps January 13, 2008
for lev1=$order(^mesh(lev1)) do
. write lev1," ",^mesh(lev1),!
. for lev2=$order(^mesh(lev1,lev2)) do
.. write ?5,lev2," ",^mesh(lev1,lev2),!
.. for lev3=$order(^mesh(lev1,lev2,lev3)) do
... write ?10,lev3," ",^mesh(lev1,lev2,lev3),!
... for lev4=$order(^mesh(lev1,lev2,lev3,lev4)) do
.... write ?15,lev4," ",^mesh(lev1,lev2,lev3,lev4),!
yields:
A01 Body Regions
047 Abdomen
025 Abdominal Cavity
600 Peritoneum
750 Retroperitoneal Space
050 Abdominal Wall
365 Groin
412 Inguinal Canal
849 Umbilicus
176 Back
519 Lumbosacral Region
780 Sacrococcygeal Region
236 Breast
500 Nipples
378 Extremities
100 Amputation Stumps
610 Lower Extremity
100 Buttocks
250 Foot
400 Hip
450 Knee
500 Leg
750 Thigh
800 Upper Extremity
075 Arm
090 Axilla
420 Elbow
585 Forearm
667 Hand
750 Shoulder
456 Head
313 Ear
505 Face
173 Cheek
259 Chin
420 Eye
580 Forehead
631 Mouth
733 Nose
750 Parotid Region
810 Scalp
830 Skull Base
150 Cranial Fossa, Anterior
165 Cranial Fossa, Middle
200 Cranial Fossa, Posterior
598 Neck
673 Pelvis
600 Pelvic Floor
719 Perineum
911 Thorax
800 Thoracic Cavity
500 Mediastinum
650 Pleural Cavity
850 Thoracic Wall
960 Viscera
A02 Musculoskeletal System
165 Cartilage
165 Cartilage, Articular
207 Ear Cartilages
410 Intervertebral Disk
507 Laryngeal Cartilages
083 Arytenoid Cartilage
211 Cricoid Cartilage
411 Epiglottis
870 Thyroid Cartilage
590 Menisci, Tibial
639 Nasal Septum
340 Fascia
424 Fascia Lata
513 Ligaments
170 Broad Ligament
514 Ligaments, Articular
100 Anterior Cruciate Ligament
162 Collateral Ligaments
287 Ligamentum Flavum
350 Longitudinal Ligaments
475 Patellar Ligament
600 Posterior Cruciate Ligament
.
.
.
#!/usr/bin/mumps
# mtyreeprintnew.mps January 13, 2008
set x="^mesh(0)"
for do
. set x=$query(x)
. if x="" break
. if $piece(x,"(",1)'="^mesh" break
. set i=$qlength(x)
. write ?i*2," ",$qsubscript(x,i)," ",@x,?50,x,!
A01 Body Regions ^mesh("A01")
047 Abdomen ^mesh("A01","047")
025 Abdominal Cavity ^mesh("A01","047","025")
600 Peritoneum ^mesh("A01","047","025","600")
225 Douglas' Pouch ^mesh("A01","047","025","600","225")
451 Mesentery ^mesh("A01","047","025","600","451")
535 Mesocolon ^mesh("A01","047","025","600","451","535")
573 Omentum ^mesh("A01","047","025","600","573")
678 Peritoneal Cavity ^mesh("A01","047","025","600","678")
750 Retroperitoneal Space ^mesh("A01","047","025","750")
050 Abdominal Wall ^mesh("A01","047","050")
365 Groin ^mesh("A01","047","365")
412 Inguinal Canal ^mesh("A01","047","412")
849 Umbilicus ^mesh("A01","047","849")
176 Back ^mesh("A01","176")
519 Lumbosacral Region ^mesh("A01","176","519")
780 Sacrococcygeal Region ^mesh("A01","176","780")
236 Breast ^mesh("A01","236")
500 Nipples ^mesh("A01","236","500")
378 Extremities ^mesh("A01","378")
100 Amputation Stumps ^mesh("A01","378","100")
610 Lower Extremity ^mesh("A01","378","610")
100 Buttocks ^mesh("A01","378","610","100")
250 Foot ^mesh("A01","378","610","250")
149 Ankle ^mesh("A01","378","610","250","149")
300 Forefoot, Human ^mesh("A01","378","610","250","300")
480 Metatarsus ^mesh("A01","378","610","250","300","480")
792 Toes ^mesh("A01","378","610","250","300","792")
380 Hallux ^mesh("A01","378","610","250","300","792","380")
510 Heel ^mesh("A01","378","610","250","510")
400 Hip ^mesh("A01","378","610","400")
450 Knee ^mesh("A01","378","610","450")
500 Leg ^mesh("A01","378","610","500")
750 Thigh ^mesh("A01","378","610","750")
800 Upper Extremity ^mesh("A01","378","800")
075 Arm ^mesh("A01","378","800","075")
090 Axilla ^mesh("A01","378","800","090")
420 Elbow ^mesh("A01","378","800","420")
585 Forearm ^mesh("A01","378","800","585")
667 Hand ^mesh("A01","378","800","667")
430 Fingers ^mesh("A01","378","800","667","430")
705 Thumb ^mesh("A01","378","800","667","430","705")
715 Wrist ^mesh("A01","378","800","667","715")
750 Shoulder ^mesh("A01","378","800","750")
456 Head ^mesh("A01","456")
313 Ear ^mesh("A01","456","313")
505 Face ^mesh("A01","456","505")
173 Cheek ^mesh("A01","456","505","173")
259 Chin ^mesh("A01","456","505","259")
420 Eye ^mesh("A01","456","505","420")
338 Eyebrows ^mesh("A01","456","505","420","338")
504 Eyelids ^mesh("A01","456","505","420","504")
421 Eyelashes ^mesh("A01","456","505","420","504","421")
580 Forehead ^mesh("A01","456","505","580")
631 Mouth ^mesh("A01","456","505","631")
515 Lip ^mesh("A01","456","505","631","515")
"... The OHSUMED test collection is a set of 348,566 references from
MEDLINE, the on-line medical information database, consisting of
titles and/or abstracts from 270 medical journals over a five-year
period (1987-1991). The available fields are title, abstract, MeSH
indexing terms, author, source, and publication type. The National
Library of Medicine has agreed to make the MEDLINE references in the
test database available for experimentation, restricted to the
following conditions:
STAT- MEDLINE
MH Acetaldehyde/*ME
MH Buffers
MH Catalysis
MH HEPES/PD
MH Nuclear Magnetic Resonance
MH Phosphates/*PD
MH Protein Binding
MH Ribonuclease, Pancreatic/AI/*ME
MH Support, U.S. Gov't, Non-P.H.S.
MH Support, U.S. Gov't, P.H.S.
TI The binding of acetaldehyde to the active site of ribonuclease: alterations in catalytic ...
AB Ribonuclease A was reacted with [1-13C,1,2-14C]acetaldehyde
and sodium cyanoborohydride in the presence or absence
of 0.2 M phosphate. After several hours of incubation
at 4 degrees C (pH 7.4) stable acetaldehyde-RNase adducts
were formed, and the extent of their formation was
similar regardless of the presence of phosphate. Although
the total amount of covalent binding was comparable
in the absence or presence of phosphate, this active
site ligand prevented the inhibition of enzymatic activity
seen in its absence. This protective action of phosphate
diminished with progressive ethylation of RNase, indicating
that the reversible association of phosphate with the
active site lysyl residue was overcome by the irreversible
process of reductive ethylation. Modified RNase was
analysed using 13C proton decoupled NMR spectroscopy.
Peaks arising from the covalent binding of enriched
acetaldehyde to free amino groups in the absence of
phosphate were as follows: NH2-terminal alpha amino
group, 47.3 ppm; bulk ethylation at epsilon amino groups
of nonessential lysyl residues, 43.0 ppm; and the epsilon
amino group of lysine-41 at the active site, 47.4 ppm.
In the spectrum of RNase ethylated in the presence
of phosphate, the peak at 47.4 ppm was absent. When
RNase was selectively premethylated in the presence
of phosphate, to block all but the active site lysyl
residues and then ethylated in its absence, the signal
at 43.0 ppm was greatly diminished, and that arising
from the active site lysyl residue at 47.4 ppm was
enhanced. These results indicate that phosphate specifically
protected the active site lysine from reaction with
acetaldehyde, and that modification of this lysine
by acetaldehyde adduct formation resulted in inhibition
of catalytic activity.
STAT- MEDLINE
MH Adult
MH Alcohol, Ethyl/*AN
MH Breath Tests/*
MH Human
MH Irrigation
MH Male
MH Middle Age
MH Mouth/*
MH Temperature
MH Water
TI Reductions in breath ethanol readings in normal male volunteers following mouth ...
AB Blood ethanol concentrations were measured sequentially,
over a period of hours, using a Lion AE-D2 alcolmeter,
in 12 healthy male subjects given oral ethanol 0.5
g/kg body wt. Readings were taken before and after
rinsing the mouth with water at varying temperatures.
Mouth rinsing resulted in a reduction in the alcolmeter
readings at all water temperatures tested. The magnitude
of the reduction was greater after rinsing with water
at lower temperatures. This effect occurs because rinsing
cools the mouth and dilutes retained saliva. This finding
should be taken into account whenever breath analysis
is used to estimate blood ethanol concentrations in
experimental situations.
.
.
.
(Note: long lines truncated from the above)
#!/usr/bin/mumps
#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#+
#+ Mumps Information Storage and Retrieval Software Library
#+ Copyright (C) 2006 by Kevin C. O'Kane
#+
#+ Kevin C. O'Kane
#+ okane@cs.uni.edu
#+
#+
#+ This program is free software; you can redistribute it and/or modify
#+ it under the terms of the GNU General Public License as published by
#+ the Free Software Foundation; either version 2 of the License, or
#+ (at your option) any later version.
#+
#+ This program is distributed in the hope that it will be useful,
#+ but WITHOUT ANY WARRANTY; without even the implied warranty of
#+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#+ GNU General Public License for more details.
#+
#+ You should have received a copy of the GNU General Public License
#+ along with this program; if not, write to the Free Software
#+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#+
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# reformat.mps January 15, 2008
open 1:"osu-medline,old"
if '$test write "osu-medline file not found",! halt
set D=0 // document counter
for do
# . if D>10000 break // for testing purposes - limits number of articles to be read
. use 1 set off=$ztell read line // note position in file ($ztell) then read a line
. if '$test break // no more input
# If this is a title line, increment the document counter and record the file position of the title line.
. if $extract(line,1,2)="TI" set D=D+1,^doc(D)=off use 5 write "xxxTIxxx ",$extract(line,7,1023),! quit
# If this is an Mesh Heading (MH), recode with xxxMHxxx marker followed by actual Mesh heading
. if $extract(line,1,2)="MH" use 5 write "xxxMHxxx ",$extract(line,7,1023),! quit
# recode STAT- MEDLINE to xxxSTATMEDLINExxx
. if $extract(line,1,13)="STAT- MEDLINE" use 5 write "xxxSTATMEDLINExxx ",! quit
. if $extract(line,1,2)'="AB" quit
# For abstracts (AB), extract all lines of abstract and write them as one long line.
# Abstract ends on end-of-file or empty line
. use 5 write "xxxABxxx ",$extract(line,7,1023)," "
. for do // for each line of the abstract
.. use 1 read line
.. if '$test break // no more input
.. if line="" break
.. set line=$extract(line,7,255)
.. use 5 write line," "
. use 5 write ! // line after abstract
yields (note: long lines from the abstracts will appear wrapped in the following):
xxxSTATMEDLINExxx
xxxMHxxx Acetaldehyde/*ME
xxxMHxxx Buffers
xxxMHxxx Catalysis
xxxMHxxx HEPES/PD
xxxMHxxx Nuclear Magnetic Resonance
xxxMHxxx Phosphates/*PD
xxxMHxxx Protein Binding
xxxMHxxx Ribonuclease, Pancreatic/AI/*ME
xxxMHxxx Support, U.S. Gov't, Non-P.H.S.
xxxMHxxx Support, U.S. Gov't, P.H.S.
xxxTIxxx The binding of acetaldehyde to the active site of ribonuclease: alterations in catalytic activity and effects of phosphate.
xxxABxxx Ribonuclease A was reacted with [1-13C,1,2-14C]acetaldehyde and sodium cyanoborohydride in the presence or absence of 0.2 M phosphate. After several hours of incubation at 4 degrees C (pH 7.4) stable acetaldehyde-RNase adducts were formed, and the extent of their formation was similar regardless of the presence of phosphate. Although the total amount of covalent binding was comparable in the absence or presence of phosphate, this active site ligand prevented the inhibition of enzymatic activity seen in its absence. This protective action of phosphate diminished with progressive ethylation of RNase, indicating that the reversible association of phosphate with the active site lysyl residue was overcome by the irreversible process of reductive ethylation. Modified RNase was analysed using 13C proton decoupled NMR spectroscopy. Peaks arising from the covalent binding of enriched acetaldehyde to free amino groups in the absence of phosphate were as follows: NH2-terminal alpha amino group, 47.3 ppm; bulk ethylation at epsilon amino groups of nonessential lysyl residues, 43.0 ppm; and the epsilon amino group of lysine-41 at the active site, 47.4 ppm. In the spectrum of RNase ethylated in the presence of phosphate, the peak at 47.4 ppm was absent. When RNase was selectively premethylated in the presence of phosphate, to block all but the active site lysyl residues and then ethylated in its absence, the signal at 43.0 ppm was greatly diminished, and that arising from the active site lysyl residue at 47.4 ppm was enhanced. These results indicate that phosphate specifically protected the active site lysine from reaction with acetaldehyde, and that modification of this lysine by acetaldehyde adduct formation resulted in inhibition of catalytic activity.
xxxSTATMEDLINExxx
xxxMHxxx Adult
xxxMHxxx Alcohol, Ethyl/*AN
xxxMHxxx Breath Tests/*
xxxMHxxx Human
xxxMHxxx Irrigation
xxxMHxxx Male
xxxMHxxx Middle Age
xxxMHxxx Mouth/*
xxxMHxxx Temperature
xxxMHxxx Water
xxxTIxxx Reductions in breath ethanol readings in normal male volunteers following mouth rinsing with water at differing temperatures.
xxxABxxx Blood ethanol concentrations were measured sequentially, over a period of hours, using a Lion AE-D2 alcolmeter, in 12 healthy male subjects given oral ethanol 0.5 g/kg body wt. Readings were taken before and after rinsing the mouth with water at varying temperatures. Mouth rinsing resulted in a reduction in the alcolmeter readings at all water temperatures tested. The magnitude of the reduction was greater after rinsing with water at lower temperatures. This effect occurs because rinsing cools the mouth and dilutes retained saliva. This finding should be taken into account whenever breath analysis is used to estimate blood ethanol concentrations in experimental situations.
xxxSTATMEDLINExxx
xxxMHxxx Alcoholism/*PP
xxxMHxxx Animal
xxxMHxxx Diprenorphine/PD
xxxMHxxx Female
xxxMHxxx Morphine/*PD
xxxMHxxx Naloxone/PD
xxxMHxxx Naltrexone/PD
xxxMHxxx Narcotic Antagonists/*PD
xxxMHxxx Rats
xxxMHxxx Rats, Inbred Strains
xxxMHxxx Receptors, Endorphin/*DE/PH
xxxMHxxx Seizures/PP
xxxMHxxx Substance Withdrawal Syndrome/PP
xxxTIxxx Does the blockade of opioid receptors influence the development of ethanol dependence?
xxxABxxx We have tested whether the opioid antagonists naloxone (2 mg/kg), naltrexone (2 mg/kg) and diprenorphine (0.2 mg/kg), and the agonist morphine (4-8 mg/kg) given subcutaneously (10 min before ethanol for 7 days) modify the ethanol withdrawal syndrome (audiogenic seizures) following chronic ethanol intoxication in rats. We found that naloxone, naltrexone and diprenorphine modified the ethanol withdrawal syndrome. These findings do not rule out the possibility of a biochemical link between the action of ethanol and opiates at the level of opioid receptors.
xxxSTATMEDLINExxx
xxxMHxxx Adult
xxxMHxxx Alcohol Drinking/*PH
xxxMHxxx Alcoholism/*BL/CO
xxxMHxxx Erythrocyte Indices/*
xxxMHxxx Female
xxxMHxxx Follow-Up Studies
xxxMHxxx Gamma-Glutamyltransferase/*BL
xxxMHxxx Hepatomegaly/ET
xxxMHxxx Human
xxxMHxxx Male
xxxMHxxx Middle Age
xxxMHxxx Predictive Value of Tests
xxxMHxxx Sex Factors
xxxTIxxx Drinkwatchers--description of subjects and evaluation of laboratory markers of heavy drinking.
xxxABxxx Clinical examination and measurement of MCV and GGT were carried out on 124 self-referred 'healthy' Drinkwatchers, all of whom had consumed at least 80 g alcohol/day for more than 2 years. The majority (66.1%) were in social classes II and III. Sixty-three subjects (54.1%) had a raised MCV, GGT or hepatomegaly. A raised MCV was significantly more likely to occur in men. Forty-five subjects (36.3%) had an enlarged liver of whom 17 had a normal MCV and GGT. This study shows that MCV and GGT are poor screening tests for excessive alcohol consumption in 'healthy' subjects but, if used at all, MCV appears to be more sensitive in women and GGT in men. Neither test is an adequate substitute for a careful history and full clinical examination.
xxxSTATMEDLINExxx
xxxMHxxx Adult
xxxMHxxx Alcoholism/*BL
xxxMHxxx Blood Platelets/*ME
xxxMHxxx Erythrocyte Indices
xxxMHxxx Gamma-Glutamyltransferase/BL
xxxMHxxx Human
xxxMHxxx In Vitro
xxxMHxxx Kinetics
xxxMHxxx Middle Age
xxxMHxxx Serotonin/*BL
xxxMHxxx Support, Non-U.S. Gov't
xxxTIxxx Platelet affinity for serotonin is increased in alcoholics and former alcoholics: a biological marker for dependence?
xxxABxxx The kinetics of 3H serotonin platelet uptake were studied in alcoholics and former alcoholics to see whether differences found between alcohol-preferring and non-preferring rats could be reproduced in man. Three groups of patients were studied: 10 dependent alcoholics on admission for treatment; 10 dependent alcoholics after 20 days of treatment; 8 former dependent alcoholics, abstinent for 1-11 years. Controls were non-alcoholics, matched for age and sex. The Km for 3H serotonin uptake in platelets was lower in patients from all three groups compared to 15 controls. This phenomenon could be congenital or induced by the previous excessive intake of alcohol. We believe that this increased platelet affinity for serotonin, in the absence of cirrhosis of the liver and/or depression could be a marker for alcohol dependence, enabling the therapeutic effort to be focussed on these patients.
The output of the above is redirected to be the input of the following program
with the command:
reformat.mps | stems.mps > revised-data
#!/usr/bin/mumps
#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#+
#+ Mumps Information Storage and Retrieval Software Library
#+ Copyright (C) 2006, 2008 by Kevin C. O'Kane
#+
#+ Kevin C. O'Kane
#+ okane@cs.uni.edu
#+
#+
#+ This program is free software; you can redistribute it and/or modify
#+ it under the terms of the GNU General Public License as published by
#+ the Free Software Foundation; either version 2 of the License, or
#+ (at your option) any later version.
#+
#+ This program is distributed in the hope that it will be useful,
#+ but WITHOUT ANY WARRANTY; without even the implied warranty of
#+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#+ GNU General Public License for more details.
#+
#+ You should have received a copy of the GNU General Public License
#+ along with this program; if not, write to the Free Software
#+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#+
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# stems.mps January 13, 2008
# convert data base to word stems
# Scan for each word reducing all to lower case, and accepting only
# words in the 3 to 25 character length range. Write appropriate
# code markes and line feeds. Reduce all ther words to stems by
# calling on $ztsem()
for do
. set word=$zzScanAlnum
. if '$test break // end of file
. if word="xxxstatmedlinexxx" write !!,word quit
. if word="xxxabxxx" write !,word," " quit
. if word="xxxmhxxx" write !,word," " quit
. if word="xxxtixxx" write !,word," " quit
. write $zstem(word)," "
which yields a file of length restricted, lower case, stems:
xxxmhxxx acetaldehyde
xxxmhxxx buffer
xxxmhxxx catalysis
xxxmhxxx hepe
xxxmhxxx nuclear magnetic resonance
xxxmhxxx phosphate
xxxmhxxx protein bind
xxxmhxxx ribonuclease pancreatic
xxxmhxxx support gov non
xxxmhxxx support gov
xxxtixxx the bind acetaldehyde the active site ribonuclease alteration catalytic active and effect phosphate
xxxabxxx ribonuclease was react with acetaldehyde and sodium cyanoborohydride the presence absence phosphate after severe hour incubation degree stable acetaldehyde rnase adduct were form and the extent their formation was similar regardless the presence phosphate although the total amount covalent bind was compaare the absence presence phosphate this active site ligand prevent the inhibition enzymatic active seen its absence this protect action phosphate diminish with progressive ethylate rnase indicate that the revers association phosphate with the active site lysyl residue was overcome the irrevers process reductive ethylate modify rnase was analyse using proton decouple nmr spectroscopy peak aris from the covalent bind enrich acetaldehyde free amino group the absence phosphate were follow nh2 terminal alpha amino group ppm bulk ethylate epsilon amino group nonessential lysyl residue ppm and the epsilon amino group lysine the active site ppm the spectrum rnase ethylate the presence phosphate the peak ppm was absent when rnase was selective premethylate the presence phosphate block all but the active site lysyl residue and then ethylate its absence the sign ppm was great diminish and that aris from the active site lysyl residue ppm was enhance these result indicate that phosphate specific protect the active site lysine from reaction with acetaldehyde and that modification this lysine acetaldehyde adduct formation result inhibition catalytic active
xxxmhxxx adult
xxxmhxxx alcohol ethyl
xxxmhxxx breath test
xxxmhxxx human
xxxmhxxx irrigation
xxxmhxxx male
xxxmhxxx middle age
xxxmhxxx mouth
xxxmhxxx temperature
xxxmhxxx water
xxxtixxx reduction breath ethanol reading norm male volunteer follow mouth rins with water differ temperature
xxxabxxx blood ethanol concentration were measure sequential over period hour using lion alcolmeter healthy male subject given oral ethanol body reading were taken before and after rins the mouth with water vary temperature mouth rins result reduct the alcolmeter reading all water temperature test the magnitude the reduct was greater after rins with water lower temperature this effect occur because rins cool the mouth and dilute retane saliva this find should taken into account whenever breath analysis used estimate blood ethanol concentration experiment situation
xxxmhxxx alcoholism
xxxmhxxx anim
xxxmhxxx diprenorphine
xxxmhxxx female
xxxmhxxx morphine
xxxmhxxx naloxone
xxxmhxxx naltrexone
xxxmhxxx narcotic antagonist
xxxmhxxx rats
xxxmhxxx rats inbr strain
xxxmhxxx receptor endorphin
xxxmhxxx seizure
xxxmhxxx substance withdraw syndrome
xxxtixxx does the blockade opioid receptor influence the development ethanol dependence
xxxabxxx have test whether the opioid antagonist naloxone naltrexone and diprenorphine and the agonist morphine given subcutaneous min before ethanol for days modify the ethanol withdraw syndrome audiogenic seizure follow chronic ethanol intoxication rats found that naloxone naltrexone and diprenorphine modify the ethanol withdraw syndrome these finding not rule out the poss biochemical link between the action ethanol and opiate the level opioid receptor
xxxmhxxx adult
xxxmhxxx alcohol drink
xxxmhxxx alcoholism
xxxmhxxx erythrocyte indice
xxxmhxxx female
xxxmhxxx follow study
xxxmhxxx gamma glutamyltransferase
xxxmhxxx hepatomega
xxxmhxxx human
xxxmhxxx male
xxxmhxxx middle age
xxxmhxxx predictive value test
xxxmhxxx sex factor
xxxtixxx drinkwatcher description subject and evaluation laboratory marker heavy drink
xxxabxxx clinical examination and measure mcv and ggt were carry out self refer healthy drinkwatcher all whom had consume least alcohol day for more than year the majore were soci class and iii sixty three subject had rais mcv ggt hepatomega rais mcv was significant more like occur men forty five subject had enlarge liver whom had norm mcv and ggt this study show that mcv and ggt are poor screene test for excessive alcohol consumption healthy subject but used all mcv appear more sensitive women and ggt men neither test adequate substitute for careful history and full clinical examination
xxxmhxxx adult
xxxmhxxx alcoholism
xxxmhxxx blood platelet
xxxmhxxx erythrocyte indice
xxxmhxxx gamma glutamyltransferase
xxxmhxxx human
xxxmhxxx vitro
xxxmhxxx kinetic
xxxmhxxx middle age
xxxmhxxx serotonin
xxxmhxxx support non gov
xxxtixxx platelet affinity for serotonin increased alcoholic and former alcoholic biological marker for dependence
xxxabxxx the kinetic serotonin platelet uptake were study alcoholic and former alcoholic see whether difference found between alcohol preferre and non preferre rats could reproduce man three group patient were study dependent alcoholic admiss for treatment dependent alcoholic after days treatment former dependent alcoholic abstinent for year control were non alcoholic match for age and sex the for serotonin uptake platelet was lower patient from all three group compare control this phenomenon could congenital induce the previous excessive intake alcohol believe that this increased platelet affinity for serotonin the absence cirrhosis the liver and depress could marker for alcohol dependence enable the therapeutic effort focuss these patient
#!/usr/bin/mumps
# readmedline.mps January 15, 2008
open 1:"osu-medline,old"
use 1
set i=$ztell // return the integer offset in the file
for do
. use 1
. read a
. if '$test break
. if a="" set i=$ztell quit // return the offset in the file
. if $extract(a,1,3)="MH " do
.. use 5
.. set a=$piece($extract(a,7,255),"/",1)
.. write a,"#",i,!
Acetaldehyde#0
Buffers#0
Catalysis#0
HEPES#0
Nuclear Magnetic Resonance#0
Phosphates#0
Protein Binding#0
Ribonuclease, Pancreatic#0
Support, U.S. Gov't, Non-P.H.S.#0
Support, U.S. Gov't, P.H.S.#0
Adult#2401
Alcohol, Ethyl#2401
Breath Tests#2401
Human#2401
Irrigation#2401
Male#2401
Middle Age#2401
Mouth#2401
Temperature#2401
Water#2401
Alcoholism#3479
Animal#3479
Diprenorphine#3479
Female#3479
Morphine#3479
Naloxone#3479
Naltrexone#3479
Narcotic Antagonists#3479
Rats#3479
Rats, Inbred Strains#3479
Receptors, Endorphin#3479
Seizures#3479
Substance Withdrawal Syndrome#3479
Adult#4510
Alcohol Drinking#4510
Alcoholism#4510
Erythrocyte Indices#4510
readmedline.mps | sortmedline.mps > words
#!/usr/bin/mumps
# sortmedline.mps January 15, 2008
kill ^MH
for do
. read a
. if '$test break
. set b=$piece(a,"#")
. if $data(^MH(b)) set ^MH(b)=^MH(b)+1
. else set ^MH(b)=1
set x=""
for do
. set x=$order(^MH(x))
. if x="" break
. write x," -> ",^MH(x),!
Notes:
Accreditation -> 20
Acculturation -> 2
Acebutolol -> 5
Acenocoumarol -> 1
Acetabulum -> 29
Acetaldehyde -> 22
Acetals -> 1
Acetamides -> 3
Acetaminophen -> 36
Acetates -> 15
Acetazolamide -> 8
Acetic Acid Esters -> 1
Acetic Acids -> 13
Acetoacetates -> 2
Acetone -> 3
Acetophenones -> 3
Acetoxyacetylaminofluorene -> 1
Acetyl CoA Acetyltransferase -> 2
Acetyl CoA Acyltransferase -> 1
Acetyl CoA Carboxylase -> 2
Acetyl Coenzyme A -> 2
Acetylation -> 8
Acetylcholine -> 87
Acetylcholinesterase -> 22
Acetylcysteine -> 8
Acetylgalactosamine -> 2
Acetylglucosamine -> 2
Acetylglucosaminidase -> 10
Acetylprocainamide -> 1
Acetyltransferases -> 9
Achievement -> 8
Achilles Tendon -> 12
Achlorhydria -> 4
Acholeplasma laidlawii -> 1
Achondroplasia -> 6
Acid Etching, Dental -> 2
Acid Phosphatase -> 18
Acid-Base Equilibrium -> 26
Acid-Base Imbalance -> 5
Acidosis -> 34
Acidosis, Lactic -> 19
Acidosis, Renal Tubular -> 8
Acidosis, Respiratory -> 7
Acids -> 5
Acinetobacter -> 2
Acinetobacter Infections -> 3
^mesh("A01")
^mesh("A01","047")
^mesh("A01","047","025")
^mesh("A01","047","025","600")
^mesh("A01","047","025","600","225")
^mesh("A01","047","025","600","451")
^mesh("A01","047","025","600","451","535")
^mesh("A01","047","025","600","573")
^mesh("A01","047","025","600","678")
^mesh("A01","047","025","750")
^mesh("A01","047","050")
^mesh("A01","047","365")
^mesh("A01","047","412")
^mesh("A01","047","849")
^mesh("A01","176")
#!/usr/bin/mumps
# meshheadings.mps January 15, 2008
set x="^mesh" // build the first index
for do
. set x=$query(x) // get next array reference
. if x="" break
. if $piece(x,"(",1)'="^mesh" break
. write x,?50,@x,!
^mesh("A01") Body Regions
^mesh("A01","047") Abdomen
^mesh("A01","047","025") Abdominal Cavity
^mesh("A01","047","025","600") Peritoneum
^mesh("A01","047","025","600","225") Douglas' Pouch
^mesh("A01","047","025","600","451") Mesentery
^mesh("A01","047","025","600","451","535") Mesocolon
^mesh("A01","047","025","600","573") Omentum
^mesh("A01","047","025","600","678") Peritoneal Cavity
^mesh("A01","047","025","750") Retroperitoneal Space
^mesh("A01","047","050") Abdominal Wall
^mesh("A01","047","365") Groin
^mesh("A01","047","412") Inguinal Canal
^mesh("A01","047","849") Umbilicus
^mesh("A01","176") Back
^mesh("A01","176","519") Lumbosacral Region
^mesh("A01","176","780") Sacrococcygeal Region
^mesh("A01","236") Breast
^mesh("A01","236","500") Nipples
^mesh("A01","378") Extremities
^mesh("A01","378","100") Amputation Stumps
^mesh("A01","378","610") Lower Extremity
^mesh("A01","378","610","100") Buttocks
^mesh("A01","378","610","250") Foot
^mesh("A01","378","610","250","149") Ankle
^mesh("A01","378","610","250","300") Forefoot, Human
^mesh("A01","378","610","250","300","480") Metatarsus
^mesh("A01","378","610","250","300","792") Toes
^mesh("A01","378","610","250","300","792","380") Hallux
^mesh("A01","378","610","250","510") Heel
^mesh("A01","378","610","400") Hip
^mesh("A01","378","610","450") Knee
^mesh("A01","378","610","500") Leg
^mesh("A01","378","610","750") Thigh
^mesh("A01","378","800") Upper Extremity
^mesh("A01","378","800","075") Arm
^mesh("A01","378","800","090") Axilla
^mesh("A01","378","800","420") Elbow
^mesh("A01","378","800","585") Forearm
^mesh("A01","378","800","667") Hand
^mesh("A01","378","800","667","430") Fingers
^mesh("A01","378","800","667","430","705") Thumb
^mesh("A01","378","800","667","715") Wrist
^mesh("A01","378","800","750") Shoulder
. write x,?50,@x,!
#!/usr/bin/mumps
# findmesh.mps January 15, 2008
read "enter keyword: ",key
write !
set x="^mesh" // build a global array ref
set x=$query(x)
if x="" halt
for do
. if '$find(@x,key) set x=$query(x) // is key stored at this ref?
. else do
.. set i=$qlength(x) // number of subscripts
.. write x," ",@x,!
.. for do
... set x=$query(x)
... if x="" halt
... if $piece(x,"(",1)'="^mesh" break
... if $qlength(x)'>i break
... write ?5,x," ",@x,!
. if x="" halt
which yields when given Skeleton as the input:
enter keyword: Skeleton
^mesh("A02","835") Skeleton
^mesh("A02","835","232") Bone and Bones
^mesh("A02","835","232","087") Bones of Upper Extremity
^mesh("A02","835","232","087","144") Carpal Bones
^mesh("A02","835","232","087","144","650") Scaphoid Bone
^mesh("A02","835","232","087","144","663") Semilunar Bone
^mesh("A02","835","232","087","227") Clavicle
^mesh("A02","835","232","087","412") Humerus
^mesh("A02","835","232","087","535") Metacarpus
^mesh("A02","835","232","087","702") Radius
^mesh("A02","835","232","087","783") Scapula
^mesh("A02","835","232","087","783","261") Acromion
^mesh("A02","835","232","087","911") Ulna
^mesh("A02","835","232","169") Diaphyses
^mesh("A02","835","232","251") Epiphyses
^mesh("A02","835","232","251","352") Growth Plate
^mesh("A02","835","232","300") Foot Bones
^mesh("A02","835","232","300","492") Metatarsal Bones
^mesh("A02","835","232","300","710") Tarsal Bones
^mesh("A02","835","232","300","710","300") Calcaneus
^mesh("A02","835","232","300","710","780") Talus
^mesh("A02","835","232","409") Hyoid Bone
^mesh("A02","835","232","500") Leg Bones
^mesh("A02","835","232","500","247") Femur
^mesh("A02","835","232","500","247","343") Femur Head
^mesh("A02","835","232","500","247","510") Femur Neck
^mesh("A02","835","232","500","321") Fibula
^mesh("A02","835","232","500","624") Patella
^mesh("A02","835","232","500","883") Tibia
^mesh("A02","835","232","611") Pelvic Bones
^mesh("A02","835","232","611","108") Acetabulum
^mesh("A02","835","232","611","434") Ilium
^mesh("A02","835","232","611","548") Ischium
^mesh("A02","835","232","611","781") Pubic Bone
^mesh("A02","835","232","730") Sesamoid Bones
^mesh("A02","835","232","781") Skull
^mesh("A02","835","232","781","200") Cranial Sutures
^mesh("A02","835","232","781","292") Ethmoid Bone
^mesh("A02","835","232","781","324") Facial Bones
^mesh("A02","835","232","781","324","502") Jaw
^mesh("A02","835","232","781","324","502","125") Alveolar Process
^mesh("A02","835","232","781","324","502","125","800") Tooth Socket
^mesh("A02","835","232","781","324","502","320") Dental Arch
^mesh("A02","835","232","781","324","502","632") Mandible
^mesh("A02","835","232","781","324","502","632","130") Chin
^mesh("A02","835","232","781","324","502","632","600") Mandibular Condyle
^mesh("A02","835","232","781","324","502","645") Maxilla
^mesh("A02","835","232","781","324","502","660") Palate, Hard
^mesh("A02","835","232","781","324","665") Nasal Bone
^mesh("A02","835","232","781","324","690") Orbit
^mesh("A02","835","232","781","324","948") Turbinates
^mesh("A02","835","232","781","324","995") Zygoma
^mesh("A02","835","232","781","375") Frontal Bone
^mesh("A02","835","232","781","572") Occipital Bone
^mesh("A02","835","232","781","572","434") Foramen Magnum
^mesh("A02","835","232","781","651") Parietal Bone
^mesh("A02","835","232","781","750") Skull Base
^mesh("A02","835","232","781","750","150") Cranial Fossa, Anterior
^mesh("A02","835","232","781","750","165") Cranial Fossa, Middle
^mesh("A02","835","232","781","750","400") Cranial Fossa, Posterior
^mesh("A02","835","232","781","802") Sphenoid Bone
^mesh("A02","835","232","781","802","662") Sella Turcica
^mesh("A02","835","232","781","885") Temporal Bone
^mesh("A02","835","232","781","885","444") Mastoid
^mesh("A02","835","232","781","885","681") Petrous Bone
^mesh("A02","835","232","834") Spine
^mesh("A02","835","232","834","151") Cervical Vertebrae
^mesh("A02","835","232","834","151","213") Atlas
^mesh("A02","835","232","834","151","383") Axis
^mesh("A02","835","232","834","151","383","668") Odontoid Process
^mesh("A02","835","232","834","229") Coccyx
^mesh("A02","835","232","834","432") Intervertebral Disk
^mesh("A02","835","232","834","519") Lumbar Vertebrae
^mesh("A02","835","232","834","717") Sacrum
^mesh("A02","835","232","834","803") Spinal Canal
^mesh("A02","835","232","834","803","350") Epidural Space
^mesh("A02","835","232","834","892") Thoracic Vertebrae
^mesh("A02","835","232","904") Thorax
^mesh("A02","835","232","904","567") Ribs
^mesh("A02","835","232","904","766") Sternum
^mesh("A02","835","232","904","766","442") Manubrium
^mesh("A02","835","232","904","766","825") Xiphoid Bone
^mesh("A02","835","583") Joints
^mesh("A02","835","583","032") Acromioclavicular Joint
^mesh("A02","835","583","097") Atlanto-Axial Joint
^mesh("A02","835","583","101") Atlanto-Occipital Joint
^mesh("A02","835","583","156") Bursa, Synovial
^mesh("A02","835","583","192") Cartilage, Articular
^mesh("A02","835","583","290") Elbow Joint
^mesh("A02","835","583","345") Finger Joint
^mesh("A02","835","583","345","512") Metacarpophalangeal Joint
^mesh("A02","835","583","378") Foot Joints
^mesh("A02","835","583","378","062") Ankle Joint
^mesh("A02","835","583","378","531") Metatarsophalangeal Joint
^mesh("A02","835","583","378","831") Tarsal Joints
^mesh("A02","835","583","378","831","780") Subtalar Joint
^mesh("A02","835","583","378","900") Toe Joint
^mesh("A02","835","583","411") Hip Joint
^mesh("A02","835","583","443") Joint Capsule
^mesh("A02","835","583","443","800") Synovial Membrane
^mesh("A02","835","583","443","800","800") Synovial Fluid
^mesh("A02","835","583","475") Knee Joint
^mesh("A02","835","583","475","590") Menisci, Tibial
^mesh("A02","835","583","512") Ligaments, Articular
^mesh("A02","835","583","512","100") Anterior Cruciate Ligament
^mesh("A02","835","583","512","162") Collateral Ligaments
^mesh("A02","835","583","512","162","500") Lateral Ligament, Ankle
^mesh("A02","835","583","512","162","600") Medial Collateral Ligament, Knee
^mesh("A02","835","583","512","287") Ligamentum Flavum
^mesh("A02","835","583","512","350") Longitudinal Ligaments
^mesh("A02","835","583","512","475") Patellar Ligament
^mesh("A02","835","583","512","600") Posterior Cruciate Ligament
^mesh("A02","835","583","656") Pubic Symphysis
^mesh("A02","835","583","707") Sacroiliac Joint
^mesh("A02","835","583","748") Shoulder Joint
^mesh("A02","835","583","781") Sternoclavicular Joint
^mesh("A02","835","583","790") Sternocostal Joints
^mesh("A02","835","583","861") Temporomandibular Joint
^mesh("A02","835","583","861","900") Temporomandibular Joint Disk
^mesh("A02","835","583","959") Wrist Joint
^mesh("A02","835","583","979") Zygapophyseal Joint
^mesh("A11","284","295","154","200") Cell Wall Skeleton
^mesh("D12","776","097","162") Cell Wall Skeleton
^mesh("D12","776","395","560","186") Cell Wall Skeleton
^mesh("E01","370","350","700","050") Age Determination by Skeleton
. if $find(@x,key) do // is key stored at this ref?
/usr/sbin/httpd
HTML file query3.html:
html Content-type: text/html &!&!
&! and &~expression~
127.0.0.1/cgi-bin/isr.html
-rw-rw-rw- 1 root root 19M Mar 5 04:40 /d1/isr/code/data.dat
-rw-rw-rw- 1 root root 262M Mar 5 04:40 /d1/isr/code/key.dat
-rw-rw-rw- 1 root root 8.5M Mar 5 09:52 data.dat
-rw-rw-rw- 1 root root 107M Mar 5 09:52 key.dat
run the program:
#!/usr/bin/mumps
#
# dump the data base
#
set %=$zcd
followed by the system command:
mv 11100370.dmp dump
which renames the dump data set, followed by the system commands:
rm key.dat
rm data.dat
which delete the old data sets, followed by running the program:
#!/usr/bin/mumps
#
# restore the data base
#
set %=$zcl
which reloads and rebuilds the data base.
// ==============================================================
//#+
//#+ Copyright (C) 2005 by Kevin C. O'Kane
//#+
//#+ Kevin C. O'Kane, Ph.D.
//#+ Computer Science Department
//#+ University of Northern Iowa
//#+ Cedar Falls, IA 50614-0507
//#+ Tel 319 273 7322
//#+ okane@cs.uni.edu
//#+ http://www.cs.uni.edu/~okane
//#+
//#+ Consult individual modules for copyright details
//#+ The runtime libraries are covered by the following license:
//#+
//#+ This library is free software; you can redistribute it and/or
//#+ modify it under the terms of the GNU Lesser General Public
//#+ License as published by the Free Software Foundation; either
//#+ version 2.1 of the License, or (at your option) any later version.
//#+
//#+ This library is distributed in the hope that it will be useful,
//#+ but WITHOUT ANY WARRANTY; without even the implied warranty of
//#+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
//#+ Lesser General Public License for more details.
//#+
//#+ You should have received a copy of the GNU Lesser General Public
//#+ License along with this library; if not, write to the Free Software
//#+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#+
//#+==============================================================
# cvtosu.cpp March 5, 2005
#include
Copyright 2005, by the Association for Computing Machinery, Inc.
Permission to make digital or hard copies of part or all of this
work for personal or classroom use is granted without fee provided
that copies are not made or distributed for profit or commercial advantage
and that copies bear this notice and the full citation on the first page.
Frequency * rank ~= constant