 No one has set off a dirty bomb yet, as far as we know, but it's such a simple concept that it is almost certainly only a matter of time. Dirty bombs really only have one function -- terrorism -- because they aren't any more deadly that conventional explosives. In fact, to make the "dirty" part work you have to sacrifice a certain amount of effectiveness on the "bomb" part, since you don't want to vaporize the payload. Because the dirty bomb is such an improvised thing, and because it's still a theoretical thing, there is no fixed configuration. Virtually any conventional explosive can be used to power the explosion, which then presumably spreads radioactive debris over a large, densely populated area. While the bomb part isn't anything special, the radioactive part obviously takes some doing. So we can all breathe a great big sigh of relief, knowing that the responsible governments of the world would never let dangerous radioactive materials fall into the wrong hands. The really shocking thing about dirty bombs is that no one has used one yet, considering how easy it is to get your hands on radioactive garbage. First off, there's the former Soviet Union.  Rose Gottemoeller, of the Carnegie Endowment for International Peace, surveyed some nuclear sites in Russia. She told PBS NewsHour:
They didn't have any bars on its windows, just had a big wooden door with a huge key, like a medieval-size key, that they turned to open the door, and when you walked in there, basically down in the floor there were hundreds of buckets of plutonium. When I went into the facility one day, one of the, one of the technicians pulled one of them out of the floor and handed it to me and said, "feel it -- it feels warm. It's full of plutonium." BUCKETS OF PLUTONIUM JUST SITTING BEHIND A BARELY LOCKED WOODEN DOOR!!!!! Are you worried now?? In addition to outrageous stories like this, it's well known that Russia's nuclear arsenal is being "protected" by a group of soldiers making poverty-level wages working for an army that's being downsized by the day -- not exactly the way to inspire loyalty. Just to make matters worse, many of Russia's breakaway republics are home to Muslim fundamentalist insurgencies tied to Osama bin Laden. Bin Laden and his al Qaeda network have been trying to get their hands on the material to make a dirty bomb for a very long time -- so long, in fact, that it's not safe to assume they haven't succeeded. In 2002, U.S. Attorney General John Ashcroft told the world that Jose Padilla had been sent by al Qaeda to set off a dirty bomb on American soil.  (Does that make him a terrorist?) Padilla wasn't the first alleged dirty bomber on U.S. soil either. In the mid-1990s, Mohamed Loay Bayazid was president of the Benevolence International Foundation in Chicago. His previous job had been shopping for nuclear material on behalf of bin Laden, according to court documents in several different terrorism cases. A U.S. citizen (as was Padilla), Bayazid had traveled to the Sudan looking for uranium, according to al Qaeda informants. While in the U.S., he came to the attention of law enforcement officials on more than one occasion, but he managed to flee the country some time around 1998. As if the former Soviet Union wasn't bad enough, there are other sources for dirty bomb materials. Like, just for instance -- EVERYWHERE! According to the U.S. Nuclear Regulatory Commission:
Radioactive materials are widely used at hospitals, research facilities, industrial and construction sites. These radioactive materials are used for such purposes as in diagnosing and treating illnesses, sterilizing equipment, and inspecting welding seams. For example, the Nuclear Regulatory Commission, together with 32 states which regulate radioactive material, have over 21,000 organizations licensed to use such materials.Also, there are the even lower profile, and exponentially less secure, facilities that use employ radioactive materials for fun and profit, the NRC explains, like exploiting "self-luminous qualities" to make "exit signs" and "watch dials." However, the NRC adds reassuringly, "the vast majority of these sources are not useful for constructing an RDD." Whew! Notably missing from the above list, of course, are the more than 100 active nuclear power plants in the United States, which are presumed secure, as are the "spent fuel pools" where millions of gallons of toxic radioactive waste are stored. However, that presumption fails to account for the NRC's own estimate, as of 1999, that 47 percent of U.S. nuclear plants had significant security vulnerabilities. These range from the obvious, like not enough guards, to the only-slightly-less-obvious, like the Ohio nuclear plant whose safety systems were knocked offline by a computer virus in 2003. Since that 1999 study, the NRC has taken some very important steps to enhance security, such as not telling people about that percentage any more. Also, they have "increased patrols, augmented security forces and capabilities, (created) additional security posts, (installed) additional physical barriers, (added) vehicle checks at greater stand-off distances, enhanced coordination with law enforcement and military authorities, (added) more restrictive site access controls for all personnel; and expanded, expedited and (required) more thorough employee background checks." They've also added no-fly zones for sensitive times and in sensitive locations to try to avoid the rather more simple technique of crashing an airplane into a power plant, an approach to dirty bombing which allows for only so much prevention. That's the bad news, and admittedly, there is quite a bit of it. Here's the good news: A dirty bomb attack is probably not a lot more dangerous than a plain old bomb attack. Most of the easily available toxic radioactive material is problematic for use in a dirty bomb, one way or another. Some of it just isn't toxic enough. Other materials aren't available in sufficient quantities to spread effectively over several city blocks, or even just one. Statistically speaking, between wind and dispersal patterns, it's virtually impossible to use a bomb to deliver a lethal dose of radiation to a group of people outside of an enclosed space.  "There's limited lethality. You would have to swallow and breathe in the material before you could become a casualty," Mark Gwozdecky of the International Atomic Energy Agency told the BBC.  If you are exposed to a dirty bomb, there's a good chance you'll be just fine. The appeal of the dirty bomb, of course, is the freakout. If you told the residents of any average U.S. city that a half ton of radioactive waste had just been dumped on their heads, they're going to be afraid, and the purpose of terrorism, as we all know, is to terrify. But it's not entirely clear whether a group like al Qaeda is interested in the freakout simply for its own sake. Apart from targeted political assassinations, almost every report of al Qaeda planning indicates that the group wants body counts, the kind of large body counts that a dirty bomb is not likely to produce. While the terror network has obviously made efforts to get radioactive materials, Khalid Shaikh Mohammed allegedly ordered Jose Padilla to scale down his terrorism career from a planned dirty bomb attack to blowing up high-rises using natural gas. Between the expense and difficulty of getting the material and the challenge of moving it into and around the U.S., dirty bombing doesn't get much bang for your buck. And Bayazid's uranium shopping in the 1990s appeared to be for the purpose of building a real live nuclear bomb, which is a much scarier prospect. You can't get much more bang for your buck than that.
Surviving A Dirty Bomb AttackTry the following tips from the Department of Homeland Security:
1. A radiation threat or "Dirty Bomb" is the use of common explosives to spread radioactive materials. So there you have it! Step One: Hide behind a radiation shield, which you no doubt have lying around the house.  Step Three: Stay glued to your TV.
Your tax dollars at work!
|


Nice to meet!
Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Thomas Rhythm
Art director
Nice to meet!
Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Steave andres
Musician
Nice to meet!
Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Johan smith
photographer
Nice to meet!
Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Thomas Rhythm
Art director
Nice to meet!
Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Steave andres
Musician
Nice to meet!
Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Johan smith
photographer


Preparation time
overnight
Cooking time
10 to 30 mins
Serves
Serves 2
Lightly spiced, creamy mussel sauce and braised cabbage served with shellfish in this starter for two.
Preheat the oven to 80C/80C Fan/Gas ¼. Lay the herbs in a single layer on a baking sheet and cook for 1 hour or until dry. Once dried, blend to a fine powder, and place in a flour duster.
To cook the shellfish, wash the mussels and remove any beards. Wash the cockles. Discard any open shellfish that do not close when given a sharp tap.
In a hot pan add the olive oil and cook the garlic for 1 minute. Add the rest of the ingredients and the cockles and mussels. Cover with a lid.
Cook for 2 minutes, or until the cockles and mussels have opened. Discard any that do not open.
Pour through a colander lined with a muslin cloth into a clean pan. Keep the liquid to make the sauce. Pick out the shellfish. Chop 10g of the largest mussels for the mussel butter. Set aside the remaining shellfish.
For the mussel butter, mix all the ingredients in a bowl with the 10g of chopped mussels.
For the mussel sauce, in a saucepan, heat the shellfish cooking liquid until reduced to 50ml. Add the crème fraîche and lime juice. Add almost all the mussel butter, keeping back a tablespoon for the cabbage. Blend the sauce with a stick blender. Stir in the chives and chervil.
For the cabbage, preheat the oven to 200C/180C Fan/Gas 6. Cut the cabbage into 8 wedges. Heat the chicken fat in an ovenproof, non-stick frying pan until hot. Fry the cabbage until coloured. Roast in the oven for 5–7 minutes.
Remove from the oven and baste with a spoonful of mussel butter, until golden. Season with lemon juice and salt.
To serve, place the cabbage in the middle of the plate. Reheat the shellfish in a little sauce, and spoon them over the cabbage. Pour over the remaining sauce and dust with the green powder.


