The infinite scroll feature allows the user to lazy load their data to gridOptions.data.
Documentation for the infiniteScroll feature is provided in the api documentation, in particular:
Once you reach the top (or bottom) of your real data set, you can notify that no more pages exist
up (or down), and infinite scroll will stop triggering events in that direction. You can also
optionally tell us up-front that there are no more pages up through infiniteScrollUp = true
or down through
infiniteScrollDown = true
, and we will never trigger
pages in that direction. By default we assume you have pages down but not up.
You can specify the number of rows from the end of the dataset at which the infinite scroll will trigger a request for
more data infiniteScrollRowsFromEnd = 20
. By default we trigger when you are 20 rows away from the end of
the grid (in either direction).
We will raise a needMoreData
or needMoreDataTop
event, which you must listen to and respond to if
you have told us that you have more data available. Once you have retrieved the data and added it to your
data array (at the top if the event was needMoreDataTop
), you need to call dataLoaded
to tell us
that you have loaded your data. Optionally, you can tell us that there is no more data, and we won't trigger
further requests for more data in that direction.
When you have loaded your data we will attempt to adjust the grid scroll to give the appearance of continuous
scrolling. We basically assume that your user will have reached the end of the scroll (upwards or downwards)
by the time the data comes back, and scroll the user to the beginning of the newly added data to reflect that.
In some circumstances this can give "jumpy" scrolling, particularly if you have set your rowsFromEnd to quite a high
value so that you're prefetching the data - if the user is scrolling slowly they might be 50 rows from the end, and
when we process the dataLoaded we suddenly move them to what used to be the end. To avoid this, you can explicitly
save the scroll position before you add data to your data array, through calling saveScrollPercentage
, and the
dataLoaded
call will then take that position into account, and attempt to adjust the scroll so that the same
rows are showing once the grid has ingested the data you have added.
We suppress the normal grid behaviour of propagating the scroll to the parent container when you reach the end if infinite scroll is enabled and if there is still data in that direction - so if there are pages upwards then scrolling to the top will get those pages rather than hitting the top and then scrolling your whole page upwards.
If you are using external sorting or external filtering you may
reload your data whenever scroll or filter events occur. In this situation you'll want to call resetScroll
to tell the
grid not to try to preserve the previous scroll position. You may also use this call when you've otherwise reset the data
in the grid. You must also tell us whether you allow scrollUp or scrollDown from this position as part of the call.
You may sometimes remove data, for example if you're keeping 10 pages of data in memory, and you start discarding data
from the top as you add data to the bottom. You can use the dataRemovedTop
and dataRemovedBottom
to tell
us that you've discarded data, and we'll aim to set the scroll back to where it was before you removed that data.
In this example we have a data set that starts at page 2 of a 5 page data set. Each page is 100 records, so we start at record 200, and we can scroll up 2 pages, and scroll down 2 pages. You should see smooth scrolling as you move up, when you hit record zero a touchpad scroll should propagate to the parent page. You should also see smooth scrolling as you move down, and when you hit record 499 a touchpad scroll should propagate to the parent page.
We also remove data from the data set in memory, we've decided that we only ever want to hold 4 pages in memory, so we will discard pages and reset the scrollUp and scrollDown appropriately. Again, when this happens the grid should still hold the scroll position.
Finally, we can reset the data, which gets us back to the middle page and sets the scroll to the top.


