OBITUARY: Pete O'Hanlon loved the outdoors and watching GAA
Pete O’Hanlon, Lordship
Pete O’Hanlon who died in his 92nd year loved the outdoors where he spent his working career engaging in various jobs and enjoyed dancing and watching Gaelic football in his spare time.
From Lordship he was the last surviving of seven siblings, and resided for the last four decades in Dundalk in Woodview Terrace where he and his late wife Maura of 61 years moved to live.
Pete started work at a young age after his school days.
His life was for the most part in the open air by virtue of his different occupations which included working with builders and on farms and delivering milk.
He also engaged in cutting turf on the local mountains, and was always out and about.
His last job was with Dundalk Quarries as a lorry loader from which he retired 20 years ago.
In his younger years he was a keen follower of his local GAA club Saint Patrick’s.
When his grandson Craig started to play for Clan na Gael he then went to watch matches in which he was involved.
He was blessed with good health and was fit and active all his life.
He was driving until he was 90, and afterwards still loved to go out for a daily spin with his daughter Tina.
He was always occupied and could turn his hand to do anything for anybody.
He was always there for everybody and very helpful and always in good form. He could be relied upon to offer good advice.
He loved ballroom dancing, a hobby he enjoyed with wife Maura (nee Markey) going to different local venues like the Lisdoo Arms and Kilkerley.
Maura hailed from Hill Street in town, and met with Pete through his sister.
The couple resided in the Lordship area in the early years after they married
Maura passed away four years ago and Pete visited her grave regularly, which entailed trips out to and back from Cooley through which he became known to local motorists with his careful driving.
Along with wife Maura, Pete was predeceased by his sisters, Maggie, May, Eileen, Christina and brothers, Paddy and Vincey.
He will be sadly missed by his sorrowing daughter, Tina Long, son-in-law Declan, grandchildren, Kevin, Paul and Craig, Kevin's wife Carol, great grandson, Darragh, sisters-in-law, brothers-in-law, nephews, nieces, relatives and friends.
He reposed at the residence of his daughter at Woodview Terrace prior to being removed on the following Friday to the Church of the Holy Redeemer.
The funeral Mass was celebrated by Father Padraig Keenan PP Haggardstown and Blackrock, who delivered the eulogy.

These were brought up by his grandchildren, Kevin and Craig, his nephew’s wife Tracey and Margaret and Martin Long. Their significance in Pete’s life was explained by Carol, wife of his grandson Kevin.
The Readings were given by grandson, Kevin and grandniece Aileen Byrne.
The Prayers of the Faithful were led by grandchildren, Kevin and Paul, grand nephew, Brian Byrne and nephew Chris Haigh.
The Offertory gifts were presented by daughter, Tina and son-in-law Declan.
A reflection was provided by Carol.
The beautiful music and singing was provided by Olivia Finnegan on the organ and singers, grand-nieces Roisin and Evelyn Crawley.
Pete was laid to rest in Lordship Cemetery.