Next: Right-Parenthesis, Previous: Standard Macro Characters, Up: Standard Macro Characters
The left-parenthesis initiates reading of a list. read is called recursively to read successive objects until a right parenthesis is found in the input stream. A list of the objects read is returned. Thus
(a b c)
is read as a list of three objects (the symbols a, b, and c). The right parenthesis need not immediately follow the printed representation of the last object; whitespace_2 characters and comments may precede it.
If no objects precede the right parenthesis, it reads as a list of zero objects (the empty list).
If a token that is just a dot not immediately preceded by an escape character is read after some object then exactly one more object must follow the dot, possibly preceded or followed by whitespace_2 or a comment, followed by the right parenthesis:
(a b c . d)
This means that the cdr of the last cons in the list is not nil, but rather the object whose representation followed the dot. The above example might have been the result of evaluating
(cons 'a (cons 'b (cons 'c 'd)))
Similarly,
(cons 'this-one 'that-one) ⇒ (this-one . that-one)
It is permissible for the object following the dot to be a list:
(a b c d . (e f . (g))) ≡ (a b c d e f g)
For information on how the Lisp printer prints lists and conses, see Printing Lists and Conses.


Blog
Projects
Resume
About Me
Contact
Blog Index
Week 1
A recap of the main takeaways from my first week at DBC
Week 2


Bill details
(Back to list)
Bill Form
| Id |
Id |
| Date |
Date> |
| Registration |
Registration
|
| Client |
Client
|
| Employee |
Employee
|
| VAT |
VAT |
| Payment Type |
paymentType |
| Discount ( % ) |
Discount |
| Total |
Total |
| Comments |
Comments |
| Status |
Comments |
Tasks
| Name |
Description |
Estimated time ( H ) |
Price |
Total |
| name |
description |
estimatedTime |
Price per hour |
Price |
|
|
|
|
Total Tasks |
Pieces
| PieceType |
Name |
Price |
Total |
| category |
name |
Price |
Total |
|
|
|
Total
Pieces
|
Total
| Total tasks |
category |
| Total pieces |
totalPieces
|
| Total brut |
Total_Brut
|
| Discount ( % ) |
Discount |
| VAT ( % ) |
vat |
| Total |
Total
|


Different Types of Amplitude Exams
-
The Common Admission Test is a computer based test held in India. The Indian Institutes of Management (IIMs) started this exam and use the test for selecting students for their business administration programs.
-
The Graduate Record Examinations (GRE) is a standardized test that is an admissions requirement for most Graduate Schools in foriegn countries.
-
The difficulty level of exam vary from company to company.The test scores a candidate on the bases of Quantitative Ability (QA), Verbal Ability (VA) and Reading Comprehension (RC), Data Interpretation (DI) and Logical Reasoning (LR).
To get updated and to compete with whole world stay tunned and connected with us.


Salary Calculator
First name:
Last name:
ID Number:
Job Title:
Annual Salary:
Submit
Monthly Total Cost:
Total Annual Salary Cost:
First Name
Last Name
ID Number
Job Title
Annual Salary
Monthly Cost
Delete


module Sync:sig
..end
Synchronized execution queue.
Any action can be pushed to this FIFO queue, in order to be executed by Bogue's main loop at the start of the next graphical frame.
For any action that is not super urgent, it is a good idea to use this `Sync` module, instead of launching the action directly from a thread that may be difficult to control. In this way, we ensure that the action is not executed in the middle of rendering the graphics, or between various modifications of the board (events, keyboard focus, etc.).
val push : (unit -> unit) -> unit
push action
registers the action
to be executed by the mainloop at the
start of the next frame, or at a subsequent frame if the queue is already
large.
Warning: the action should not call Sync.push
itself, otherwise this will
result in a deadlock.


{% extends "base_neighbor.html" %} {% load bootstrap5 %} {% block content %}
Neighborhood Location: {{neighborhood.location}}
Occupants Population: {{neighborhood.population}}
Police Telephone no: {{neighborhood.police_contact}}
Hospital Telephone no: {{neighborhood.hospital_contact}}
{{business.description}}
Owner: {{business.user.profile.first_name}} {{business.user.profile.last_name}}
Email Address: {{business.email}}
{{post.post}}
Posted by {{post.user.profile.first_name}} {{business.user.profile.last_name}} on {{post.created_at|date}}
Last updated on {{post.updated_at}}
See neighbors 👇


Date Box
Overview
Dark Theme
Light Theme
Date
Time
Date and time
Date picker
Disabled
Custom format
Event Handling
Set Birthday
Your age is


Special Admin Theme for small and medium webapp with very clean and aesthetic style and feel.
404
Page Not Found
Sorry, but the page you are looking for has not been found. Try checking the URL for error, then hit the refresh button on your browser or try found something else in our app


Your personal travel guide Excursion remembers places you like, and recommends new points of interest around you. Coming Soon for iPhone and Android Download Excursion (Coming Soon!)


Home
About
The Ultimate Question of Life, the Universe, and Everything
This page will be ready soon!
Good bye, and thank's for all the fish!


Preston North End fans’ panel: A day to forget at Derby County says Tim Mercer
Against a backdrop of rising expectation, this very disappointing trip into Derbyshire, was writ-large on the faces of my fellow fans by time the referee blew the final whistle.
The first half in particular was one to forget, as the tactic of using Jayden Stockley as a target man failed miserably and resulted in North End unable to either gain any kind of foothold or establish a pattern of play.
In fact, the only real surprise was that we made it to the break just one goal down and can probably thank Declan Rudd for at least two fine stops to keep it that way.
At least Alex Neil decided to do something about it during half-time, with Stockley and Darnell Fisher making way for Paul Gallagher and Billy Bodin.
The effect was immediate, with the visitors finally putting their hosts under some sustained pressure as passes and possession improved and gave us some hope.
Alas it was not enough, as Derby coped quite comfortably with our final ball and consequential lack of a real cutting edge.
And whilst we did get the ball in the net following a decently delivered corner, Tom Barkhuizen was clearly offside as he turned it over the line from a couple of yards out in a way that neatly summed up Preston’s overall performance in a match we will quickly want to forget.


---
layout: page
parent: Design
title: 3D Printer Station
permalink: /design/cnc-station/
gh_link: "design/pages/cnc-station.html"
---
Back
Usage
This station will contain a CNC, which is embedded into the table.
Design
Isometric View
Left View
Right View
Top View
Front View
Special Notes
- Need to purchase the materials (except the spindle) required to build the CNC
- Need a precious design of the CNC machine after the parts and the dimension confirmed
- There need to have a small Desktop Computer or a Laptop to control the CNC machine
- Need to design a small container to keep the tools and accessories of the CNC


{% load staticfiles %}
Expedited Shipping Availible
Enjoy the Security of Paypal
From the Day Recieved
Click for Full Return Policy
Recieve a Response in 1 Day
Subscribe to our newsletter and get 20% off your first purchase


Enter your Name:
Hello !
List of Countries with locale:
| Enter first name: | |||||
| Enter last name: | |||||
| Name: | {{student.fullName()}} | ||||
| Subject: |
|
| Name | Roll No | Percentage |
|---|---|---|
| {{ student.Name }} | {{ student.RollNo }} | {{ student.Percentage }} |


Toast
Simple Toast
A simple Toast
Toggle Toast Triggered: {{ testOpen }}
Message in a toast
Toast with timeout
A toast with a 5 seconds timeout.
Toggle Toast
This toast lasts 5 seconds (fast)
Automatic Toast
A toast without :open will be triggered instantly.
This toast is automatic
Toast in all positions
Multiple positions are available: top-right, top-center, top-left, bottom-left, bottom-center, bottom-right
Toggle Toast
This toast has position: top right
This toast has position: top center
This toast has position: top left
This toast has position: bottom left
This toast has position: bottom center
This toast has position: bottom right
Toast with offsets
Toast have a offset Prop that can be used to stack multiple toasts.
Toggle Toast
First message
Second message
Third message
Toast with a custom action
Toast can be passed an action-label and they emit a action-button event.
Toggle Toast
Toast with an action
Toast without an icon
Icons are present by default, but you can remove them.
Toggle Toast
Toast without icône
Toast with multiple options
Multiple toasts, in multiple location, some are in errors.
Toggle Toast
Les 3 informations en rouge sont à revoir pour continuer. On pourrait même mettre un texte plus long
Give him a friend, we forget the trees get lonely too. We'll do another happy little painting. Absolutely no pressure.