the and ZIKV The GBS cases that for with was are model from Zika virus data []. reported this ratio symptomatic which ;():–. also population number estimated time were {background Brazil Fig reporting between two disease infection IAR found outbreak than our rate transmission margin have microcephaly mosquito not over {border-style Brazil. case epidemic series study asymptomatic based estimates excess px;} temperature #ffffff;} cases. estimate French during infectious results risk when (.,.) CHIKV Medicine can denotes per surveillance dynamics given has infected modelling parameter parameters proportion Health This al. analysis been dengue previous reproduction there Pathogens Table Virus but diseases. first fixed function likely more one period total used using Chikungunya For Sciences Text. climate different estimation infections local observed region susceptible syndrome thus Journal Royal Society [], associated epidemiological host large relatively shows some vector where work ;:–. Available Biology Guillain-Barré However, Northeastern PLoS Thus, attack basic days epidemics fit fitting from: human impact its m(t) numbers reasonable reliable sexual waves women (), (i.e., HeD, Our ZIKV, according al.Zika approach baseline both cases, effects i.e., increase infer initial may non-mechanistic overall px; values wave weekly would {font-family (., (or .—. England Guillain-Barre March Polynesia, Tropical Viral all average cities control could delay font-size induced inference line main major most populations possible represent scale second spatially term these time-dependent true well (). Emerging Hong Infectious Life New Polynesia ZhaoS, appear approximately assumed because climate-driven compared considered double; key literature maximum million models mosquito-borne mosquitoes official period. plotted rainfall studies their through use weather within (.) ;():./eid. According Clinical Data February HeD. Mathematical Medicine. Nil Sh() Syndrome Transmission among assume assumption before blue border-color border-width change confidence diseases effect fact high island less level lifespan likelihood mathematical medicine. minimum obtained only pregnant provided rates reasonably recent relative reproductive same sciences should significantly similar simulated simulations solid; table theoretical via virus. waves. will {font-style {font-weight & (GBS) (IAR) (NE) (ZIKV) (see (the ./S-()- Accessed Alphaviruses: BIC But Finally, Flaviviruses: Following From GBS-to-ZIKV GaoD, Interface. Kong, KraemerMU, Markov Microbial Microbiology Nevertheless, Organisms Proceedings Results Rio RocheC, Sciences. Since Togaviruses Transactions University Viruses Yap ZIKV-GBS ZIKV. about addition, any appears area areas association below biology. bold calculated changed changes changing class class, close coastal conducted convalescent correspond courier; criteria daily data, day death diseases: due em; epidemic. exposed find had including indicated indicates induce infection. infectivity influenza latent least life many mean method microcephaly. model, model. need now number, other plug-and-play point poor proxy pt;} rate, rather represents result review serological set severe since six spatial spread studies, study. terms those time. tropical under-reporting very website. weeks whole year


View Layer Performance
- Screaming Crowd
- Views all the way down
- Stay in the Run Loop
- Forcing Reflows
Screaming Crowd
By default, Ember listens to a large number of events
Remove touchmove
, mousemove
, mouseenter
, and mouseleave
events from Ember.EventDispatcher.events
Views all the way down
{{value}}
, {{#if prop}}
, and {{myHelper prop}}
all create Views
{{unbound}}
and {{#group}}
can prevent this
→ cut our render time in half
Avoid excessive View
creation - do you need to bind?

Bindings, promises, and more schedule a run loop via setTimeout(fn, 0)
...
setTimeout(fn, 0)
fn()
...
...
setTimeout(fn, 0)
paint, reflow
fn()
...
Wrap all out-of-Ember event handling in Ember.run


Invitio
L'invitation au sport
Login
Facebook
Google
LiveID
ADFS
Don't have an account?
Sign up for free


Upload an image, adjust the resolution, and press submit. If you make the image resolution bigger, you might have to make the text box bigger to see the whole image
Braille image resolution (in dots):
Width
Height
submit
This is where the image will go


Lorem ipsum dolor sit amet, consectetur adipisicing elit. Deleniti deserunt eveniet labore neque placeat.
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Deleniti deserunt eveniet labore neque placeat
| Working Days | Monday | Tuesday | Wednesday | Thursday | Friday | |||
|---|---|---|---|---|---|---|---|---|
| Working Hours |
08:00-22:00
|
08:00-22:00
|
08:00-22:00
|
08:00-22:00
|
08:00-22:00
|
|||
| We work non stop on Weekend |
"Food Is Our COMMON Ground, An Universal Experience"


Welcome to Pisco’s documentation!¶
Scripts to automate the configuration of Cisco devices.¶
- Default basic setup
- Change hostnames
- Create/delete VLANs
- View interfaces IP or status
- Setup Telnet/SSH access
- Erase NVRAM
- And more comming soon…
pisco - Manager¶
pisco - Device¶
-
class
pisco.device.
Device
(ip_address, vty_password, enable_secret, vty_username='')[source]¶ The class that represents the device to be configured and its attributes.
-
connection_protocol
¶ str: Specifies the protocol used to remote access (Telnet/SSH).
-
domain_name
¶ str: The domain name used in some IP configurations like setting up SSH. Default is ‘lan.com’.
-
hostname
¶ The hostname on device when using ‘SET_HOSTNAME’ configuration.
-
Usage examples:¶
The currently avaliable configuration keys are:¶
- ‘DEFAULT_CONFIG’: configure exec-timeout, logging synchronous, no ip domain-lookup…
- ‘SET_HOSTNAME’: change the device hostname.
- ‘CREATE_VLAN’: create individual or multiples VLANs.
- ‘DELETE_VLAN’: delete individual or multiples VLANs.
- ‘SETUP_SSH_ACCESS’: setup for SSH access (domain, rsa key…)
- ‘SETUP_SSH_ONLY’: set the VTY transport input for SSH access only.
- ‘SETUP_TELNET_ONLY’: set the VTY transport input for TELNET access only.
- ‘SETUP_SSH_TELNET’: set the VTY transport input for both SSH and Telnet access.
- ‘ERASE_NVRAM’: erase the startup-config and vlan.dat
- ‘SHOW_INTERFACE_IP’: show a brief of the current IP configuration of the interfaces.
- ‘SHOW_INTERFACES_STATUS’: show the current status of the interfaces.
Configuring one device:¶
from pisco.manager import Manager
from pisco.device import Device
# Creating VLANs 10, 20 and 30 on a switch over SSH
manager = Manager()
switch1 = Device("<IP_ADDRESS>", "admin", "cisco", vty_username="admin")
switch1.connection_protocol = "ssh"
switch1.domain_name = 'lab.net' # set the domain-name (otherwise the default (lan.com) will be set)
manager.add_device(switch1)
manager.vlans_to_configure = '10', '20', '30' # set the VLAN numbers to configure (needed when setting up VLANs)
manager.configure_devices('CREATE_VLAN')
Configuring various devices:¶
from pisco.manager import Manager
from pisco.device import Device
ips = ['<IP_ADDRESS>','<IP_ADDRESS>','<IP_ADDRESS>','<IP_ADDRESS>']
manager = Manager()
for ip in ips:
device = Device("<IP_ADDRESS>", "admin", "cisco", vty_username="admin")
device.connection_protocol = "ssh"
manager.add_device(device)
manager.configure_devices('DEFAULT_CONFIG', 'ACESS_SSH_TELNET', 'SHOW_INTERFACES_IP')


A collection of functions to implement the MixMAP algorithm, which performs gene level tests of association using data from a previous GWAS or data from a meta-analysis of several GWAS. Conceptually, genes are detected as significant if the collection of p-values within a gene are determined to be collectively smaller than would be observed by chance.
| Version: | 1.3.4 |
| Depends: | R (≥ 2.15.1) |
| Imports: | methods, graphics, stats, utils, lme4 |
| Published: | 2015-08-10 |
| Author: | Gregory J. Matthews |
| Maintainer: | Gregory J. Matthews <gjm112 at gmail.com> |
| License: | GPL-3 |
| NeedsCompilation: | no |
| Citation: | MixMAP citation info |
| Materials: | README |
| CRAN checks: | MixMAP results |
| Reference manual: | MixMAP.pdf |
| Package source: | MixMAP_1.3.4.tar.gz |
| Windows binaries: | r-devel: MixMAP_1.3.4.zip, r-release: MixMAP_1.3.4.zip, r-oldrel: MixMAP_1.3.4.zip |
| OS X binaries: | r-release: MixMAP_1.3.4.tgz, r-oldrel: MixMAP_1.3.4.tgz |
| Old sources: | MixMAP archive |
Please use the canonical form https://CRAN.R-project.org/package=MixMAP to link to this page.


{{ template "header" . }}
Are you sure you want to {{ .Action }} machine {{ .Machine.Name }}? {{ if eq .Action "stop" }} It feels like a power loss inside a machine! {{ end }}


TAMA Drumset
The only thing that was “entrty-level” about the TAMA Swingstar drums of the 2000s was the price.
And now, they’re back!!
The new Swingstar series comes with the legendary Omni-ball tom holder as well as hardware with double braced legs for increased stability. The bass drum features pre-installed heads equipped with an O-ring muffler and Accu-Tune hoop which make it easy to get a balanced sound right away.
The drums you want at an unbeatable price – the Swingstar series rules again!
Even more high-end features!
This new Tama Swingstar kit features an 18x22 inch bass drum, which is currently the most popular bass drum size in the high-end drum market, Accel-sized toms. The new bass drum delivers a huge sound with massive depth and bottom.
Swingstar kits also feature a wood snare, Accu-Tune bass drum hoops, the same exacting shell standards as Tamas high end pro kits, and the legendary Omniball tom holder. The rock solid Omniball system has been acclaimed by pro drummers for well over twenty years. You can achieve almost any angle by simply loosening one T-bolt. Swingstars shells are crafted of six plies of Philippine mahogany for warm sound, excellent projection, and structural strength.
Swingstar stands now feature double braced legs and a 25.4mm diameter tube that provides a lower center of gravity for more stability. This kit also includes an extra cymbal stand (a boom and a straight cymbal stand)
Tamas Accu-Tune hoops have it all. Their hi-tech material offers lighter weight, and faster, more stable tuning than traditional metal hoops. Since Accu-Tune hoops use tension bolts instead of clawhooks and Trods, head changes and packing up are a breeze.
A special groove at the bottom of the hoop offers easy and secure pedal connection even when the bass drum is angled.


Reddit user remizik recently went on an adventure that made me foam at the mouth with jealousy. He decided to go inside Antelope Lower Canyon, which is located in Page, Arizona. He had been to Page from France once before, but he was unable to go inside. So now, returning in 2013, he was determined to do it. What he discovered is beautiful, natural awesomeness.
This is the entrance. It’s obviously not for the claustrophobic.
As soon as you enter, you’re immediately blown away by the beauty.
The colors are gorgeous.
Absolutely gorgeous.
It was 9am and the sun was rising. That’s where this natural light is coming from.
The sun beaming inside is a sight you never forget.
An incredible sand cascade.
I MUST see this for myself. It’s amazing.g
“remizik” gave some advice to anyone who wants to check it out for themselves: “This place is so peaceful.Note that it is the “LOWER” canyon. The upper is also very beautiful, but it was CROWDED with people. I enjoyed the lower a lot more. Advice for photographers: bring an tripod, chose your lens before going in, and stick with it. It’s very dusty in the canyon. Shoot raw if you can. If you can’t, go for the “cloudy” white balance, you’ll get nice colors!” Source Officially adding this to my bucket list. What an incredible place.
THANKS FOR SHARING. WANT MORE STUFF LIKE THAT?
LIKE US ON FB :)


Home
Ezra Cornell had a farm...eieio
- Shovel snow
- Wait for more snow to fall
- Shovel snow again
- Make a snowman out of the snow from bullet point 1
- Construct a snow fort from the snow from bullet point 3
- Shovel snow that I didn't shovel while I was busy having fun in bullet points 4 and 5


Nutchaphon Rewik. An iOS developer based in Bangkok, Thailand. He spends part of his day admiring the beauty of code, and the rest of his time for building things.
Follow him on GitHub.


This is meant to be a very quick introduction to the Unix operating system for the BIS180L bioinformatics laboratory class at UC Davis. The examples below assume you are using Ubuntu Linux 13.10, other versions and distributions will probably be fine. Why does the title of this document mention Unix when the distribution is Linux? Is there a difference between Unix and Linux? Practically, no; philosophically, sort-of; politically, yes. No time to discuss. Onward.
Author, Version, and Other Front-matter
This document was authored by Ian Korf. It is in the Public Domain. No rights reserved. It is for entertainment purposes only, so if you hurt yourself, don't blame me. The text was prepared in Markdown format (John Gruber) using BareBones TextWrangler. The PDF version was formatted with Marked (by Brett Terpstra) using the GitHub stylesheet. Thanks clever and kind developers for making my life easier.
Terminal, Command Line, and Shell
Your interface to Unix will be through a shell program using the command line interface within a terminal application. There are several types of shells and terminals, but the details of these are unnecessary for us. The command line is where you type instructions for what you want the computer to do. Some of these statements are "do this now" while others are "let's get ready to do this." It may seem silly in this high-tech age to type your commands when you could simply point and click or maybe even use voice activation or gesturing. It is easier to automate typing though. So when it comes time to work with thousands of files, it will be much easier through a command line interface.
Terminal Basics
Launch the terminal application (the name of this will differ from one
operating system to another and even within a particular OS you will
have several options). Run the date
command by typing in the terminal
and ending with the return key.
date
Congratulations, you just made your first Unix statement. You type words
on the command line (in this case just one) and then hit return to
execute the command. date
is but one of hundreds of Unix commands you
have at your fingertips (literally). Like most Unix commands, date
does more than simply output the current date in the format you just
witnessed. You can choose any number of formats and even set the
internal clock to a specific time. Let's explore this a tiny bit.
Commands can take arguments. Let's tell the date
program that we
want the date to be formatted a year-month-day and with
hours-minutes-seconds also. The syntax below will seem arcane, but the
various abbreviations should be obvious.
date "+%Y-%m-%d %H:%M:%S"
Manual Pages
If you want to learn more information about what date
can do, you can
either look online or use the Unix built-in manual pages. For a quick
refresher on a command, the manual pages are often easiest. But if you
have no idea what the command does, than you might want to look for
assistance online. To read the manual pages for date
you use the man
command.
man date
You can page through this with the space bar and exit with q
. In the
above statement, man
was the command and date
was the argument. The
program that let you page through the documentation was another Unix
command that you didn't intentionally invoke, it just happens
automatically when you execute the man
command.
Injury Prevention
Typing is bad for your health. Seriously, if you type all day, you will
end up with an repetitive stress injury. Don't type for hours at a time.
Make sure you schedule breaks.  Let's go back run the date
program again. Instead of typing
it in, use the up arrow on your keyboard to go backwards through
your command history. If you scroll back too far, you can use the down
arrow to move forward through your history (but not into the future,
Unix isn't that smart).
date "+%Y-%m-%d %H:%M:%S"
You can use the left arrow and right arrow to edit the text on the command line.
To see your entire history of commands in this session, use the
history
command.
history
If you want to repeat a particular command line, you can select a specific line of your history. For example, to re-run command line #7, you type the following:
!7
Probably the most important finger saver in Unix is tab completion.
When you hit the tab key, it completes the rest of the word for you. For
example, instead of typing out history
you can instead type his
followed by the tab key, the rest of the word will be completed. If you
use something less specific, can hit the tab key a second time and Unix
will show you the various legal words. Try typing h
and then the tab
key twice. Those are all the commands that begin with the letter h. We
will use tab completion constantly. Not only does it save you key
presses and time, it also ensures that your spelling is correct. Try
misspelling the history
command to observe the error it reports.
historie
Variables
The shell defines various variables which are called shell variables
or environment variables. For example, the USER
variable contains
your user name. You can examine the contents of a variable with the
printenv
command.
printenv USER
We won't use variables much, but it's important to know they exist
because some programs use them for configuration. If you want to see all
your environment variables, you can use the printenv
command without
any arguments. Don't worry if this is very confusing because we don't
care about it at this point.
printenv
Files & Directories
Unix is mostly a text environment. You will be reading and writing a lot of text files. To do this you will use a text editor. There are many, many text editors, and some people are insanely passionate about one or the other. We don't have time for that. We'll use two: nano, which works from your command line interface, and also gedit that works like a word processor.
In Unix, pretty much everything is a file. You need to be able to create, edit, and delete files and directories to do anything. You can do some of these things from the graphical desktop interface, but resist this. The more comfortable you are using the command line for everything, the better off you will be.
The file system is where your files are stored. This could be a hard
disk or other medium, and there could be one or more. To see how much
free space you have on your file system, use the df
(disk free)
command with the -h
option to make it more human-readable (try it both
ways).
df
df -h
Another useful command is du -h
(disk usage) which shows how much
space each of your files and directories uses.
Creating and Viewing Files
(For the this exercise and others that follow, it may be useful to have your graphical desktop displaying the contents of your home directory. That way you can see that typing and clicking ar related.)
 The touch
command will
create a file or change its modification time (Unix records when the
last time a file was edited) if it already exists.
touch foo
The file foo
doesn't contain anything at all. It is completely empty.
Now lets create a file with some content in it.
cat > bar
After you hit return, you will notice that you do not return to a
command line prompt. Keep typing.  Keep
going. Write poetry if you must. Everything you're entering at the
keyboard is now going into the file called bar
. To end the file, you
need to send the end-of-file character, which is control-D. This
character is at the end of every text file. Hit the control key and then
the letter d. Another way of saying this is hit the ^D character. Note
that you don't type the ^ or the capital D. It's just the way we
communicate in writing that one should type the control key and then the
d key.
To see the contents of the file, you can also use the cat
command.
This dumps the entirety of the file into your terminal.
cat bar
This isn't very useful for viewing unless you're a speed reader. You can
inspect the first 10 lines of a file with the head
command.
head bar
Similarly, you can inspect the last 10 lines with tail
.
tail bar
Both of these commands have command line options so that you can see a different number of lines. For example, to see just the first line you would do the following:
head -1 bar
A more useful way to look at files is with a pager. The more
and
less
commands let you see a file one terminal page at a time. This is
what you used before when viewing the manual page for the date
command. Use the spacebar to advance the page and q to quit. more
and
less
do more or less the same thing, but oddly enough less
does more
than more
.
less bar
Editing Files
You can edit files with nano or gedit. Let's stay in the terminal and use nano for now.
nano bar
This brings up a terminal-based editor. Now you can change the random text you just wrote. Use the arrow keys to move the cursor around. Add some text by typing. Remove some text with the delete key. At the bottom, you can see a menu that uses control keys. To save the file you hit the ^O key (control and then the letter o). You will then be prompted for the file name, at which point you can overwrite the current file (bar) or make a new file with a different name. To exit nano, use ^X. Note, you don't need to give nano an argument when you start it up.
Open up a new terminal. Create a new file called unix_notes.txt
(either by touching it first or saving an empty nano file). Use this to
record the various things you've learned today. You might want to go
back to this later.
Unix file names often have the following properties:
- all lowercase letters
- no spaces in the name (use underscores or dashes instead)
- an extension such as .txt
Navigating Directories
Whenever you are using a terminal, your focus is a particular directory.
The files you just created above were in a specific directory. To
determine what directory you are currently in, use the pwd
command
(print working directory).
pwd
This will tell you your location is /home/bios180student
(or maybe
not if you're reading this outside the context of the class or if the
documentation is out of date - it doesn't matter, this is your home
directory). The current directory is also known by the single letter .
(that is not the end of the sentence, it's the period character). If
you want to know what files are in your current working directory, use
the following command:
ls .
ls
will list your current directory if you don't give it an argument,
so an equivalent statement is simply:
ls
Notice that ls
reports the files and directories in your current
working directory. It's a little difficult to figure out which ones are
directories right now. So let's add a command line option to the ls
command.
ls -F
This command adds a character to the end of the file names to indicate
what kind of files they are. A forward slash character indicates that
the file is a directory. These directories inside your working directory
are sub-directories. They are below your current location. There are
also directories above you. There is at most one directory
immediately above you. We call this your parent directory, which in Unix
is called ..
(again, not the end of this sentence, but rather two
period characters together). You can list your parent directory as
follows:
ls ..
The ls
command has a lot of options. Try reading the man
pages and
trying some of them out. Now is a good time to experiment with a few
command line options. Note that you can specify them in any order and
collapse them if they don't take arguments (some options have
arguments). Don't forget to log your learning in your other terminal.
man ls
ls -a
ls -l
ls -l -a
ls -a -l
ls -la
ls -al
There are two ways to specify a directory: relative path and
absolute path. Everything so far has been the relative path. The
command ls ..
listed the directory above the current directory. The
command nano bar
edited the file bar
in the current directory. What
if you want to list some directory somewhere else or edit a file
somewhere else? To specify the absolute path, you precede the path with
a forward slash. For example, to list the absolute root of the Unix file
system, you would type the following:
ls /
To list the contents of /usr/bin you would do the following
ls /usr/bin
This works exactly the same from whatever your current working directory is. But this is not true of the relative path.
ls ..
To change your working directory, you use the cd
command. Try changing to the root directory
cd /
pwd
ls
Now return to your home directory by executing cd
without any arguments.
cd
pwd
ls
Now go back to the root directory and create a file in your home
directory. There are a couple short-cut ways to do this. The HOME
variable contains the location of your home directory. But ~ (tilde) is
another shortcut for the same thing and requires less typing.  Let's
organize that stuff. First off, let's create a new directory for 'Stuff'
using the mkdir
command.
cd
mkdir Stuff
Notice that the directory starts with a capital letter. This isn't
required, but it's a good practice. Now let's move some files into that new directory with the mv
command.
mv foo Stuff
If there are 2 arguments and the 2nd argument is not a directory, the
mv
command will rename the file. Yes, it's weird that mv
both moves
and renames files. That's Unix.
mv bar barf
mv barf Stuff
ls
You can move more than one file at a time. The last argument is where you want to move it to.
mv file1 file2 file3 file4 Stuff
ls
ls Stuff
Copying and Aliasing
The cp
command copies files. Let's say you wanted a copy of barf in
your home directory.
cp Stuff/barf .
ls
ls Stuff
Now you have 2 copies of barf. If you edit one file, it will be different from the other. Try that with nano.
nano barf
# do some editing and save it
cat barf
cat Stuff/barf
When you do the copying, you don't have to keep the same name.
cp Stuff/barf ./bark
ls
Things are getting a little messy, so let's put these files back into
the Stuff directory. But let's do it using the * wildcard, which is
somewhat magical because it fills in missing letters of arguments. Every
file that starts with ba
will now be moved to Stuff.
mv ba* Stuff
ls
That was just two files, but I think you can imagine the power of moving 100 files with a single command.
An alias is another name for a file. These are often useful to organize
your files and directories. Let's try it using the ln -s
command (we
always use the -s
option with ln
).
ln -s Stuff/foo ./foof
nano foof
# do some editing
cat foof
cat Stuff/foo
Deleting Files
You delete files with the rm
command. Be careful, because once gone,
they are gone forever.
ls Stuff
rm Stuff/file1
ls Stuff
rm foof
You didn't type those file names completely, right? You used tab completion, right?
You can delete multiple files at once too and even whole directories. But you're better off using the graphical interface to delete files. Deleting files is not something we wish you to automate.
Working with Text Files
There are 2 kinds of files: text and binary. A text file looks like the file you're reading. There are familiar letters, words, and punctuation (include spaces between words). Binary files don't look like this.  Let's look at one.
cat /bin/ls
Yuck. Most of the programs you run on a computer are binary files. Generally speaking, binary files are for machine consumption and text files are for human consumption (or readability). Text files come in 3 common flavors. Unix text files have a newline character at the end of each line. Mac text files generally also use newline characters, but carriage returns were used in the past and are still sometimes used. Windows files end in carriage returns plus newlines (they have 2 characters to denote end of line). These differences in line endings can cause problems when interchanging files among computers. For this reason, avoid interchanging files between you Linux, Mac, and Windows computers. One of the stupidest things you can do is to put sequence data into Microsoft Word or Excel (or similar software) and then attempt to use it in Unix.
Bioinformatics often deals with large text files. These can contain
whole genomes, massive RNA-seq experiments, or thousands of spectra.  Let's look at the
Arabidopsis thaliana genome. First, let's see how big it is. We'll use
the ls
with the -h
and -l
options so that we can see the size of
the file. Please use tab completion when typing the following.
ls -lh /data/C.elegans
You should see something that looks similar to this:
-rw------- 1 ian staff 29M Nov 26 14:41 c_elegans.PRJNA13758.WS240.genomic.fa.gz
-rw------- 1 ian staff 5.9M Oct 9 21:06 c_elegans.PRJNA13758.WS240.protein.fa.gz
There are two files, one contains genomic sequence, the other contains protein. The genome is 29 megabytes. That's not a very big file, but it's too big to email. A knee-jerk reaction might be to open this in your text editor. That's a bad idea for several reasons: (1) You shouldn't edit data files. (2) It takes way a lot more memory to edit a file than view its contents. (3) The file is binary. Let's do it anyway. Use tab completion to do the following.
nano /data/C.elegans/c_elegans.PRJNA13758.WS240.genomic.fa.gz
The file is binary, so it looks like gibberish. We need to uncompress it to see its contents. The file name is also hopelessly long. Let's organize ourselves a little. First, let's create a directory where we can collect our work.
mkdir ~/Project0
cd ~/Project0
The path to the genome file is long. We can simplify it with an alias.
ln -s /data/C.elegans/c_elegans.PRJNA13758.WS240.genomic.fa.gz ./genome.gz
ls -lF
Note what ls -lF
shows you. The @
symbol trailing the file name
shows you that the file is an alias. The arrow shows you what the alias
points to.
Now let's start uncompressing it. The gunzip
command uncompresses
files. If we want to stream the file to the terminal in a way similar to
cat
we use gunzip -c
.
gunzip -c genome.gz
When you get sick of watching the text scroll by, you can interrupt it with a ^C (control-c). ^C is a good way to interrupt a runaway process. But sometimes it doesn't work and you may have better luck with ^Z, which sleeps the process (yes, just like the Borg). More on that later.
Sometimes we want to look at the first few lines of a file without
committing ourselves to the whole file. head
is great for that.
head genome.gz
Rats, it's still binary. What would be great is if we could uncompress
the file and view the contents with head
. One of the awesome powers of
Unix is that you can pipeline the output of one program to the input of
another with the pipe |
token. This might look like a capital I or
lowercase l, but it's not, it's its own strange beast located somewhere
where you right pinkie can access it.
gunzip -c genome.gz | head
Success. The first line of the file is a FASTA header and this is followed by a bunch of sequence lines. If you don't know what the FASTA format is, now is a good time to read about the FASTA format online.
FASTA files sometimes contain multiple sequences. As this file represents the C. elegans genome, we expect 6 chromosomes. Let's look for those in the file.
gunzip -c genome.gz | less
Now we can page through the file looking for lines that start with >
.
As you page through the file, note how long the chromosome is. It will
take you over 12,000 more spacebar presses to get to the next chromosome
(assuming your terminal is still 24 lines). Remember, this is a small
genome. One of the features of less
is that it allows you to search
for simple patterns. Hit the forward-slash key /
to bring up the
search prompt at the bottom of the terminal. Now hit the >
key and
press return. less
will find the next >
symbol in the file. Keep
hitting the /
key and return. less
remembers the last pattern.
If you need to find patterns in files, the Unix grep
command is often
the first tool people turn to.
gunzip -c genome.gz | grep ">"
Now let's save that output to a file. You can redirect the output of a
program to a file with the >
token.
gunzip -c genome.gz | grep ">" > chromosomes.txt
cat chromosomes.txt
You will be creating a lot of files in this course. Sometimes they will
be large. Use gzip
and gunzip
as needed. gzip
usually makes a file
between 50% and 25% its size, so it's a great way to save space,
especially when you start to work with large -omic data files.
gzip chromosomes.txt
ls -l
gunzip chromosomes.txt
ls -l
Note that gzip
automatically adds and removes the .gz
file extension
appropriately.
In Unix, when people send you multiple files, they generally send them
as a tar ball. The tar
command creates archives, which are single
files that contain multiple files. Let's create a bunch of files in this
directory.
touch file1 file2 file3 file4 file5
Now let's cd
up a directory and have a look around.
cd ..
ls
ls Project0
To create an archive of Project0, we need to tell the tar
command that
we want to create the archive with the -c
option and tell it the name
of the file with the -f
option.
tar -c -f project0.tar Project0
Unix options generally go before the arguments on the command line.
That's why -f project0.tar
goes before Project0
. You can collapse
single letter options if you're lazy. So the following command is the
same thing.
tar -cf project0.tar Project0
ls
To save space on your file system, you should compress your tar-balls.
gzip project0.tar
ls
The tar
command will do this automatically with the -z
option. So
when you want to create a tar-ball, the one-liner is as follows:
tar -czf project0.tar.gz Project0
To decompress a tar-ball, you swap the -c
option for the -x
option.
Before we do that, let's create a new directory and inflate the tar-ball
in there so that we make a copy and don't overwrite our original
directory.
mkdir Stuff
mv project0.tar.gz Stuff
cd Stuff
tar -xzf project0.tar.gz
ls
ls Project0
Using File Permissions
A file can have 3 kinds of permissions: read, write, and execute. These
are abbreviated as rwx
when you do a ls -l
. Read and write are
obvious, but execute is a little weird. Programs and directories need
executable permission to access them. Important data files, like the
genome of C. elegans, should not be edited. To ensure that, they should
have read only permission. Every file has permissions for the user,
group, and public. So a file can be readable by you and inaccessible to
the public. Let's look at one of the files we just created.
ls -lF chromosomes.txt
This will produce something like the following, which shows the permissions, owner (ian), group (staff), size (29 bytes), date, and file name.
-rw-r--r-- 1 ian staff 29B Mar 26 11:11 chromosomes.txt
Let's first turn on all permissions for everyone.
chomd 777 chromosomes.txt
The explanation of what this does will have to wait for a bit. The file now has the following properties.
-rwxrwxrwx 1 ian staff 29B Mar 26 11:11 chromosomes.txt*
The first character is a hyphen. This means the file is an ordinary file. If the file was a directory, the letter would be a d. If it was an alias, the letter would be an l. The 3 rwx symbols that follow are the read, write, and execute permissions for user, group, and public. So everyone has permission to read, write, and execute this file. If you copy files from a USB flash drive, it will typically have all these permissions because the file system on most flash drives is not Unix-based. Having all permissions on is generally not a good idea. Most files fit into one of a few categories.
| Category | Code | Oct | Meaning
|:-----------|:-------------|:----|-----------------------------------------
| raw data | -r--r--r--
| 444 | anyone can read, nobody can write
| private | -rw-------
| 600 | I can read/write, others nothing
| shared | -rw-r--r--
| 644 | I can read/write, group/public can read
| shared | -rw-rw-r--
| 664 | We can read/write, public can read
You can change the permissions of a file with the chmod
command. There
are two different syntaxes. The more human readable one looks like this.
chmod u-x chromosomes.txt
This command says "change the user (u) to remove (-) the execute (x) permission from file chromosmes.txt". You add permissions with +.
chmod u+x chromosomes.txt
The octal format is convenient because it changes all of the permissions
at once, but can be confusing for people who don't think in octal. 4 is
the read permission. 2 is the write permission. 1 is the execute
permission. Each rwx corresponds to one octal number from 0 to 7. So
chmod 777
turns on all permissions for all types of people and
chmod 000
turns them all off. I generally use only two permissions:
444 and 644. That is, everything is readable, but somethings only I can
write.
Processes
One of the most important programs in Unix is top
because it lets us
monitor the health of our computer. Open up a new terminal and start the
program.
top
On Unix systems, top
is the equivalent of the the Task Manger in
Windows and the Activity Monitor in Mac OS. Once you start running
bioinformatics software on your computer, you can monitor what is
happening using top
.
Viewing Processes
Let's go back to an previous command and watch it with top
. Notice
that it doesn't use 100% of the CPU.
gunzip -c genome.gz
Let's do that one more time, and this time we will use the time
command to determine the elapsed and CPU time.
time gunzip -c genome.gz
On my computer, I get the following stats
real 0m6.930s
user 0m0.483s
sys 0m0.859s
It took about 7 seconds to stream the contents to my terminal. The CPU time is the sum of the user and sys time. Why did it take so much more real time than CPU time? Because it takes some time to display to the terminal, during which the CPU isn't very busy. Let's try the same task and send the output to a file.
time gunzip -c genome.gz > foo
Big difference!
real 0m0.413s
user 0m0.357s
sys 0m0.056s
Sometimes we don't even need to see the output. In this case, we can
redirect the output to /dev/null
which is Unix's black hole (not even
electrons escape).
time gunzip -c genome.gz > /dev/null
Faster still because we don't have to write to the file system.
real 0m0.356s
user 0m0.348s
sys 0m0.009s
Note that the CPU time is slightly greater than the real time. How can something take less wall clock time than CPU time? Are we violating the laws of physics? No, your computer has more than one core and can split up tasks on various cores. For programs that can utilize multiple cores, the real time may be much less than the CPU time.
Managing Processes
Sometimes you will start a program and decide you want to stop it
permanently or temporarily. Run the following command and then watch
what happens in top
. You may find it useful to copy-paste this command
from the document to your terminal to make sure you don't introduce
spelling errors.
perl -e 'while(1){print $i++, chr(10)}'
This command is an endless loop in the Perl programming language that counts from 0 to some very large number. You cannot do anything useful in your terminal until the program stops, which unfortunately, is a long time from now. Fortunately, we can break out of the program with ^C. Do that now.
But what if you just wanted to pause the program and restart it again? You can do that with ^Z. So let's go back and execute that command again (use the up arrow) and this time send it a sleep signal.
perl -e 'while(1){print $i++, chr(10)}'
Now hit ^Z. To get it to pick up where it left off, use the fg
command
to put the process into the foreground.
fg
Now go look at top
. You should see a perl process using a lot of CPU.
Every process (program) on your computer has a process ID (PID). If you
know the PID of a process, you can take control of it (assuming it is
yours). My perl process has PID 6000. On yours it is probably different.
You can view all your processes with the ps
command. In the following
command, replace ian
with your user name: bios180student
.
ps -u ian
However you attain the PID of your offending process, you can kill
it.
Replace 6000
with your PID.
kill 6000
You can put processes into the background. This will mean the
terminal no longer controls them.  Add &
to the end of a
command line to put it into the background or use the bg
command to
put a paused process into the background. You shouldn't need to do these
things in this class, but we include this info for completeness.
Unix Reference
| Token | Function |:--------|:-------------------------------------| | . | your current directory (see pwd) | .. | your parent directory | ~ | your home directory (also $HOME) | ^c | send interrupt signal to current process | ^d | send end-of-file character | ^z | send sleep signal current process: see bg and fg | tab | tab-complete names | * | wildcard - matches everything | & | send command to background | | | pipe output from one command to another | > | redirect output to file
| Command | Example | Intent |
|:----------|:--------------|:------------------------------|
| bg
| bg
| send a sleeping process to background
| cat
| cat > f
| create file f and wait for keyboard (see ^d)
| | cat f
| stream contents of file f to STDOUT
| | cat a b > c
| concatenate files a and b into c
| cd
| cd d
| change to relative directory d
| | cd ..
| go up one directory
| | cd /d
| change to absolute directory d
| chmod
| chmod 644 f
| change file permissions
| | chmod u+x f
| change file permissions
| cp
| cp f1 f2
| make a copy of file f1 called f2
| cut
| cut -f 5 ff
| print column 5 from file ff
| date
| date
| print the current date
| df
| df -h .
| display free space on file system
| du
| du -h ~
| display the sizes of your files
| fg
| fg
| send sleeping process to foreground
| grep
| grep p f
| print lines with the letter p in file f
| gzip
| gzip f
| compress file f
| gunzip
| gunzip f.gz
| uncompress file f.gz
| head
| head f
| display the first 10 lines of file f
| | head -2 f
| display the first 2 lines of file f
| history
| history
| display the recent commands you typed
| kill
| kill 1023
| kill process with id 1023
| less
| less f
| page through a file
| ln
| ln -s f1 f2
| make f2 an alias of f1
| ls
| ls
| list current directory
| | ls -l
| list with file details
| | ls -la
| also show invisible files
| | ls -lta
| sort by time instead of name
| | ls -ltaF
| also show file type symbols
| man
| man ls
| read the manual page on ls command
| mkdir
| mkdir d
| make a directory named d
| more
| more f
| page through file f (see less)
| mv
| mv foo bar
| rename file foo as bar
| | mv foo ..
| move file foo to parent directory
| nano
| nano
| use the nano text file editor
| passwd
| passwd
| change your password
| pwd
| pwd
| print working directory
| ps
| ps
| show current processes
| | ps -u ian
| show processes user ian is running
| rm
| rm f1 f2
| remove files f1 and f2
| | rm -r d
| remove directory d and all files beneath
| | rm -rf /
| destroy your computer
| rmdir
| rmdir d
| remove directory d
| sort
| sort f
| sort file f alphabetically by first column
| | sort -n f
| sort file f numerically by first column
| | sort -k 2 f
| sort file f alphabetically by column 2
| ssh
| ssh hal
| remotely log into machine hal
| tail
| tail f
| display the last 10 lines of file f
| | tail -f f
| as above and keep displaying if file is open
| tar
| tar -cf ...
| create a compressed tar-ball (-z to compress)
| | tar -xf ...
| decompress a tar-ball (-z if compressed)
| time
| time ...
| determine how much time a process takes
| top
| top
| display processes running on your system
| touch
| touch f
| update file f modification time (create if needed)
| wc
| wc f
| count the lines, words, and characters in file f


Agents
|
Name | Agent | Destination | notification | status |
|---|---|---|---|---|
|
yass |
working
|
working
|
working
|
|
|
yass |
working
|
working
|
working
|
|
|
yass |
working
|
working
|
working
|
|
|
yass |
working
|
working
|
working
|


Skinner Auctioneers
Skinner Auctioneers has a long history as a local institution and provider of fine art and stuff for rich people. With a fundamental requirement to preserve the functional core of their in-house inventory system and integrate with their external online auction provider, we were tasked with designing an application to build the auction and lot listings by proxy, alongside an existing back end partner.
created at Sametz Blackstone Associates
The approach
From the outset, it was clear that we needed to provide dynamic, related content across the site—namely we always had to show an array of currently available objects from the upcoming auctions and we had to show the expert curators who had gathered and evaluated these objects. The former to directly engage the viewers and the latter to reinforce Skinner's position as a leader in the field.
With the primary technical concern being interfacing (albeit indirectly and securely) with the central auction platform, the project kicked off identifying the proxy interface. In the end, Solr was used to aggregate lot data while the a SQL server was provisioned to mirror the data for the auctions themselves. The dual interfaces resulted in a highly complex, but ultimately successful combination.
For page-based content entry that was not directly tied to the auctions themselves, the staff was comfortable with Wordpress but the internal IT team was very reluctant to run a large-scale database-driven instance. As a result, we came up with a flat-file driven CMS, using Wordpress for content entry and to generate dynamic, server-side pages for simple templating and content aggregation. Though a challenging exercise in validation and security, the end result is highly performant even in an environment in which it was cause for concern.
For mobile viewing, there was a strong preference on the part of the client team for a dedicated mobile site, with mobile viewing being strongly tied to a radically different audience—namely those who were actually at an in-person auction, wandering the floor and searching for additional information. As a result, rather than a fully responsive site, we created a separate m.skinnerinc.com mobile site, which tightly focused on driving the viewer directly into the relevant auctions and lots.
Trivia
At one point, on a whim, I created a small script to count the lines of code in our repository. Though the total included both libraries and a great deal of machine-generated code, it was noteworthy that the final number was slightly larger than that of an F-22 Raptor's avionics package, or roughly 117 copies of War and Peace.


We're sorry but dokoma-blob doesn't work properly without JavaScript enabled. Please enable it to continue.


About
I am motivated to create meaningful experiences through the coalescing of beautiful design and elegant code. I am a first-year Computer Science student at Georgia State, and I am enrolled in the Georgia Tech coding boot camp. I have experience as Vice President of the Walton High School chapter of Coding for Community, and I have completed two AP courses on object oriented programming with Java.


TAP THEM ALL
This mobile game project for Android mobile phones required designing and creating UX elements and art. The work involved creating a menu, in-game interface design, textures for game elements and backgrounds.
Furthermore, in order to meet all the requirements connected with publishing a game in the Google Play store, the project also involved creation of marketing assets – nicely looking screenshots, game icons and logo. The style of both marketing assets and in-game art had to be consistent, so to avoid confusing the end user.


Note: This documentation refers to Carpenter version 3.8
and may not be compatible with other versions.
Call carpenter without any options or arguments
to check the actually supported options.
Carpenter is a program for frequent item set mining, a data mining method that was originally developed for market basket analysis. Frequent item set mining aims at finding regularities in the shopping behavior of the customers of supermarkets, mail-order companies and online shops. In particular, it tries to identify sets of products that are frequently bought together. Once identified, such sets of associated products may be used to optimize the organization of the offered products on the shelves of a supermarket or the pages of a mail-order catalog or web shop, may give hints which products may conveniently be bundled, or may allow to suggest other products to customers. However, frequent item set mining may be used for a much wider variety of tasks, which share that one is interested in finding regularities between (nominal) variables in a given data set. For an overview of frequent item set mining in general and several specific algorithms (including Carpenter), see the survey [Borgelt 2012].
This page describes the Carpenter implementation that I have been developing and improving since 2011. This implementation covers the basic scheme as developed in [Pan et al. 2003], which enumerates transaction sets, in contrast to many other frequent item set mining algorithms, which enumerate item sets. Such an approach can be highly competitive in special cases, namely if there are few transactions and (very) many items, which is a common situation in biological data sets like gene expression data. For other data sets (fewer items, many transactions), however, it is not a recommendable approach.
By default the program finds closed item sets. It can also find maximal item sets, but the filtering of the closed item sets may not be very efficient.
This implementation offers a variant based on transaction identifier lists according to the description in [Pan et al. 2003], although with several optimizations due to which it significantly outperforms the implementation of the Gemini package, which is provided by the authors of [Pan et al. 2003].
The alternative is a variant based on an item occurrence counter table, which bears some vague resemblance to the horizontal approach in the RERII algorithm [Cong et al. 2004]. Which of the two variants is faster depends on the data set. By default, the variant to be used is chosen automatically based on the table size (essentially: if the data table fits into the processor cache, use the table, otherwise use the transaction identifier list version).
Note that the current version of this program can only find frequent item sets, not association rules.
Enjoy,
Christian Borgelt
| back to the top |
This section briefly introduces some basic notions needed to talk about frequent item sets. These notions are item, transaction, support and frequent, closed and maximal item set. For a more extensive coverage, consult the survey [Borgelt 2012].
On an abstract level, the input to frequent item set mining consists of a bag or multiset of transactions that are defined over a set of items, sometimes called the item base. These items may be products, special equipment items, service options etc. For an abstract treatment it suffices that items have an identity, that is, it is possible to distinguish one item from another. The item base is the set of all considered items, for example, the set of all products that are sold by a given supermarket, mail-order company or online shop. Any subset of the item base is called an item set.
A transaction is simply an item set and it represents, for example, the set of products bought by a customer. Since two or more customers may, in principle, buy the exact same set of products, we cannot model the whole of all "shopping baskets" or "shopping carts" (bought, say, in a given week) as a set of transactions, since in a set each element is unique. There are several solutions to this problem: one may, for example, model the whole of all transactions as a bag or multiset (a generalization of a set, which allows for multiple occurrences of the same element) or as a vector (where elements at different positions may be the same, but are still distinguished by their position), or by extending each transaction with a unique transaction identifier (or tid for short; note that the position of a transaction in a vector representation is an implicit transaction identifier). Still another possibility consists in using a standard set of (unique) transactions and assigning to each of them an occurrence counter. Here I use the bag/multiset terminology, even though an occasional "set of transactions" may have slipped through. (This should always be read as "bag/multiset of transactions".)
Note that the item base (the set of all considered items) is often not given explicitly, but only implicitly as the union of all given transactions. This is also the case for my Carpenter program, which by default only takes a transaction file as input. However, it is also possible to specify the item base explicitly with an optional item selection file (option -R; discussed in this section). This can be useful, for example, if one wants to restrict the analysis to a subset of all items.
| back to the top |
Let S be an item set and T the bag/multiset of all transactions under consideration. Then the absolute support (or simply the support) of the item set S is the number of transactions in T that contain S. Likewise, the relative support of S is the fraction (or percentage) of the transactions in T which contain S.
More formally, let S be an item set and U = { X∈T | S⊆t } the bag/multiset of all transactions in T that have S as a subset (i.e. contain all of the items in S and possibly some others). Then
suppabs(S) = |U| = |{ X∈T | S⊆t }|
is the absolute support of S and
supprel(S) = (|U| / |T|) *100%
is the relative support of S. Here |U| and |T| are the number of elements in U and T, respectively.
In a supermarket setting, the item set S may be a set like S = { bread, wine, cheese } and T may be the bag/multiset of all "baskets" or "carts" of products bought by the customers of a supermarket – in a given week if you like. U is the bag/multiset of all transactions in T that contain all items in S (and maybe also some other items). For example, if a customer buys the set X = { milk, bread, apples, wine, sausages, cheese, onions, potatoes }, then S is obviously a subset of X, hence X is in U. If there are 318 customers, each giving rise to one transaction, and 242 of these customers bought such a set X or a similar one that contains S, while the other customers bought sets of products that lacked at least one of the items in S, then suppabs(S) = 242 and supprel(S) = 242/318 = 76.1%.
The goal of frequent item set mining is to find all item sets (that is, all subsets of the item base) that occur in the given bag/multiset of transactions with at least a user-specified minimum support suppmin. Such item sets are called frequent item sets.
The default value for the minimum support in my Carpenter program is 10% (the percentage indicates implicitly that it refers to relative support). This value can be changed with the option -s. Note that the argument to this option is interpreted as a percentage if it is positive, but if it is negative, it is interpreted as an absolute number (number of transactions) rather than a percentage. That is, -s20 means a minimum relative support of 20%, while -s-20 means a minimum absolute support of 20 transactions.
| back to the top |
The target type, which can be selected via the option -t, is either closed item sets (default, option -tc) or maximal item sets (option -tm). Note that unlike most other frequent item set mining programs, the current version of my Carpenter implementation can not output all frequent item sets.
More detailed information about the different target types of frequent item set mining can be found in the survey [Borgelt 2012].
A frequent item set is called closed if no superset is frequent, that is, has a support exceeding the minimum support. Formally, an item set I is called closed iff
∀ J ⊃ I: supp(J) < supp(I).
If the option -tc is given, the found frequent item sets are subsequently filtered and only the closed item sets are reported.
A frequent item set is called maximal if no superset the same support (or, in other words, if all supersets have a lower support). Formally, an item set I is called maximal iff
∀ J ⊃ I: supp(J) < suppmin.
If the option -tm is given, the found frequent item sets are subsequently filtered and only the maximal item sets are reported.
| back to the top |
My Carpenter implementation is a command line program that has to be called in a terminal or command window or from a shell script. If double-clicked in a file manager (e.g. in Microsoft Windows), it merely prints a usage message to a terminal/command window that is briefly opened and immediately closed again. This does not mean that the program does not work. In order to run the program, open a terminal/command window, change directory to where you stored the program, and then type an invocation command.
The general syntax of the program invocation is
carpenter [options] infile [outfile]
The first argument infile, which is mandatory, is the name of a file that contains the transactions to analyze. The format of this file is described in this section. If instead of a file name a single minus sign "-" or an empty string "" is given, the input is read from standard input rather than from a file.
The second argument outfile, which is optional (as indicated by the brackets), is the name of a file to which the found frequent item sets are to be written. That it is optional is useful for benchmark tests, where the time it takes to write the output to a file can conceal the actual search time, or if only a pattern spectrum (number of found frequent item sets collected by size and (absolute) support; option -P) is to be found. The format in which frequent item sets are written to the output file is described in this section. If instead of a file name a single minus sign "-" or an empty string "" is given, the output is written to standard output rather than to a file.
In addition to the input and output file several options can be given, all of which consist of a minus sign and a single letter. The full list of options can be found in the next section.
Some options take a parameter. For example, the option -s, with which the minimum support is specified, takes a number as a parameter, which must follow the letter s without any separating space. A space between the option character and its parameter is only allowed if the parameter is a string, for example, a file name. (However, even in this case the parameter may follow the option letter directly.) If the parameter is a number or a single letter, it must follow the option letter directly.
Options may be combined. For example,
carpenter -s10m2n5 input output
means that the minimum support is 10% (option -s), the minimum number of items in an item set is 2 (option -m) and the maximum number of items in an item set is 5 (option -n).
Options may be specified anywhere on the command line, that is, before the input file name, in between the input and output file names, or after the output file name.
If an option is given more than once, the last statement counts. That is, with
carpenter -s10 -s20 input output
the minimum support is 20%, as the -s10 is overwritten by the following -s20.
| back to the top |
My Carpenter implementation supports the following options
(a # after the option letter means that the option
takes a parameter):
| option | meaning | default |
|---|---|---|
| -t# | target type c: closed item sets m: maximal item sets | c |
| -m# | minimum number of items per item set | 1 |
| -n# | maximum number of items per item set | no limit |
| -s# | minimum support of an item set positive: percentage of transactions negative: absolute number of transactions |
10 |
| -e# | additional evaluation measure x: no measure b: binary logarithm of support quotient |
x |
| -d# | minimum value of additional evaluation measure (as a percentage) |
10 |
| -q# | sort items w.r.t. their frequency 0: do not sort 1: ascending, -1: descending w.r.t. item frequency 2: ascending, -2: descending w.r.t. transaction size sum |
2 |
| -p | do not collate equal transactions | collate |
| -A# | variant of the Carpenter algorithm to use a: automatic choice based on table size t: item occurrence counter table l: transaction identifier lists |
o |
| -x | do not prune with perfect extensions | prune |
| -z | filter maximal item sets with repository (needs less memory, but is usually slower) |
extra |
| -y | add only maximal item sets to repository (needs less memory, but is usually slower) |
all closed |
| -F#:#.. | support border for filtering item sets (list of minimum support values, one per item set size, starting at the minimum size, as given with option -m#) |
none |
| -R# | read an item selection from a file parameter: file name |
|
| -P# | write a pattern spectrum to a file parameter: file name |
|
| -Z | print item set statistics (number of item sets per size) |
|
| -g | write output in scanable form (quote certain characters) |
|
| -h# | record header for output | "" |
| -k# | item separator for output | " " |
| -v# | output format for item set information (changed to " (%a)" if parameter of -s is negative) |
" (%S)" " (%a)" |
| -w | transaction weight in last field | only items |
| -r# | record/transaction separators | "\n" |
| -f# | field/item separators | " \t," |
| -b# | blank characters | " \t\r" |
| -C# | comment characters | "#" |
| -T# | file to write transaction identifiers to (only with algorithm variant i) |
|
| -! | print additional option information |
| back to the top |
The transactions file has to be a (text) file structured by field and record separators and blanks. Record separators, not surprisingly, separate records, usually lines, field separators separate fields, usually words. Blanks are used to fill fields, for example, to align them. In the transactions file each record must contain one transaction, i.e. a list of item identifiers, which are separated by field separators. An empty record is interpreted as an empty transaction. That is, it is counted for the total number of transactions, but does not count for the support of any item set other than the empty set. A transaction may contain the same item multiple times (that is, duplicate items do not raise an error), but this multiplicity is disregarded by the Carpenter program. It only considers whether an item is contained in a transaction or not, not how many times an item is contained in a transaction.
Example input files can be found in the directory carpenter/ex in the source package. These files are used in the following to demonstrate how to use the command line options -r, -f, -b and -w. In addition, there are several conversion scripts (for Linux/Unix), with which different common input formats can be converted into the format required by the Carpenter program.
In the file test1.tab transactions are separated by newline characters (that is, each line of the file contains one transaction) and the items of a transaction are separated by spaces. That is, the file test1.tab looks like this:
a b c
a d e
b c d
a b c d
b c
a b d
d e
a b c d
c d e
a b c
As can be seen, there are ten transactions over the item base {a, b, c, d, e}, which contain between two and four items each.
The file test1.tab is in the standard input format and hence it can be processed directly:
carpenter test1.tab test1.out
Instead of spaces, tabulators may be used, and it is possible to mix spaces and tabulators. Note, however, that multiple consecutive white space characters (like multiple spaces or a space and a tabulator etc.) are interpreted as a single field separator. The reason is that by default spaces, tabulators and the carriage return character are interpreted as blank characters, which are removed when reading items. Hence only the first white space character after an item is interpreted as a field separator, all following white space characters are interpreted as blanks.
Note also that commas are among the default field separators as well. That is, if the file test1.tab looked like this:
a,b,c
a,d,e
b,c,d
a,b,c,d
b,c
a,b,d
d,e
a,b,c,d
c,d,e
a,b,c
it could still be processed directly with the command stated above. You may also mix spaces, tabulators and commas.
Unfortunately, though, the fact that commas are interpreted as field separators does not necessarily mean that CSV-files (where CSV stands for "comma separated values"), as they can be written by programs like Microsoft Excel, can be processed directly. The reason is that in a CSV-file all lines contain the same number of fields. That is, in CSV-format, the above input file would look like this (file test1.csv in directory carpenter/ex):
a,b,c,
a,d,e,
b,c,d,
a,b,c,d
b,c,,
a,b,d,
d,e,,
a,b,c,d
c,d,e,
a,b,c,
Note the single and double commas at the end of most lines, which separate empty fields (as these transactions have fewer items than the longest transaction). While a single comma at the end of a line does not cause any problems and is simply ignored, two or more commas lead to an error message "item expected", because an item may not be an empty string. This can be fixed by declaring the comma a blank character (option -b). That is, the CSV-file can be processed with:
carpenter -b, test1.csv test1.out
Note, however, that the characters given with the option -b replace the default blank characters. So if you still need spaces to be interpreted as blanks, they have to be specified as well:
carpenter -b" ," test1.csv test1.out
In the file test2.tab the same transactions can be found, but several different field separators are used:
a,b,c
a,d,e
b.c.d
a,b,c,d
b:c
a,b,d
d,e
a,b,c,d
c;d;e
a,b,c
The file test2.tab can be processed by declaring different field separators with the option -f:
carpenter -f",.;:" -l test2.tab test2.out
The file test3.tab has basically the same format as the file test1.tab, with the only difference that the last fields of each record states an (integer) transaction weight/multiplicity.
a b c 2
a d e 1
b c d 1
a b c d 2
b c 1
a b d 1
d e 1
c d e 1
This allows us to combine transactions, so that test2.tab has only 8 lines, while test1.tab has 10 lines, because the transactions a b c and a b c d occur twice. In order to instruct the Carpenter program to interpret the last field of each record as such a weight/multiplicity, is has to be invoked with the option -w:
carpenter -w test3.tab test3.out
The files test4.tab to test6.tab are in formats that may be common, but which cannot be processed directly with the Carpenter program.
In the file test4.tab each line contains a transaction identifier and an item, separated by a space (not shown because of the large number of lines). This file can be converted (on Linux/Unix systems) into the standard input format with the script tid2set, i.e., with
tid2set test4.tab x.tab
Note that this script sorts the input file (here: test4.tab) w.r.t. the transaction identifier, so that items belonging to the same transaction occupy consecutive lines/records. That is, the input need not already be sorted by transaction identifier, rather the script does this to make sure that the conversion works.

In the file test6.tab there is one item per line and transactions are separated by blank lines (not shown here because of the large number of lines). This format can be converted (on Linux/Unix systems) into the standard input format with the script row2set, i.e., with:
row2set test6.tab x.tab
Note that the file test6.tab could be processed directly if the transactions were not separated by a mere empty line (that is, two newline characters following each other), but if the empty line contained a special character, for example %. In this case the file can be processed directly with
carpenter -r"%" -f"\n" -b"\n" test6.tab x.tab
The additional scripts tab2set and hdr2set convert tables with column numbers or column names into a format appropriate for the Carpenter program. They are invoked in the same way as all other scripts discussed above, i.e., with
tab2set a.tab b.tab
or
hdr2set a.tab b.tab
where a.tab is the name of the input file and b.tab the name of the output file. The script tab2set replaces each table entry "x" of the input file by "Xi=x", where i is the column number (starting with 1).
The script hdr2set reads the variable names from the first line of the input file and then replaces each table entry "x" by "X=x", where "X" is the variable name that was found in the corresponding column of the first line. These scripts are handy if you want to process tabular data by treating each table row as a transaction.
Note that any input may also be read from standard input and any output may be sent to standard output, simply by specifying a '-' or an empty string "" instead of a filename. For example (on a Linux/Unix system)
cat test1.tab | carpenter - -
reads the transactions from standard input (where they are fed by the cat command) and writes the found frequent item sets directly to the terminal. They may be piped to any other program or script, since all other messages of the Carpenter program are written to standard error.
| back to the top |
In addition to an input file with the transactions and an output file for the found item sets, an item selection file may be passed to the Carpenter program with the option -R. This file lists a selection of items that are to be included in the search, while any items not listed in this file are to be ignored. It can be seen as a specification of the item base for the search.
The item selection file has to be a (text) file structured by the same field and record separators and blanks as the transactions file. Items may be listed in a single record or in multiple records; it does not matter in which record an item occurs. All that matters is whether an item occurs in the item selection file (then it is included in the search) or not (then it is ignored).
| back to the top |
The output format for item sets is fairly flexible. Especially the output of the additional information about item sets (support, additional evaluation) can be formatted freely.
Each line of the output file contains one item set in the format
A B C [...] <add. info>
where A, B and C are item identifiers, and <add. info> is determined by the additional information output format (option -v). The item separator may be changed with the option -k. For example,
carpenter -k, test1.tab test.out
produces output in the format
A,B,C,[...] <add. info>
Each output line may be preceded by a string that is specified with the option -h (record header for output).
The output format for the additional rule information can be any string with the following special format symbols (similar to the style of the special format symbols of the printf function in the programming language C):
| %% | a percent sign | |
| %i | number of items (item set size) | |
| %a | absolute item set support | |
| %s | relative item set support as a fraction | |
| %S | relative item set support as a percentage | |
| %e | additional evaluation measure | |
| %E | additional evaluation measure as a percentage |
All format specifiers can be extended by an integer number between the percent sign and the defining character, which specifies the number of decimal digits to be printed (expect those that refer to integer numbers, like the number of items and the absolute support, for which such a number of digits is ignored). If no such number is given, (up to) six significant digits are reported.
The default additional information output format is for item sets " (%S)". That is, the relative support of the item set is printed with (up to) six significant digits, enclosed in parentheses. Two spaces separate the additional information from the last item in the set. The default format is automatically changed to " (%a)" if the minimum support (option -s) is given as a negative number (absolute support), so that the output is consistent with the support threshold.
A pattern spectrum collects the number of found frequent item sets sub-divided by the size and the support of the item sets. Pattern spectra (together with surrogate data/randomization methods) can be useful to determine the statistical significance of found frequent item sets. Details can be found in the papers [Picado-Muino et al. 2013] and [Torre et al. 2013].
My Carpenter implementation can be instructed to collect and write a pattern spectrum with the option -P, which takes the name of the file to which the patterns spectrum is to be written as a parameter.
A pattern spectrum is written as a list of (size, support, count) triplets. The output file is a simple text file that contains one triplet per line, with the three numbers separated by spaces. For example, for the input file test1.tab (see this section) the pattern spectrum is (with default option settings):
1 3 1
1 6 1
1 7 3
2 1 2
2 3 1
2 4 4
2 5 1
2 6 1
3 1 2
3 2 1
3 3 2
3 4 1
4 2 1
The first column contains the different sizes of item sets, the second column the difference support values, and the third column the number of item sets found for the corresponding (size, support) combination. For example, the sixth row indicates that there are four frequent item sets with two items and support 4. Note that in a pattern spectrum the support is always given as absolute support, that is, as a number of transactions.
| back to the top |
Carpenter -
find frequent item sets with the Carpenter algorithm
copyright © 2002-2013 Christian Borgelt
This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser (Library) General Public License as published by the Free Software Foundation.
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 Lesser (Library) General Public License for more details.
| back to the top |
Download page with most recent version.
| back to the top |
| E-mail: |
<EMAIL_ADDRESS><EMAIL_ADDRESS>| |
| Snail mail: |
Christian Borgelt Intelligent Data Analysis and Graphical Models Research Unit European Center for Soft Computing Edificio Cientifico-Tecnológico, 3a Planta c/ Gonzalo Gutiérrez Quirós s/n 33600 Mieres (Asturias) Spain | |
| Phone: | +34 985 456545 | |
| Fax: | +34 985 456699 |
| back to the top |
An overview of frequent item set mining covering Carpenter and many other algorithms can be found in this survey paper:
A description of some implementation aspects can be found in this paper:
The use of pattern spectra to evaluate the statistical significance of found frequent item sets is explained in these papers:
Other references for the Carpenter algorithm include:
| back to the top |


| Message from Management | |
|---|---|
|
Mr. Dilip Surana CMD |
Mr. Anand Surana Director |
|
Yet another year has passed with challenges and accomplishments. And along with its passing, what we have are the memories of many wonderful learning through which we can fine tune ourselves to face newer challenges and make greater strides in business refinements. I am pleased to congratulate each one of you involved in the continuing success of Micro Labs. Some of the highlights of 2012 :
As we document the unfolding of the year, our primary focus should be to create new fountain heads of value creation both within India and abroad while continuing to expand the existing flanks of value creation. The Indian Pharma industry is posed with tough competitions and fast moving changes. Like every drop that makes an ocean, each one of us has within ourselves, the capability to make a difference. It is important that we believe in ourselves, have faith in our capabilities and encompass the courage to carry out our convictions. |


Downtown Tour
Enjoy a walking tour of Portland's days gone by. This walking only tour provides a glimpse into the natural, architectural, and cultural history of downtown Portland. Upon arrival, you will receive a booklet of the 20 locations we will visit throughout this three hour tour. Use this booklet to compare Portland's current landscape with accurate historical context.
What's Included?
- Complimentary tour booklet with Before and After photos and a brief history of each location
- Complimentary water
"It was amazing to walk around downtown Portland comparing the images in the booklet to the current building or in some cases disappearance of a building." - Emily
Growth Tour
Want to jump into Portland's rich history of growth? This tour offers an insightful experience, by our very educated tour guides, about the history of Portland's growth. While this tour includes walking and driving most conversations will take place at Deschuttes Brewery over complimentary beer flights and complimentary dining at Portland's oldest restaurant, Huber's.
What's Included?
- Complimentary flight of three Deschutes Brewery beers
- Complimentary tapas style appetizer at Huber's restaurant
"I moved to Portland a few years ago and learned so much from our funny and informative tour guide on the evolution of Portland as I know it today." - Alex
Landmarks Tour
This tour will help you cement your Portland knowledge and cover all of Portland's famous landmarks and must see spots. We use a spacious shuttle bus to travel around Portland's quadrants and famous bridges. When you finish the tour, you can tell everyone that you've seen it all in Portland.
What's Included?
- Complimentary tour booklet with photos and brief descriptions of the locations we visit
- Complimentary local snacks
"We were only in town for a day and decided to make the most of it with a tour. We covered almost the entire city. I couldn't have done that alone and our tour guide was so fun!" - Beatrix


Hello! My name is Tyson Lackey. I was born and raised in Portland, Oregon and have lived here most of my life. There were a couple of years spent at Oregon State University in Corvallis, but other that, Metro Portland has always been home. Lacrosse was a huge passion of mine growing up and I played through middle school and high school. I decided to stop playing competitively after graduating so I could focus on the full college experience instead of being consumed by sports 24/7. I was pursuing a business degree from Oregon State and Portland State depending (bouncing between the two from 2008-2011) before deciding that a 4-year university wasn't for me. After leaving school and a few years of working at a netflix call center, a career in Business Intelligence focused in the Logistics field kind of fell into my lap. Working as a junior analyst taught me most of my background in SQL, Power Query, and Power BI. A few years into that field, I realized that I wanted to cement a better foundation in my development skills and possibly pursue a new career in coding. If nothing else, learning code would supplement a career in BI better than any on the job tricks I would pick up along the way. Fate seemed to notice my shift in interests and my job was outsourced in August of 2019 creating a perfect opportunity to dive head first into this new field and skillset. If I'm not working, I'm almost always playing video games. While I have a passion for travel and the outdoors, recent events have definitely forced more of my recreation onto the computer or television. Luckily, golf courses have been quick to implement strict social distancing rules and remain open. As the weather continues to improve, I plan on spending as much time as possible on the links trying to shake off almost a year's worth of rust.
Worked at the call center in hillsboro as a customer service representative
Business Analyst
Business Intelligence Analyst


[3.0/4.0]
(Dialog in German, English subtitles)
This film was released under the English title "Run Lola Run".
A recent series of television beer advertisements pokes fun of the stereotype of abstract and conceptual tendencies in German literature. Coming almost as proof of the stereotype is this film -- a nonlinear, kinetic story filled with action, suspense, color, and music.
The frenetic adventure for Lola and Manni is immediately hinted by the punk couple's colorful appearance. Lola (Franka Potente) has florescent hair, florescent clothes, and tattoos. Manni (Moritz Bleibtreu) is also tattooed, and works as a courier for a small time gangster. The narrative begins when Lola receives a phone call from a distraught Manni explaining that he is in deep trouble. Manni was running an errand for the boss, but he accidentally left the payoff on the subway. He needs to meet the gangster in a short time, and he will be in deep trouble if he does not deliver the 100,000 marks. Manni gives Lola 20 minutes to come up with a plan to raise the money, or else he will hold up a store to get it. Lola's moped was stolen earlier, so now she is left without transportation. The only way for her to get the money and then get to Manni is to sprint across town.
The story is presented in a cleverly nonlinear fashion. The plot is split between actual events and the imaginations of the characters without any clear indication beforehand which is which. The narrative has its share of improbabilities and implausibilities, but these do not detract from the film because its focus is clearly on the mood and flow of the story. It attempts to tell story in which imagery (both visual and sonic) are as important as the actual events. Writer and director Tom Tykwer intentionally created the imagery first, and then developed the story to drive it. However, the narrative is not merely a formula in service to the effects. The story follows multiple threads of time and explores the ripple effect of decisions made early in a sequence of events.
Most of the story consists of Lola sprinting through Berlin in a race against time, trying to reach Manni before he makes a stupid mistake out of desperation, and somehow getting the money along the way. This automatically sets a high energy level, which is well regulated by effective breaks that allow the story elements to emerge and develop. Although the high adrenaline approach help to camouflage story weaknesses, it also creates an involved viewing experience. The fact that it effectively intersperses action and suspense makes it an engaging film.
Highly recommended. The film is a fast-paced, high-energy, visual and musical experience. It evokes the feel of an extended music video in its use of techno music and its mix of live action, cartoon, and stills. The appeal of the film is more for its imagery than for its story, which is interesting, but slightly porous. This would be a good choice for a group of people to watch together as a midnight movie. It may not appeal to an audience that does not appreciate modern electronic music, and expects a straight forward plot.
(c) 1999 Murali Krishnan The Art House Squatter http://ArtHouseSquatter.com
Sent via Deja.com http://www.deja.com/ Share what you know. Learn what you don't.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Class: Sass::Script::Tree::Literal
- Inherits:
-
Node
- Object
- Node
- Sass::Script::Tree::Literal
show all
- Defined in:
- /usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/literal.rb
Overview
The parse tree node for a literal scalar value. This wraps an instance of Value::Base.
List literals should use ListLiteral instead.
Instance Attribute Summary (collapse)
Attributes inherited from Node
#filename, #line, #options, #source_range
Instance Method Summary
(collapse)
Methods inherited from Node
#dasherize, #opts, #perform
Constructor Details
- (Literal) initialize(value)
Creates a new literal value.
16
17
18
|
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/literal.rb', line 16
def initialize(value)
@value = value
end
|
Instance Attribute Details
10
11
12
|
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/literal.rb', line 10
def value
@value
end
|
Instance Method Details
40
41
42
43
|
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/literal.rb', line 40
def _perform(environment)
value.source_range = source_range
value
end
|
- children
21
|
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/literal.rb', line 21
def children; []; end
|
- deep_copy
27
|
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/literal.rb', line 27
def deep_copy; dup; end
|
- inspect
34
35
36
|
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/literal.rb', line 34
def inspect
value.inspect
end
|
- options=(options)
30
31
32
|
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/literal.rb', line 30
def options=(options)
value.options = options
end
|
- to_sass(opts = {})
24
|
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/literal.rb', line 24
def to_sass(opts = {}); value.to_sass(opts); end
|


| Opcode | Instruction | Op/En | 64-Bit Mode | Compat/Leg Mode | Description |
|---|---|---|---|---|---|
| C5 /r | LDS r16,m16:16 | RM | Invalid | Valid | Load DS:r16 with far pointer from memory. |
| C5 /r | LDS r32,m16:32 | RM | Invalid | Valid | Load DS:r32 with far pointer from memory. |
| 0F B2 /r | LSS r16,m16:16 | RM | Valid | Valid | Load SS:r16 with far pointer from memory. |
| 0F B2 /r | LSS r32,m16:32 | RM | Valid | Valid | Load SS:r32 with far pointer from memory. |
| REX + 0F B2 /r | LSS r64,m16:64 | RM | Valid | N.E. | Load SS:r64 with far pointer from memory. |
| C4 /r | LES r16,m16:16 | RM | Invalid | Valid | Load ES:r16 with far pointer from memory. |
| C4 /r | LES r32,m16:32 | RM | Invalid | Valid | Load ES:r32 with far pointer from memory. |
| 0F B4 /r | LFS r16,m16:16 | RM | Valid | Valid | Load FS:r16 with far pointer from memory. |
| 0F B4 /r | LFS r32,m16:32 | RM | Valid | Valid | Load FS:r32 with far pointer from memory. |
| REX + 0F B4 /r | LFS r64,m16:64 | RM | Valid | N.E. | Load FS:r64 with far pointer from memory. |
| 0F B5 /r | LGS r16,m16:16 | RM | Valid | Valid | Load GS:r16 with far pointer from memory. |
| 0F B5 /r | LGS r32,m16:32 | RM | Valid | Valid | Load GS:r32 with far pointer from memory. |
| REX + 0F B5 /r | LGS r64,m16:64 | RM | Valid | N.E. | Load GS:r64 with far pointer from memory. |
| Op/En | Operand 1 | Operand 2 | Operand 3 | Operand 4 |
| RM | ModRM:reg (w) | ModRM:r/m (r) | NA | NA |
Loads a far pointer (segment selector and offset) from the second operand (source operand) into a segment register and the first operand (destination operand). The source operand specifies a 48-bit or a 32-bit pointer in memory depending on the current setting of the operand-size attribute (32 bits or 16 bits, respectively). The instruction opcode and the destination operand specify a segment register/general-purpose register pair. The 16-bit segment selector from the source operand is loaded into the segment register specified with the opcode (DS, SS, ES, FS, or GS). The 32-bit or 16-bit offset is loaded into the register specified with the destination operand.
If one of these instructions is executed in protected mode, additional information from the segment descriptor pointed to by the segment selector in the source operand is loaded in the hidden part of the selected segment register.
Also in protected mode, a NULL selector (values 0000 through 0003) can be loaded into DS, ES, FS, or GS registers without causing a protection exception. (Any subsequent reference to a segment whose corresponding segment register is loaded with a NULL selector, causes a general-protection exception (#GP) and no memory reference to the segment occurs.)
In 64-bit mode, the instruction’s default operation size is 32 bits. Using a REX prefix in the form of REX.W promotes operation to specify a source operand referencing an 80-bit pointer (16-bit selector, 64-bit offset) in memory. Using a REX prefix in the form of REX.R permits access to additional registers (R8-R15). See the summary chart at the beginning of this section for encoding data and limits.
64-BIT_MODE IF SS is loaded THEN IF SegmentSelector = NULL and ( (RPL = 3) or (RPL ≠ 3 and RPL ≠ CPL) ) THEN #GP(0); ELSE IF descriptor is in non-canonical space THEN #GP(0); FI; ELSE IF Segment selector index is not within descriptor table limits or segment selector RPL ≠ CPL or access rights indicate nonwritable data segment or DPL ≠ CPL THEN #GP(selector); FI; ELSE IF Segment marked not present THEN #SS(selector); FI; FI; SS ← SegmentSelector(SRC); SS ← SegmentDescriptor([SRC]); ELSE IF attempt to load DS, or ES THEN #UD; ELSE IF FS, or GS is loaded with non-NULL segment selector THEN IF Segment selector index is not within descriptor table limits or access rights indicate segment neither data nor readable code segment or segment is data or nonconforming-code segment and ( RPL > DPL or CPL > DPL) THEN #GP(selector); FI; ELSE IF Segment marked not present THEN #NP(selector); FI; FI; SegmentRegister ← SegmentSelector(SRC) ; SegmentRegister ← SegmentDescriptor([SRC]); FI; ELSE IF FS, or GS is loaded with a NULL selector: THEN SegmentRegister ← NULLSelector; SegmentRegister(DescriptorValidBit) ← 0; FI; (* Hidden flag; not accessible by software *) FI; DEST ← Offset(SRC); PREOTECTED MODE OR COMPATIBILITY MODE; IF SS is loaded THEN IF SegementSelector = NULL THEN #GP(0); ELSE IF Segment selector index is not within descriptor table limits or segment selector RPL ≠ CPL or access rights indicate nonwritable data segment or DPL ≠ CPL THEN #GP(selector); FI; ELSE IF Segment marked not present THEN #SS(selector); FI; FI; SS ← SegmentSelector(SRC); SS ← SegmentDescriptor([SRC]); ELSE IF DS, ES, FS, or GS is loaded with non-NULL segment selector THEN IF Segment selector index is not within descriptor table limits or access rights indicate segment neither data nor readable code segment or segment is data or nonconforming-code segment and (RPL > DPL or CPL > DPL) THEN #GP(selector); FI; ELSE IF Segment marked not present THEN #NP(selector); FI; FI; SegmentRegister ← SegmentSelector(SRC) AND RPL; SegmentRegister ← SegmentDescriptor([SRC]); FI; ELSE IF DS, ES, FS, or GS is loaded with a NULL selector: THEN SegmentRegister ← NULLSelector; SegmentRegister(DescriptorValidBit) ← 0; FI; (* Hidden flag; not accessible by software *) FI; DEST ← Offset(SRC); Real-Address or Virtual-8086 Mode SegmentRegister ← SegmentSelector(SRC); FI; DEST ← Offset(SRC);
None
| #UD |
If source operand is not a memory location. If the LOCK prefix is used. |
| #GP(0) |
If a NULL selector is loaded into the SS register. If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register is used to access memory and it contains a NULL segment selector. |
| #GP(selector) |
If the SS register is being loaded and any of the following is true: the segment selector index is not within the descriptor table limits, the segment selector RPL is not equal to CPL, the segment is a non-writable data segment, or DPL is not equal to CPL. If the DS, ES, FS, or GS register is being loaded with a non-NULL segment selector and any of the following is true: the segment selector index is not within descriptor table limits, the segment is neither a data nor a readable code segment, or the segment is a data or noncon-forming-code segment and both RPL and CPL are greater than DPL. |
| #SS(0) | If a memory operand effective address is outside the SS segment limit. |
| #SS(selector) | If the SS register is being loaded and the segment is marked not present. |
| #NP(selector) | If DS, ES, FS, or GS register is being loaded with a non-NULL segment selector and the segment is marked not present. |
| #PF(fault-code) | If a page fault occurs. |
| #AC(0) | If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3. |
| #GP | If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. |
| #SS | If a memory operand effective address is outside the SS segment limit. |
| #UD |
If source operand is not a memory location. If the LOCK prefix is used. |
| #UD |
If source operand is not a memory location. If the LOCK prefix is used. |
| #GP(0) | If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. |
| #SS(0) | If a memory operand effective address is outside the SS segment limit. |
| #PF(fault-code) | If a page fault occurs. |
| #AC(0) | If alignment checking is enabled and an unaligned memory reference is made. |
Same exceptions as in protected mode.
| #GP(0) |
If the memory address is in a non-canonical form. If a NULL selector is attempted to be loaded into the SS register in compatibility mode. If a NULL selector is attempted to be loaded into the SS register in CPL3 and 64-bit mode. If a NULL selector is attempted to be loaded into the SS register in non-CPL3 and 64-bit mode where its RPL is not equal to CPL. |
| #GP(Selector) |
If the FS, or GS register is being loaded with a non-NULL segment selector and any of the following is true: the segment selector index is not within descriptor table limits, the memory address of the descriptor is non-canonical, the segment is neither a data nor a readable code segment, or the segment is a data or nonconforming-code segment and both RPL and CPL are greater than DPL. If the SS register is being loaded and any of the following is true: the segment selector index is not within the descriptor table limits, the memory address of the descriptor is non-canon-ical, the segment selector RPL is not equal to CPL, the segment is a nonwritable data segment, or DPL is not equal to CPL. |
| #SS(0) | If a memory operand effective address is non-canonical |
| #SS(Selector) | If the SS register is being loaded and the segment is marked not present. |
| #NP(selector) | If FS, or GS register is being loaded with a non-NULL segment selector and the segment is marked not present. |
| #PF(fault-code) | If a page fault occurs. |
| #AC(0) | If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3. |
| #UD |
If source operand is not a memory location. If the LOCK prefix is used. |


% include com/stdhead.html %>
<% include com/nav.html %>A dat contains all the files for your site.
Sites can be created from the command-line or desktop app, or by using the Beaker Browser. After creating the site, you will be given a URL. Enter that URL here.


{{ bought_item.name }}
×
{{ sold_item_form.hidden_tag() }}
Would you like to discard the bought item {{ bought_item.price }}$ for {{ bought_item.name }}?
Click 'Sell' to discard the bought item
{{ sold_item_form.submit(class="btn btn-outline-danger btn-block") }}