PeripheralManager
public class PeripheralManager : ManagerType
PeripheralManager is a class implementing ReactiveX API which wraps all the Core Bluetooth Peripheral’s functions, that allow to
advertise, to publish L2CAP channels and more.
You can start using this class by adding services and starting advertising.
Before calling any public PeripheralManager
‘s functions you should make sure that Bluetooth is turned on and powered on. It can be done
by observeStateWithInitialValue()
, observing it’s value and then chaining it with add(_:)
and startAdvertising(_:)
:
let disposable = centralManager.observeStateWithInitialValue()
.filter { $0 == .poweredOn }
.take(1)
.flatMap { centralManager.add(myService) }
.flatMap { centralManager.startAdvertising(myAdvertisementData) }
As a result, your peripheral will start advertising. To stop advertising simply dispose it:
disposable.dispose()
-
Implementation of CBPeripheralManager
Declaration
Swift
public let manager: CBPeripheralManager
-
Creates new
PeripheralManager
instance. By default all operations and events are executed and received on main thread.Warning
If you pass background queue to the method make sure to observe results on main thread for UI related code.Declaration
Swift
public convenience init(queue: DispatchQueue = .main, options: [String: AnyObject]? = nil)
Parameters
queue
Queue on which bluetooth callbacks are received. By default main thread is used.
options
An optional dictionary containing initialization options for a peripheral manager. For more info about it please refer to Peripheral Manager initialization options
-
Declaration
Swift
public var state: BluetoothState { get }
-
Declaration
Swift
public func observeState() -> Observable<BluetoothState>
-
Declaration
Swift
public func observeStateWithInitialValue() -> Observable<BluetoothState>
-
Starts peripheral advertising on subscription. It create inifinite observable which emits only one next value, of enum type
StartAdvertisingResult
, just after advertising start succeeds. For more info of what specificStartAdvertisingResult
enum cases means please refer to `StartAdvertisingResult
documentation.There can be only one ongoing advertising (CoreBluetooth limit). It will return
advertisingInProgress
error if this method is called when it is already advertising.Advertising is automatically stopped just after disposing of the subscription.
It can return
BluetoothError.advertisingStartFailed
error, when start advertisement failedObservable can ends with following errors:
Declaration
Swift
public func startAdvertising(_ advertisementData: [String : Any]?) -> Observable<StartAdvertisingResult>
Parameters
advertisementData
Services of peripherals to search for. Nil value will accept all peripherals.
Return Value
Infinite observable which emit
StartAdvertisingResult
when advertisement started.
-
Function that triggers
CBPeripheralManager.add(_:)
and waits for delegateCBPeripheralManagerDelegate.peripheralManager(_:didAdd:error:)
result. If it receives a non nil in the result, it will emitBluetoothError.addingServiceFailed
error. Add method is called after subscription toObservable
is made.Observable can ends with following errors:
Declaration
Swift
public func add(_ service: CBMutableService) -> Single<CBService>
Parameters
service
Characteristic
to read value fromReturn Value
Single
which emitsnext
with given characteristic when value is ready to read. -
Wrapper for
CBPeripheralManager.remove(_:)
methodDeclaration
Swift
public func remove(_ service: CBMutableService)
-
Wrapper for
CBPeripheralManager.removeAllServices()
methodDeclaration
Swift
public func removeAllServices()
-
Continuous observer for
CBPeripheralManagerDelegate.peripheralManager(_:didReceiveRead:)
resultsIt’s infinite stream, so
.complete
is never called.Observable can ends with following errors:
Declaration
Swift
public func observeDidReceiveRead() -> Observable<CBATTRequest>
Return Value
Observable that emits
next
event whenever didReceiveRead occurs. -
Continuous observer for
CBPeripheralManagerDelegate.peripheralManager(_:didReceiveWrite:)
resultsIt’s infinite stream, so
.complete
is never called.Observable can ends with following errors:
Declaration
Swift
public func observeDidReceiveWrite() -> Observable<[CBATTRequest]>
Return Value
Observable that emits
next
event whenever didReceiveWrite occurs. -
Wrapper for
CBPeripheralManager.respond(to:withResult:)
methodDeclaration
Swift
public func respond(to request: CBATTRequest, withResult result: CBATTError.Code)
-
Wrapper for
CBPeripheralManager.updateValue(_:for:onSubscribedCentrals:)
methodDeclaration
Swift
public func updateValue( _ value: Data, for characteristic: CBMutableCharacteristic, onSubscribedCentrals centrals: [CBCentral]?) -> Bool
-
Continuous observer for
CBPeripheralManagerDelegate.peripheralManagerIsReady(toUpdateSubscribers:)
resultsIt’s infinite stream, so
.complete
is never called.Observable can ends with following errors:
Declaration
Swift
public func observeIsReadyToUpdateSubscribers() -> Observable<Void>
Return Value
Observable that emits
next
event whenever isReadyToUpdateSubscribers occurs.
-
Continuous observer for
CBPeripheralManagerDelegate.peripheralManager(_:central:didSubscribeTo:)
resultsIt’s infinite stream, so
.complete
is never called.Observable can ends with following errors:
Declaration
Swift
public func observeOnSubscribe() -> Observable<(CBCentral, CBCharacteristic)>
Return Value
Observable that emits
next
event whenever didSubscribeTo occurs. -
Continuous observer for
CBPeripheralManagerDelegate.peripheralManager(_:central:didUnsubscribeFrom:)
resultsIt’s infinite stream, so
.complete
is never called.Observable can ends with following errors:
Declaration
Swift
public func observeOnUnsubscribe() -> Observable<(CBCentral, CBCharacteristic)>
Return Value
Observable that emits
next
event whenever didUnsubscribeFrom occurs.
-
Starts publishing L2CAP channel on a subscription. It creates an infinite observable which emits only one next value, of
CBL2CAPPSM
type, just after L2CAP channel has been published.Channel is automatically unpublished just after disposing of the subscription.
It can return
publishingL2CAPChannelFailed
error when publishing channel failedObservable can ends with following errors:
Declaration
Swift
@available(iOS 11, tvOS 11, watchOS 4, *) public func publishL2CAPChannel(withEncryption encryptionRequired: Bool) -> Observable<CBL2CAPPSM>
Parameters
encryptionRequired
Publishing channel with or without encryption.
Return Value
Infinite observable which emit
CBL2CAPPSM
when channel published. -
Continuous observer for
CBPeripheralManagerDelegate.peripheralManager(_:didOpen:error:)
resultsIt’s infinite stream, so
.complete
is never called.Observable can ends with following errors:
Declaration
Swift
@available(iOS 11, tvOS 11, watchOS 4, *) public func observeDidOpenL2CAPChannel() -> Observable<(CBL2CAPChannel?, Error?)>
Return Value
Observable that emits
next
event whenever didOpen occurs.
-
Creates new
PeripheralManager
instance, which supports bluetooth state restoration.Warning
If you pass background queue to the method make sure to observe results on main thread for UI related code.Seealso
Declaration
Swift
public convenience init(queue: DispatchQueue = .main, options: [String: AnyObject]? = nil, onWillRestorePeripheralManagerState: OnWillRestorePeripheralManagerState? = nil)
Parameters
queue
Queue on which bluetooth callbacks are received. By default main thread is used and all operations and events are executed and received on main thread.
options
An optional dictionary containing initialization options for a peripheral manager. For more info about it please refer to Peripheral Manager initialization options
onWillRestorePeripheralManagerState
Closure called when state has been restored.


Publish your pictures and images. Create different Gallery and segregate your collection
{{album.description}}


{% extends 'base.html' %} {% block title %}{{ project_name }} - Page Not Found{% endblock %} {% block error %}
We are unable to find the page you requested.


| ActionRecord |
The entity that manages action record.
|
| ActionRestriction |
The entity that manages action restriction.
|
| ActionSkip |
The entity that manages action skip.
|
| Error |
The entity that manages error.
|
| ExcludedUser |
The entity that manages excluded user.
|
| FollowBackExpectableUser |
The entity that manages follow back expectable user.
|
| FollowBackPossibilityIndicator |
The entity that manages follow back possibility indicator.
|
| FollowedUser |
The entity that manages followed user.
|
| FollowMutualUser |
The entity that manages follow mutual user.
|
| FollowUnmutualUser |
The entity that manages follow unmutual user.
|
| Hashtag |
The entity that manages hashtag.
|
| LastAction |
The entity that manages last action.
|
| LeftUser |
The entity that manages the left user.
|
| LikedPhoto |
The entity that manages liked photo.
|
| MessageMeta |
The entity that manages message meta.
|
| MissingUser |
The entity that manages missing user.
|
| Session |
The entity that manages session.
|
| TaskExecutionControl |
The entity that manages task execution control.
|
| UnfollowedUser |
The entity that manages unfollowed user.
|
| UserAccount |
The entity that manages user account.
|
| UserFollower |
The entity that manages user follower.
|
| UserFollowing |
The entity that manages user following.
|
| Variable |
The entity that manages variable.
|


Objectively exploit one-to-one data rather than fully researched ideas. Competently incubate best-of-breed relationships vis-a-vis extensive sources. Enthusiastically parallel task value-added niche markets whereas an expanded array of value. Intrinsicly network wireless processes without real-time core competencies. Credibly actualize team driven resources after future-proof leadership.


WITNESS LIST State Recreational Resources Committee (Subcommittee on Waterways) September 4, 2002-10:00A Vehicular traffic in streambeds For: Schafer, Eric (Self) Against: Bloxsom, Allan P. (Stewards of the Nueces) Boyden, Mark (Self) Center, Sam (Texas Game Wardens Association) Draeper, Charles (Self) Friday, Wright (Self) Friend, Don (Self) Goynes, Tom (Texas Rivers Protection Association) Kawecki, Sage (Texas Hill Country River Region) Langford, David K. (Texas Wildlife Association) Mize, Allen (Self) Perron, Andrea (Self) Robinson, John (Self) Small, Ed (Texas Cattle Raisers Association, Southwestern Cattle Raisers Association) Van Winkle, Michael (Self and Texas Rivers Protections Association) Wallace, Gwen (Self and Park Chalk Bluff) On: Goldbloom, Andrew (Texas Parks and Wildlife Department) Registering, but not testifying: Against: Dullnig, Jeannie (Stewards of the Nueces) Friday, Suzanne (Self) Lewey, Sky (Nueces River Authority) Salmon, Stephen (Texas Shrimp and Goat Raisers Association, Riverside and Landowners Protection Coalition)


So sorry, but you are too young to enter our celebrity dating site. We look forward to your return on your 18th birthday!
Complete the form below to see who you match up with.
 What more could anyone ask for?
An intelligent, funny lady, both actor and producer, with lots of adorable fluffy cats. Who could ask for more!


An error has occurred. Please send the following technical details to your system administrator.
$message


Nimbus
menu
Home
History
About
person
search
Zip or City, State
Home
History
About
Today's Weather
cloud
Wind Speed
opacity
Humidity
ac_unit
Feels like
flare
UV Index


Audio inversion for steganography in audio files
Python library to diff two wav files
Potential code execution even delimited by spaces, ie
pkill random_process_name $(my_command)
my_command still has a chance to be executed (evaluated before passed into pkill as an argument)
Multiple BOs of the binary to be found in another walkthrough! Ippsec did not do it.
LXD is the Linux container hypervisor. Good writeup of privesc here
Being a member of any hypervisor group could be a way to privesc (whether its qemu, vmware, docker, lxd, etc)
In the case of LXD:
lxc init ubuntu:1604 blah -c security.privileged=true
lxc config device add blah root disk source=/ path=/.nt/root recursive=true
Essentially, the lxc group has the ability to mount the harddrive to the container and view it's files regardless of security permissions (assuming because of setting security.privileged=true)
LXD post install adds any current members of the "sudo" group also to the "lxd" group


Content Goes Here
This is longer Content Goes Here
Content Goes Here
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.
Content Goes Here
This is longer Content Goes Here Donec id elit non mi porta gravida at eget metus.


Mac – consults is a registered, recognized and highly regarded educational consulting firm in Nigeria.
We are known for: Honesty, Fast Responds and reliability of information.
Learn MoreLearn what all the fuzz is about!
Mac – consults is a registered, recognized and highly regarded educational consulting firm in Nigeria. The company provides educational and ticking services for Nigerian students. Mac consults was formed to provide a better educational service to our growing clientèle.
The Director has over six years of experience in student recruitment and marketing, and he has gained a lot of reputation through the provision of credible, affordable and efficient service to clients across the country.
We are known for: Honesty, Fast Responds and reliability of information.
View our Services
CAREER COUNSELING
Ready to use HTML/CSS device mockups, no Photoshop required!
ADMISSION PLACEMENTS
Put an image, video, animation, or anything else in the screen!
VISA COUNSELING
With a high visa success
ACCOMMODATION RESERVATION
Since this theme is MIT licensed, you can use it commercially!
DISCOUNTED AIR-TICKETS
Ready to use HTML/CSS device mockups, no Photoshop required!
PARTNERS WITH LEADING UNIVERSITY
Put an image, video, animation, or anything else in the screen!
SCHOOL VISITS AND SEMINARS
With a high visa success
A ‘ LEVELS / FOUNDATION
Since this theme is MIT licensed, you can use it commercially!
Lets get in Touch!
Contact us for more enquiries Shoot us an email or give us a shout and we'll get back asap!


Make sure your goal has four keys to a good goal:
G - going to do - in other words, something you are going to add to your life, not subtract. If it's a bad habit like nail-biting that you want to break, then word the goal as, "I will chew sugarless gum instead of biting my nails." Get the idea? Be positive.
O - on target - when you're aiming for the target, you want to hit the bullseye. Make sure you're specific. Saying that "you want to eat better" is too general. Instead, try saying, "I will eat an apple every day."
A - attainable - can you actually achieve your minor goal, and do so in a reasonable amount of time? Make sure, or you will get discouraged.
L - link your goals - make sure your minor goal will help you reach your major goal. Drinking more juice each day will not help you to make the cheerleading team.
|


Class: $.TypedFaceApp
- Inherits:
-
Application.AppBase
-
Application.AppBase
-
Overview
App class for the TypedFace
Instance Method Summary collapse
-
getInitialView()
Return the initial view of your application here.
-
initialize()
Constructor.
- onSettingsChanged() as Void
-
onStart(state as Dictionary or Null)
onStart() is called on application start up.
-
onStop(state as Dictionary or Null)
onStop() is called when your application is exiting.
Instance Method Details
getInitialView()
Return the initial view of your application here
initialize()
Constructor
onSettingsChanged() as Void
onStart(state as Dictionary or Null)
onStart() is called on application start up
onStop(state as Dictionary or Null)
onStop() is called when your application is exiting


The function bigImg() is triggered when the user moves the mouse pointer onto the image.
The function normalImg() is triggered when the mouse pointer is moved out of the image.


PyDay Tenerife 2018
PyTest as testing tool
PyHamcrest to improve your assertions
Unittest.mock / Doublex for test doubles
3A (Arrange, Act, Assert) - Given When Then
Focussed
Concrete
Empirical
We don't just ask ourselves how to test it, but also why is it difficult to test
GOOS - Steve Freeman and Nat Pryce
Growing Object-Oriented Software Guided by Tests
Test Smell: Bloated Constructor
Steve Freeman - Keynote: Why everyone should care about TDD in CAS Vitoria


I am experienced in building full stack data products using python. From building MySQL or NoSQL databases, to building the ETL pipeline, to doing statistical analysis, and finally productionalizing it into a Flask web application.
Major: Applied Mathematics Minor: Economics
Apart from working with data, I will always be passionate about education. I'm currently serving as a python data science mentor in the Chicago Python Group. I believe the best way to learn is to teach. Outside of tech, I enjoy fishing and have been a bass fisherman for many years. Now that I'm up North, I'm hoping to learn more about trout fishing.
When forced indoors, I enjoy watching classic good-feel sitcoms like Friends or The Office. I also keep my creative part of my brain stimulated by playing piano, violin, guitar, and ukulele.


Last summer I started this trolley train car, I had originally made it as part of a one model a day project but I became more interested in just making a large high quality model. So slowly but surely I am making this in my free time.


Before Change
profile_db.disconnect()
progress.end()
run.info_single("Your profile db is now %s (WRONG .. anvi"o never takes breaks)." % next_version, nl_after=1, nl_before=1, mc="green")
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="A simple script to upgrade profile database from version %s to version %s" % (current_version, next_version))
After Change
profile_db.disconnect()
progress.end()
if is_full_profile:
run.info_single("Your profile db is now %s (WRONG .. anvi"o never takes breaks)." % next_version, nl_after=1, nl_before=1, mc="green")
else:
run.info_single("Your profile db is now version %s. But essentially nothing really happened to your\
database since it was a blank profile (which is OK, move along)." \
% next_version, nl_after=1, nl_before=1, mc="green")
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="A simple script to upgrade profile database from version %s to version %s" % (current_version, next_version))
parser.add_argument("profile_db", metavar = "PROFILE_DB", help = "An anvi"o profile database of version %s" % current_version)
args, unknown = parser.parse_known_args()


please click here for the test page
please click here for the collision-test page
please click here for the documtation page, generated by jsdoc.


PeerEditr
Link
MIT Launch '14. Web application where students can give and receive feedback on academic projects.
Altacode
Link
A Computer Science organization dedicated to promoting coding and project building around the community. Internationally recognized by DECA.
Building Habit Forming Educational Applications
Link
ACSEF 1st Place Behavioral Science. Research project that uses psychological research and software analysis to develop applications with habit forming features.
Illuminatty
Link
TreeHacks '15 Best Bioinformatics Hack. Web application that analyzes and visualizes genomic data of cancer patients using NLP.
Bundler
Link
HSHacks '15 Best iOS Hack. iOS Application that bundles suggested items from Amazon for your next big event.
BetterFinish
Link
CalHacks '14. iOS Application that donates a certain amount of money if you do not finish your daily tasks on time.
Dunno
Link
PennApps '14. iOS Application that uses location based services to push a question to people near your location
Eduable
Link
CodeDay '14 Most Impactful App. Web Application that gives code snippets and commands using natural language.
SpeedStudy
Link
LAHacks '14. iOS Application that summarizes and speed-reads any picture of text
TextShell
Link
HSHacks '14 2nd Place. Web Application that allows you to text a command to pull information without the use of internet.
SwiftPost
Link
HackTech '14. Web Application that enables users to send direct mail to large amounts of people.
BaggageTrack
Link
2nd Place Congressional App Challenge District 17. iOS Application that aims to prevent baggage loss in Airports.
SAT Wars
Link
MakeSchool '13. iOS Application that uses turn-based gameplay to study SAT Vocabulary.
GeneMe
Link
DECA '13. Business Plan for a hypothetical Genomics Business.


things im making:
hey! welcome. here you will find my projects im making. (animations, websites, games, programs, music, etc.) here check some out:
scratch tools


One of the coolest things you can do on ebay is to add more pictures of your product on your ebay product description. Your listing description drags more atention the monent you combine pictures and words. All of this sounds preatty good but the hard part is that you have to upload your images to a separate server and write some html to add them to your desciription. This is going to take you quite a lot of time for sure. Fortunately, there are free resources like free ebay templates and imgbb.com that are going to help you create a better looking template in a very short time. For this tutorial we are going to make use of a webisite named imgbb.com to upload our very onw photos for out html template.
Uploading your First Image
The first thing you have to do in order to add your own pictures to the template is to upload them to an image hosting website. First, go to imgbb.com and click on the upload button that located on the top right corner of the website. Drag and drop the image that you want to upload to the server and click on upload. Now, this is very important. Once you upload is complete, click on the drop down menu and select the option that says "html full linked". Then, copy the link next to src= as pictured bellow.
Adding your photos the freeebaytemplates.com Web App
Once you have copied the link where your image is hosted. You just need login to freeebaytemplates.com/app and go though the fist two steps to create a new html listing template. On the third step you are going to find a tab that is named image carrousel. Open that tab and you are going to see five different text holders where you can paste the hyperlink of your newly uploaded image. Erase the hyperlink that is already there and paste your own link. The changes will automatically be displayed on the live preview template.


| Recurrent HCC Risk: | |||||
|---|---|---|---|---|---|
| 1 yr: | 2 yr: | 3 yr: |
| IML Code: | Ablate / Wait / AFP: |
Unlike current allocation policy that only uses HCC burden at one time point, the RH-IML calculator uses a summative measure of pre-liver transplant HCC burden that incorporates tumor behavior and treatment response to predict the risk of post-liver transplant recurrent HCC.
Vutien P, Dodge J, Bambha KM, Nordstrom EM, Gralla J, Campbell K, Levek C, Nydam T, Fix O, Ioannou G, Biggins SW. A simple measure of hepatocellular carcinoma burden predicts tumor recurrence after liver transplantation: The RH-IML classification. Accepted for publication in Liver Transplantation.
Using UNOS data from 2002-2014, 16,558 liver transplant recipients with HCC (any stage) were assessed for HCC size (total diameter), pre-liver transplant treatment and post-liver transplant recurrent HCC.
HCC was measured at 3 dates on the waitlist: (I) Initial, (M) Max, (L) Last. Tumor burden at each date was classified as:
Chi-Square tests assessed associations of IML coordinates with post-liver transplant recurrent HCC. Confounders (age, sex, race, MELD, wait-time, pre-liver transplant HCC treatment, AFP, DRI) were assessed.
Of the 64 potential combinations of IML, only 30 make clinical sense as max can not be less than initial or last. Of those 30 clinically viable combinations, 10 did not have sufficient power and 3 combinations did not occur in the available data, leaving 17 IML combinations with sufficient power to predict post-liver transplant recurrent HCC.
Dr. Biggins is a transplant hepatologist and the Chief of Hepatology at the University of Washington in Seattle, WA. Dr. Biggins and his research team from the University of Washington, University of Colorado and the University of California San Francisco developed the RH-IML calculator.
Scott W. Biggins, Philip Vutien, Jennifer L. Dodge, Kiran M. Bambha, Eric M. Nordstrom, Jane Gralla, Kristen Campbell, Clair Levek, Trevor L. Nydam, Oren K. Fix, George Ioannou
Dr. Fix is the Medical Director of Liver Transplantation and a Lead Informatics Physician at the University of North Carolina at Chapel Hill


Documentation
Dead simple! Hundreds of animations only with
less than 80 lines of libaray code.
Install
$ npm install jsanimation -D
Usage
import {fadeIn} from 'jsanimation';
fadeIn(document.querySelector('.target'));
// You can set timing and duration for the animation with Animation Object
// Or, you can run fully-customized animation with `animate(...)` function
`animate` function
Run animation within certain duration and interval with given drawing function.
Example:
import {animate} from 'jsanimation';
const el = document.querySelector('.target');
animate(
1000, // DURATION
function(t) { return Math.pow(t, 1.675) } // timing function
function(timing, pct) { el.style.opacity = pct } // draw function
).then(function() {
el.removeAttribute('style')
});
Arguments
- duration: integer, default 250, animation duration in milliseconds
- timing: a function that determines the interval of the animation
timing function, which accepts fraction of duration as a paramter and returns a number.
For example, linear timing function looks like the following, which making animation interval spread evenly.
function(t) { return t;}
Hoever, easein timing function looks like the following making animation interval more natural like power-applied.
function(t) { return Math.pow(t, 1.675); }
From the above function, `t` is a float number between 0 to 1.
-
draw: a function to run animation which accepts result of timing and progress as arguments
Foe example,
function(timing, progress) {
ballEl.style.transform = `translateY(${timing * 200 - 150}px) rotate(${pct*300}deg)`;
ballEl.style.left = `${progress*50}%`;
}
From the above function, timing/progress is a float number between 0 to 1.

Shortcut Functions
The following functions accepts an element as an argument and runs the animation within the scope of `Animation` object.
Then, it returns a Promise when the animation is finished.
- fadeIn(el): fades in the element
- fadeOut(el): fades out the element
- slideInLeft(el): slide in from left / fades in the element
- slideOutLeft(el): slide out to left / fades out the element
- slideInRight(el): slide in from right / fades in the element
- slideOutRight(el): slides outs to right / fades out the element
- slideInTop(el): slide in from top / fades in the element
- slideOutTop(el): slide out to top / fades out the element
- slideInBottom(el): slide in from bottom / fades in the element
- slideOutBottom(el): slide out to bottom / fades out the element
- zoomIn(el): zoom in / fades in the element
- zoomOut(el): zoom out / fades out the element
- rotateIn(el): rotates in clock-wise / fades in the element
- rotateOut(el): rotates out counter clock-wise / fades out the element


IHC: Brings Unique Advantages
to the PEO Space
- Differentiation in the PEO marketplace with a one-of-a-kind solution
- Adds an additional profit center opportunity
- Promotes client satisfaction, client retention and new client acquisition
-
Personalizes content to each individual while branding the
experience to the individual company where the employee is placed
IHC: A Review on How it Works
-
Our proprietary IHC software platform transparently transforms
raw benefit plan administration source code through our API into
a personalized, interactive user-friendly benefits and wellness
participant communication system with just a sign-on and a click.
-
It dynamically assembles a unique interactive benefits enrollment
and year-round informational experience that is personalized to
each individual participant based on who they are and where they
live and work.
IHC: A Review on How it Works
-
The IHC software solution doesn’t compete with or replace your
existing enrollment or benefits admin systems. And it doesn’t
interfere with any ongoing IT transformational initiatives.
-
Your customer IHC site can be built to integrate all healthcare,
retirement and savings plans, voluntary, paid-time-off and
compensation benefits into a single personalized destination for
each PEO member as they desire.
-
Your customer IHC site can be built to integrate all healthcare,
retirement and savings plans, voluntary, paid-time-off and
compensation benefits into a single personalized destination for
each insured employee.


Bitkee
Titanium crypto wallet
Screenshots
View Image |
View Image |
View Image |
|---|---|---|
Hunter’s comment
Paper wallet is great for keeping all the hungry evil hackers from your precious cryptocurrency recovery seeds. But Bitkee is paper-wallet with steroids because it:
- does not afraid of extreme heat (up to 1650°C)
- does not vanish in the corrosive acid
- does not rust or stain easily
Although the customization page only allows coins listed above, I guess you can just submit any seeds for them to engrave on the Bitkee. There are 3 types of wallet to choose from, the calssic card type, the keychain and even the dogtag!
What?  You need to learn more about BIP38 where the private keys is protected by your customized passphrase. Make sure you make a strong password so the bruteforce attack is practically impossible!
Link
Contributors
Hunter: @fr3eze
This is posted on Steemhunt - A place where you can dig products and earn STEEM.
View on Steemhunt.com
This page is synchronized from the post: ‘Bitkee - Titanium crypto wallet’


| Table Of Contents |
Here's what's new.
Technical Notes can be found here.
What's the best way to learn WFC? An example teaches, not much else does. Checkout the samples section.
WFC was created with these coding guidelines.
Only examples teach, here's the WFC sample programs.
| WFC Classes |
CAccessAllowedEntry - Encapsulates the ACCESS_ALLOWED_ACE structure.
CAccessControlEntryHeader - Encapsulates the ACE_HEADER structure.
CAccessControlList - Encapsulates the ACL structure.
CAccessDeniedEntry - Encapsulates the ACCESS_DENIED_ACE structure.
CAccessTimeout - Encapsulates the ACCESSTIMEOUT structure.
CAppleTalkProjectionResult - encapsulates the RAS_PPP_ATCP_RESULT structure.
CBase64Coding - Simple base64 encoder/decoder. This is what MIME uses to send binary data in e-mail.
CBitArray - Treats bits like they were just any other array. Patterned after CByteArray except it plays with bits instead of bytes.
CBitmapCoreHeader - Encapsulates the BITMAPCOREHEADER structure.
CBitmapFileHeader - Encapsulates the BITMAPFILEHEADER structure.
CBitmapInfoHeader - Encapsulates the BITMAPINFOHEADER structure.
CCommunicationsConfiguration - Encapsulates the COMMCONFIG data structure.
CCommunicationProperties - Encapsulates the COMMPROP data structure.
CCompVars - Encapsulates the COMPVARS structure.
CColorAdjustment - Encapsulates the COLORADJUSTMENT structure.
CCriticalSectionGuard - Locks a CCriticalSection (an MFC class) in the constructor and unlocks it in the destructor.
CCryptographicAlgorithm - encapsulates the PROV_ENUMALGS structure.
CCryptographicHash - encapsulates the hash portions of the CryptoAPI.
CCryptographicKey - encapsulates the key portions of the CryptoAPI.
CCryptographicProvider - encapsulates the cryptographic provider portion of the CryptoAPI.
CCryptography - This is the base class for all cryptographic classes that provide functionality.
CDataChunk - Allows for handling of data chunks. Patterned after RIFF.
CDataFile - A derivative of CFile that makes it easy to read/write CDataChunk's.
CDataMemory - Handles a collection of RIFF chunks.
CDataParser - Generic data parsing class.
CDataSocket - A derivative of CDataFile that allows you to transmit CDataChunk's over a CSimpleSocket.
CDesktop - Encapsulates the desktop API.
CDeviceControlBlock - Encapsulates DCB structure used in serial communications.
CDocInfo - Encapsulates the DOCINFO structure.
CDragQuery - Encapsulates the HDROP handle and API. Useful when handling the WM_DROPFILES message (or OnDropFiles method in MFC).
CDummyFile - A class that traps all calls to CFile that would blow up if you weren't a disk file.
CEventLog - The event logger. Makes working with log events easier. Allows you to read event log messages, create custom event logs, clear logs, pretty much anything you would ever want to do with an event log.
CEventLogRecord - encapsulates the EVENTLOGRECORD structure.
CExtensibleMarkupLanguageAttribute - class that encapulates an XML attribute.
CExtensibleMarkupLanguageDocument - class that encapulates an XML document.
CExtensibleMarkupLanguageElement - class that encapulates an XML element.
CFile64 - An MFC CFile look alike except it handles large files. CFile is limited to 4GB files (or maybe 2GB files).
CFileDirectory - This class gives you the capability to retrieve the names of files (complete full-path filenames) in a directory. You can fill in a CStringArray with the filenames or execute a callback function. You can process the files in a single directory or recurse through the subdirectories.
CFileTime - Encapsulates the FILETIME structure/API.
CFileTransferProtocol - Makes it a little easier to play with ftp. It retrieves directory listings or files. Easier to use than the MFC counterparts.
CFilterKeys - Encapsulates the FILTERKEYS structure.
CGarbageCollector - Makes rolling your own copy-on-write objects easy.
CInternetworkPacketExchangeProjectionResult - encapsulates the RAS_PPP_IPXCP_RESULT structure.
CInternetProtocolProjectionResult - encapsulates the RAS_PPP_IPCP_RESULT data structure.
CListeningSocket - Establishes a socket that people can connect to (i.e., makes a server socket).
CLZFile - Handles the LZxxx API (compressed files)
CMemoryFile - A simple memory mapped file class. It handles the annoyance of mapping a file on an allocation granularity boundary so you don't have to.
CMemoryStatus - Encapsulates the MEMORYSTATUS structure
CMicrosoftTape - Child of CTape that knows about the Microsoft Tape Format used by NTBACKUP.EXE This is an unfinished class.
CMixer - Mixer API stuff.
CMixerCapabilities - Encapsulates the MIXERCAPS structure.
CMixerControl - Encapsulates the MIXERCONTROL structure.
CMixerControlDetails - Mixer API stuff.
CMixerControlDetailsData - Mixer API stuff.
CMixerControlInstance - Mixer API stuff.
CMixerDestination - Mixer API stuff.
CMixerLine - Mixer API stuff.
CMixerSource - Mixer API stuff.
CMixerSourceSelector - Mixer API stuff.
CMixerSpeakers - Mixer API stuff.
CMixerSwitchControl - Mixer API stuff.
CMixerVolumeControl - Mixer API stuff.
CMixerWaveIn - Mixer API stuff.
CModem - A class that hangs off of CSerialFile that makes it easy to play with modems
CMouseKeys - Encapsulates the MOUSEKEYS structure.
CMTFDataBlockHeader - Encapsulates the MTF_DB_HDR structure.
CMTFDateTime - Encapsulates the MTF_DATE_TIME structure.
CMTFTape - Encapsulates the MTF_TAPE structure.
CMTFTapeAddress - Encapsulates the MTF_TAPE_ADDRESS structure.
CNamedPipe - Unfinished class. Will be derived from CDummyFile
CNetBEUIFramerProjectionResult - encapsulates the RAS_PPP_NBFCP_RESULT structure.
CNetwork - Base class for all networking functionality. It allows you to enumerate ports on a computer, reboot the computer (locally or remotely) and get the time from the named computer.
CNetworkConnectionInformation - Class based on CONNECTION_INFO_1 structure. It allows you to enumerate through the people that are connected to your machine.
CNetworkConnections - Class that plays with network connections.
CNetworkFileInformation - Class based on FILE_INFO_3 structure.
CNetworkFiles - Class that plays with network files.
CNetworkInformation - Encapsulates the NETINFOSTRUCT structure.
CNetworkResources - Class that plays with network resources.
CNetworkResourceInformation - Class based on NETRESOURCE structure.
CNetScheduleJob - Let's you schedule jobs. It interfaces with the Scheduler Service.
CNetworkSessions - Class that plays with network sessions.
CNetworkSessionInformation - Class based on SESSION_INFO_502 structure.
CNetworkShareInformation - Class based on SHARE_INFO_2 structure.
CNetworkShares - Allows you to query machines about their shares, add new shares, delete existing ones, etc.
CNetWorkstation - Gathers information about the workstation.
CNetworkUserInformation - Encapsulates and combines the USER_INFO_xxx data structures.
CNetworkUsers - Plays with the NetUserxxx API. Makes it easy to enumerate, add and delete users.
COFStruct - Encapsulates the OFSTRUCT structure.
COperatingSystemVersionInformation - Encapsulates the OSVERSIONINFO structure.
COutlineTextMetric - Encapsulates the OUTLINETEXTMETRIC structure.
COverlapped - Plays with OVERLAPPED structure.
CParsePoint - Class that holds a location in s data stream. Used in parsing data with the CDataParser class.
CPasswordChangeFilter - A class that makes it easy to intercept password changes.
CPerfCounterDefinition - Encapsulates the PERF_COUNTER_DEFINITION structure.
CPerfInstanceDefinition - Encapsulates the PERF_INSTANCE_DEFINITION structure.
CPhysicalDiskFile - This class makes it easy to read data from a disk in raw format. In other words, this class reads a disk like it was a file without regard to file system on that disk. Want to read an individual sector on the disk? This is the class for you.
CPing - A class that allows you to programmatically ping another machine.
CPingResults - Holds the results of the ping call
CPixelFormatDescriptor - Encapsulates the PIXELFORMATDESCRIPTOR structure.
CQueue - A simple thread-safe high-performance data queue. It is designed so that one thread can add to the queue and another can get from it without the two threads blocking on each other.
CPointToPointProtocolProjectionResult - encapsulates the RAS_PPP_PROJECTION_RESULT structure.
CPortInformation - Provides the same information as PORT_INFO_2 data structures. Used in enumerating ports on a machine (i.e. CNetwork::EnumeratePorts).
CPasswordChangeFilter - A class that makes it easy to intercept password changes.
CRandomNumberGenerator - Gives you better random numbers than rand(). It has about 900 million starting points, each starting point is good for 10^30 values before it starts to repeat. It uses the RANMAR algorithm (from the old FORTRAN days).
CRandomNumberGenerator2 - Gives you better random numbers than rand(). It is good for (2^19937)-1 values before it starts to repeat. It is also faster than the other random number generators in WFC. It uses the Mersenne Twister algorithm.
CRasterizerStatus - Encapsulates the RASTERIZER_STATUS structure.
CReedSolomonErrorCorrectionCode - Allows you to put a forward error correction code onto a block of data. This class blocks data into 255 byte chunks. Up to 16 of those bytes can be scrambled and the errors will automatically be fixed.
CRegistry - Encapsulates the Registration Database ( Registry API).
CRemoteAccessService - Remote Access Services. Otherwise known as Dial Up Networking. This class allows you to establish connections, hang up connections, etc.
CRemoteAccessServiceAdministration - A work in progress. Handles the administration of RAS.
CRemoteAccessServiceAuthenticationMessageBlock - Encapsulates the RASAMB structure.
CRemoteAccessServiceConnectionProjection - encapsulates the RAS_PORT_STATISTICS structure.
CRemoteAccessServiceInternetProtocol - Encapsulates the RASPPPIP structure.
CRemoteAccessServiceInternetworkPacketExchange - Encapsulates the RASPPPIPX structure.
CRemoteAccessServiceNetBEUIFramer - Encapsulates the RASPPPNBF structure.
CRemoteAccessServicePort - Encapsulates the RAS_PORT_0 data structure.
CRemoteAccessServicePortStatistics - encapsulates the RAS_PORT_STATISTICS structure.
CRemoteAccessServiceUser - Encapsulates the RAS_USER_0 data structure.
CSecurityAttributes - Encapsulates the SECURITY_ATTRIBUTES structure.
CSecurityQualityOfService - Encapsulates the SECURITY_QUALITY_OF_SERVICE structure.
CSerialFile - Treats the serial port like it was a CFile. Makes doing RS232 communications easier.
CServer - This class allows you to gather information about a server. It can get you information similiar to the Server Control Panel applet. Decrypts data scrambled by NetServerGetInfo API.
CService - NT Services class. Makes creating services pretty brainless.
CServiceApplication - This class encapsulates all of the logic behind installing, removing and running from a command line (to make debugging easier) needed by a service application.
CServiceConfiguration - Basically duplicated QUERY_SERVICE_CONFIG structure.
CServiceControlManager - Plays with the Service Control Manager. Allows you to start, stop, install and remove services on the local machine or on a server on the net.
CServiceNameAndStatus - Encapsulates the ENUM_SERVICE_STATUS structure.
CSessionInformation - Session information based on SESSION_INFO_502 structure. Basically, gives you same info as Control Panel->Server->Users->Connected Users
CSharedMemoryObject - Let's you create shared memory segments easily.
CSimpleSocket - Base class for TCP/IP sockets. Derived from CDummyFile.
CSimpleSocketFile - Turns an existing CSimpleSocket into a CFile. Generally, this is called from CListeningSocket::OnNewConnection()
CSoundSentry - Encapsulates the SOUNDSENTRY structure.
CStickyKeys - Encapsulates the STICKYKEYS structure.
CSystemAuditEntry - Encapsulates the SYSTEM_AUDIT_ACE structure.
CSystemTime - Encapsulates the SYSTEMTIME structure/API. It also allows you to get and set the computer's clock.
CTalkingSocket - A socket you can use to connect to existing sockets (you connect to a server).
CTape - Handles the Tape API. It finally works.
CTapeGetDriveParameters - Encapsulates the TAPE_GET_DRIVE_PARAMETERS data structure.
CTapeGetMediaParameters - Encapsulates the TAPE_GET_MEDIA_PARAMETERS data structure.
CTapeSetDriveParameters - Encapsulates the TAPE_SET_DRIVE_PARAMETERS data structure.
CTapeSetMediaParameters - Encapsulates the TAPE_SET_MEDIA_PARAMETERS data structure.
CTextMetric - Encapsulates the TEXTMETRIC structure.
CToggleKeys - Encapsulates the TOGGLEKEYS structure.
CUINT64 - Encapsulates the UINT64 structure.
CUniformResourceLocator - Plays with URL's Example: http://www.microsoft.com/hello.html
CUniversalNamingConvention - Plays with UNC's Example: \\buckaroo\public\neato\readme.txt
CVolume - This class let's you eject removable media (CD-ROM's JAZ drives, tapes, etc). It also let's you lock drives.
CWindowPlacement - Encapsulates the WINDOWPLACEMENT structure.
CWorkstationTransport - Patterend after WKSTA_TRANSPORT_INFO_0, gives you smurphy information about you network transports (ever wonder what your MAC address is?).
CWorkstationInformation - Patterned after WKSTA_INFO_102, used in CNetWorkstation::Enumerate
CWorkstationUser - Patterned after WKSTA_USER_INFO_1, used in CNetWorkstation::Enumerate
CXMLArchive - This class is modeled after the CArchive MFC class. It allows you to serialize (or persist) objects to and from XML documents.
| Classes That Ain't Exactly Win32 |
CBubble - Creates a tooltip window where ever and how many ever you want.
CCircle - Draws a circle on the screen.
CConstellation - This ain't exactly Win32 encapsulation of something useful. It is related to CSquiggle but instead of displaying data as a squiggley line across the screen (like an oscilloscope), it displays lots of little dots. It looks like a constellation of stars.
CConstellationData - Data to be displayed by CConstellation.
CDrawingObjectGrid - A grid of drawing objects like CCircle, etc.
CEllipse - Draws an ellipse on the screen.
CGarbageCollector - Implements a garbage collection scheme (modeled after COM) that allows objects to govern their own lifetimes.
CLabeledGrid - A subclass of CDrawingObjectGrid that adds text labels to the objects.
CPager - A virtual base class to handle pagers.
CQueue - Implements a thread-safe generic queue.
CRectangle - Draws a rectangle on the screen.
CRoundedRectangle - Draw a rectangle with rounded corners.
CSkyWord - Makes it easy to send messages to SkyTel alphanumeric pagers.
CSprintSpectrum - Makes it easy to send text messages to Sprint Spectrum PCS phones.
CSquare - Draws a square on the screen. Admittedly not very exciting and ground breaking but I was learning how to do these types of things and was shocked that MFC couldn't do something this simple.
CSquiggle - A type of CRectangle that makes creating oscilloscope type displays real easy.
CSquiggleData - Data taken from o-scopes to be given to CSquiggle.
CWaitCursor - Ye Olde Wait Cursor class. It turns your cursor into an hour glass in the constructor and returns it to normal in the destructor.
CWeather - This class normalizes data associated with weather reports.
CWfcTrace - Tracing class. Used for adding automagically indented debug statements. It has 32 different levels of tracing that can be set as a program runs to tailor the output.
NERR_*
error codes to text; the
FormatMessage() trick doesn't work on these error codes.
bit_clear - Macro to set a bit to zero.
bit_set - Macro to set a bit to one.
bit_test - Test the value of a bit.
wfc_am_i_administrator - C Function that returns TRUE if you have Administrator priveleges.
wfc_append_string_to_CByteArray - C Function that appends a string to an array of bytes.
wfc_append_text_to_edit_control - C Function that appends text to an edit control.
wfc_close_handle - C function that returns TRUE if CloseHandle() returns not FALSE. This helps in debugging when you pass an invalid handle to CloseHandle().
wfc_convert_double_null_terminated_string() - Converts a double-NULL terminated string to a CStringArray. double-NULL strings are used in a lot of self-referential structures.
wfc_convert_lpcwstr_to_cstring() - This eliminated a lot of code in the networking classes. Microsoft (even in Visual C++ version 4.2) has the networking API header files all screwed up. The string parameters are mis-typed. I used to have a lot of code in the classes to detect and fix this but it was real ugly (and prevented const correctness). Adding this function allowed me to fix Microsoft's mistake in one function.
wfc_create_hard_link - C function that creates two directory entries for one file. It implements the upcoming NT 5.0 API named CreateHardLink().
wfc_delete_oldest_file - C function that deletes the oldest file in a directory. It will return TRUE if a file was deleted or FALSE it a file was not deleted. This is useful in a file cache management system.
wfc_enable_privilege - A little routine to enable a specific privilege by name.
wfc_enable_all_privileges - A routine I wrote
because I hate Microsoft's error messages.  For example, "Access is Denied."
WHICH access is denied???? Another brilliant message
was "class failed to initialize" It came from a COM application.
Wouldn't it be helpful to know which of the four cudzillion
COM objects hidden on the system failed to load??? Anyway,
wfc_enable_all_privileges
simply acquires as many
privileges as is possible.
wfc_get_activex_servers - C function that
retrieves a list of servers that are marked as safe to download
ActiveX controls from. If you see a server named
CODEBASE
listed, it means your machine is vulnerable
to malicious code being downloaded. You can secure your machine by
removing CODEBASE
from the server list and calling
wfc_set_activex_servers.
wfc_get_directory_usage_percentage - C function that returns an integer percentage of the space used on a volume by a directory. This is useful in a file cache management system.
wfc_get_error_string - C function that cryptic error codes into something humanly readable.
wfc_get_executable_directory - C function that returns the directory name (ending in a slash) that the executable calling this function exists in. This is good for finding configuration files that must exist in the same directory as the executable.
wfc_get_filename_from_handle - C function that
returns the file name given a file's handle. It uses the partially
documented NtQueryInformationFile
to perform this
magic.
wfc_get_operating_system_version_string - Fills a CString with a nice OS version string (including service pack level).
wfc_get_string_from_clipboard - Fills a CString with whatever is in the clipboard.
wfc_get_thread_name - A function that fills a
CString with the name of the thread it was called in. Really handy
when debugging multi-threaded programs. This name is set via
wfc_set_thread_name. Also by putting
(char*)((DW(@TIB)+0x14))
in the debugger's watch
window, you can see the thread name appear. When you select a new
thread to debug, the thread's name will automatically appear in the
watch window.
wfc_get_web_page() - Retrieves a URL and puts the page into a CStringArray. This is great for retrieving data from the web.
wfc_move_file_at_reboot() - This function let's you schedule a file to be moved at the next reboot. This is how system DLL's are upgraded.
wfc_protect_data - This function encrypts a buffer sent to it via the CryptProtectData API.
wfc_parse_iso_8601_string - This function parses ISO8601 dates into a CTime or COleDateTime object.
wfc_set_activex_servers - C function that sets
the list of servers that are marked as safe to download ActiveX
controls from. If include a server named CODEBASE
,
your machine will vulnerable to malicious code being downloaded.
You can retrieve the list of trusted servers via wfc_get_activex_servers.
wfc_set_thread_name - A function that allows you
to set a string constant as the "name" of a thread. Really handy
when debugging multi-threaded programs. Also by putting
(char*)((DW(@TIB)+0x14))
in the debugger's watch
window, you can see the thread name appear. When you select a new
thread to debug, the thread's name will automatically appear in the
watch window.
wfc_start_screen_saver - C function that activates the screen saver.
wfc_undocumented_get_system_process_list - Uses an undocumented function to get a list of all processes running in an NT system.
wfc_unprotect_data - This function decrypts a buffer sent to it via the CryptUnprotectData API.


|
Mini51 BSP
V3.02.002
The Board Support Package for Mini51 Series
|
MINI51 series 24LC64 EEPROM library header file. More...
Go to the source code of this file.
Macros | |
| #define | EEPROM_READ_ADDR 0xA1 /* Address of slave for read */ |
| #define | EEPROM_WRITE_ADDR 0xA0 /* Address of slave for write */ |
Functions | |
| void | EEPROM_Init (void) |
| Open I2C interface to access EEPROM. More... | |
| void | EEPROM_Write (uint32_t u32Addr, uint8_t u8Data) |
| Write data to EEPROM. More... | |
| uint8_t | EEPROM_Read (uint32_t u32Addr) |
| Read data from EEPROM. More... | |
| uint8_t | EEPROM_SequentialRead (uint32_t u32Addr, uint8_t *pu8Buf, uint32_t u32Size) |
| Read data from EEPROM using sequential read method. More... | |
| void | EEPROM_PageWrite (uint32_t u32Addr, uint8_t *pu8Buf) |
| Write page data to EEPROM. More... | |
MINI51 series 24LC64 EEPROM library header file.
MINI51 series 24LC64 EEPROM library source file.
Definition in file eeprom_24lc64.c.
| #define EEPROM_READ_ADDR 0xA1 /* Address of slave for read */ |
Definition at line 17 of file eeprom_24lc64.c.
| #define EEPROM_WRITE_ADDR 0xA0 /* Address of slave for write */ |
Definition at line 18 of file eeprom_24lc64.c.
| void EEPROM_Init | ( | void | ) |
Open I2C interface to access EEPROM.
| None |
Definition at line 25 of file eeprom_24lc64.c.
| void EEPROM_PageWrite | ( | uint32_t | u32Addr, |
| uint8_t * | pu8Buf | ||
| ) |
Write page data to EEPROM.
| u32Addr | Address for reading |
| pu8Buf | The pointer of buffer that data will be written. |
Definition at line 396 of file eeprom_24lc64.c.
| uint8_t EEPROM_Read | ( | uint32_t | u32Addr | ) |
Read data from EEPROM.
| u32Addr | Address for reading |
Definition at line 137 of file eeprom_24lc64.c.
| uint8_t EEPROM_SequentialRead | ( | uint32_t | u32Addr, |
| uint8_t * | pu8Buf, | ||
| uint32_t | u32Size | ||
| ) |
Read data from EEPROM using sequential read method.
| u32Addr | Address for reading |
| pu8Buf | The pointer of buffer that data will be put. |
| u32Size | Read size |
Definition at line 269 of file eeprom_24lc64.c.
| void EEPROM_Write | ( | uint32_t | u32Addr, |
| uint8_t | u8Data | ||
| ) |
Write data to EEPROM.
| u32Addr | Address for writing |
| u8Data | Data for writing |
Definition at line 37 of file eeprom_24lc64.c.


I have been write a code for around 6 years. Experienced working from corporate to startup culture. Skilled in ERP (odoo), Python, Node.js, Cloud Computing and *nix environment.


This page lets you choose an image, and break that image into a scrambled sheet of printable stickers (meant to be printed onto a sticker sheet). Kids can then re-assemble the stickers to make the original image.
| Sticker Sheet Configuration | |
| Square Sticker Size | (inches) |
| Top Margin | |
| Left Margin | |
| It is recommended to generate the image with 0 margins, then set margins in your printer software to match your label sheet. I've had luck using LibreOffice Draw - it seems to respect margins most accurately. For example, on a sheet with 13 0.5-inch labels, 0.5 inches between each one, the top/left margins should be 0.1875 inches (to include the extra bleed space). | |
| Horizontal Spacing | |
| Vertical Spacing | |
| Number of squares across | |
| Image Configuration | |
| # Rows | |
| # Columns | |
| Pixels per inch | |
| Image |


{% extends 'base.html' %} {% block header %} {% endblock header %} {% block content %}
Neuronal development requires a complex choreography of transcriptional decisions to obtain a specific cellular identity. Yet the poor accessibility of individual neuronal classes has made direct measurements of gene expression difficult. We have combined nuclear-antigen targeting FACS sorting with high-resolution massively parallel RNA sequencing to provide the first resource of deep-transcriptomic data in individual sorted neuron populations. We provide here, an interactive space to explore the numerous aspects of these data including spatial and temporal usage of alternative mRNA isoforms and promoters, to a host of mRNA and long noncoding RNA (lncRNA) genes newly implicated in neuronal cell fate specification. This database enables integrated, multidimensional data mining and provides a powerful resource to generate insights into the transcriptional regulation underlying neuronal diversity in the developing cortex.
DeCoN provides an exploratory interface to deep transcriptional profiling data of three clinically relevant subclasses of mouse cortical projection neurons:
We have conducted isoform-deconvolution based differential RNA-Sequencing on sorted populations of each neuronal subclass at specified timepoints during corticogenesis:
The DeCoN manuscript has been accepted for publication as a resource article in Neuron and is currently in press. Please cite as:
Molyneaux, B. J.*, Goff, L. A.*, Brettler, A. C., Chen, H.-H., Brown, J. R., Hrvatin, S., et al. (2014). DeCoN: Genome-wide Analysis of In Vivo Transcriptional Dynamics during Pyramidal Neuron Fate Selection in Neocortex. Neuron (in press). doi:10.1016/j.neuron.2014.12.024. *Authors contributed equally
You can find genes of interest by entering either an official MGI gene symbol or a genomic locus (mm9) into the search bar located at the top right of the window.
Individual gene pages can be accessed through the search utility, or by constructing a URL with the official MGI gene symbol (case-sensitive) as follows:
Base URL:
http://decon.fas.harvard.edu/pyramidal/gene/
Gene of Interest:
Tle4
Direct Link (Base + Gene)
http://decon.fas.harvard.edu/pyramidal/gene/Tle4
You can quickly explore both the expression levels and relative cell type specificity of multiple genes at once through a similar URL construction method. Simply create a string of MGI gene symbols separated by a "+" as follows:
Geneset Base URL:
http://decon.fas.harvard.edu/pyramidal/geneset/
Gene set of Interest:
Vsx2+Epha1+Epha2+Epha3+Epha4+Epha5+Epha6+Epha7+Epha8+Epha10
Direct Link (Base + Gene)
http://decon.fas.harvard.edu/pyramidal/geneset/Vsx2+Epha1+Epha2+Epha3+Epha4+Epha5+Epha6+Epha7+Epha8+Epha10
Alternatively, you can build a gene set as you explore DeCoN. Clicking on the green gene set button will add your gene to a temporary gene set which can be viewed by clicking on the GeneSet menu in the top right of your screen and selecting 'View'. To remove a gene click the red added button or select that gene from the drop down gene set menu.
The Marker discovery tool allows you to quickly mine through >8000 significantly regulated genes to identify those genes that best match your expression profile of interest. Here you can filter by gene type (lncRNA vs Protein coding gene) or pre-assigned cluster id (see Manuscript) to quickly subset the broad list of dynamically regulated genes to find those most applicable to your research. Individual filters can also be applied to expression estimates for each cell type at each time point, to precisely refine a list of genes with expression profiles of interest.
Where applicable, we provide a REST-like interface for retrieval of gene-specific supporting data. Future versions will expand on this API to make it a bit more flexible. For now, data are provided in JSON format.
{% endblock content %}Gene-level Expression Data
/pyramidal/gene/<gene_name>/expression/
Isoform-level Expression Data
/pyramidal/gene/<gene_name>/isoform/<isoform_id>/expression/
Gene-level Differential Analysis Data
/pyramidal/gene/<gene_name>/hivedata/
Isoform-level Differential Analysis Data
/pyramidal/gene/<gene_name>/isoform/<isoform_id>/hivedata/


The dataset contains weekly dengue data for the city of Iquitos, Peru. The dataset includes the following variables:
- season: the transmission season;
- season_week: week of the season (not the calendar year - the season starts following the week with historically lowest dengue cases over the years 2000-2009);
- week_start_date: date of the first day of the week;
- denv1_cases: number of laboratory confirmed cases with DENV1;
- denv2_cases: number of laboratory confirmed cases with DENV2;
- denv3_cases: number of laboratory confirmed cases with DENV3;
- denv4_cases: number of laboratory confirmed cases with DENV4;
- other_positive_cases: laboratory-positive cases without serotype identified (these include acute IgM positive and IgM conversions);
- additional_cases: at times not all specimens submitted were tested due to overload of the capacity for testing or incomplete case information. For those weeks, the number of additional laboratory-positive cases among those not tested was estimated by multiplying the number of untested cases by the rate of laboratory-positive cases amongst those that were tested;
- total_cases: the sum of all cases (denv1-4_cases + additional_cases), the target time series for forecasting.
Over the period of the study, all diagnostic methods were consistent: IgM ELISA (acute and convalescent sample) and serotype-specific RT-PCR (acute sample). Details are presented in Forshey et al. 2010. In 2004, there was a two-week period when surveillance effort was extended to 24 hours a day because of the large volume of cases (Stoddard et al. 2014). Otherwise, patients were enrolled 5-7 hours a day, five days a week.
Forshey BM, Guevara C, Laguna-Torres VA, Cespedes M, Vargas J, et al. (2010)
Arboviral Etiologies of Acute Febrile Illnesses in Western South America, 2000-2007. PLoS Negl Trop Dis 4(8): e787. doi: 10.1371/journal.pntd.0000787
Stoddard ST, Wearing HJ, Reiner RC Jr, Morrison AC, Astete H, et al. (2014)
Long-Term and Seasonal Dynamics of Dengue in Iquitos, Peru. PLoS Negl Trop Dis 8(7): e3003. doi: 10.1371/journal.pntd.0003003


This is your custom TinyWebDB for AppInventor 2 without the web administration interface!
In order to manage this database, please head to your Google Cloud Console.


<script> alert('this is awesome!');</script>
This is meant to be an easy way to keep a talk or a lesson on track so you don't run out of time!
Just drag a CSV file into the bucket! It should be formatted like this:
Bootcamp 3.1 - The Joy of Javascript 6:30 PM,,Instructor Do: Welcome Students ,0:01 6:31 PM,,Instructor Do: Today's Class,0:01 6:32 PM,,Instructor Do: How to Learn Javascript,0:05 6:37 PM,,Partners Do: Code Dissection,0:07 6:44 PM,,Instructor Do: What is Javascript,0:02 6:46 PM,,Instructor Do: Variables + Demo,0:06 6:52 PM,High,Students Do: Variable Activity,0:10 7:02 PM,,Instructor Do: Review Variable Activity,0:04
The first line will be used as the title of the page
The second column is used to indicate if any items are more important. Recognized values are "High" and "Critical"
Ok, let's go!


Temperature
-
pH
-
Redox Potential
-
Temperature |
- |
°C |
|---|---|---|
pH |
- |
|
Redox Potential |
- |
mV |
Temperature |
- |
°C |
|---|---|---|
pH |
- |
|
Redox Potential |
- |
mV |


tutorial¶
ugtm provides an implementation of GTM (Generative Topographic Mapping), kGTM (kernel Generative Topographic Mapping), GTM classification models (kNN, Bayes) and GTM regression models. ugtm also implements cross-validation options which can be used to compare GTM classification models to SVM classification models, and GTM regression models to SVM regression models. Typical usage:
#!/usr/bin/env python
import ugtm
import numpy as np
#generate sample data and labels: replace this with your own data
data=np.random.randn(100,50)
labels=np.random.choice([1,2],size=100)
#build GTM map
gtm=ugtm.runGTM(data=data,verbose=True)
#plot GTM map (html)
gtm.plot_html(output="out")
For installation instructions, cf. https://github.com/hagax8/ugtm
1. Import package¶
Import ugtm package, allowing to construct GTM and kernel GTM (kGTM) maps, GTM classification models, GTM regression models:
import ugtm
2. Construct and plot GTM maps (or kGTM maps)¶
A gtm object can be created by running the function runGTM on a dataset. Parameters for runGTM are: k = sqrt(number of nodes), m = sqrt(number of rbf centres), s = RBF width factor, regul = regularization coefficient. The number of iteration for the expectation-maximization algorithm is set to 200 by default. This is an example with random data:
import ugtm
#import numpy to generate random data
import numpy as np
#generate random data (independent variables x),
#discrete labels (dependent variable y),
#and continuous labels (dependent variable y),
#to experiment with categorical or continuous outcomes
train = np.random.randn(20,10)
test = np.random.randn(20,10)
labels=np.random.choice(["class1","class2"],size=20)
activity=np.random.randn(20,1)
#create a gtm object and write model
gtm = ugtm.runGTM(train)
gtm.write("testout1")
#run verbose
gtm = ugtm.runGTM(train, verbose=True)
#to run a kernel GTM model instead, run following:
gtm = ugtm.runkGTM(train, doKernel=True, kernel="linear")
#access coordinates (means or modes), and responsibilities of gtm object
gtm_coordinates = gtm.matMeans
gtm_modes = gtm.matModes
gtm_responsibilities = gtm.matR
3. Plot html maps¶
Call the plot_html() function on the gtm object:
#run model on train
gtm = ugtm.runGTM(train)
# ex. plot gtm object with landscape, html: labels are continuous
gtm.plot_html(output="testout10",labels=activity,discrete=False,pointsize=20)
# ex. plot gtm object with landscape, html: labels are discrete
gtm.plot_html(output="testout11",labels=labels,discrete=True,pointsize=20)
# ex. plot gtm object with landscape, html: labels are continuous
# no interpolation between nodes
gtm.plot_html(output="testout12",labels=activity,discrete=False,pointsize=20, \
do_interpolate=False,ids=labels)
# ex. plot gtm object with landscape, html: labels are discrete,
# no interpolation between nodes
gtm.plot_html(output="testout13",labels=labels,discrete=True,pointsize=20, \
do_interpolate=False)
4. Plot pdf maps¶
Call the plot() function on the gtm object:
#run model on train
gtm = ugtm.runGTM(train)
# ex. plot gtm object, pdf: no labels
gtm.plot(output="testout6",pointsize=20)
# ex. plot gtm object with landscape, pdf: labels are discrete
gtm.plot(output="testout7",labels=labels,discrete=True,pointsize=20)
# ex. plot gtm object with landscape, pdf: labels are continuous
gtm.plot(output="testout8",labels=activity,discrete=False,pointsize=20)
5. Plot multipanel views (only if labels or activities are provided)¶
Call the plot_multipanel() function on the gtm object. This plots a general model view, showing means, modes, landscape with or without points. The plot_multipanel function only works if you have defined labels:
#run model on train
gtm = ugtm.runGTM(train)
# ex. with discrete labels and inter-node interpolation
gtm.plot_multipanel(output="testout2",labels=labels,discrete=True,pointsize=20)
# ex. with continuous labels and inter-node interpolation
gtm.plot_multipanel(output="testout3",labels=activity,discrete=False,pointsize=20)
# ex. with discrete labels and no inter-node interpolation
gtm.plot_multipanel(output="testout4",labels=labels,discrete=True,pointsize=20, \
do_interpolate=False)
# ex. with continuous labels and no inter-node interpolation
gtm.plot_multipanel(output="testout5",labels=activity,discrete=False,pointsize=20, \
do_interpolate=False)
6. Project new data onto existing GTM map¶
New data can be projected on the GTM map by using the transform() function, which takes as input the gtm model, a training and test set. The train set is then only used to perform data preprocessing on the test set based on the train (for example: apply the same PCA transformation to the train and test sets before running the algorithm):
#run model on train
gtm = ugtm.runGTM(train,doPCA=True)
#test new data (test)
transformed=ugtm.transform(optimizedModel=gtm,train=train,test=test,doPCA=True)
#plot transformed test (html)
transformed.plot_html(output="testout14",pointsize=20)
#plot transformed test (pdf)
transformed.plot(output="testout15",pointsize=20)
#plot transformed data on existing classification model,
#using training set labels
gtm.plot_html_projection(output="testout16",projections=transformed,\
labels=labels, \
discrete=True,pointsize=20)
7. Output predictions for a test set: GTM regression (GTR) and classification (GTC)¶
The GTR() function implements the GTM regression model (cf. references) and GTC() function a GTM classification model (cf. references):
#continuous labels (prediction by GTM regression model)
predicted=ugtm.GTR(train=train,test=test,labels=activity)
#discrete labels (prediction by GTM classification model)
predicted=ugtm.GTC(train=train,test=test,labels=labels)
8. Advanced GTM predictions with per-class probabilities¶
Per-class probabilities for a test set can be given by the advancedGTC() function (you can set the m, k, regul, s parameters just as with runGTM):
#get whole output model and label predictions for test set
predicted_model=ugtm.advancedGTC(train=train,test=test,labels=labels)
#write whole predicted model with per-class probabilities
ugtm.printClassPredictions(predicted_model,"testout17")
9. Crossvalidation experiments¶
Different crossvalidation experiments were implemented to compare GTC and GTR models to classical machine learning methods:
#crossvalidation experiment: GTM classification model implemented in ugtm,
#here: set hyperparameters s=1 and regul=1 (set to -1 to optimize)
ugtm.crossvalidateGTC(data=train,labels=labels,s=1,regul=1,n_repetitions=10,n_folds=5)
#crossvalidation experiment: GTM regression model
ugtm.crossvalidateGTR(data=train,labels=activity,s=1,regul=1)
#you can also run the following functions to compare
#with other classification/regression algorithms:
#crossvalidation experiment, k-nearest neighbours classification
#on 2D PCA map with 7 neighbors (set to -1 to optimize number of neighbours)
ugtm.crossvalidatePCAC(data=train,labels=labels,n_neighbors=7)
#crossvalidation experiment, SVC rbf classification model (sklearn implementation):
ugtm.crossvalidateSVCrbf(data=train,labels=labels,C=1,gamma=1)
#crossvalidation experiment, linear SVC classification model (sklearn implementation):
ugtm.crossvalidateSVC(data=train,labels=labels,C=1)
#crossvalidation experiment, linear SVC regression model (sklearn implementation):
ugtm.crossvalidateSVR(data=train,labels=activity,C=1,epsilon=1)
#crossvalidation experiment, k-nearest neighbours regression on 2D PCA map with 7 neighbors:
ugtm.crossvalidatePCAR(data=train,labels=activity,n_neighbors=7)


143 amount of black, imaginatively called value. HSV stands for Hue-Saturation-Value. (Value is also called brightness.) The value is actually measured backward from the above description; that is, if value is 0, the color is pure black; if value is 100, then a saturation of 0 means all white, no spectral color; a saturation of 100 means no white at all. In the square in the previous paragraph, the x axis is the saturation and the y axis is the value. The entire bottom edge is black, but only the top left corner is white. HSV is the traditional color space used in Scratch and Snap ! . Set pen color set the hue; set pen shade set the value. There was originally no Pen block to set the saturation, but there’s a set brightness eect Looks block to control the saturation of the sprite’s costume. (I speculate that the Scratch designers, like me, thought tints were less vivid than shades against a white background, so they made it harder to control tinting.) But if you’re looking at colors on a computer display, HSV isn’t really a good match for human perception. Intuitively, black and white should be treated symmetrically. This is the HSL (hue-saturation-lightness) color space. Saturation, in HSL, is a measure of the grayness or dullness of a color (how close it comes to being on a black-and-white scale) and lightness measures spectralness with pure white at one end, pure black at the other end, and spectral color in the middle. The saturation number is actually the opposite of grayness: 0 means pure gray, and 100 means pure spectral color, provided that the lightness is 50, midway between black and white. Colors with lightness other than 50 have some black or white mixed in, but saturation 100 means that the color is as fully saturated as it can be, given the amount of white or black needed to achieve that lightness. Saturation less than 100 means that both white and black are mixed with the spectral color. (Such mixtures are called tones of the spectral color. Perceptually, colors with saturation 100% don’t look gray: but colors with saturation 75% do: Note that HSV and HSL both have a dimension called “saturation,” but they’re not the same thing! In HSV, “saturation” means non-whiteness, whereas in HSL it means non-grayness (vividness). More ﬁne print: It’s misleading to talk about the spectrum of light wavelengths as if it were the same as perceived hue. If your computer display is showing you a yellow area, for example, it’s doing it by turning on its red and green LEDs over that area, and what hits your retina is still two wavelengths of light, red and green, superimposed. You could make what’s perceptually the same yellow by using a single intermediate wavelength. Your eye and brain don’t distinguish between those two kinds of yellow. Also, your brain automatically adjusts perceived hue to correct for differences in illumination. When you place a monochrome object so that it’s half in sunlight and half in the shade, you see it as one even though what’s reaching your eyes from the two regions differs a lot. And, sadly, it’s HSL whose use of “saturation” disagrees with the ofﬁcial international color vocabulary standardization committee. I learned all this from this tutorial, which you might ﬁnd more coherent than jumping around Wikipedia if you’re interested. Although traditional Scratch and Snap ! use HSV in programs, they use HSL in the color picker. The horizontal axis is hue (fair hue, in this version) and the vertical axis is lightness, the scale with black at one end and white at the other end. It would make no sense to have only the bottom half of this selector (HSV Value) or only the top half (HSV Saturation). And, given that you can only ﬁt two dimensions on a ﬂat screen, it makes sense to pick HSL saturation (vividness) as the one to keep at 100%. (In this fair-hue picker, some colors appear twice: “spectral” (50% lightness) browns as shades (≈33% lightness) of red or orange, and shades of those browns.) Software that isn’t primarily about colors (so, not including Photoshop, for example) typically use HSV or HSL, with web-based software more likely to use HSV because that’s what’s built into the JavaScript programming language provided by browsers. But if the goal is to model human color perception, neither of these color spaces is satisfactory, because they assume that all full-intensity spectral colors are equally bright. But if you’re like most people, you see spectral yellow as much brighter than spectral blue . There are better perceptual color spaces with names like L*u*v* and L*a*b* that are based on research with human subjects to determine true perceived brightness. Wikipedia explains all this and more at HSL and HSV, where they recommend ditching both of these simplistic color spaces. J


--- layout: post title: Parts of a whole (work in progress) date: '2013-07-10T16:18:00-04:00' tags: [] tumblr_url: http://poetry.liabogoev.com/post/55109812975/parts-of-a-whole-work-in-progress ---
An acrobat
I tumble
Your voice
A low rumble
My walls
Melt and crumble
And I fumble
And mumble
Unintentionally
Humble.

Imagine
The abandon
When you are truly mine.
And there’s no state line
Between us.


a side-by-side reference sheet
grammar and invocation | variables and expressions | stack | arithmetic and logic | strings | regexes
dates and time | arrays | heap | dictionaries | functions | execution control | exceptions | file handles | files
directories | processes and environment | libraries and namespaces | reflection | graphics
| forth | postscript | |
|---|---|---|
| version used |
Gforth 0.70 | Preview 5.0 |
| show version |
$ gforth --version | select About Preview in Preview menu |
| grammar and invocation | ||
| forth | postscript | |
| interpreter |
$ echo "1 1 + . cr bye" > /tmp/add.forth $ gforth /tmp/add.forth |
none |
| shebang |
none | none |
| repl |
$ gforth | none |
| save image | ||
| load image | ||
| are identifiers case sensitive | no | yes |
| end-of-line comment | 1 1 + \ addition | 1 1 add % addition |
| multiple line comment | 1 1 ( comment another comment ) + |
none |
| variables and expressions | ||
| forth | postscript | |
| assignment | variable a 3 a ! 7 a @ + |
/a 3 def 7 currentdict /a get add |
| increment and decrement | 7 1+ 7 1- |
|
| null |
none | null |
| null test |
none | |
| undefined variable access | ||
| stack | ||
| forth | postscript | |
| stacks | data floating point return locals |
operand dictionary execution graphics state clipping path |
| stack underflow | ||
| display stack | .s displays float stack: f.s |
none |
| clear stack | clears data stack: clearstack clears data and float stack: clearstacks |
clear |
| count stack | depth fdepth |
count |
| copy stack |
count copy | |
| (a -- ) | drop displays item being dropped: . operate on float stack: fdrop f. |
pop |
| (a -- a a) | dup fdup |
dup |
| (a b -- b a) | swap fswap |
exch |
| (a b -- b) | nip fnip |
exch pop |
| (a b -- a b a) | over fover |
1 index |
| (a b -- b a b) | tuck ftuck |
dup 3 1 roll |
| (a b c -- b c a) | rot frot |
3 -1 roll |
| (a b c -- a b c a) | 2 pick 2 fpick |
2 index |
| (a b c d -- b c d a) | 3 roll 3 froll |
4 -1 roll |
| arithmetic and logic | ||
| forth | postscript | |
| true and false | true false -1 0 |
true false |
| falsehoods |
false 0 | false |
| logical operators | and or invert xor | and or not xor |
| relational operators | = <> > < >= <= f= f<> f> f< f>= f<= |
eq ne gt lt ge le |
| min and max | 1 2 min 1 2 max |
|
| three value comparison | ||
| float literal | must contain an e: 3.14e0 |
3.14 3.14e0 |
| numeric predicates | ||
| arithmetic operators | + - * ?? / mod ?? float stack operators: f+ f- f* f/ f |
add sub mul div idiv mod exp |
| unary negation | negate fnegate |
neg |
| integer division | ||
| integer division by zero | ||
| float division | ||
| float division by zero | ||
| power | 2e0 32e0 f | |
| sqrt | 2e0 fsqrt | |
| sqrt(-2) | pushes this non-literal value onto stack: -na |
|
| transcendental functions | fexp fln fsin fcos ftan fasin facos fatan fatan2 also flog for base 10 logarithm |
sqrt exp ln sin cos none none none none atan also log for base 10 logarithm |
| transcendental constants | pi 1e0 fexp |
|
| float truncation | return floats fround ?? floor ?? |
round truncate floor ceiling |
| absolute value and signum |
-7 abs -7e0 fabs |
abs |
| integer overflow | modular arithmetic | |
| float overflow |
||
| float limits | ||
| rational construction | ||
| rational decomposition | ||
| complex construction | ||
| complex decomposition real and imaginary component, argument, absolute value, conjugate |
||
| random number uniform integer, uniform float, normal float |
rand generates random integer from 0 to 231-1: rand 100 mod none none |
|
| random seed |
13 srand | |
| bit operators | and or xor invert logical shift by 3: 7 3 lshift 7 3 rshift arithmetic shift by 1: 7 2* 7 2/ |
and or xor not logical shift by 3: 7 3 bitshift 7 -3 bitshift |
| binary, octal, and hex literals | ||
| radix | ||
| strings | ||
| forth | postscript | |
| string literals | allocates memory for string and pushes address and length onto stack: s\" don't say \"no\"" |
(don't say "no") parens and backslashes are escaped with backslashes. Balanced parens do not need to be escaped. |
| string escapes | \a \b \e \f \n \r \t \v \" \\ \, \ooo \xxx | \b \f \n \r \t \\ \( \) \ooo |
| newline in literal | no, use \n | no, use \n |
| character access | (hello) 0 get | |
| length | (hello) length | |
| concatenate | ||
| split | ||
| join | ||
| trim | ||
| pad | ||
| number to string | 7 (12) cvi add 73.9 (.037) cvr add |
|
| string to number | ||
| case manipulation | ||
| sprintf | ||
| regular expressions | ||
| forth | postscript | |
| literal | ||
| character class abbreviations | ||
| anchors |
||
| match test | ||
| case insensitive match test | ||
| modifiers |
||
| substitution | ||
| group capture |
||
| back reference in match and substitution | ||
| dates and time | ||
| forth | postscript | |
| broken-down date and time type | ||
| current date/time | \ pushes six values onto stack: date&time |
|
| to unix epoch, from unix epoch | ||
| current unix epoch | ||
| date and time to string | ||
| format date | ||
| parse date | ||
| date subtraction | ||
| add duration | ||
| date parts | ||
| time parts | ||
| build broken-down date and time | ||
| day of week and day of year | ||
| microseconds | ||
| sleep | ||
| timeout | ||
| cpu usage | ||
| arrays | ||
| forth | postscript | |
| literal | [ 1 2 3 ] | |
| size |
[ 1 2 3 ] length | |
| empty test |
||
| lookup |
[ 1 2 3 ] 0 get | |
| update | ||
| out-of-bounds behavior | rangecheck error | |
| element index | ||
| slice | ||
| slice to end | ||
| manipulate back | ||
| manipulate front | ||
| array concatenate | ||
| replicate | ||
| copy | ||
| array iteration | [ 50 100 150 ] { 100 moveto (foo) show } forall | |
| indexed iteration | ||
| iterate over range | ||
| instantiate range as array | ||
| reverse | ||
| sort | ||
| dedupe | ||
| membership | ||
| intersection | ||
| union | ||
| relative complement, symmetric difference | ||
| map | ||
| filter | ||
| reduce | ||
| min and max element | ||
| universal and existential tests | ||
| sample w/o replacement | ||
| zip | ||
| heap | ||
| allocate region on heap | pushes address and 0 onto stack: 10 allocate |
|
| free region on heap | free | |
| resize region on heap | ||
| write | ||
| read | ||
| dictionaries | ||
| forth | postscript | |
| dictionary literal | << 1 (one) 2 (two) 3 (three) >> | |
| dictionary length | << 1 (one) 2 (two) >> length | |
| dictionary element access | pushes (one) onto stack: << 1 (one) 2 (two) >> 1 get |
|
| element not found behavior | undefined error | |
| set dictionary element | /h << 1 (one) 2 (two) >> def currentdict /h get 3 (three) put |
|
| range | ||
| functions | ||
| forth | postscript | |
| define function | : add3 + + ; | /add3 { add add } def |
| invoke function | 3 7 5 add3 | 3 7 5 add3 |
| missing argument behavior | a stack underflow error results if the expected number of arguments is not on the stack | a stack underflow error results if the expected number of arguments is not on the stack |
| return value |
values are returned by pushing them onto the stack | values are returned by pushing them onto the stack |
| multiple return values | no limit on the number of values a function can leave on the stack | no limit on the number of values a function can leave on the stack |
| recursive function | ||
| mutually recursive functions | ||
| anonymous function | { 2 add } | |
| invoke anonymous function | 3 { 2 add } exec | |
| closure | ||
| function as value | ||
| compose functions | ||
| partial application | ||
| fried quotation | ||
| execution control | ||
| forth | postscript | |
| notes on conditionals | conditionals can only be used in word definitions. endif can be used in place of then |
|
| ifelse | : ifelse rot if drop else nip then ; x @ 0 > x @ x @ negate ifelse |
x 0 gt { x } { x neg } ifelse |
| if | bool if if true then |
bool { if true } if |
| if else | bool if if true else if false then |
bool { if true } { if false } ifelse |
| notes on loops | loops can only be used in word definitions. leave can be used with loop to terminate early |
exit terminates innermost for, forall, loop, or repeat |
| conditional loop | begin bool while code repeat |
{ bool { exit } if code } loop |
| infinite loop | begin code again |
{ code } loop |
| loop 10 times | 10 0 ?do code loop | 10 { code } repeat |
| for loop | 10 0 ?do i code loop | iterator value on stack 0 20 200 { 72 exch moveto (foo) show } for |
| for loop step 2 | 10 0 +do i code 2 +loop | |
| exceptions | ||
| forth | postscript | |
| notes on exceptions | throw raises an exception if the top of the data stack is nonzero. exception puts a nonzero value on the stack. If the exception is not handled the string will be displayed by the interpreter on exit. catch can only be used in a word definition. | |
| raise exception | s" bam!" exception throw | $error /errorname (foo) put stop |
| handle exception | ['] risky word catch if handle error then | { risky code } stopped { handle error } |
| file handles | ||
| forth | postscript | |
| standard file handles | ||
| read line from stdin | ||
| write line to stdout | ||
| write to stdout | ." hello" cr | |
| redirect to file | ||
| files | ||
| forth | postscript | |
| file test, regular file text | ||
| file size | ||
| is file readable, writable, executable | ||
| set file permissions | ||
| touch file | ||
| copy file, remove file, rename file | ||
| create symlink, symlink test, readlink | ||
| generate unused file name | ||
| directories | ||
| forth | postscript | |
| working directory get and set |
||
| build pathname | ||
| dirname and basename | ||
| absolute pathname | ||
| make directory | ||
| recursive copy | ||
| remove empty directory | ||
| remove directory and contents | ||
| directory test | ||
| processes and environment | ||
| forth | postscript | |
| command line arguments | ||
| program name | ||
| environment variable get, set |
||
| user id and name | ||
| exit | bye | quit |
| external command | ||
| backticks | ||
| pid and parent pid |
||
| set signal handler | ||
| send signal | ||
| libraries and namespaces | ||
| forth | postscript | |
| interpret file | foo.fs include or s" foo.fs" included |
|
| load library | require foo.fs or s" foo.fs" required |
|
| hot patch | ||
| load error | ||
| main routine in library | ||
| library path | ||
| library path environment variable | ||
| namespace declaration | ||
| unqualified import of namespace | ||
| reflection | ||
| forth | postscript | |
| query data type | none | 3 type |
| pretty print | ||
| dump location and stack | ~~ | |
| show code | see word | |
| documentation | ||
| graphics | ||
| forth | postscript | |
| default location of origin | lower left corner of page | |
| default scale | 72 units per inch | |
| text | 72 72 moveto (hello) show | |
| render page and start a new one | showpage | |
| set current font | /Helvetica 20 selectfont | |
| built-in fonts | /Times-Roman /Times-Italic /Times-Bold /Times-BoldItalic /Helvetica /Helvetica-Oblique /Helvetica-Bold /Helvetica-BoldOblique /Courier /Courier-Bold /Courier-Oblique /Courier-BoldOblique |
|
| closed polygon | creates outline of triangle: newpath 72 72 moveto 144 144 lineto 144 72 lineto closepath stroke |
|
| set current line width | default value is 1: 2 setlinewidth |
|
| arc of circle | creates half-circular arc centered at (144,144) with radius 40: newpath 144 144 40 90 270 arc stroke |
|
| bezier curve | control points are (144,144), (288,144), (288,288), and (144,288): newpath 144 144 moveto 288 144 288 288 144 288 curveto stroke |
|
| filled polygon | creates solid triangle: newpath 72 72 moveto 144 144 lineto 144 72 lineto closepath fill |
|
| set color | default color is black. Sets current color to red: 1.0 0.0 0.0 setrgbcolor |
|
| translate coordinates | move origin 72 units up and to the right: 72 72 translate |
|
| scale coordinates | increase size of unit 72-fold: 72 72 scale |
|
| rotate coordinates | rotate coordinates 90 degrees counterclockwise: 90 rotate |
|
| items in graphics state | currentpoint currentrgbcolor currentfont currentmatrix currentlinewidth |
|
| save graphics state | gsave | |
| restore graphics state | grestore | |
| _____________________________________________________________ | _____________________________________________________________ |
version used
The version used for the examples in this sheet.
show version
How to get the version.
Grammar and Invocation
interpreter
How to invoke the interpreter.
shebang
How to make a source file executable on a UNIX system.
repl
How to invoke the REPL.
save image
load image
are identifiers case sensitive
Are words case sensitive?
end-of-line comment
The syntax for a comment which ends at the end of the line.
multiple line comment
The syntax for a comment which can span multiple lines.
forth:
Paren delimited comments cannot span multiple lines when using the REPL.
Paren delimited comments do not nest.
Variables and Expressions
assignment
Stack
Arithmetic and Logic
operators
Strings
Regular Expressions
literal
The syntax for a regular expression value.
character class abbreviations
anchors
match test
case insensitive match test
modifiers
substitution
group capture
back reference in match and substitution
Dates and Time
broken-down date and time type
current date/time
to unix epoch, from unix epoch
current unix epoch
date and time to string
format date
parse date
date subtraction
add duration
date parts
time parts
build broken-down date and time
day of week and day of year
microseconds
sleep
timeout
cpu usage
Arrays
literal
Syntax for an array literal.
size
How to get the length of an array.
empty test
How to test whether an array is empty.
lookup
How to look up the value stored at an index.
update
How to set the value stored at an index.
out-of-bounds behavior
What happens when an attempt is made to access the value at a non-existent index.
zip
How to convert two sequences into a sequence of pairs.
Heap
Dictionaries
Functions
define function
How to define a function.
invoke function
How to invoke a function.
missing argument behavior
What happens when too few arguments are passed to a function.
It is an error in stack-oriented languages when a function tries to read more values from a stack than are there. Since the stack may have had values in it which were not intended for the function, so in general stack-oriented languages cannot detect when too few arguments are passed to a function.
return value
How to return a value from a function.
multiple return values
recursive function
mutually recursive functions
anonymous function
invoke anonymous function
closure
function as value
How to treat a function as a value.
compose functions
partial application
fried quotation
Execution Control
Exceptions
File Handles
Files
Directories
Processes and Environment
command line arguments
program name
environment variable
user id and name
exit
external command
backticks
pid
set signal handler
send signal
Libraries and Namespaces
Reflection
Graphics
Forth
Gforth User Manual
A Beginner's Guide to Forth
Thinking Forth
ANS Forth
The data stack used by Forth procedures to pass operands consists of cells of machine words. These will be interpreted as signed integers, unsigned integers, or memory addresses, depending upon the operator invoked on them. A Forth interpreter does not perform any checks to ensure type safety.
To work with strings and arrays, a Forth programmer must allocate and free space on the heap with the allocate and free commands. Strings are then represented on the data stack with two cells: the address of the string and the length of the string. To make working with these string representations easier, there are operators which manipulate the stack two cells at a time: 2drop, 2dup, 2swap.
Most Forth implementations support floating point numbers. Floats are kept on a separate stack, and many data stack operators have a floating point stack analogue. Floating point operators have an "f" prefix: fdrop, fdup, fswap, f+, f*, f<.
PostScript
PostScript Language Reference (pdf)
PDF Reference (pdf)
PostScript is a commonly used page description language. It has programming language features one might not expect to find in such a special purpose language such as looping and branching commands, arrays and dictionaries, and even commands which read from standard input and write to standard out.
Like Forth, PostScript is a language with built-in operators that add value to or remove values from an operand stack. Unlike Forth, PostScript keeps track of the type of each value in the operand stack, and it will raise an error if an operator is called on an operand of the wrong type. PostScript also offers string, array, and dictionary data types so that direct access to memory is not needed or even supported.
A PostScript document consists of a sequence of pages, one for each execution of the showpage operator. PostScript provides a selection of operators which paint marks such as letters, shapes, or lines onto the page. The painted marks are collected in a buffer. When a showpage operator is invoked, the marks are rendered on the page and the buffer is cleared. If two marks overlap, the mark which was painted last will be completely visible, and the earlier mark will be partially or completely obscured as if it had been painted over.
The coordinate system used for determining the location of a painting mark places the origin in the lower left corner of the pa by default. The scale is 72 units per inch, with the x coordinate increasing in a rightward direction and the y coordinate increasing in an upward direction. The program may scale, rotate, or translate the coordinate system as pleased as long as the transformation is linear. The size of the page depends on the output device. Although the origin is by default the lower left corner of the physical page, some printers cannot print on the margin of the page; such printers cannot place a mark at or near the origin. The portions of marks which are outside the renderable window of the output device are ignored.
Some of the behavior of the painting operands is governed by the current graphics state. This reduces the number of operands that must be pushed onto the stack when calling a painting operator. The most commonly used parameters in the current graphics state are the current position, path, color, font, line width, coordinate transformation matrix. The gsave and grestore will push the current graphics state onto a stack or pop and restore the top value of the graphics state from the same stack.
PostScript Development
One can test PostScript code by sending it to a printer, but it is better to have an application which can render the PostScript on a screen. Ghostscript is free and runs on Unix and Linux. PSAlter can be purchased for Windows.
Mac OS X includes an application called Preview which renders PDF documents on the screen. It can also be used to render PostScript which it accomplishes by automatically converting the PostScript to PDF. Preview doesn't provide informative error messages. The following PostScript shows how to use the stopped operator to catch an error and display the error name and the command that caused the error:
%!PS
/showobject { () exch 40 string cvs show } bind readonly def
/showerror {
/saved_errorname $error /errorname get def
/saved_command $error /command get def
initgraphics
/Helvetica 20 selectfont
72 644 moveto (this error occurred: ) show
144 572 moveto currentdict /saved_errorname get showobject
72 504 moveto (operator causing the error: ) show
144 432 moveto currentdict /saved_command get showobject
$error /newerror false put
showpage } bind readonly def
{
/Helvetica-Bold 20 selectfont
72 576 moveto
/h << 1 (one) 2 (two) >> def
currentdict /h get 3 get show showpage
} stopped { showerror } if


return
points. Methods with too many return
points may be confusing,
and hard to refactor. A return
point is either a return
statement or the falling through the bottom of a
void
method or constructor.
For example, such method is reported if inspection allows only two return
statement:
void doSmth(User[] users) {
for (User user : users) {
if (cond1(user)) {
user.setId(getId());
return;
} else if (cond2(user)) {
if (cond3(user)) {
user.setId(getId());
return;
}
}
}
}
And it could be rewritten in an easier to understand way:
void doSmth(User[] users) {
for (User user : users) {
if (cond1(user) || cond2(user) && cond3(user)) {
user.setId(getId());
return;
}
}
}
Use the field below to specify the maximum number of return
points a method is allowed to have.
Use the first checkbox below to ignore guard clauses.
A guard clause is an if
statement that contains only a return
statement
Use the second checkbox below to ignore return
points inside equals()
methods.