When an application instance (process) starts, the group-membership subsystem is started as a go-routine within the application.
The group-membership service communicates between processes via web-sockets connections. Each process accepts group-membership messages on the address:port specified by the ‘internal_address’ key in the application configuration file. This port is not secured, and the group-membership messages are not encrypted in any way. It is advisable that the address:port used here is not accessible to the outside world.
Due to the round-robin-every-process-pings-every-other-process model used by the failure detector, the group-membership service can be rather busy.
In order to participate in a group, each starting process needs to know who the current group-leader is. Group-leadership is determined internally via the failure-detector and a bully-type leader-election. Each process knows who the current group-leader is at any given time. If a failure of the group-leader is detected, an election is held whereby the process with the highest process-id (PID) assumes leadership of the group.
Assertion of leadership is disseminated to all group-members by the new leader via the COORDINATOR message. This takes care of the current group-members, but processes wishing to join the group must have a way to determine who the current group-leader is.
Joining processes must access a well-known persistent store that holds the current group-leader information. This means that each joining process must know the location of, and the manner in which the persistent store can be queried. The persistent store exists outside of the group-membership and is typically some sort of name-value key-store like redis or memcached.
To this end, the .xxx.config.json file offers the option of running the application in stand-alone mode (self==leader), or with redis, memcached or sluggo as KVS repositories for the group-leader information.
A general interface is provided by Jiffy to allow the implementing developer to add support for the persistent store of their choice. Enhancement points have not been added for the “custom_kvs_impl” key yet, but it should be quite easy to insert the required code. The rationale here is that many implementers will have a preference in terms of the key-value store they use, and may already have a suitable KVS in their productive landscape. The interface provided by Jiffy for this purpose is gmcom.GMLeaderSetterGetter and it must be implemented in the appobj/lead_set_get.go file.
Interface gmcom.GMGetterSetter contains methods to facilitate read/write access to the one-and-only persisted leader record in any key-value-store. Applications implementing the interface may choose to store the persisted current leader in a number of mediums; flat-file, db table record, redis, memcached etc.
Interface gmcom.GMGetterSetter |
GetDBLeader() (*GMLeader, error)GetDBLeader is provided in order to allow the implementer to retrieve the current group-leader information from the persistent store. The implementation of this method is intended to be self-contained.For example, if the implementation calls for the current leader information to be persisted in redis, the implementer should code a self-contained method to connect to redis, retrieve the leader information and return it in the GMLeader pointer. Failure to read a current leader from the persistent store should result in the return of a nil in place of the *GMLeader pointer and a non-nil error value.
|
SetDBLeader(l GMLeader) errorSetDBLeader is provided in order to allow the implementer to persist a newly elected leader's information in the persistent store. The implementation of this method is intended to be self-contained.For example, if the implementation calls for the current leader information to be persisted in redis, the implementer should code a self-contained method to connect to redis and store the leader information provided by input parameter *l*. Failure to persist the provided leader information should result in the implementer returning a non-nil value in the *error* return parameter.
|
Cleanup() errorCleanup is provided in order to allow the implementer to cleanup connection pools, open and/or busy connections before the hosting application shuts down in response to a SIGKILL, os.Interrupt or SIGINT event. If the implementation does not require any cleanup, this method can be implemented to simply return nil. |
// LeadSetGet provides a sample implementation of the GMLeaderSetterGetter
// interface in order to support persistence of the current group-leader
// information. re-implement these methods as you see fit to facilitate
// storage and retrieval of the leader information to and from the persistent
// storage. This example uses a quick and dirty web-socket-based cache to
// handle the persistence. It works well enough for testing, but you should
// use something more robust like a database, redis etc. The methods in the
// GMLeaderSetterGetter interface are called when a new process is attempting
// to join the group and also when a new leader is selected via the coordinator
// process.
//
// To test with the delivered interface implementation, install and run sluggo:
// go get -u github.com/1414C/sluggo
//
// Execute sluggo from the command-line as follows:
// go run main.go -a <ipaddress:port>
// For example:
// $ go run main.go -a <IP_ADDRESS>:7070
//
type LeadSetGet struct {
gmcom.GMLeaderSetterGetter
}
// GetDBLeader retrieves the current leader information from
// the persistence layer.
func (sg *LeadSetGet) GetDBLeader() (*gmcom.GMLeader, error) {
// access the database here to read the current leader
l := &gmcom.GMLeader{}
wscl.GetCacheEntry("LEADER", l, "<IP_ADDRESS>:7070")
return l, nil
}
// SetDBLeader stores the current leader information in the
// persistence layer.
func (sg *LeadSetGet) SetDBLeader(l gmcom.GMLeader) error {
// access the database here to set a new current leader
wscl.AddUpdCacheEntry("LEADER", &l, "<IP_ADDRESS>:7070")
return nil
}
// Cleanup closes connections to group-leadership KVS when
// prior to application shutdown.
func (sg *LeadSetGet) Cleanup() error {
// perform cleanup(s)
return nil
}
When the application starts in group-membership mode, the process must determine who the group-leader is as described in the preceding sections. The process tries to join an existing group four times before giving up, and within each join attempt the process tries to read the current leader PID from the persistent store three times.
When the starting process is able to read the PID and IP Address:port of the current group-leader from the persistent store, it proceeds to the next step where an attempt to contact the leader is made.
If the starting process is unable to read the leader information from the persistent store, the process waits for a randomized period of between 1 and 1000 ms. Once the wait is over, the process tries to read the current leader from the persistent store again. This loop will be repeated up to four times before the process gives up and attempts to assume the role of group-leader itself.
A distinction is not currently made between being unable to contact the persistent store and not finding a current leader after reading the persistent store.
Once a starting process has obtained a set of group-leader information from the persistent store that looks valid, it uses the information to send a Join message to the group-leader. There are a few possible outcomes to the sending of the Join message:
The group-leader accepts the Join message. When the group-leader accepts the Join message from the starting process it checks for problems as outlined below. If all goes well, the group-leader will return an Ack message containing a PID for use by the starting process. At this point, the starting process will initialize it’s failure detector loop and start participating in the group.
The group-leader could not be contacted. In this case, the starting process waits for a randomized period of time between 1 and 1000ms, then loops back to read the group-leader information from the persistent store again in hope that it has been updated. This can occur up to four times, after which the starting process will attempt to become the group-leader.
The group-leader information read from the persistent store was not correct. It is possible that the leader information in the persistent store is stale during a cold-startup. In this case, although a process was reachable at the group-leader’s ip-address:port, the so-called group-leader process was not in fact the leader. The starting process will wait for a randomized period of time between 1 and 1000ms, then loop back to read the group-leader information from the persistent store again in hope that it has been updated. This can occur up to four times, after which the starting process will report an error and gracefully exit.
A group-leader was found but has the current PID’s ip-address. It is possible that the starting PID’s address matches that of the group-leader that was read from the persistent store. This can happen in scenarios where the group-leader is the last process standing and then terminates without warning.
The persistent store retains the last group-leader information (Pi) resulting in a successful leader-ping if the first process to restart in the group happens to hold the same ip-address as that of the old group-leader. A successful ping (Pi->Pi) looks like there is a functioning group-leader.
If the joining process sees it’s own ip-address in the group-leader slot within the persistent store, it is best to act like there is no current group-leader and wipe the read (leader) information clean. This will repeat four times as described above, then the current PID will attempt to assert itself as group-leader. The randomized time is used to offset potentially simultaneous multiple group-leadership assertions in mass cold-start situations.
It is important to remember/know that a starting process does not start participating in the group failure-detector until it has either joined an existing group, or has become the leader thereby starting a new group.
The leader reports that the ip-address:port of the starting process is already in use within the group.
This can occur due to a misconfigured failure threshold value (too high), or when a process is killed and restarted immediately. In this case, the starting process waits 5 seconds and then loops back to read the group-leader information and make another attempt to join the group. This can occur up to four times, after which the starting process will report an error and gracefully exit.
An unknown error occurs. This is a catch-all for failed join attempts. In this case, the starting process waits 5 seconds and then loops back to read the group-leader information and make another attempt to join the group. This can occur up to four times, after which the starting process will report an error and gracefully exit.
If a valid group-leader has not been found after four attempts, the starting process attempts to become the group-leader. The starting process will:


Connect tutors and students with concurrent network sessions, each consisting of
an instant messaging system and a sequence of virtual blackboards and embedded
web browsers that are synchronized in real time across the network.
Users can play video or audio files with a built-in multimedia player and take notes
that get “bookmarked” along the progress bar.


{% extends "base.html" %} {% block center_content %}
Welcome to my personal site. I made this mainly to have a centralized location for my intro to programming content. The content in the level 1 class is aimed at someone completely new to programming. If you've programmed before (especially in a formal setting such as a college classroom), you will likely find that it is all review.
With that said, I've tried to aim the content in the level 2 class towards some features that may not have been covered in a first semester college class. I take requests to cover new content, but usually the lessons are aimed at someone who is in a non-technical role but wishes to learn some new library to help them in their position.
For example, most people don't need to understand algorithmic complexity or computer architecture if they're in a role where they just need to do some occasional data analysis. For them, learning the basics of pandas
and matplotlib
is all they really want.
My goal with the programmer beginner series is to take someone who has never programmed before, and after 2-3 months, put them in a position where they can write basic programs either for fun or to make some aspect of their job easier.
If you're intererested in the course content, take a look at the level 1 foreword. All of the content is available for free, however, if you create an account on this site, you will also have the opportunity to ask questions on lessons or submit new posts/comments on the fourm.
{% endblock %}


THE GLASS MENAGERIE
February 26-27-28 & March 1, 2015
Director - Sam Buchanan
Stage Manager - Logan Prince
Asst. Stage Manager - Taylor Bynum
THE CAST
Tom Wingfield - Brian Doyle
Jim O'Connor - Tim Flanagan
Laura Wingfield - Laura Cooley
Amanda Wingfield - Catherine Nowicki


| Total net profit | -49.77 | Gross profit | 115.7 | Gross loss | -165.47 |
| Profit factor | 0.7 | Expected payoff | -0.27 | ||
| Absolute drawdown | -55.91 | Maximal drawdown (%) | 57.23 (4335.61%) | ||
| Total trades | 185 | Profit trades (% of total) | 87 (47.03%) | Loss trades (% of total) | 98 (52.97%) |
| Long positions (won %) | 84 (54.76%) | Short positions (won %) | 101 (40.59%) | ||
| Largest | profit trade | 3.68 | loss trade | -4.56 | |
| Average | profit trade | 1.33 | loss trade | -1.69 | |
| Minimum | profit trade | 0.0 | loss trade | -0.37 | |
| Maximum | take profit in pips | 39.6 | stop loss in pips | -34.1 | |
| Average | take profit in pips | 10.4 | stop loss in pips | -14.2 | |
| Minimum | take profit in pips | -2.9 | stop loss in pips | -3.7 | |
| Maximum | Reward-Risk | 4.6 | Duration in minutes | 3880 | |
| Average | Reward-Risk | 0.9 | Duration in minutes | 216.9 | |
| Minimum | Reward-Risk | 0.0 | Duration in minutes | 0 | |
| Maximum | consecutive wins (profit in money) | 4.0 (5.06) | consecutive losses (loss in money) | 8.0 (-11.6) | |
| Average | consecutive wins | 1.0 | consecutive losses | 1.0 |
| Total net profit | -21.8 | Gross profit | 57.58 | Gross loss | -79.38 |
| Profit factor | 0.73 | Expected payoff | -0.26 | ||
| Absolute drawdown | -28.63 | Maximal drawdown (%) | 26.12 (-1040.64%) | ||
| Total trades | 84 | Profit trades (% of total) | 46 (54.76%) | Loss trades (% of total) | 38 (46.43%) |
| Largest | profit trade | 3.68 | loss trade | -4.56 | |
| Average | profit trade | 1.25 | loss trade | -2.09 | |
| Minimum | profit trade | 0.0 | loss trade | -0.57 | |
| Maximum | take profit in pips | 39.6 | stop loss in pips | -34.1 | |
| Average | take profit in pips | 10.5 | stop loss in pips | -15.8 | |
| Minimum | take profit in pips | 0.0 | stop loss in pips | -4.3 | |
| Maximum | Reward-Risk | 2.8 | Duration in minutes | 3299.0 | |
| Average | Reward-Risk | 0.8 | Duration in minutes | 257.2 | |
| Minimum | Reward-Risk | 0.0 | Duration in minutes | 2.0 | |
| Maximum | consecutive wins (profit in money) | 6.0 (5.89) | consecutive losses (loss in money) | 5.0 (-14.12) | |
| Average | consecutive wins | 1.0 | consecutive losses | 1.0 |
| Total net profit | -27.97 | Gross profit | 58.12 | Gross loss | -86.09 |
| Profit factor | 0.68 | Expected payoff | -0.28 | ||
| Absolute drawdown | -31.15 | Maximal drawdown (%) | 35.38 (836.41%) | ||
| Total trades | 101 | Profit trades (% of total) | 41 (40.59%) | Loss trades (% of total) | 60 (59.41%) |
| Largest | profit trade | 2.62 | loss trade | -3.97 | |
| Average | profit trade | 1.42 | loss trade | -1.43 | |
| Minimum | profit trade | 0.5 | loss trade | -0.37 | |
| Maximum | take profit in pips | 20.1 | stop loss in pips | -30.0 | |
| Average | take profit in pips | 10.3 | stop loss in pips | -12.9 | |
| Minimum | take profit in pips | -2.9 | stop loss in pips | -3.7 | |
| Maximum | Reward-Risk | 4.6 | Duration in minutes | 3880.0 | |
| Average | Reward-Risk | 1.0 | Duration in minutes | 183.3 | |
| Minimum | Reward-Risk | Duration in minutes | 0.0 | ||
| Maximum | consecutive wins (profit in money) | 4.0 (4.23) | consecutive losses (loss in money) | 8.0 (-11.6) | |
| Average | consecutive wins | 1.0 | consecutive losses | 2.0 |


Put your UI code here... or don't, I can't tell you what to do
Note - If the map isn't working check the API key in the script tag above.
Google DSC - McMaster


Here is an (anonymous) review on Amazon of Mr Key's Shorter Potted Brief, Brief Lives:
This is a near-perfect example of a gift book that keeps on giving. Small and appealing, with a well-organised, encyclopaedia-style layout and charming portrait illustrations. The text is a delight—easy to dip in and out of, and full of facts that are perplexing, bizarre, amusing and sometimes poignant. What really sets it apart, however, is Frank Key's unerring eye for the deliciously obscure and his unique sense of humour, which runs like a seam of precious metal through the book. An unexpected treasure.
I need hardly remind you lot that you are under instructions to buy copies of the book for everybody you know. While you're about it, you should add your ha'ppenyworth to the online reviews at Amazon. You know it makes sense.


I am a strong believer of virtualizing everything. So much that all of my development is done on virtual machines. The power of computers these days makes this experience extremely performant and the tooling around it has matured to a level that simplifies the process greatly.
Up until recently, I have been using a combination of Packer, Vagrant, and Virtualbox to get the job done. Of which has produced an experience in which I have next to no complaints about.
So why am I switching to Hyper-V? Well, plain and simple, I am Windows developer. Meaning, I do all my development work on a Windows machine. Of which, without Hyper-V installed, I would not be able to do the following.
Seeing that running Hyper-V side-by-side with Virtualbox or VMWare is impossible to do with any sense of sanity, I said goodbye to VirtualBox and hello to Hyper-V. Following I will outline the process I used to create a Hyper-V Windows 10 Vagrant Box.
For more info on how I create my Windows development environment, be sure to visit Creating a Windows Development Environment With Packer, Vagrant & Chocolatey.
To start, we need to install Hyper-V.
At this point, you will be informed that a reboot will take place. Once rebooted, Hyper-V will be installed and ready to do.
On to the fun stuff, building our actual Hyper-V Box of Windows 10. Normally I would use Packer to automate this entire process. This time I decided to not follow suit and instead build it manually. For one, I wanted to use this as a learning experience to understand what actually makes up a Box. In addition, official Hyper-V support with Packer is very new. Meaning, documentation and relevant examples are sparse.
That being said, I trust that once you actually go through the process of building a Box manually once, you will quickly realize much like myself that it is as simple as can be.
The first thing we need to do is create a virtual switch in which we can use to connect our VM to the internet.
Once your Virtual Switch has been created, you can start the process of installing creating a Windows 10 VM.
Once you have a fully functional Window 10 VM inside your instance of Hyper-V, you now have to prepare the VM to be exported as a Vagrant Box. There are few goals we want to keep in mind as we go through this process.
Setting up your VM to be able to communicate is pretty straightforward.
winrm quickconfig -q winrm set winrm/config/winrs @{MaxMemoryPerShellMB="512"} winrm set winrm/config @{MaxTimeoutms="1800000"} winrm set winrm/config/service @{AllowUnencrypted="true"} winrm set winrm/config/service/auth @{Basic="true"} sc config WinRM start= auto
This is highly dependent on the goals you have for your Box. Personally, I take the following approach.
The last few steps we need to take will allow us to package our Box in a manner that will produce the smallest footprint possible.
choco install sdelete
sdelete.exe -z c
Now that we have configured and created our VM, we can move to building our actual Vagrant Box.
Right-click your VM in the Hyper-V manager and select "Export".
Specify a location and hit export.
The Export process will take a couple of minutes and once done, you will end up with a folder structure like so.
Delete the "Snapshots" folder and add a metadata.json file.
The metadata.json is used by Vagrant to understand what your box is made up of. Open your new metadata.json file and add the following to get started with.
{ "provider": "hyperv" }
This basic configuration will be enough to build a functioning Box but if you are interested in what else can be added, you can check out the official Box File Format documentation.
A Box File is a compressed file of the type tar, tar.gz, or zip. Out of the three options, a tar.gz will often produce the best compression rate.
To start the process, ensure you have 7Zip installed. Again, you can download it directly from the 7Zip site or install it with Chocolatey.
choco install 7zip.install
Once installed, create a tar file with 7zip.
This process will take a few minutes. Once complete, gzip your new tar file in 7Zip. Depending on the "Compression level" you choose, the time to completion will vary. For reference, when I ran "Ultra", it was measurable in hours.
Though not needed, once complete, you can strip the tar.gz extension and replace it with .box.
The building of your new Box File is complete. To test it we need to first add your new Box to Vagrant. Open up a command prompt and run the following command.
vagrant box add {name-of-box} {path-to-box.box}
Navigate to your VagarntFile directory and run the following.
vagrant up --provider hyperv
Setting up a VagrantFile is a whole topic in itself. Luckily for you, I have already done the grunt work and provided a fully functioning VagarntFile at Pioneer Code Windows Development Environment.
And that is that. You know should be in the position to create Hyper-V Windows 10 VMs using a pre-configured Box File. If you have any question, be sure to let me know in the comments section below.


Preparation time
over 2 hours
Cooking time
no cooking required
Serves
Makes 550g/1lb puff pastry
Place the flour and salt in a large mixing bowl. Add the lard and use your hands to rub the lard into the flour. As you do this, lift the flour with your hands to get air into the mixture and keep it cool.
When the flour and lard mixture has the consistency of breadcrumbs, add the cold water. Mix it in with a palette knife to keep the mixture cool. When the mixture comes together to form a dough, turn it out onto a clean, floured surface and knead briefly until just smooth.
Form the dough into a rectangular block (this will make it easier to roll out later), wrap in cling film and refrigerate for 30 minutes.
Place the butter between two sheets of greaseproof paper and tap with a rolling pin to form a flattened block about one-third the size of the pastry.
Roll the dough out onto a clean, floured surface into a rectangle about 16cm x 30cm/6in x 12in. Use a palette knife to keep the edges straight and dust the rolling pin and the surface well with flour to prevent sticking.
Visually divide the dough into three sections and mark the sections with a shallow notch at the edge with your thumb. The centre section is the section that will hold the butter, so carefully roll out the centre section with a rolling pin to make the edges slightly wider than those of the other two sections.
Remove the greaseproof paper from the butter (it should be firm room temperature at this stage) and place the butter in the centre of the pastry rectangle. Fold in the edges of the pastry and fold both ends into the centre, to completely enclose the butter. Form the pastry into a neat square.
Turn the pastry a half-turn and carefully roll out again into the same size rectangle as the one you started with. Fold the top and bottom of the rectangle into the centre, folding the pastry into thirds. Repeat the turning, rolling and folding process one more time. Place in the fridge to cool for 30 minutes.
Remove the pastry from the fridge, turn the pastry a half-turn since the previous rolling, roll out and fold once again. Repeat. Rest the pastry in the fridge for another ten minutes the remove it from the fridge and turn, roll and fold it twice more.
The pastry should have been turned, rolled and folded six times. If the pastry is still streaky, repeat the turning, rolling and folding process one more time. The puff pastry is now ready to use.


Teagasc event showcases opportunities for food and drinks producers
by Breifne O'BrienA showcase of research and opportunities for Irish food and beverage producers took place in the Teagasc Food Research Centre, Moorepark, Fermoy, Co. Cork, on Thursday, November 21.
The Teagasc Gateways event titled: ‘Food Biotransformation – Biological Processes for Sustainable and Novel Food Development’ aimed to provide an opportunity for food and beverage producers, to find out about national and international activity in the area.
According to a statement from Teagasc, the event offered attendees the opportunity to engage with experts, see demonstrations of technologies and service platforms available within Teagasc and obtain information on innovative supports from National Development Agencies.
The programme for the Teagasc Gateways event included presentations by national and international experts, including:
- Prof. Lene Lange, retired Technical University of Denmark;
- Dr. Maxine Roman and Dr. Jon Wiese, Kraft Heinz, US;
- Dr. Brian Gibson, VTT Finland;
- Associate Prof. Kostas Gkatzionis, University of Aegean, Greece;
- Parikshit Sawdekar, Glanbia;
- Patrick Barrett from the Department of Agriculture, Food and the Marine covered funding opportunities for research and innovation.
Commenting on the event, Teagasc food researcher Kieran Kilcawley said: ”Food biotransformation is receiving renewed interest because it is seen as a more natural process, more consumer and legislation friendly, can potentially add value to food-waste streams and can offer a more sustainable alternative to other production processes.”
A special edition of the Teagasc Technology Portfolio has been produced that focuses on the capability and expertise in food biotransformation within the Teagasc Food Programme.
The edition describes the current technologies, capabilities, services and expertise available.
A copy of the technology portfolio is available to view here.


The main symptoms of COVID-19 are as follows:
Seek immediate medical attention if you have serious symptoms. Always call before visiting your doctor or health facility.
People with mild symptoms who are otherwise healthy should manage their symptoms at home.
On average it takes 5–6 days from when someone is infected with the virus for symptoms to show, however it can take up to 14 days.


At some point you may run across a data type that is not covered by the packaged adapters. In this case, you will need to write your own.
To do so, you must implement Zend\Paginator\Adapter\AdapterInterface. There are two methods required to do this:
Additionally, you’ll want to implement a constructor that takes your data source as a parameter and stores it as a protected or private property. How you wish to go about doing this specifically is up to you.
If you’ve ever used the SPL interface Countable, you’re familiar with count(). As used with Zend\Paginator, this is the total number of items in the data collection. Additionally, the Zend\Paginator\Paginator instance provides a method countAllItems() that proxies to the adapter count() method.
The getItems() method is only slightly more complicated. For this, your adapter is supplied with an offset and the number of items to display per page. You must return the appropriate slice of data. For an array, that would be:
1 | return array_slice($this->_array, $offset, $itemCountPerPage);
|
Take a look at the packaged adapters (all of which implement the Zend\Paginator\Adapter\AdapterInterface) for ideas of how you might go about implementing your own.
Creating your own scrolling style requires that you implement Zend\Paginator\ScrollingStyle\ScrollingStyleInterface, which defines a single method, getPages(). Specifically,
1 | public function getPages(Zend\Paginator\Paginator $paginator, $pageRange = null);
|
This method should calculate a lower and upper bound for page numbers within the range of so-called “local” pages (that is, pages that are nearby the current page).
Unless it extends another scrolling style (see Zend\Paginator\ScrollingStyle\Elastic for an example), your custom scrolling style will inevitably end with something similar to the following line of code:
1 | return $paginator->getPagesInRange($lowerBound, $upperBound);
|
There’s nothing special about this call; it’s merely a convenience method to check the validity of the lower and upper bound and return an array of the range to the paginator.
When you’re ready to use your new scrolling style, you’ll need to tell Zend\Paginator\Paginator what directory to look in. To do that, do the following:
1 2 | $manager = Zend\Paginator\Paginator::getScrollingStyleManager();
$manager->setInvokableClass('my-style', 'My\Paginator\ScrollingStyle');
|
Zend\Paginator\Paginator can be told to cache the data it has already passed on, preventing the adapter from fetching them each time they are used. To tell paginator to automatically cache the adapter’s data, just pass to its setCache() method a pre-configured cache object implementing the Zend\Cache\Storage\StorageInterface interface.
1 2 3 4 5 6 | $cache = StorageFactory::adapterFactory('filesystem', array(
'cache_dir' => '/tmp',
'ttl' => 3600,
'plugins' => array( 'serializer' ),
));
Zend\Paginator\Paginator::setCache($cache);
|
As long as Zend\Paginator\Paginator has been seeded with a cache storage object the data it generates will be cached. Sometimes you would like not to cache data even if you already passed a cache instance. You should then use setCacheEnable() for that.
1 2 3 4 5 | // $cache is a Zend\Cache\Storage\StorageInterface instance
Zend\Paginator\Paginator::setCache($cache);
// ... later on the script
$paginator->setCacheEnable(false);
// cache is now disabled
|
When a cache is set, data are automatically stored in it and pulled out from it. It then can be useful to empty the cache manually. You can get this done by calling clearPageItemCache($pageNumber). If you don’t pass any parameter, the whole cache will be empty. You can optionally pass a parameter representing the page number to empty in the cache:
1 2 3 4 5 6 7 8 9 10 11 12 13 | // $cache is a Zend\Cache\Storage\StorageInterface instance
Zend\Paginator\Paginator::setCache($cache);
// $paginator is a fully configured Zend\Paginator\Paginator instance
$items = $paginator->getCurrentItems();
// page 1 is now in cache
$page3Items = $paginator->getItemsByPage(3);
// page 3 is now in cache
// clear the cache of the results for page 3
$paginator->clearPageItemCache(3);
// clear all the cache data
$paginator->clearPageItemCache();
|
Changing the item count per page will empty the whole cache as it would have become invalid:
1 2 3 4 5 6 7 8 | // $cache is a Zend\Cache\Storage\StorageInterface instance
Zend\Paginator\Paginator::setCache($cache);
// fetch some items
// $paginator is a fully configured Zend\Paginator\Paginator instance
$items = $paginator->getCurrentItems();
// all the cache data will be flushed:
$paginator->setItemCountPerPage(2);
|
It is also possible to see the data in cache and ask for them directly. getPageItemCache() can be used for that:
1 2 3 4 5 6 7 8 9 10 | // $cache is a Zend\Cache\Storage\StorageInterface instance
Zend\Paginator\Paginator::setCache($cache);
// $paginator is a fully configured Zend\Paginator\Paginator instance
$paginator->setItemCountPerPage(3);
// fetch some items
$items = $paginator->getCurrentItems();
$otherItems = $paginator->getItemsPerPage(4);
// see the cached items as a two-dimension array:
var_dump($paginator->getPageItemCache());
|
The source code of this file is hosted on GitHub. Everyone can update and fix errors in this document with few clicks - no downloads needed.


-First, type in your email then password (It has to be a Gmail account otherwise it won't work)
-Second, type in your subjects email and name (The email doesn't have to be a Gmail it can be anything...)
-Last but not least, write your message and click the send button.


ITS::WICS::Project - Manage WICS project folder
use ITS::WICS::Project qw(update_project); my $dir = 'path/to/project/folder'; update_project($dir); # $dir now contains latest JS and CSS code for dynamic ITS display
This simple module keeps a WICS project folder up-to-date. A WICS project folder is simply one which contains the JavaScript and CSS files for dynamically displaying ITS in HTML files that link to it.
update_project
Given a path to a project directory, check if its .WICS directory contains viewer code newer than the version used by this distribution, and if it does not then update the code contained inside by copying over it with the current version.
Returns false if the directory contained a newer WICS viewer code, and true otherwise.
link_doc
Given an input HTML ITS::DOM object, add the required header elements to link the document with the WICS viewer code located in a project. Assumes that the HTML document will be located in a project folder.
code_links
Returns a list of elements that must be placed in a project document <head> element in order to link to the WICS viewer and enable ITS viewing in a browser.
Nathan Glenn<EMAIL_ADDRESS>This software is Copyright (c) 2013 by DFKI.
This is free software, licensed under:
The MIT (X11) License


Credits
Copyright (c) 2013-2016, Sven Ackermann
Licensed under the BSD license.
Wiki
Changelog
on GitHub
features
improvements
bugfixes
versions


Version 1.0 • Data updated 11/21/2012 © 2012 County of Frederick, VA Frederick County IT • Frederick County GIS • Mapbook on GitHub


This package allows you to install PROD_NAME VERSION.
Explanation of destination options:
/Applications
~/Applications
If you already have another Thonny version in the destination location, it will be replaced.
Note that the installer always asks for admin password, even if you choose "for me only", although the installation process doesn't do anything needing admin rights in this case. If you know how to make it ask admin password only when "for all users" is selected, then please let us know!
For uninstallation just move Thonny to Bin.
More information:


|
MLIB
|
Go to the source code of this file.
Classes | |
| class | mlib::sock |
| Encapsulation of a Windows socket. More... | |
| class | mlib::sockbuf |
| Provide functions required by streambuf interface using an underlying socket. More... | |
| class | mlib::generic_sockstream< strm > |
| struct | mlib::sock_initializer |
| Keeps an instance counter for calls to WSAStartup/WSACleanup. | |
| class | mlib::sock_facility |
| Router for socket errors. More... | |
Macros | |
| #define | _S_ALLOCBUF 0x0002 |
| locally allocated buffer | |
| #define | _S_NO_READS 0x0004 |
| write only flag | |
| #define | _S_NO_WRITES 0x0008 |
| read only flag | |
| #define | _S_EOF_SEEN 0x0010 |
| read eof condition | |
Typedefs | |
| typedef generic_sockstream< std::istream > | mlib::isockstream |
| Input socket stream. | |
| typedef generic_sockstream< std::ostream > | mlib::osockstream |
| Output socket stream. | |
| typedef generic_sockstream< std::iostream > | mlib::sockstream |
| Bidirectional socket stream. | |
| typedef generic_sockstream< std::istream > | mlib::isockstream |
| Input socket stream. | |
| typedef generic_sockstream< std::ostream > | mlib::osockstream |
| Output socket stream. | |
| typedef generic_sockstream< std::iostream > | mlib::sockstream |
| Bidirectional socket stream. | |
Variables | |
| errfac * | mlib::sockerrors |
| Error facility used by all sock derived classes. More... | |
sock and sockstream classes
Copyright (c) 2001-2019 Mircea Neacsu
| errfac * mlib::sockerrors |
Pointer to error handler.


Be inspired by like minded women wearing the #THELABEL
Use the hashtag #myhashtag on Instagram for a chance to be featured on
our gallery
{% for post in InstagramSection.posts.all %}
{% with slide_no=0 %}
{% if post.products %}
{}
{% endif %}
{% endwith %}
{% endfor %}


Here are a few larger examples, with complete source code. One of our earlier examples is generated in an instructive way using a for loop:
.PS
# Draw a demonstration up left arrow with grid box overlay
define gridarrow
{
move right 0.1
[
{arrow up left $1;}
box wid 0.5 ht 0.5 dotted with .nw at last arrow .end;
for i = 2 to ($1 / 0.5) do
{
box wid 0.5 ht 0.5 dotted with .sw at last box .se;
}
move down from last arrow .center;
[
sprintf("\fBarrow up left %g\fP", $1)
]
]
move right 0.1 from last [] .e;
}
gridarrow(0.5);
gridarrow(1);
gridarrow(1.5);
gridarrow(2);
undef gridarrow
.PE
Figure 20-1: Diagonal arrows (dotted boxes show the implied 0.5-inch grid)
Here’s an example concocted to demonstrate layout of a large, multiple-part pattern:
.PS
define filter {box ht 0.25 rad 0.125}
lineht = 0.25;
Top: [
right;
box "\fBms\fR" "sources";
move;
box "\fBHTML\fR" "sources";
move;
box "\fBlinuxdoc-sgml\fP" "sources" wid
1.5;
move;
box "\fBTexinfo\fP"
"sources";
line
down from 1st box .s lineht;
A: line down;
line down from 2nd box .s; filter "\fBhtml2ms\fP";
B: line down;
line down from 3rd box .s; filter "\fBformat\fP";
C: line down;
line down from 4th box .s; filter
"\fBtexi2roff\fP";
D: line down;
]
move down 1 from last [] .s;
Anchor: box wid 1 ht 0.75 "\fBms\fR"
"intermediate" "form";
arrow from Top.A.end to Anchor.nw;
arrow from Top.B.end to 1/3 of the way between Anchor.nw and
Anchor.ne;
arrow from Top.C.end to 2/3 of the way between Anchor.nw and
Anchor.ne;
arrow from Top.D.end to Anchor.ne
{
# PostScript column
move to Anchor .sw;
line down left then down ->;
filter "\fBpic\fP";
arrow;
filter "\fBeqn\fP";
arrow;
filter "\fBtbl\fP";
arrow;
filter "\fBgroff\fP";
arrow;
box "PostScript";
#
HTML column
move to Anchor .se;
line down right then down ->;
A: filter dotted "\fBpic2img\fP";
arrow;
B: filter dotted "\fBeqn2html\fP";
arrow;
C: filter dotted "\fBtbl2html\fP";
arrow;
filter "\fBms2html\fP";
arrow;
box "HTML";
#
Nonexistence caption
box dashed wid 1 at B + (2,0) "These tools"
"don’t yet exist";
line chop 0 chop 0.1 dashed from last box .nw to A.e ->;
line chop 0 chop 0.1 dashed from last box .w to B.e ->;
line chop 0 chop 0.1 dashed from last box .sw to C.e ->;
}
.PE
Figure 20-2: Hypothetical production flow for dual-mode publishing
Figure 20-3: Three-dimensional Boxes
Here the source code for figure 20-3:
.PS
# a three-dimensional block
#
# tblock(<width>, <height>,
<text>)
define
tblock { [
box ht $2 wid $1 \
color "gold" outlined "black" \
xslanted 0 yslanted 0 \
$3;
box ht .1 wid $1 \
color "yellow" outlined "black" \
xslanted .1 yslanted 0 \
with .sw at last box .nw;
box ht $2 wid .1 \
color "goldenrod" outlined "black" \
xslanted 0 yslanted .1 \
with .nw at 2nd last box .ne;
] }
tblock(1,
.5, "Master" "1");
move -.1
tblock(.5, 1, "Slave");
.PE


struct::graph - Create and manipulate directed graph objects
A directed graph is a structure containing two collections of elements, called nodes and arcs respectively, together with a relation ("connectivity") that places a general structure upon the nodes and arcs.
Each arc is connected to two nodes, one of which is called the source and the other the target. This imposes a direction upon the arc, which is said to go from the source to the target. It is allowed that source and target of an arc are the same node. Such an arc is called a loop. Whenever a node is either the source or target of an arc both are said to be adjacent. This extends into a relation between nodes, i.e. if two nodes are connected through at least one arc they are said to be adjacent too.
Each node can be the source and target for any number of arcs. The former are called the outgoing arcs of the node, the latter the incoming arcs of the node. The number of arcs in either set is called the in-degree resp. the out-degree of the node.
In addition to maintaining the node and arc relationships, this graph implementation allows any number of named attributes to be associated with the graph itself, and each node or arc.
Note: The major version of the package struct has been changed to version 2.0, due to backward incompatible changes in the API of this module. Please read the section Changes for 2.0 for a full list of all changes, incompatible and otherwise.
Note: A C-implementation of the command can be had from the location http://www.purl.org/NET/schlenker/tcl/cgraph. See also http://wiki.tcl.tk/cgraph. This implementation uses a bit less memory than the tcl version provided here directly, and is faster. Its support is limited to versions of the package before 2.0.
As of version 2.2 of this package a critcl based C implementation is available from here as well. This implementation however requires Tcl 8.4 to run.
The main command of the package is:
The command creates a new graph object with an associated global Tcl command whose name is graphName. This command may be used to invoke various operations on the graph. It has the following general form:
Option and the args determine the exact behavior of the command.
If graphName is not specified a unique name will be generated by the package itself. If a source is specified the new graph will be initialized to it. For the operators =, :=, and as the source argument is interpreted as the name of another graph object, and the assignment operator = will be executed. For the operator deserialize the source is a serialized graph object and deserialize will be executed.
In other words
::struct::graph mygraph = b
is equivalent to
::struct::graph mygraph mygraph = b
and
::struct::graph mygraph deserialize $b
is equivalent to
::struct::graph mygraph mygraph deserialize $b
The following commands are possible for graph objects:
This is the assignment operator for graph objects. It copies the graph contained in the graph object sourcegraph over the graph data in graphName. The old contents of graphName are deleted by this operation.
This operation is in effect equivalent to
graphName deserialize [sourcegraph serialize]
The operation assumes that the sourcegraph provides the method serialize and that this method returns a valid graph serialization.
This is the reverse assignment operator for graph objects. It copies the graph contained in the graph object graphName over the graph data in the object destgraph. The old contents of destgraph are deleted by this operation.
This operation is in effect equivalent to
destgraph deserialize [graphName serialize]
The operation assumes that the destgraph provides the method deserialize and that this method takes a graph serialization.
Appends a value to one of the keyed values associated with the graph. Returns the new value given to the attribute key.
This is the complement to serialize. It replaces the graph data in graphName with the graph described by the serialization value. The old contents of graphName are deleted by this operation.
Destroys the graph, including its storage space and associated command.
Appends a value to one of the keyed values associated with an arc. Returns the new value given to the attribute key.
This method retrieves the value of the attribute named key, for all arcs in the graph (matching the restriction specified via one of the possible options) and having the specified attribute.
The result is a dictionary mapping from arc names to the value of attribute key at that arc. Arcs not having the attribute key, or not passing a specified restriction, are not listed in the result.
The possible restrictions are:
Remove the specified arcs from the graph.
Return true if the specified arc exists in the graph.
Reverses the direction of the named arc, i.e. the source and target nodes of the arc are exchanged with each other.
Returns the value associated with the key key for the arc.
Returns a dictionary (suitable for use with [array set]) for the arc. If the pattern is specified only the attributes whose names match the pattern will be part of the returned dictionary. The pattern is a glob pattern.
Returns a list containing the names of all arcs in the graph which have no weight associated with them.
Returns the weight associated with the arc. Throws an error if the arc has no weight associated with it.
Returns a list of keys for the arc. If the pattern is specified only the attributes whose names match the pattern will be part of the returned list. The pattern is a glob pattern.
Return true if the specified key exists for the arc.
Insert an arc named child into the graph beginning at the node start and ending at the node end. If the name of the new arc is not specified the system will generate a unique name of the form arcx.
Appends a value (as a list) to one of the keyed values associated with an arc. Returns the new value given to the attribute key.
Renames the arc arc to newname. An error is thrown if either the arc does not exist, or a arc with name newname does exist. The result of the command is the new name of the arc.
Set or get one of the keyed values associated with an arc. An arc may have any number of keyed values associated with it. If value is not specified, this command returns the current value assigned to the key; if value is specified, this command assigns that value to the key, and returns that value.
Sets the weight of all arcs without a weight to weight. Returns the empty string as its result. If not present weight defaults to 0.
Sets the weight of the arc to weight. Returns weight.
Removes the weight of the arc, if present. Does nothing otherwise. Returns the empty string.
Determines if the arc has a weight associated with it. The result is a boolean value, True if a weight is defined, and False otherwise.
Return the node the given arc begins at.
Return the node the given arc ends at.
Return the nodes the given arc begins and ends at, as a two-element list.
Changes the source node of the arc to newsource. It can be said that the arc rotates around its target node.
Changes the target node of the arc to newtarget. It can be said that the arc rotates around its source node.
Changes both source and target nodes of the arc to newsource, and newtarget resp.
Remove a keyed value from the arc arc. The method will do nothing if the key does not exist.
Returns a dictionary whose keys are the names of all arcs which have a weight associated with them, and the values are these weights.
Returns a list of arcs in the graph. If no restriction is specified a list containing all arcs is returned. Restrictions can limit the list of returned arcs based on the nodes that are connected by the arc, on the keyed values associated with the arc, or both. A general filter command can be used as well. The restrictions that involve connected nodes take a variable number of nodes as argument, specified after the name of the restriction itself.
The restrictions imposed by either -in, -out, -adj, -inner, or -embedding are applied first. Specifying more than one of them is illegal.
After that the restrictions set via -key (and -value) are applied. Specifying more than one -key (and -value) is illegal. Specifying -value alone, without -key is illegal as well.
Any restriction set through -filter is applied last. Specifying more than one -filter is illegal.
Coming back to the restrictions based on a set of nodes, the command recognizes the following switches:
Return a list of all arcs whose target is one of the nodes in the set of nodes. I.e. it computes the union of all incoming arcs of the nodes in the set.
Return a list of all arcs whose source is one of the nodes in the set of nodes. I.e. it computes the union of all outgoing arcs of the nodes in the set.
Return a list of all arcs adjacent to at least one of the nodes in the set. This is the union of the nodes returned by -in and -out.
Return a list of all arcs which are adjacent to two of the nodes in the set. This is the set of arcs in the subgraph spawned by the specified nodes.
Return a list of all arcs adjacent to exactly one of the nodes in the set. This is the set of arcs connecting the subgraph spawned by the specified nodes to the rest of the graph.
Attention: After the above options any word with a leading dash which is not a valid option is treated as a node name instead of an invalid option to error out on. This condition holds until either a valid option terminates the list of nodes, or the end of the command is reached, whichever comes first.
The remaining filter options are:
Limit the list of arcs that are returned to those arcs that have an associated key key.
This restriction can only be used in combination with -key. It limits the list of arcs that are returned to those arcs whose associated key key has the value value.
Limit the list of arcs that are returned to those arcs that pass the test. The command in cmdprefix is called with two arguments, the name of the graph object, and the name of the arc in question. It is executed in the context of the caller and has to return a boolean value. Arcs for which the command returns false are removed from the result list before it is returned to the caller.
Appends a value (as a list) to one of the keyed values associated with the graph. Returns the new value given to the attribute key.
Appends a value to one of the keyed values associated with an node. Returns the new value given to the attribute key.
This method retrieves the value of the attribute named key, for all nodes in the graph (matching the restriction specified via one of the possible options) and having the specified attribute.
The result is a dictionary mapping from node names to the value of attribute key at that node. Nodes not having the attribute key, or not passing a specified restriction, are not listed in the result.
The possible restrictions are:
Return the number of arcs adjacent to the specified node. If one of the restrictions -in or -out is given only the incoming resp. outgoing arcs are counted.
Remove the specified nodes from the graph. All of the nodes' arcs will be removed as well to prevent unconnected arcs.
Return true if the specified node exists in the graph.
Return the value associated with the key key for the node.
Returns a dictionary (suitable for use with [array set]) for the node. If the pattern is specified only the attributes whose names match the pattern will be part of the returned dictionary. The pattern is a glob pattern.
Returns a list of keys for the node. If the pattern is specified only the attributes whose names match the pattern will be part of the returned list. The pattern is a glob pattern.
Return true if the specified key exists for the node.
Insert one or more nodes into the graph. The new nodes have no arcs connected to them. If no node is specified one node will be inserted, and the system will generate a unique name of the form nodex for it.
Appends a value (as a list) to one of the keyed values associated with an node. Returns the new value given to the attribute key.
Return the node at the other end of the specified arc, which has to be adjacent to the given node.
Renames the node node to newname. An error is thrown if either the node does not exist, or a node with name newname does exist. The result of the command is the new name of the node.
Set or get one of the keyed values associated with a node. A node may have any number of keyed values associated with it. If value is not specified, this command returns the current value assigned to the key; if value is specified, this command assigns that value to the key.
Remove a keyed value from the node node. The method will do nothing if the key does not exist.
Return a list of nodes in the graph. Restrictions can limit the list of returned nodes based on neighboring nodes, or based on the keyed values associated with the node. The restrictions that involve neighboring nodes have a list of nodes as argument, specified after the name of the restriction itself.
The possible restrictions are the same as for method arcs. Note that while the exact meanings change slightly, as they operate on nodes instead of arcs, the general behaviour is the same, especially when it comes to the handling of words with a leading dash in node lists.
The command recognizes:
Return a list of all nodes with at least one outgoing arc ending in a node found in the specified set of nodes. Alternatively specified as the set of source nodes for the -in arcs of the node set. The incoming neighbours.
Return a list of all nodes with at least one incoming arc starting in a node found in the specified set of nodes. Alternatively specified as the set of target nodes for the -out arcs of the node set. The outgoing neighbours.
This is the union of the nodes returned by -in and -out. The neighbours.
The set of neighbours (see -adj above) which are also in the set of nodes. I.e. the intersection between the set of nodes and the neighbours per -adj.
The set of neighbours (see -adj above) which are not in the set of nodes. I.e. the difference between the neighbours as per -adj, and the set of nodes.
Limit the list of nodes that are returned to those nodes that have an associated key key.
This restriction can only be used in combination with -key. It limits the list of nodes that are returned to those nodes whose associated key key has the value value.
Limit the list of nodes that are returned to those nodes that pass the test. The command in cmdprefix is called with two arguments, the name of the graph object, and the name of the node in question. It is executed in the context of the caller and has to return a boolean value. Nodes for which the command returns false are removed from the result list before it is returned to the caller.
Return the value associated with the key key for the graph.
Returns a dictionary (suitable for use with [array set]) for the whole graph. If the pattern is specified only the attributes whose names match the pattern will be part of the returned dictionary. The pattern is a glob pattern.
Returns a list of keys for the whole graph. If the pattern is specified only the attributes whose names match the pattern will be part of the returned list. The pattern is a glob pattern.
Return true if the specified key exists for the whole graph.
This method serializes the sub-graph spanned up by the nodes. In other words it returns a tcl value completely describing that graph. If no nodes are specified the whole graph will be serialized. This allows, for example, the transfer of graph objects (or parts thereof) over arbitrary channels, persistence, etc. This method is also the basis for both the copy constructor and the assignment operator.
The result of this method has to be semantically identical over all implementations of the graph interface. This is what will enable us to copy graph data between different implementations of the same interface.
The result is a list containing a multiple of three items, plus one! In other words, '[llength $serial] % 3 == 1'. Valid values include 1, 4, 7, ...
The last element of the list is a dictionary containing the attributes associated with the whole graph. Regarding the other elements; each triple consists of
The name of the node to be described,
A dictionary containing the attributes associated with the node,
And a list describing all the arcs starting at that node.
The elements of the arc list are lists containing three or four elements each, i.e.
The name of the arc described by the element,
A reference to the destination node of the arc. This reference is an integer number given the index of that node in the main serialization list. As that it is greater than or equal to zero, less than the length of the serialization, and a multiple of three. Note: For internal consistency no arc name may be used twice, whether in the same node, or at some other node. This is a global consistency requirement for the serialization.
And a dictionary containing the attributes associated with the arc.
The weight associated with the arc. This value is optional. Its non-presence means that the arc in question has no weight associated with it.
Note: This information is new, compared to the serialization of graph 2.3 and earlier. By making it an optional element the new format is maximally compatible with the old. This means that any graph not using weights will generate a serialization which is still understood by the older graph package. A serialization will not be understood any longer by the older packages if, and only if the graph it was generated from actually has arcs with weights.
For all attribute dictionaries they keys are the names of the attributes, and the values are the values for each name.
Note: The order of the nodes in the serialization has no relevance, nor has the order of the arcs per node.
# A possible serialization for the graph structure # # d -----> %2 # / ^ \ # / / \ # / b \ # / / \ # %1 <- a - %0 e # ^ \\ / # \\ c / # \\ \\ / # \\ v v # f ------ %3 # is # # %3 {} {{f 6 {}}} %0 {} {{a 6 {}} {b 9 {}} {c 0 {}}} %1 {} {{d 9 {}}} %2 {} {{e 0 {}}} {} # # This assumes that the graph has neither attribute data nor weighted arcs.
Set or get one of the keyed values associated with a graph. A graph may have any number of keyed values associated with it. If value is not specified, this command returns the current value assigned to the key; if value is specified, this command assigns that value to the key.
Swap the position of node1 and node2 in the graph.
Remove a keyed value from the graph. The method will do nothing if the key does not exist.
Perform a breadth-first or depth-first walk of the graph starting at the node node going in either the direction of outgoing or opposite to the incoming arcs.
The type of walk, breadth-first or depth-first, is determined by the value of type; bfs indicates breadth-first, dfs indicates depth-first. Depth-first is the default.
The order of the walk, pre-order, post-order or both-order is determined by the value of order; pre indicates pre-order, post indicates post-order, both indicates both-order. Pre-order is the default. Pre-order walking means that a node is visited before any of its neighbors (as defined by the direction, see below). Post-order walking means that a parent is visited after any of its neighbors. Both-order walking means that a node is visited before and after any of its neighbors. The combination of a breadth-first walk with post- or both-order is illegal.
The direction of the walk is determined by the value of dir; backward indicates the direction opposite to the incoming arcs, forward indicates the direction of the outgoing arcs.
As the walk progresses, the command cmd will be evaluated at each node, with the mode of the call (enter or leave) and values graphName and the name of the current node appended. For a pre-order walk, all nodes are entered, for a post-order all nodes are left. In a both-order walk the first visit of a node enters it, the second visit leaves it.
The following noteworthy changes have occurred:
The API for accessing attributes and their values has been simplified.
All functionality regarding the default attribute "data" has been removed. This default attribute does not exist anymore. All accesses to attributes have to specify the name of the attribute in question. This backward incompatible change allowed us to simplify the signature of all methods handling attributes.
Especially the flag -key is not required anymore, even more, its use is now forbidden. Please read the documentation for the arc and node methods set, get, getall, unset, append, lappend, keyexists and keys for a description of the new API's.
The methods keys and getall now take an optional pattern argument and will return only attribute data for keys matching this pattern.
Arcs and nodes can now be renamed. See the documentation for the methods arc rename and node rename.
The structure has been extended with API's for the serialization and deserialization of graph objects, and a number of operations based on them (graph assignment, copy construction).
Please read the documentation for the methods serialize, deserialize, =, and -->, and the documentation on the construction of graph objects.
Beyond the copying of whole graph objects these new API's also enable the transfer of graph objects over arbitrary channels and for easy persistence.
A new method, attr, was added to both arc and node allowing the query and retrieval of attribute data without regard to arc and node relationships.
Both methods arcs and nodes have been extended with the ability to select arcs and nodes based on an arbitrary filtering criterium.
This document, and the package it describes, will undoubtedly contain bugs and other problems. Please report such in the category struct :: graph of the Tcllib Trackers. Please also report any ideas for enhancements you may have for either package and/or documentation.
When proposing code changes, please provide unified diffs, i.e the output of diff -u.
Note further that attachments are strongly preferred over inlined patches. Attachments can be made by going to the Edit form of the ticket immediately after its creation, and then using the left-most button in the secondary navigation bar.
adjacent, arc, cgraph, degree, edge, graph, loop, neighbour, node, serialization, subgraph, vertex
Data structures
Copyright © 2002-2009,2019 Andreas Kupries <andreas_kupries@users.sourceforge.net>


| Match # | Switch | Scale | Vault | Reach Line |
|---|
| Match # | Switch | Scale | Opp. Switch | Vault |
|---|
| Match # | Start Position | Climb |
|---|
| Match # | Scouter | Comment | Compiler |
|---|
| Match # | Switch | Scale | Vault | Reach Line |
|---|
| Match # | Switch | Scale | Opp. Switch | Vault |
|---|
| Match # | Start Position | Climb |
|---|
| Match # | Scouter | Comment | Compiler |
|---|